From bd1f510621f2fb1a0df79ee3c3324ba42f1e1797 Mon Sep 17 00:00:00 2001 From: X39 Date: Thu, 18 Feb 2021 03:43:30 +0100 Subject: [PATCH 01/98] grrr --- .gitmodules | 3 + clients/vscode/sample/example.sqc | 9 + clients/vscode/sample/example.sqf | 2 +- server/CMakeLists.txt | 8 +- server/extern/sqlite | 1 + server/extern/sqlite3.def | 281 ++++++++++++++++++++++ server/extern/sqlite3.dll | Bin 0 -> 1958912 bytes server/extern/vm | 2 +- server/tools/schema2cpp/Program.cs | 71 ++++++ server/tools/schema2cpp/SchemaToCpp.cs | 180 ++++++++++++++ server/tools/schema2cpp/schema2cpp.csproj | 12 + 11 files changed, 566 insertions(+), 3 deletions(-) create mode 160000 server/extern/sqlite create mode 100644 server/extern/sqlite3.def create mode 100644 server/extern/sqlite3.dll create mode 100644 server/tools/schema2cpp/Program.cs create mode 100644 server/tools/schema2cpp/SchemaToCpp.cs create mode 100644 server/tools/schema2cpp/schema2cpp.csproj diff --git a/.gitmodules b/.gitmodules index d2fafb9..30c8aab 100644 --- a/.gitmodules +++ b/.gitmodules @@ -4,3 +4,6 @@ [submodule "vm"] path = server/extern/vm url = https://github.com/SQFvm/vm.git +[submodule "server/extern/sqlite"] + path = server/extern/sqlite + url = https://github.com/sqlite/sqlite.git diff --git a/clients/vscode/sample/example.sqc b/clients/vscode/sample/example.sqc index 35cfd90..c27a69d 100644 --- a/clients/vscode/sample/example.sqc +++ b/clients/vscode/sample/example.sqc @@ -1,3 +1,12 @@ +for (it : arr) +{ + diag_log(it); + for (it2 : it) + { + diag_log(it, it2); + } +} + // Assign local values /* test */ $"test {{{ 1 + 1 }}}"; diff --git a/clients/vscode/sample/example.sqf b/clients/vscode/sample/example.sqf index 4508de1..b73342f 100644 --- a/clients/vscode/sample/example.sqf +++ b/clients/vscode/sample/example.sqf @@ -1 +1 @@ -private _a = 1; private _b = 2; private _c = 3; private _d = 4; private _f = { scopename "___sqc_func"; params ["_arga", "_argb"]; diag_log format ["%1 - %2", _arga, _argb] }; global = { scopename "___sqc_func"; params ["_val"]; if (_val > 10) then { true breakout "___sqc_func" } else { if (_val > 12) then { if (_val < 50) then { false } else { true } breakout "___sqc_func" } } }; ["sqc", "hello world"] call _f; diag_log "test"; player getvariable "TAG_SomeVar"; private _arr = [1, 2, 3]; _arr select { scopename "___sqc_func"; (_x > 2) breakout "___sqc_func" }; for "_i" from 0 to 100 do { diag_log "test" } \ No newline at end of file +{ diag_log _it; { diag_log [_it, _it2] } foreach _it } foreach arr; private _a = 1; private _b = 2; private _c = 3; private _d = 4; private _f = { scopename "___sqc_func"; params ["_arga", "_argb"]; diag_log format ["%1 - %2", _arga, _argb] }; global = { scopename "___sqc_func"; params ["_val"]; if (_val > 10) then { true breakout "___sqc_func" } else { if (_val > 12) then { if (_val < 50) then { false } else { true } breakout "___sqc_func" } } }; ["sqc", "hello world"] call _f; diag_log "test"; player getvariable "TAG_SomeVar"; private _arr = [1, 2, 3]; _arr select { scopename "___sqc_func"; (_x > 2) breakout "___sqc_func" }; for "_i" from 0 to 100 do { diag_log "test" } \ No newline at end of file diff --git a/server/CMakeLists.txt b/server/CMakeLists.txt index 1b27732..2c990ff 100644 --- a/server/CMakeLists.txt +++ b/server/CMakeLists.txt @@ -50,14 +50,20 @@ list(APPEND sqfvm_language_server_src "${CMAKE_CURRENT_BINARY_DIR}/git_sha1.cpp" find_package(Threads) +find_package (SQLite3) + + option(SQFVM_LANGUAGE_SERVER_BUILD_EXECUTABLE "BUILD EXECUTABLE" ON) if (SQFVM_LANGUAGE_SERVER_BUILD_EXECUTABLE) add_executable(sqfvm_language_server ${sqfvm_language_server_src}) + include_directories(sqfvm_language_server ${SQLite3_INCLUDE_DIRS}) + include_directories(sqfvm_language_server PUBLIC ${PROJECT_SOURCE_DIR}/src) + target_link_libraries(sqfvm_language_server PRIVATE slibsqfvm_sqc) target_link_libraries(sqfvm_language_server ${CMAKE_DL_LIBS} ${CMAKE_THREAD_LIBS_INIT} ${ST_CXXFS_LIBS}) - target_include_directories(sqfvm_language_server PUBLIC ${PROJECT_SOURCE_DIR}/src) + target_link_libraries (sqfvm_language_server ${OUT_TARGET} ${SQLite3_LIBRARIES}) target_compile_options(sqfvm_language_server PRIVATE $<$,$,$>: diff --git a/server/extern/sqlite b/server/extern/sqlite new file mode 160000 index 0000000..40803ca --- /dev/null +++ b/server/extern/sqlite @@ -0,0 +1 @@ +Subproject commit 40803caa1d622b5f824fd00906672a425537016f diff --git a/server/extern/sqlite3.def b/server/extern/sqlite3.def new file mode 100644 index 0000000..e30c214 --- /dev/null +++ b/server/extern/sqlite3.def @@ -0,0 +1,281 @@ +EXPORTS +sqlite3_aggregate_context +sqlite3_aggregate_count +sqlite3_auto_extension +sqlite3_backup_finish +sqlite3_backup_init +sqlite3_backup_pagecount +sqlite3_backup_remaining +sqlite3_backup_step +sqlite3_bind_blob +sqlite3_bind_blob64 +sqlite3_bind_double +sqlite3_bind_int +sqlite3_bind_int64 +sqlite3_bind_null +sqlite3_bind_parameter_count +sqlite3_bind_parameter_index +sqlite3_bind_parameter_name +sqlite3_bind_pointer +sqlite3_bind_text +sqlite3_bind_text16 +sqlite3_bind_text64 +sqlite3_bind_value +sqlite3_bind_zeroblob +sqlite3_bind_zeroblob64 +sqlite3_blob_bytes +sqlite3_blob_close +sqlite3_blob_open +sqlite3_blob_read +sqlite3_blob_reopen +sqlite3_blob_write +sqlite3_busy_handler +sqlite3_busy_timeout +sqlite3_cancel_auto_extension +sqlite3_changes +sqlite3_clear_bindings +sqlite3_close +sqlite3_close_v2 +sqlite3_collation_needed +sqlite3_collation_needed16 +sqlite3_column_blob +sqlite3_column_bytes +sqlite3_column_bytes16 +sqlite3_column_count +sqlite3_column_database_name +sqlite3_column_database_name16 +sqlite3_column_decltype +sqlite3_column_decltype16 +sqlite3_column_double +sqlite3_column_int +sqlite3_column_int64 +sqlite3_column_name +sqlite3_column_name16 +sqlite3_column_origin_name +sqlite3_column_origin_name16 +sqlite3_column_table_name +sqlite3_column_table_name16 +sqlite3_column_text +sqlite3_column_text16 +sqlite3_column_type +sqlite3_column_value +sqlite3_commit_hook +sqlite3_compileoption_get +sqlite3_compileoption_used +sqlite3_complete +sqlite3_complete16 +sqlite3_config +sqlite3_context_db_handle +sqlite3_create_collation +sqlite3_create_collation_v2 +sqlite3_create_collation16 +sqlite3_create_filename +sqlite3_create_function +sqlite3_create_function_v2 +sqlite3_create_function16 +sqlite3_create_module +sqlite3_create_module_v2 +sqlite3_create_window_function +sqlite3_data_count +sqlite3_data_directory +sqlite3_database_file_object +sqlite3_db_cacheflush +sqlite3_db_config +sqlite3_db_filename +sqlite3_db_handle +sqlite3_db_mutex +sqlite3_db_readonly +sqlite3_db_release_memory +sqlite3_db_status +sqlite3_declare_vtab +sqlite3_deserialize +sqlite3_drop_modules +sqlite3_enable_load_extension +sqlite3_enable_shared_cache +sqlite3_errcode +sqlite3_errmsg +sqlite3_errmsg16 +sqlite3_errstr +sqlite3_exec +sqlite3_expanded_sql +sqlite3_expired +sqlite3_extended_errcode +sqlite3_extended_result_codes +sqlite3_file_control +sqlite3_filename_database +sqlite3_filename_journal +sqlite3_filename_wal +sqlite3_finalize +sqlite3_free +sqlite3_free_filename +sqlite3_free_table +sqlite3_fts3_may_be_corrupt +sqlite3_fts5_may_be_corrupt +sqlite3_get_autocommit +sqlite3_get_auxdata +sqlite3_get_table +sqlite3_global_recover +sqlite3_hard_heap_limit64 +sqlite3_initialize +sqlite3_interrupt +sqlite3_keyword_check +sqlite3_keyword_count +sqlite3_keyword_name +sqlite3_last_insert_rowid +sqlite3_libversion +sqlite3_libversion_number +sqlite3_limit +sqlite3_load_extension +sqlite3_log +sqlite3_malloc +sqlite3_malloc64 +sqlite3_memory_alarm +sqlite3_memory_highwater +sqlite3_memory_used +sqlite3_mprintf +sqlite3_msize +sqlite3_mutex_alloc +sqlite3_mutex_enter +sqlite3_mutex_free +sqlite3_mutex_leave +sqlite3_mutex_try +sqlite3_next_stmt +sqlite3_open +sqlite3_open_v2 +sqlite3_open16 +sqlite3_os_end +sqlite3_os_init +sqlite3_overload_function +sqlite3_prepare +sqlite3_prepare_v2 +sqlite3_prepare_v3 +sqlite3_prepare16 +sqlite3_prepare16_v2 +sqlite3_prepare16_v3 +sqlite3_profile +sqlite3_progress_handler +sqlite3_randomness +sqlite3_realloc +sqlite3_realloc64 +sqlite3_release_memory +sqlite3_reset +sqlite3_reset_auto_extension +sqlite3_result_blob +sqlite3_result_blob64 +sqlite3_result_double +sqlite3_result_error +sqlite3_result_error_code +sqlite3_result_error_nomem +sqlite3_result_error_toobig +sqlite3_result_error16 +sqlite3_result_int +sqlite3_result_int64 +sqlite3_result_null +sqlite3_result_pointer +sqlite3_result_subtype +sqlite3_result_text +sqlite3_result_text16 +sqlite3_result_text16be +sqlite3_result_text16le +sqlite3_result_text64 +sqlite3_result_value +sqlite3_result_zeroblob +sqlite3_result_zeroblob64 +sqlite3_rollback_hook +sqlite3_rtree_geometry_callback +sqlite3_rtree_query_callback +sqlite3_serialize +sqlite3_set_authorizer +sqlite3_set_auxdata +sqlite3_set_last_insert_rowid +sqlite3_shutdown +sqlite3_sleep +sqlite3_snprintf +sqlite3_soft_heap_limit +sqlite3_soft_heap_limit64 +sqlite3_sourceid +sqlite3_sql +sqlite3_status +sqlite3_status64 +sqlite3_step +sqlite3_stmt_busy +sqlite3_stmt_isexplain +sqlite3_stmt_readonly +sqlite3_stmt_status +sqlite3_str_append +sqlite3_str_appendall +sqlite3_str_appendchar +sqlite3_str_appendf +sqlite3_str_errcode +sqlite3_str_finish +sqlite3_str_length +sqlite3_str_new +sqlite3_str_reset +sqlite3_str_value +sqlite3_str_vappendf +sqlite3_strglob +sqlite3_stricmp +sqlite3_strlike +sqlite3_strnicmp +sqlite3_system_errno +sqlite3_table_column_metadata +sqlite3_temp_directory +sqlite3_test_control +sqlite3_thread_cleanup +sqlite3_threadsafe +sqlite3_total_changes +sqlite3_trace +sqlite3_trace_v2 +sqlite3_transfer_bindings +sqlite3_txn_state +sqlite3_unsupported_selecttrace +sqlite3_update_hook +sqlite3_uri_boolean +sqlite3_uri_int64 +sqlite3_uri_key +sqlite3_uri_parameter +sqlite3_user_data +sqlite3_value_blob +sqlite3_value_bytes +sqlite3_value_bytes16 +sqlite3_value_double +sqlite3_value_dup +sqlite3_value_free +sqlite3_value_frombind +sqlite3_value_int +sqlite3_value_int64 +sqlite3_value_nochange +sqlite3_value_numeric_type +sqlite3_value_pointer +sqlite3_value_subtype +sqlite3_value_text +sqlite3_value_text16 +sqlite3_value_text16be +sqlite3_value_text16le +sqlite3_value_type +sqlite3_version +sqlite3_vfs_find +sqlite3_vfs_register +sqlite3_vfs_unregister +sqlite3_vmprintf +sqlite3_vsnprintf +sqlite3_vtab_collation +sqlite3_vtab_config +sqlite3_vtab_nochange +sqlite3_vtab_on_conflict +sqlite3_wal_autocheckpoint +sqlite3_wal_checkpoint +sqlite3_wal_checkpoint_v2 +sqlite3_wal_hook +sqlite3_win32_is_nt +sqlite3_win32_mbcs_to_utf8 +sqlite3_win32_mbcs_to_utf8_v2 +sqlite3_win32_set_directory +sqlite3_win32_set_directory16 +sqlite3_win32_set_directory8 +sqlite3_win32_sleep +sqlite3_win32_unicode_to_utf8 +sqlite3_win32_utf8_to_mbcs +sqlite3_win32_utf8_to_mbcs_v2 +sqlite3_win32_utf8_to_unicode +sqlite3_win32_write_debug diff --git a/server/extern/sqlite3.dll b/server/extern/sqlite3.dll new file mode 100644 index 0000000000000000000000000000000000000000..c883b485446d874f427c0022e1d05b46fc54f9cf GIT binary patch literal 1958912 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

34$tRwn`HRLOj6UP2|Q6 zwBaw_9+DVf_c(nmm^@&+Gk=00H5oCKk-r)eItYjTGXawT zqyDTQ0KqHo#aMm+17X>KG~bb+@3hZz0-G(8uR!p&!P+p0`1(+*{U>w=s zp`H9K56L~)?vk`AsC3RCa7q8PoRTJ(XaRt|5}0LWS~$+i*6V;xkgA!L&1*4b@Ek*+ zF%eb&=?JWhJvZOIE&K(z?`QzTvPGV8>t2E~7|Z z(3}w$k;61+o?4!jpgh`yLY9>vYw*~O^Jots!{;gYon8tq=xDkfxOa)J_WW*AGq8GW zpDS+76iTk&=e=ZZfg399L|F^EHm73e2pe-+F#4`*a|T{19E^5j|FEbPOUtuEm_P-8 z;nonv(uB55zQW6;CMRAb(G^TBGDQ|(O!{Z%<3W8;Gq8B`T2zQPJ}4N^*r+6rh}HpP z8^%>qWj)`3+IH`zx^nlq1GZwBHaUb6ajT_>#DUAv?j2DAsu=@L`M3pfY1U#SWaNgt zC%{nA*9X-_5pLE&q&7_Md22jYOn}i8C^EF5fup5aLP=w=?yF#!R7q=Z=?|`jyNz9Cj;?hR!3+|R zvIQ`vI2)!}J(tUst$Jd0l;j5O{SAPN3jVkBaLTOdFe_BHO8&hXN<>G@%EkD{ON)L# zX)8^;Xf$^3PGj$4KRr9K|4Hrf9k(Ue#noE;;XFbIwBh*ylj;tnNpj_@eTCh|eQs>+ zUV)ZHe=h3f@bdB^(zG@tRDTf3KnlJ6EHYew6a8Nh{(aZa@Gg}r-;lJOZeusE1a5Db zY|~5T67^%hU5CeF@?7tBq-Afk6I6QvmDUo2iNND<1=6i3q}Nm39(h`?=(Cb6YFhLM zs6pW7ZjWhJiFcLWY6<&TFR<<#I^I$x|85|yJ31UlGseTg?g93Jazu|c$WMka=#I$9z=_qNOUZp|?N9!=^w zR0f_HU(%@6q!WpM@>UjHW`Qj1!UiL^;iaVUP+f)miau())8v=GPHF-EH6E`U<#z1d zICBBE-ph;~(JN%us`Nx)(uNT$Zqk+mY2THN9d1X5ccdGeYT7PTxT%F2G%7s@5%7+x z5ztUTz*n-D^O-Nh!3Su*CcU>Wk z1K2@<{sf7+MLN}@O9KvowC{}fI4Tp9N-hsY)02WrLNui>#_UdX;vI*;N=U`ACD_x- zC;@V@LAf*X$Y+{HDU$#56!DQ-gz#qcq#~Eta4&+`8h-R{JYkH8tiUriPXBzI2LlOz z11B`G`_rLm=kFi`HjGX1%-M&TqUI8XW@Gy2QylFckZ(xoIS@7CDZNO?30hs**TUIg zS@ul%l|8Zc;{E|LYg4pclGdU09F{}Jj8Jichf@M+)|3v{l~6r{c_o{Rp_0RAr`y|I z*4SM$QmG6ff2+%6pH8n$bYcQV0C#Rsg7PU>g5MWq+QZGC*bwaor1`tUQ$C}>GA@&y zD+a4==fOf>a()oKc2{<~vF#T~|Kg1-Xt%wiH`*0+T6~WDYKp{{Goj?Z?6PRNT>;Z~ zjX}@bAGctpN}C@@>p+5OoUTv;o#NIu|9f9ZY;SJ6yK>j|*mS2jLNwh? zfS$NqJ5#7Ryr@8>o& zSjd~mlMd~T&w2Z+{~EPZp7A6~F~6l^-;!X8n)JzyXJbbxO9rNuJTD||yy%DQ6S?wJ zN?NRdsKl2?VjR2ty{YTR8Bfj+xPK$a#&;o@%K~eZF2&faI9jR?DlxrY+f?R=JTTtH z){wJ^8-6ZqC!_*AKNKTvDMzyqS>6aw8Kik2O5bs-Q+aOoPU9)>#4^WGZ?x{JMv+%F(E^gmLsGJp^}N5~kL zu~Rng1zE=6JRJQEm49Z_JQv$3v)9XDK=XeJdI6O*TwZ?3r9kM*sZilCNXES`%;634#`%Y^;E_(5uHmMO zJ4uuN6FSaqKnZ;bJojToe7PCoNA7Yv-dTS=C{)4<7cwMx%9LkvJ>2De3uyC9Rw{!& zob>W$xzur-$p~#&#;wVQSp;okCD$*EOA>BhW9BKAge0}faq)>waH!s0p7oot zN(mja&~h(yYZ|Pr8#ajBukrTLS)B2IVqnr4MZO&+s>p#`z2*UbHblnQrL*iz`<_ZI6 zivoWm9mH0H#NNBjrb4W9aB8+6qR($Szcz zMZQ=^h9kcoNqJ4NyrvSw9;K|XD53UX2|&9X^-7@j`XhqynMNw)kx?iFyAc&N$BLS% zQrE~%w8op6D%Bt66=6W8P(jo5c%BRElpKoaeywD+Nw3;MVcp^SlOa_OW)RzxF(`Jb8OdP~aqlqyVZ%Ma;koVp zBjUpYED3J1m%@b6yAHtQjkF7exepGK?GwocZ8z z{H_u(!K=|Qv{8;Ke-S0++##eUM>dA^g3vb=ma$QCU{xnqvpBs$Srk0+A$(G$JM`!J9m-tF2{$P=nu68+sb*3t0L0}RE%&^nKl}>!6 z8Gjw*kr^=G=zuw3tH~f4gOG@?bl|T!sc>_=@Fpr3!e6IeZfsJyerP^xpeYBi%l^}r zb#Qt;ow7~@+0cX)pRcfnuJQ*@QI6`5qc_O)r(sAJ9=J4-9*UTdAt#ow{zK#xA0Xp5 zEq77%z6g@Rm8Zq^AH&Eq;n(8@|B>NOh_9s03%CrYl6m8-Kqe)`tkRGgv=aVp2d%?% zy5I`gUOhY?(H-SAf)Mtv#H+dL zZ8pI?_BY_14EL4oVBO9AG2*;cx|w98n;nZ;(MRarlx~OjITklgTHMIoMCVrT%C@`M z9j2E^VO1)_(5C~%DQ>n?VXvchIWY4(GJ7@r#NTWJ)M0ahX@=)Yxw6H$?As>E@pkQg z)U5m1Q;ks0oNk612_?L>$`)q&cJ%G@_BlBNs>E)VDw()fx3z!gkde9oRTS$p?zkbt zZ(C*`G; zwJ6xUR8%K_(ngTQtqNrrr54(FnFhBT?-mgv# z{Gh{W$md+BumiLdz^Y|BP_yRW#|zu(kV(RSk9QHhlY3zj&EmU}$MS=;i%<)!2WDT1 z68tpQyJY_;V>!z{tp%yxNMO!SHsjl2+bX&vLt2au^$xCroO7XX3N&ZjEt2?-R zD-EG_Y0LaT=1sD{_D!pREeGa)6PR?r2{aypLqA)FH+31}C@+DL)YmWbs;{2|6Yu)@ zc!AVavR~~_nlH=P2!*wj)A=kd3=PgqO~UGz*+|>=)f{`Oj#zx!5fDDxC$f zLt-?2hSczw!#07(z^N8TI>N>yv9M-a`wVJhkMOE!!M^yfNMcWAm!oRAeh0OE!4ShI zO8sS$`&OLa55~q{H!s3vfKMvd{c5~0I|wrO{Pip>i}Lj!bRh?NUEY)EHI>Oflplmg z<3wpJJQ~4!=q(O-*&j!eW=jKC`7u4ExY!{{e7r@{uw8w^h3un|{Y6p;SO}%ljR+#0 z0V$7UQ?-PFTmAwJ)bF5nFOowzKX89%?m&E6vo(VXndnGwMqg_)>A+`-icM6aBJNeV zqQ&29_SpTscF%Z!?_|$dfA7~kI34Kp;0#5LXZY;BCiuIyX(92s^lzdL&6e{E{6Ykx z0MnGEbbf_?q1(F%(sE}0A``wXIMl^@Nv-;bPA^UikAhtmYS9&}A$v0r;R1eq zc*<;)i?!g~9B{4K-Ui=Cm83NE3@J|f$dJH^M_V4HN%6jH7?JT&fyiXFHLKVMj4P|a(^ zhKdP%AvFI(e>RWSRbS}K z+kXHILd73YajcnG{?{`S`G0iI{Q7v6ur5-w4*EYecrV4oUcS$wb2L#{)7$Ti!YKN&Bme&Wz3Gkz{|KnC&$ z`AMLUQ0u>uQxr%`d4<4{*^H|Fe`TFq+CWZ}uyED>!!jcVIa-z58(V4kzE2F?xCJF> z7q%+@khpCZsc)lYN2|wFHByErkdriM@87B#_j<3DV3yh-2g>XvY!5I3QD6_x=N@@jKdkf4nnM z>=eYS4J@P;MqkB`Br4wi)PU}IO{h4Nuo%N%`QwDYHFU(C>+AjK%LVk5vmwu&rgbnlhHPy5K>gPj!$vrrwpg_6aK zZ$NPn(PGW^D&8CuyZ&{&u(9AmX7@2#3)_YH{bwkl*<_Gl^p_-p`DEz9WXR`1?8`w- z&^)QnSUu(#W5#n}6YhUJR}uz&h0DBIz8b?a?`U65${cT+ug16xraTe@(4YnhMJ!KX z#rnbJ{Oo>;2iXnRpCkKjr~)& ztWEJ_qC*z_#K3)+xAgq6@y6oDU0IRFr@K$Fu?@GrGOSKu9-Y~L{IKH0lGs#;)l^ZQ z=~6{&aXD_X)DFXn3>$#h#&bJ%)xKr8jjxaKgN2Aoy(w)F9)^ZCvES~=wiEs3@zZZ7 z>F$kII`~%inoU>AHQRgW0yNqV$U%ZIZtuWi362QxcG5z5u0qZ6=UNlx!rB~u0oK~X zn(g5qg8M3WLD_(wh4b64OdQ)DkR2Pq*vK-~9?@)v&`u(I)%o(1R$Z>yZUH^>LOg%@ zS?agc9w7udo9rMK#|hDmK6?1=6u24UYzVr@czrz)c=)d{L^ka&yVKeeVQ+=b3}d_K zl7NF`sY(T~s}F^d0V33Y9z%d$A9b?;3YBK_0Gr^m0v9?mO9{PacN-7LP4kz0tKf~D z_s*n~!cD^Vr_!(f17<}W{gsWF)?ti^;Mj0GIQBfJ{}Sgv(4LdGXVTkqQhP3POSX6G5p(aU9q|Q!!{38HfaK z@>5e1(a_-P(tr>Xe7!AHiCU4DNJR5ZI2w?ACV^J{pbG2FP(J6!RfBRJaT(*IZ{P` z8*=z-EP^MuPrhQ;myD`wp`&z`F;~zE`>ELQG;&J*4Hm)su2f&(gZ*Uv<=9?EX0D#& zngAm9RHUv96rmz!Wcx?~I@Ra!c#dhX* z_pG;&S)sNKMo3L;I84K^3AlZ)ehx?NmF#u@`}(djoW%B!n_l5LjR(OBcn4r|v-niIKKaSWYmIO||${UW|_n8-@NZ z3Y5SE?kUqsP4Eo_!q19!q*dr)#TC`5pP){@NeH${Jo_mErTXB(1>is$3;EA)?V7ZL8E+Ip@fu?&?Jhjw4N0f};8N#g#p zk>Pf7^1{7a{Ae%kcZnbE_0OLDZJdzg$0PqUC9%ML7Li=PT}&@p`eaJN?%CAzy#~CI z;yiC%^(P=|lF{j;8V1bg{+euo!9;e@vzAqmV~RA5z3Ru&8rz{pw1B%DfX6X`Qr#Mv zJa1Pn1l%>_S#gfBcnF~R*}=VB8UnQy1Oa(>_ccIm5j{KH3ga&3RoCPWxKhy_@pNejIo+N9u>l3`)(? z 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

  • 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%0A)6zK459Mo_R3%mW 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

    GBRpSH@bL!Z2}Jv<-3aDQ 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 z z_Z(j8&fzq74kOH==a(8u(S~1S=kUdUGjrH{x0%E6R`a?aKf!gM`to6OxQ>!pj=g-7 z2~gJG4o)9Qs#HX8o7~U{y858w%Jz4`-{@~G9i_j6yZbxF?eDMt)AaYYE#~#5`~=sP zAKu@-@9eKvd0jtRXBm|AQ&}UTGGdGDtFaHt65l=;wEq;0AIgtT;jcGp@i(WDXtjs( zRs=Z>mAZX>rNi{~ZhnI68nS(LcjBxc^vrE0nhI_W#<^ZwcfO8Xr(4%;2yik%x#e7I z+@@<`m(k%KWcvqvYc^v7dMgU-rbx16tIU(;pyhkX*Zj2T0P#PIJ-+50T*n^~XW@yC z0vy6mck}Bzoj?9nhG(?qGVN?fm-5pSsRx1W=t$IK-S!gi!M$Uq6Dsk>_wKLU9Ghb$ zZ_f0Y*fc^2bs_}~&b`lTL(V9CIFGK7qRj6j9>4jpyvm88b2buH^dgh@5xJ|q>VUdT zIdoSTVT19hL|CIvj@zdOjm}CfK!aLj3qoIqGbh`Th1O%QFf75u>{1L3BBG#-ImSS% z8LZGwuW>e)G|^J9>18;!r4T|%2Ho>PsNd_{`a`R(MIrErcD<*4Vl97(t130sPG{8j z4iY-^owa_@4e{Sx?g;vo!PJJ*lNE`CNs5HwGUL}S7xD_3ST&r)+61+b>JZCmCf$YN zXJ9m>Od)Wg8z{@Dhju#kgh-KksGByQVXDK#QR`US<3;m62HHo=&yoGl_{)@`tZn<=?X&S=$;|=&2!Z$rIDoq(n!v@FwqmhQ;DK;rd6~T_Rp8Qi02yeONJ*)=7o_x{5N`(h;lwB2bmK7dd7jOPDTdS)y$_Vv*k1XD!xGOL{4;{?9}g zq^^V;yxKf!T|xHo11k&UlYopI;la4cZdsgsD#xvSZHQ;(fcAnao{3bX`n4CF!?phF zY3o$Ct$yaiXXHdn2lCBBF8Z4bL6VIlQnyO_2sHSCZwa}$#b@CkzNK?56Y`Glfa7pc zMm^Gb{B7?jA^3+Pax~0tf>KFvAQ-lMetA(Q>~pn!F~Aif&Uos-q$%~axc2|kN%#yK zQ(^s!4i*4}lp=MXH)?{YT$t}t&`a(r>5zN5x>&(?5!13rcu zL%s_TonB0yoN0wP%B4n!>EeWMQ1Hic$rphlq=Bv>AhA8TsXsPRaC}&LhT*S z^Cmj;o>ZT7pm<)o>TCgF83_u`&LILZsA~%0vr{MNY8bL%la0{iC;f)NSC7YyP}mFu zjZ@}p|7V8Ik{9`uzr7vf2(t#^0B{i7XNVnp?W4|u25mz7`Zeo9h#L|?6#of98^Egg zCeD97EhKl7S|$~jeLyORqhV3$PuQ*{5n(Num7pBEWBV`+b4p3=pqV<;Oc7i6Si2Sg znnC?L9NP?BmO&UAzvv!IdD*@3^rZXd!;i|)53_%a)<45Sc6e=Ld%!b(z={# z`X8#ODqDP%m7L}$y%j{xN)RylnHUTWkupHWn(UnG#2Lqz0oi!vRF&GRR+%LrM#Gl$ z2H%zh!J?&LwPxyP-B%}{?$N_K-Jr_K`t;%H4-`Bkpe5)<9IiWlk!LCk{ogu2R!Gh!>%jcC68eCk+Ju{lza zygE5a6(2HPp-3+D&tS8hbnOyW?0oJp61mt4C8e(D>x_mA09`lVY1%&D*YW`SL7yb2 zQPE^9)2OqGujhCEfH(0s(T(Zs8M3dLVUv69Wh00RCogJn_n)0x=`8LStlYe~z;;L& zZUUR+#}5`X{=RGC_}tjyVC5?d`eKFYYxy$Om@Ly~MhOOd0aiu*c$mBh+L}|H4DQd) z=rGNwH{DjbuW@(k4Awfe1e3}7wxInAU8qi6ef?ZhiJ9c!y1ufwVbgQO1 zF>y)n*$&q~8nh$V&#l~!k4k3NgKNw9QuF?c2Q}}}fSPx!ZV6JG>4$m{O4e`?X6~zV z=|%rnI!E&M0Uuwdj+>WQJT}#z)htZ)!5IF^vG(&E^&33$BI3M3h>iKd^z~9h2q@dczG zFOjNhd8sE_Sl#?mtbf{Mh3MQ*HFm*G^y0St4~TT6TPyd)PG^u4zST3xKe-adc7B5E zrtj?;q{`Ga2{qQwk&y&=^%KKXR zU3B^*12YBgAYB=5^csD935Lv!Yn$_1WDMctuI7Hr2(!>iz za1bdKO>u$J<=kK)PSOEkiL>br7?Win;W#?pz7!Lw*Q&4SnBS4wydI_ooOr$=cG)JcQLHp5EA+eJp zgf%ry{uXgj)@j>7jG{#t#-i7B{lh@vT`SJuEA;VVrzFR)gLu#wl^&;wr|d&QAHO$9 zsNm+$yZdJ7I)$)G?_y%T$qD^T01+lQZ($!YNQvMZwn~%y&{4)^2Ps+=Y$9uJ^Y(Ai zo6gUxsfzo=w)vW6UY$iy?rCSRF*NF-R|F~HAT-`D#~0Bn(asqP&(F;W0aPGanw1=GuM(P(G3B3z})oLBr9_s$|I_)d3bMk!7XdESok|VwUJj%BPo2h{@?ls;W8{+b~&%?!WEwS zVskUo;9Ny7$Q?C2RC!s+qEFfdLqErw*xS0XZ>Vxlz;{bqXw>sTZ0j}u=KB&cI0IeT znsYy+<7rwc*&fhLdvKYo8dl(*ZY)=hBVs=DA8LF5t^oNy4^4be91p&#Zr5Odrloya zuG*K#Ik->6PV8kogbnveM&HD>b~t0Yu8=RJ`D69j^7eJw%7${<*Eza0!Gv*|-m3S0 z=XZM%+Y!&}vQ4BKbT8hgZ+cDq4=XXl-`lsm*5F-9o!w9%LHo~~n0(Er2^!rnAe_e@ zEV-Rd$oX3FDZa}!MBdAB1pNf;b-C>b)LM9s-NyM^uk&++0}Uc%NCuhDMVvBb3(Ogg z-~dI)72V=E>Dt=(gC$Kgl@l96tV)05 zU>D@m>9^9U0>hKLbn>QSghQ7B#fZYd*_@5iwJ1r>*LcJkwsd8~6cDJxF8IXWZo(^V zj{S8tLU+wUi{s0P0t#d)E*&j%*4$wBf^#>&iu>>#V;G?2$a0$hy?myDzp|#KpJ92P ziWWJe%N0T8G7jp*#Dsx)v<&ArEsHaRH}DnMf$@05VCS`1x8(IoaF2!Ox0zKV#_9IP zy}A#Kj(fz0;4m|Zd>`=W^R5c{;47B_DO9d=wJTv#a~w!-zFyOGCU9?WMgJr2~{#W-+P$cMHcOt~xdjyqYhz)Iq?=o#gT|V( z>^5iXV|a<2*;SPjh)o}x8!HH{8kxdvxt@JQe-7*2_bHm`9msGLVvACVEp8V;8t%e~ z@_IXfVj}X0rT}j8+3r4nm=z|XtbjNz z@f6~;WCA24Q5&k<=4-wgghK`b^F3@jS=5&c1rd>u93ZuJu*BB^g6OyQ3cl*x%qznT z2{D*Mo-yVb3my?7`Vp@Qy=o_5m~>@u3V(nEazy`&zU7twYG79z#j^Y#EG2SL|#?dC44euD4}lWj9>EJ?$q%BWquF9Y};gVMg`Dl16gXyLb$+a7o_*yjCDWGLxvCalWk>5BAJx>(5 z;J{BmB_e3-Sx=uW=50s1=sDgJMgB*7%srX4ty7CGn`;# zCVTQQtKwQe41021qB;Bh0Pc>@mJ6(k4ONf(Lw&3Et#TrRQ;_cPVa%!z;T2MqZ+!+?6tFprv zABu>YhYSC#2apQOx%XZLD3~ec-L>J3RPI?G3?;vqQ(gJT6%&NhM3~|`kxZ`idI&N{ z74%|aaj25;Bl9KH_pP}A|ImpfM$7T~wszug;-QumBe5$_Q_IT!Rmn3)KYpllI-4U~ zq48l#{WN=PMw)5iJABVvq;AW`$Dr;yqVM_cA7-iLV*ha7#SOkS z{VF?F`Up;hARzr4`#`73FS2HQ4*Aea2u4r5FA}2Xk;DG}iGwIwXvH_?X3H)EQK_na zHOUF6?{-?Fb_LVlY+~Hu`Y)En-_G^j_;WgiP}Yx^%;x>qmRAM?z8k*Bvt%_vC-*=n zn-knw*S!e>_?3%V@a+B`4>k7zFv!Nw34;ubXWkNNdbQpP zODNK`ehQ_T?q{Cv(V+>EF{pJo^^?8|<5NXQ-eIP%o4>sgN@yPd2os?ZAmGplFS&|G z6b75-<-93idXnKrSZ?7@bGCZ|Ow=ceW?@{@40>!Ih+asqUU{Os&wt=C7%yFPn=aA= zKdV>u9oDG>3w5P8*O(#$*JeH%nJ(IFp4?@cA-%i`P3rv!1n9m*%YT$0E;WGO-DJd3 zF68)bzQM@j*~b|WdX;;DL%4qX5#X@Z8rflha9ECStEQwn@x_arAEY%EVq=u(H`|~% z&vI~j8Tx~jGSW^Kyw%(zNxkECV=%a!9}EVEat+dlpI1{yG|=(T5A%s z%b5QO6B0S8Iaxel79>#)5jc>l&ORKICaI{lbfA3s(CBDdy`ENs>z<$qEv-K*uO8`k z;H~fbXxdq~gy0m4`95KSvI&7eB;OKBF>FUK#4DoIsXp#{M6M7i1q>Q#nz%39MC#lB zT~y|O+j*}U=sABGuN-)++A$a&84ZTyfri&IVbGv@P}^(0hTj^L<+lo)&mX%VBe4}F z(LRqzUzVyTKu15*jjDiWpJU;R~^U zrC^qBDb3iO+C)vu#J|uX_?Ie|f7#~ztk|_pSd#VDGR#cv$19p z?GY%nRpoiwt4f(}={Sr?qo)J!b5&E{+Ijlo9y1}qlV1!REBMsBplx}j2!p^EeeJbD zp7`GLS^NQo!FVTew`YmenX7ZVuM~^Q$WwyxgE`SNU9nRicpk%f50SHWkA421ryBQV zFeog80*TP~*_+mS0?3?OI- zRsZ2yF81#CIrKXdOo>jof|A}Nfc^*iRom78LN66^axHa7k!{;KB@Te~4EVL6uh1Pv z&%@3J*0`p7{MpIr{4zs-pC$cRU-#e_0fpbPk2O(&#LqWB&*TyAaom6M8_V~t8J{~& zm?k=4+#UKUh##oIEUDu2oXJ!)exSq^l#cr;cdoKv+}&JC&Ml2Vt+(^brrb5YW|>Ob zlk$D*U+^wm%4<%6M5^(vugmu?#E4;6>M|mL`XlzGq%GMUtqzo5H79mHrTZ_asJ8nV z2c7N8{y8d~oCG#B8yDwEUf-H&vyBvVhx6D~3aq;)b(!URWKvnnmL*7(#|KoUEBR7%t~JYu zel^{zY7uuN?Tj(KGyfh50nGt7dUU|Iraf!?ZzYFsQ%^1{bmdy8G*7ZBt|}&QqHuG6 zY)=4^>JJ9p_5@tdYa_8zJYqgJw*xpF8=!ee_@(_j;^wbl7bOgeJ*eRM1 zuo;IwV*kUw-69-`N!xf~vWdk0Dhv^f^eF`+-SC0N*t?MFzcHost^aI3AhZWlumvMv ztfO8WwgJ}#1D*TD7t$4Q2r{ZCoFD7n^vZOkcYQ}*A6`FFgo6wFS@xw&$JAm4GrP1{ z0BhP_FkG$n@vW~njgCK}(K9|!qe81vEh=e6nPRvZ4fH;F5!eT#2)A4vI*1xE)a*^@ z9dx7v<rkADeRauE3e>q6v(g(& zns_W}%M##bFTeAH&WR)F3TX-*Dp6!eHC@oI{F{ zCUB??*Egv;f>{y~W&qT!Nwr}TG`9mG%G{C}LPu__EqD5lgqDB&Jz!DVbnZ`L!?ZNT z3&Gq|88vx&<7?8KEZA9xn{(q2YjgrgG+!`5M;~B1jGu3^p!OPMHHpc%;!f_UN!0J- z@gC#t^a`T}9(>Ib`GgafAs@b~Fq~LO>Z)aa3yr@Yqj#yZeJ!FN*(c8TI}aKG^=M2{3T9KoPkNwK(7VgFc8|-8G>&A9GTB1(pTr=qURHE8gxU z#PNx%E&G^W#uyd7&f_)cuU8;Qf=>(g9+v&NleVN+Z!zV zb%y9`z7;uuh*sU&Cg#sLq|aMDuQD#L_(kW(A6UY#@^;1Dyj{D5jzQp%dH=Neb4S*1O|nMmo(+$Pfp$_2og!}H2zlVT%l#}PfTPBpKo?VB)QV;iUDI@ zF|gM84MXokf<@p@atXgMiBTEPRG55q@~{W*g!KOzPcr;Ycf8Hs-b3VvDwY1{wTfzv z7cba*R?M=J%VBQDUH{kpY1bY%Vt-2MhOiePiyMLL8i&43;>+CS{}Q&(EHTcLI~+@f zF`y|zk{*?b#}X}#R4gfuo|GohQ@g)%mZxzI;Z=R>=jHcbI1F)6sHDU=bESr?WnXww z{WFp2zi_pCCT9<3-QQS;9;?y6Th9PJnPDXheh-z*824~WDx(V^ASp^@&8~xTsiH)e zgtQkhrxxzc-Ty{fupOd9Gd2O{GWwYDejSoPqS)vw2#Sx)m}O7_M0HesK(?TxfMqxQaq$4b77 zwdiSx-J}H$vjfojlQ=FD=$m987@AH9WrBSlW71Y^TR(u-l>FN7EZq7=I(7DY1o$3c zcmiT(he!}*GFQx1fbY2q@I6>?g@3Dw&t{t->C?M3 zVVmqpEnQ3Vk_+IH@e`FEWJK1ax;t2*p-?RJ3e0UK&+K@&QpD9g zHZeXw9YpcWzr^@ZCQnnv*A<0)N=2>Jo+m-*s92Wo5Vd472JRvLnRDtPswL0C0JN(yU)dLzk!S0HxM)&qpca~UDS z0sy?8FFno{av%mPz5uO%3jK{NQpw{Yj6?|nVwCqc`4e0-2404AYdJ&Vx}~g#E=t#4 z%|p(8sCk{++Vfy}k$pj*z%xFl;X0j*>8s%ZH=`1Zdr&nz$OTi&PTJ*cZc?mV^C0ul z7(R;Bzl{;YP2=g7Ea$PUdMO-lBj?v;!jw1%e9Kes8C9zg}=q+v)r#S3=F41UYBybiT`dIB^uc^oGH!^pt;p&hfQm z^;;dxc;~gbg2gZTP3WY#+~_3n+1KAlj}35c*|V}=TeBO;EOiVF#HMvsd=zYYvlio;AZ=~nJP0aMf{PrydOod|8Soj97n}@bg5GD0eF6=X!9Ew8SF`ootzwS88$Y!#JC=T8N6XWYs>GrOc?}R z+~FotFq!zKcNDIg4w}sfjR(tOMhivHA6z4ACj1kZB7`zs38uG^%RXC#9vp@Shq14= zIWIFXol& z>5(xD181OqqLLL2LU{>UGmCd<;tAF8wM`3ugG?blz`hs1mD>{nk*IXNEmo#2R>wp3Hfak zPXJ3!EX}Gl#NIA>2YvjX!M^@)FaIykK)|T^jEN1HlGy*8b;Z~c%$!#=t`3#2EX3!@Ug*`|AoHg+DiIF6Yb9+LU_!n zD{&LBylJp|%plj%_&p|9cq=}!;v{3ggS<&a&&m`PLCBohKGFCh6~O}_hES2$I5SHE zChbea{z5=ObQ;5uSuNZt-PPg_ znQ)L;NhFNu3tC&QMTAAo#)Z^a-l@uX*8z3I4~I@bHM4t-3v?X-#9{)<<9@vd{+pN{ zu>AwM-DGazZZWBWnvXc=Le7oJqQ-kraj3;ccaw109v6N%ao~(i{^85k1DB4_hS!?XB)akv)5VQlm1`({>y5cC*SRwmy zX@6Dz+Zx7Ek%|??u{muKv4(P*Rk8e&(? zEy-isq0e+(IEXwjd4_5?@^H82SMSFg7#0AgL8&pFAN*^#z0Nss0LEU2BZ+IT<5c~G zL&XWU$?)1^tmCGW?J?GomhCW6W*O|!%#R-4jRqt0T(e<6*QuSI_0 znOu6vd>VE`kK8gnr%j#Y$g3^wKu`a`pMgWGP`N)GNF%u8*PEDx=9{PEyYkC(qJyf- z%U1NwGXhET=HWn2Xw?FI;T9Bf)LM|67*CGYjm6=3YkruVGqL}So3rGA8m#B%t}Ucr z$qRCWiKSk|)WJ!FIpcb4FcBV5otP8hdOD9Af{ArP_WbDBA50|fb?@$Se-7|Nmew<4 zecG$f6pgoRV&`=ETE1&$O^bl0t|6m+$a0;t{s|KF8vi5hSm5a=f+x#fS{SiEZA|-K z@io6{;E5;^l22wq$%Kk+aQVsl7|C|3PC!sI%-ZmBK{#)b--vv)+3UL{Ix297$?=>? zt6WW>3O9vw^1?nVUGenJ_2+0F&9?v5eZ9rgN90vLhlOpF*rZ!LeYGU6pn=dTWC9U; zN^!`pCNG#E7bp}o&!K8(3JUv>{r%Nk2jiOxLY3dwassYc?lbb8&KG{>g6qq=uQ$yC zuCMMCxSBEsT+Oa0sO-%Ti?|x7&C37&HoTG;3V1CCUQG_`9(er{@cJde>zCdIUQIVh z`@1DNHJGf)L1dc-Hi6OLnQOgtl$%-rHlKff{!KT4oDs^H4AL2)jG2E@NW)0OZo){P zZ=h3n0ycWS*l2jhEOgGk{GTy>G>}?q#n%Z^k=Homq}W4o*R7Tz0jWutno+`BWDHFj z;$NE1^1ep+Ji>6wh@c@jYc@*1si-NxQ_@6TI=I#ean2CpgaeLdIN*moO%kc@j`}$c z%QnsOTNM`;6K^iQp_q6_@eO_snH7U$uV-9#YwRluu@cV@+RI5p|DbU?v44|puR#=+ z7fc+}H34de(U2RcTWo(p6JaijfM$`z9h|Z;FLQo)0GaM5(69yL2j+zA3FR)~6~* zwB@(zKS_$0aQz+=jFP;K1YXJ+^@Ot<8IIy-0E&wHuvqo*hB%p(B#rc1`^Oq-G%?09uYW6Djd@=?AlOtFz43B!ul3-vnZqLWE;oJS; z%I6y~R%+9HyEAVroLt^3E>XZo3srzUQT3|HeoThEE-!oC9|ct80YqgB!>Z7=LK9`A zuVrH?*1xPMFU5qY>Q>B%_J-{SzOGu$zuWnDC;#r{-&+2)l1mljwVARD_i%qJGJwkQ z6YPDyq?m@9#8ta$63aRc<9{Oda!3qn3t5K9kKd$`@jLmqD7*X42$AmBJ@ZC-Rn@V` zXK?8?eI4o^|HAg$ChBJ-IR~}IOFBS<$VgL~P91H+gxYUpqJl0>yXR|pvzCodhEBNkvFXN6QJEIz6zj)gWO&g z*Rn4!gGz~&$I3Ro_f0~P24w!@O!$vHpziWA<%^9fsETZ+Pz6J$5R4bA%3u>g}eY?jsu>!h%EyX=AYcelg6RYpb zn#vroIMStWSf#tf4SFaOtMAL2>K$+OP$pL2cTKEJ{L-FpvnE#GzxCa|)k93IZdlE4 zrne8CV|uG*qOwrI=y98K%9R5=Yo#D-uNq5HQms@?ve5eSpJiW!l6f*lE>#oc#QGg2 zME9+E%&3ZRA>Z!w!)`Sg-zMo$=jWDhbY<&3Q&XDoEU__}+3^d=H3!CgSe z2Dzi++X~qzE(&XwdhsK}#mDtw<~*LYcQ(nmregTHCzF$FM9ALc{03AYputjZCX@`i zW$d{xS2ADw0)OSP%ZF*mCdc#ieqL#Vr|;sEBT9deKD(wciis~HW>}OjF>P?@2d(-O zaNrj&Q#U?2EYGzlaFV|}$SKpIbH3&-Eg$ebAFhjCLpVa;O_;GEqMTb&D$0TlS33(k z-!IWaS=N3Dk=y#YC1}Sv*Zv9=>D;zcUEd=R4V5(b?q6Jt=&&}uLrfiZD{U&X8LUDX zZJSb4jD+9hSPu9r%a$Kw)uW`?nVF7UuVc9t0)sIG3{oy*WFN7Sy_xow{zhoCPdM=j zL%PV5yDI-wE4^7tc#$rvQkEV!PBjWkMj;YLqYNR86`JA1rIS#!tPdyz{vZpHDU*SZ zZu>A6#oskvhUKq@6$V|Az%hBa~7n8r_|49no#uBv>jDQxDasd9A8&tQNq z;7L17{uRK;v+7ttc;fO+O_gVn?*O1?*Ii{q_T^2>J$IlFD^#-B9nK%0*8wy-7>8Md zqKp;CM4+?jygO84yR)@-3E)L$G0w>beoeL7%-s#XcVgM>0N>}=c-@=Osz8cmN!auT zY>)_%C6f!^S|MBpX9)=^2}DxZ+H6=uoMf0F%B&6RY7(5aH!DVtI7MHx9H`lj#UNnq z$Dt9M+wIQ3fBmg=vMSg3XLn6Rvp2#Ru_ud$%|R(gfo2MrraNa+!}=z5g6VtiI;?PfCG%MNGw z6D%ak^`;ebJQ19Y`F|dbVpNX} z#wVBg?FslU?H#z_Of1?4Vg!IeNMC!_nX)sfJ~NoO?96m~*l0e-mNfoUc9;VfvLhGO zb}j=lYp~l)79CvdPG!Z{vQsHdqp;EZRDt;sH)Xi0WWik&4kso6+z+|y`(6EjYOkc` z5jZn97}YIGo(T=kj~{?Yw@+wb(8ko$@Oxj=!-V-vzR$v_06GS39o-B|82KXVW-VP5 z`5Ea-wAEuqiGRujGKBDdeyeN`62raNZFQ=h?dt0r0Ftw~lJT7Pc>+tmk4 zn$(S`$O3%@Yh9=BlLb@tLFDj0du{nQUPl(|53B~##Q?uy305?nYmt+Mb8F+u6 z?ejnGwd5-(%|QCAt~awFbjsEZSoVTaU=6czRDXDfkI%0-4|K3%y0$tYf@iz&AwYl! zy2b}`qo+X-3-KCM52Ulhmd*3A*4q!zLurj*yD$V z>`6$kS_MwE7~fiuH4(}gMl1#dHaLOrNnr!DRTGf1f?Y{UCErb>R2T2-419$u77p{> zXuO2w7FY`|fq*~5`ozzLQ19jr{XDa2wzw1k$pYjb;SWy21uHDnS;ebD>pHS@QWp<=4)U#42Oq_Sc(`Sj}qL zjfo(w4wdV(BW>GuI>W!lcPC5X>(3gvahOjQ&0PR~W;0!V<6G%=T;BDc zY+s6laGT}68(%UE0<$DYm?2206=G{(YkkyIGk<#{e!#b8zape{ZRDHI9gW420hT); z&6%B8jJ(8eP(1!wPEBIr-iUo|sf;^A?CpMV;|Nn$Lp;jIyu#JJ95BMk$*Z{J-&MCd z0an_7GN9wH+~jLMz=e@JVUr+>280VZb7GrNbFI&Vj3jxB ziD7|l^__wcH<1dYM$1W_s`CsLD*1;H%nh_8 zAP0|5^zsi`z(n{!*cDmuan|P_2zMgvdGc`T*!3k8}ofYbel8i66I`}=xxhC%0*hTkoG@7A3TZ6*`9r1 zb7&FxRA-d-UL8`-dv!`_t<#V$Ox@QiwdW$dw;tk~d%3 zE~cH6AsT=_w{c=juZ^zTm?nz1i~@UXc!XHG3_I`?kPQUC#tuUU}| z2(Vh*bpGAG=I?Q1Tm;O462Iqr9%kIcX+Kjv$4B5w*GJ$t&NnhIj(2W!ub4z)hbijY z4rgiRkvY09bA7$#aInLMtgYacFFbDg^s^R$_AD*s~XSN1uIWZvNSs+}9t}^z8#}BEg%RAI4JJAD!I0 z0yCSU1KGC_!HnEXR!(O{^T(bRa}b8)#4viD1nxp4<6LH}<0sSGefVp>kq(@@kF0@B zhpHO$$5t&LqH1Kv-cwgbSop(MGcgLCH1L#%TscYf1hS$q3)6s19Q6#_wynklT4=Q90y_hr)J# zNyM&Z__eZH%jB<-aobNkh54T7v7BdzEbJ$&9s%j6^0Ve`&uYhhGSffKCWjTzM)pXd zgK&-do(tJqa9rH<^jpwlU&}VeW=7ex{G^;kgVc+zfMhmuQ<@iSnO-u?*LdtV*N;JC7BrcV|{C?Pb6k*Sfa6w*r~KCjBDf5 zglRR46DuML`}joYUq_oyxcbbDLww=GKXF(~b&2cAPCAA{kFQxS>+@PR`C9(n3}h@c z^eEq&S#%RH-RXPZ;23-BxiZ-_mG79esrZE(cOCHh~~6 zXW=e>w?GiW0%xyxu>f)4kd*Im{v~ryY!2fgic}|J*A&)_BBtFMZxsfTIYg;licdyM zg63p_Iqb{6<`&aocjh&HOYG{=6~WQ5`M&$BXUwYzmc`~l8R~+Pr9N6N`0E9~H!i{! zpvGS0tse7Ajcji&D=lQ7oHbESaqm%RrN`o$MKkW9#4F0kW4U#F~ALq)G>I} z*4V#=)2*GC!p_OeB9e%~bUd1)ko23v^>!7$SaT(>2hm{c5GHObF!VK6biB$${~TAdg_ zn&=cK=J4kv5oKTV*I9n{v$v-HsVTlk2FxJD(;=+b?eVo?dz;ZBV~qwkI0;Z3ADCnh z*h3_C)k*X(c)Ia3I;XI95qo?wSSS!uAmqWWGxJs=>`j`{`R6y}th8mxpFlFK?H1MP zTNBASR-Mb%X^LiQ?R!&w zEoFe=@CH6~FF%OpT^kEa^D536U2NHyXC#PmZakDmcl%|EWkQX?N>>q=qAgY=vfLLG zQ8lckJr+a~9rlHA2H;!gWkS`ubykP1SZ^twSAl3LLwT z1lgaDxJLcT0Mo8GR`p^0%)OFV<%+?!y6K&jzkh?F&k(#9pwCi@@y`%Ej5L6;XH%q{ zBWzAn`5m#siUxE&^ZpNe?*boHc_#i(ZZIUk2@o(MN|dOvphki<>7dRbGszj5KvXVK zQKG>qD%A)x5>`kCC((?Dv9@blyS1(T+wI!h*0%n*X(b_$1dy9VnmXC@cCb#4E@-TiO<7|xk<-t%6c_j#ZD<0)$>*48})NJ&7fWHcAeZ?&@0|kzcO9Anr=aikKsXHI%bJx(}&VFMzdFK&&<;7EVpMEs_51-*2J+ z%9>PqJ{2@sf?_AP8{lCODj72^BWb6_G6N=lNHG97edfk_#83 z;OsXA)T{QdV!USMN_`;Qe2HKM>#*o7=L!r!1hV9L@GPeUw3eU2B4^n3L#>4Xg;>~@ zPt#h&R0g?&(^t2DPHg6BvS}LvWwSBJnP|T$#e)@_)XdyjrJ1K{Et%@+F6-;ckbIA} zzR$Xg+nMgh0(Us!Zp?#>&*83oO_u(M9v`PaQXU`e(Vl1{OMv!7mmbCjL)%hb3`Aj$ zml6$t7!Z*t4Y@%CHc$46akhs2_7RWgOHiJo6jZ^o#7`R|wmp{iOV}ouvtD7&0ycAo zY8idhBfKE&tSZ&R57}2tl6v{9{aa%5E_55F^Aa=fJ!_j!DTThEf=i`VRqX9rY1Nn5 z28|@9Gk(_+)@9wDoDu@C$YC+m5rC~1&~@u5oJDnKQ#5~<1MaVc)4#Tu8{P%spj$0s z)^DD~SWMUYjt+{+`Ft;@#-b6^RH zMBd!U6CrfMwAJgL=?oIjEkki;&2_vAuer_Tk=A9n7;0M%$XkFg9Gt@n%_}5GbL743)p{WEKI|l*Ct$&w%<860GDVC6 z4t7~5@Tq_RFac%U7Mqur&2?)=hil)O;cMp>Ayall<`%)i+9Oxhh#ZzluGSR?+OwQP zm(jwdeOFDfSK`@Ia2C)}&Btl@&a(Q!YoX*@PouEJSD4|@S|kUmwqgD?Ov_dr);%t! z`#*TbAe^BR63T@}sl^`7NRFllIjHG`tgBnw+>;xf%ft`#;?I0Iq`=7I3JAMz_c-8f z*%dsIo;jJ;AtUOMWF?FRwt1Txiw%VoJuQVn1(XyHVK*0;)gC_<*+0M{TeY36AE**q zV5gjYoOQ$r33ytr9IG|EsGi9Yut@@BY*widLbmay+xiyq{RHa7_+c>AxorSQ_7~W* z7X$#LZ@IQe$lTfAJkdI7x#z&pF^v7RG5mor3B8p?1$M=32kE!lFt-LV?5Hf2&e(lm z(z_4a9kJUJ1%rM zG(~HX**Uc;q)HOI7e(xu(Ibg?Et@o7+i;mcer0~3<*6o2WxTivZP*!z%rqRUk#$0@ z1*Se7NLx4oktUl&2nTmy)>OaySRifg1U{UgKn6NQibmQ%tCbVtS?XsBQ)ye~FA~D! zrl&M*i^19Q?ITA8QI-ZWDkqRx&KfztH*uu0NX{!h&m)fEhK1DK9f)krwceb^KIExv zoEZ$#&^9cdK$pSZvCJ`nw8}g#KnZu4smyU&d+rgDv=XeA05fbc@-do+1(|&@pm`4j zqKhZ=w&#Y5wGCCZfwH;zE6$)gbr>d(JX)y_crs{9K=|JQVf$l-X2gEn0?HcNnzQMgB>MfLpxsOsqNCS<2*^p(uEk!Ex^;Q=AKaPVB@er`mL1$;eh_Wvn%Y1c9d1gt=!>+LpQy)j z^gRcLsY(BWw(eUz0=obn&#=p^vUX;Qlv%bfxaR(cq0R_+&XS`!qZ=&Mo@HInKC&lLO^rb8jWSM|02zFg`C#nl zh{i~W2nkHGu29h|@Yt`Fqn2B{O@QQoYhK*Hmj3%kxlf+~WnZg|^i*n`c^KMCEY7um zb^=^}a|a?2A&PIniL)#K>08TVVmf(|nN>Pf6e9B|Y+8Y0*s5-7L+!TAfly|Vqo^vj z#Nn(mb*C8IqOrm7LKw>;aWrTVgSKA$cFAmN-jv%TtUk8bU=%qu$tYfLeZ36l0CJAK z!2`J-=8B8a+gylU{eZ1WkJ&v+5#W{1|e1}gmr1N5?!?R0-&^<$_ z*+RV;(cpSER> z)i<{{5v%{BuWVI;)^Zu&=)ILQxvk{ZXClLPny9>yH)&d=M4pj=cB$4{u zllUR?p|yw+-NTT)BjidgVvAB$SDWWEYYIel;?H>5=lZ=C`5l9iL&|6=FCu@M`UO3w z`~Y@YGtfVZH2xm-99mbM{^FVB1=D&VExe_H==^hx=zP{LUyo&ek;i0byfi;FvR8Mf zhlX*4O^Rni_hkoMTjk}NOuiVqajKfdJ?1{1O|Y(-BToPJTy=Si6rzoKvHwPjh@W;& zb72hw5N90gk>5z-QjAJUCBW$g$U+EBzjm8I+90X;RUO1V_>hUQaH4 z>fKs^J*bs4~4vH;TG*lX^4-K7#;hQEw5^xVV8 zmp!kWdx)jiS~Ug&pE|b8_TSW|L8JsSx&nzd>AE!9d?}xJp>sUMsal+?m)+G2P>|PH zyGJB)VyqH7yZ!#7iF4|Na z%cJJ`H|dEmf{B;;pyD?ojbmwTMEHf>Tu`m85-tbw6{Tamx(|<3xU5SHjT^~d)(3%a zIDQH_kjfQx0H>!n;$bfLaGG-Y%>HA)Q-y5>7CX7(!w69TEl`~yw16*P*i|eb5G%1y z)!uC|>XzsEqLF+==3ENwOObskwlAezjGKB(ahtj#*R(i?Td5EEMU}Y^WgBC8zFuTP zzKp{{jTFi0{V+S0voQlT12QKO1QSn43EVglcvRzeb!w6CBXtP~wrY3~rxX z%~b``YtS3PHVjvv7FkEj_il1z($|)`d4zyh#&foZc6>Itp{8suRuUBy6Dp?@-pA`SB#!BbLPU6ly? zpSB+0JndgIFc}ouBdYsPTkY?1fTxxd8^cp2&stb|H>l9hSp5D%+J*SVu`v zRG}ky88{DMy-z7EjhMf%0S6vv4W!K0x?-q6dx;+?Y*0f7MEs~Bq$SDbM?OYbah3;* z3nsMZbe5hP3FkYHBZR&bFlM{PM+@`0w=SSkZNobC1J~@gMMxuZ*LtLp_jFN0_2*}W zMcfK)ymY|-U5bK-?~$q3He8*qZ4m!jn>y7dyCEXXIqC4E&#v}!g6`0^Jk7D-+SfRW z7rW5wJsKYEh_B>ykY}FQ>@=P|D9`F3CEMkY;K5gUz*$itW(Dw!yW$l*r@H-iT_Y&6 zOujicSx*4d51!S?vygCPECG5>uvEo3U~2QHy@`|vz+A%yM7HM|gs)UnkA(+sk|4lV5l3AG z27|yst@{v|5QvCR7VfzpW)yyZ!+z)x%sRR#_D+{x z+3a?E1Z=pHgAImYSlpv@qoG!)`fC@_wS zKozlTXXhjRVXM^31occ*6w#nL`e;?0MFY50R8&;29{3_{%!kyCK=zJrV&{NB1j0%% zFhso^84{j`hXX%8^Yr;gf&c0mAfC^lkpHl7XZg{P5x|1jj_4`9Zc+QjZiKJjNt_Lc zby$9XY)LLehnEu@>cD{k%))8>aRvftzF4KhptrzhzU|YzZ>i($cKo~Qt6Wd6@Fn?4j8j9y^s}<{`&EA-D>3Y`6BI7(efv-3{NUr>mT5(JPCb;6s{#ycfE=@&GC0wPu|x zIGI=h$y^o~r2jVy+5_{=@gRr>G>b(-QdA{kDhSg)g>QdW=mvgDp7)kKPmql&aYM$? zX%RwogarulaTm|kduJ_j2Xm*3wY_{LDr<%+35yT%6Y=jEG_?d_w;uW6;@gH#Z|gZX zTTXxbXqOEDd1+D9&s9_=eDZ-3fDxAQku-hd9RkBo|7lZ(6Y>Kvt~L^qr>R(ERjul~ zc_Z2H3#o%WQvi!}Wp|(MQO!vK=DvtCifgBpOFl zN_l3TkchfP@(3pgdGv5;2^ z%7y;Hzyk|%1; zDXR+Z_{TV|QeS+|(6?#|<7Go1rfRag zU>BjQsTr3OK6NjcqE_rf{IrMiZ$f^r%%rvgE)f1JnoFlb6y5U~9bFP>G z-GZN8n;tXZ^ZI})2#5G3ezU27cu`vOBUle0n-Zzjzsha6={i}?xz~tn){wi};8+ov zE+6S$pGHLxEXDC`_w?T6{q#2P^yj^%)#@ocpT8LZvxhw|?F5BDpDsNiu(_C6=#P@& z`}H;d#G0N%D(}^|5~x|G-|wqKj54wvqv*Uq%huqOO<_hAXld7)gPc8(#rE)MRhsWv z%EO1#g3}2~pvUH?5rJUM6gYIL!e5pa)Tlo{vDLM2_3Lypp5vYVid@-CZ4x8vED@PY zGUqMRu%;rVfwq1IA#qSVZZSN1_)lrBo={F?cOpKFf4tLs-J~@?tL0F`>GXXyr&wja zTU*}?_fIhS?MC~-tng}QK9lA-ES=NM!`|js0Cjezi+ILbY(IDCjkJe4v^(x&Tq32F zRWs_28SSs3mz<{|JjQNzB@g@U^-}inr=<4hN9-eeM6Rtq6r-x%W(5IlaQCl}(BWX@ z!^G-BY$CN5!3#i-yKENQb)2-ZWmd6kyVf$C`}isbL|l>GVhI9`n&w2V7(D&nzs8=w z--a`3@(+>%hg2&Z(r?2Lsf-o>hd;5c_`jyMls$fW81#wsS2}3Vf(iQEWj$i5-J0CQ z%1o0^y6L3f9NCSzCh#=aUh^dEHK&Q00%Epn)ozh&D5&vHi7$lv`sK2rCY+%xG2eVb zZLkzvBsyi$T4uAUJZwCVswK6(`r)rMEm{Ati+^p{>l>6g>==`XY{Dx48K0Rmx}!Vb_eQoV>2 zj1g(%PdT6C)ZYHdZ)f#-it`DeEYQ#H3e8s*Ax^}>YCxb9W?a=}?on7lTmQUA^BjqJjzj+^&QhG97k0<`D%U~*6o9a}R} zO+7;>c8FS@j(MA(503MI=c?stTAVnN+{d%jg~`R&xLJVQp9~L$H-FA8PSf&7;X;{3 zbryOkF!(G~S!nwA6UX6u#?!AEE$<^}=ab}d7(CGzyQhX7Dngdw4~kou995x(an6s! zDtt3cU>hFIhDi z&@dPsVb_hAnUNbge?)X&ZJ#)J0LwG=AbA3)d*vrlpbOfc0V$iBUNIMxz0*I<_9@2X zhv`XxxpF7xte9)upDO?9#ZLdLim^V+Kq|!s((Hyrmk>(LZNVub2(r&AA#EFawnImU zn@)BF^SsSFh-@KWxLyd2y&Ez*E=srJ_?znA9)gXYtH22|0celsWA7QaH? z?lIrv>zbIJsr{lukB#gifK%OmpGmx_*ZbI;`$X_iE7;T-n>D=WP!7x?d=;dKuzP|n zCD~YAha8iBY`ulcZtz7(cJ#G5)MHLeUD?d)W;YY9^{db+qeX5SOBMGUNbhJXFL^fJ-2%H zP!;J2w8I%Mznh3RAwm`v>&O63H?gzde2Hf_AxYlFABwNDU*G`(Wr9DR_3)kf4pH*@ zc{`w_&JIeLrc_qo+GhV-v# zQL-X5za8;7N{5~k>!+tR~Ul9$_m^ZW-XXpW2U&js+dQ8)K9Tk`EA;+kI9 zy|IXAM&zh-#p(Q;zJdhX+J=4cTl(RP;Az;2^h%NCe~DjYtUa3Gi`!02!JpCIgEGFY zDEVULo0QaUn=tVG{vKXu%hQ#AiM%)*p;phqcaitscS&{cNv!z3K;-r805c%HgDsq? zZ*sVSUiD%+TD=`ImLPW7l@|qEcCj_0(P)cLN`1CPHd3HvZ!lY|-5YZ--|j^c(3jmL zu`rvdSkxVx?6LMaSDa{&vUG*mKYy8Eae+uXccDGJf&RB!jIX`OP%l;8CwIhqM7g~?SWZlo*~dV zcL;O}$UluaXqHM@kOa69*cr&Pc>N$~MgRNVKfa3(>wRhV?opq`tA^~Lrqr$(ftiD< z;%v2D1a_6F!w3mA2c?L;uPnJIfUD&>l60Wm+?XTYCc@k z#mbJw0!dpZxr(?6F?p4_0XWHZVk5;(s3=gjI8VEWNYfxN>WD)Sa?#B$9fit3h3pV{ ztD=*+?Py_OMI#5MZE>DI%I=8{H$eBY{{qolauFsKd3-4x;@o^AHfcN1LL(j4 z+v5bSFV3G6opBP>XSK)m{_4eGys#&^9;&u01$g zxb}p`;pnzBodxxnOED9DOU_5};BG6x8s&E~vqt<1b+P+hrS7RWUT(hx8&Jl6Sv=?- zu~h$aI^KUjWc>I#lP(5FXD7-V2~r|B2BLT=7-N~Z-I0iQtDG1jQ8cu5`?2VS6I8fK zjx(RREzz!<&$#S!9_K+hW87j~%~uU_t|d<r>%X8mtiEyr zvGGhu1aW;|L4fuHU@8aB3-qPdIx?~sm+H#2o{0!`gjGRd{_SpRT2aM~u$Ielep>s8 z)Ey-##JA;6ahyG(L!eBXlmU^heXzfb+}UNeNg1g%a^bQk$+H^74t><~mADGgnPG|X z2Y85lATj_gqCdrI=2;M~x7jxXk$4mXmDudpF4P*y&+G22)7g3M}}vIp^e{l9Kl_VZo5MER62vrLeHe2fR)$R3jW(l~Um+0;j>3p#sTL?4i zkt1uK99i@8btPP8tB4Qm3=3!aC%Pf&@?FkQW~aA2J#xM0eahvURgyMYYyL6|!Z}nm zQ&_eWv?t0ZxYF&2TT;3t(eqmxgg7am;A!>hbcEgNUFyZw`>S{Irqiq2B#<41%kHLh z50O$*I(Y}hP8WZ^3+12Sa^aU{6u?%3L{>nrZJ|n^Ic1zOJe)@D^HiP0)>lX)C4FWn zuIx}{>ST^oc`~Il@$;Gg;5mA@FD+Dvh$bUAF|vbr+0iObe4>QS=5H*2qxs9`Zy0}! zOj-Q}TD&uZ0qqH|?n)0`BkRc4|Afg#e+ivg_84AcyUbn4Td!?!wfLV{aa}Z`+h`LRYh9BK>qI^1^4rEQ~&txA2aYjYX($ot!lq{s@NRQEC`NJhJ@8b zsuF>1tqRdANx3;(t}cq)KF=ZAbgz*vN4LD^m3z=9%2w}IRJl+TC4|burPynRpp4*^ z!DTw`1~A6*x=1;GM;kd$8qX1@eL>#VhmR)`v4w>DXu~4VoKxCWQIrNgF`{W3Pvw0e zx&U{fiaf6QJzrO-ODPrY&@f_7yi`&v25%r|fZ+&T2mZSTmLOwgjd|0Ok{yv(o$aq? zMs}wMT-_^N%Dy1gGc2T3$51j-OMw-nBhriU(hH-Glqg0tbHCJwdDTw)8oZf9#diG< zwL+jPZ~sVR5o9BxWkr^0%`z;yJHdxi_z|HLNITC#4f)7}B|<0Y9Hjja_Ja&LGztp`>0m&yt-kD5n2)dp87zqq_=ek=-CxvSO*%6t;xuVu#wRpzooWD1qC1mT1{zRlZa%Jo^p7^sZu~tP$oOaj zwV%5IQc);L-&v*;zZ4jp1d8KoVnHuUt0E8BoMn2FQ|DEq z-dpi0D{hY(CMegMjx^7V1koyuTeWp1-G*yj-r zmW)&%m$qIOh>TQAx^vA1OOw4zY)vlFSq#|5Ed5Zh!^1koMtv_R6E}VZm!7+ss*hVK zf&I?R?g7v^uA8y(GgK|3E|pqD@rmJnDJn9p`Cl2752O6%2h>d$xigV!w-iw3<9CN( zErG43GmpoF`F4j7txz4_%BAO7D*coW4+5``^!N@{&8Y87H9``wfw7CLSlZt!);~Qt zjj28*C$sSQo;8-Msl43oSrM1`tk2o4_;LluPN@n(jLP6I9C;xw_foMI|M!hQ7!;Bf3pMK^T~KyTDm87FjcXpB{^__zkun||7m25O{pMWiRRJle zT2ACYx!+58V^>2r?e>Dfs#47^;@wW(2^&z2Fn#dp*mRPrtN+N#v8y_X;_(ZKT<+tI z>@Cxj6E>%>e&yD+E0)$?j(ojemTJQ6D{4dpJ?fx{d}?r(byoP@hFQ3tVf8RzE=v*^<07 zOKDSOE;!Uw%=Vy~kbwx4pJ!H}yGz9wxz>Ou6NL#3i$K7z18C|Z+e(kGQ~cQsGi&z- zq&M_TLe2Z;k9Ne2vDV4Y@`;)CD|uy(dPpvjZAC`n;HOP{WYsj1#-Q1#yGD#()`~Q` zBfM%NM_blD1D-54{)*XL2(^@YJES^o{nkj|s9+Y#pHNx!(rKM~-Y|Si$wrhlW}rrM zYpTxG)QQd}i#jnPZ%fw6`ysUs{ILD^e1>?6!5%J(lxD16DAF*QsTRIRRH}V{s|=&{ z(uo|Bv8-=j-J8IFCYF_JxApBy5{c%g2DO%~D_4TA7jK4@Lo2%@Q7x&%KGUPmh<;6) z?pXqpC%u$>y}~<*Pkyb(JWZJJWraoL*Cuh3-+bL&x@uf7t8CSz&04#KFVN+dIpa&Wn|GnZ$w{<4=l3SUw~up3;Hh2K zgp)wh0LW}$5a)<%!?)+C42)@;g|iCG&^)&w0v4; zIUBD{ZGih3LwrK`cD0Ffyt0W$-B+nLak~+X$QGAIubm`^SJw1%L~NX#o!h}}!{rxD z{@z5j)9AwfL5kmQe8P*}*3mLqdIcK*tUEEj;n#wJc3J=OTR}*YYYVvJd#q>yDgm!g z+UWf$Mc{=zu9s~@$V7rotH;e=Y@^)-W5_^fiZ!oQM**1Q8Nj0GaQ zS&7CX+Y0_pXZFDSg;$Mp5I~zS_@P@3Gb&(im}Ag91y34eFM~{})QE~bF~*V#{zq6f zCG4^1LoPLe0&J55k%lkwbwhy&m)NA_HxyiSz%aY8!~DHyWR!$Y3@z1IS+rw2tianr}$@nc~R7G`Y@{e@Z!h z+(aPXR6|i0nX6v#n#Z)c-FjDfkpr4e*lvS3hI;HaRDl;n4)*cEjNYy3TJtQX%k1Rm zOtI6RqnGAu&F9DzVxJ^wW&8Rw!CF_e3+`2U7BoLvTSKB4bX!~B$zk8(2hx=#Gr!9^ z_1$+#$Mc2<&k591_e$^UdaLSQBcgkx4K@5e(DRH8HsDKrXj^B;GMD%=_81vh@;vJN zrdqu{)}c0OOI$Cs=If}J{5ayO)@{xE3#}!qHDVizrF?XQTJ%V#VMJGg;Z!sClPI;% z!1cV2)_7hc_tBNr>T(fO6_UIS`{qn=!w(m#Kj58n&{8iE}C3Om&4xD;^0&z|F+lHFpnkIH*d6EZz}We zjO@~3q386ehp}YG2fUE!aOy5kp;No(47S9kIe*}=Jz@2Sum*HnYaYWxS^RVMVFY7t z@7W?E??h++oHE%57>jk^+cInK7#q*N@s`l?o3CBQN{m1tcqE=0UwiHspCw9m+gn|KW-L+oN(P>5%8~ zA^8;@TJt5`kwTDD;adU>qB$0bh0hYTG3cUOU;AQHlQRv!dwC)MaSmc9EWbQvZ{$yD zOo871#&DfmrlREps>G;-Dmfo(aS7}Vft~hRJN&)O*7v15`r7v$xtLSsZFCe+i|c?# ztHfg7j;?K(U)@I;(cM;rS0x;wvEfz69HEinRUeXhHoWQsf`1r^9r2f;iBBDYokjS| zn2!THxO28ihb7+J2iG6P=?oqEH!y52*`aNIc~tA%G0UOuQk4^rlU6>ffk&M*Fge*k zXix*+8EAlxUZqE#OcVQhkdX=&tefw2R*uh{@~*q}mOTE(h{--aON*HnC6xog?otOk zfFkqtRYks?KV8o7z1C~HZ7^zJE;+QxBWL45Q6$OxQN$=vkQe$HpUU?4KwQo=?eI}0 zZIKSKIQy1FW{hGBFL50tri1O%&9#U>cjVa{cM6V5a=nosA54Me{$ZL$@*?OGDn*DvYC z#O6?FSZC#k^!R8x7s~PyDmathnUN+T9&CpKQZ73fhB}x}zEmB|O^Woo*QE~T6E8{~ z%y-$OmmTodh~gj+AKSlumOc4yLM5~8&uS#vBBgWJRVvRxr`SJk|EJ7=ov(pxA+Uo2 zufi`R*2=$-gXy91rMfei8(uXcEtC!GoF>%GRZyUpo?z!WvR1#@2YesU*0=T3f;x$@ z6){M7so)9lxerUoFq^K|A&gWNN$P)8nF7IY3M3BDhW(}f^RuY#`&_I31pe)ZS)94hYiffOB$;m|~8Ub&X+0WP8~Xjyr~_=w%!n`G@J9@Cixg^V7Hk zMSn{B`G~C6@}zSQQ@Xfg<7nx7itJq6(UmU9OGxY_ zCHi^Tn*Q++b|uNFmaP>m7rGfwfbl|LhL5H#&k7&S3Y}3}J|=VmY@lI#)yO$lDnRv9 z0jJx?XMvl_$E&mO+p4P>hWXF36n>-yZcZqU5%ooA4H<#l_NhG;0s_MPCL{8gLayR@ zx62w29^)yFun{>QK8Y9hzzhFG(3`ny5EG1G)Qc%K%=NhN?M@WN$?op58j()e6K4FK z_`qbApWrDzS9fp(%tubyrPV=_-1v&(IEn2DX7%{Ux+z3@SeMQ4w>mUw<9Z&Q}eF-Ij^)0 zSLG7W_W9s&f_g7@-p1LQwRPWU#}?cvSfQ*N|E$zANyYLPSnqDb?tZeQ zKSx^YHFpo9&*b%u6~bi7F*43D@3H#?HSNo_a$k8jIom+|Ac^JQGr^?7Z^hxVOg1AD zOgCe3ghs#<$@*T^(U}Ijl6B-E1Ojl&Le2+I-t;d(RAL{uW4DNxip``dfFOW?SB?Xz3MUi`+Fgv$taP~cjW&#CK?<^^)zeRD zI%R*6^aHX5R#|`gkO?bM31|+h26}`luE98wi$O#NVJw!)Gh~i0`tgVaB%P(%!A$en zxScxD1F0-joES1HvV#)i$)LI7m?+5J-bCC3$6tOFJiTOxfTSL7s7;5EZSHLt2U%0k zhr}TTYtT-0{DkBq6$dARVFo7Z@&bpIKRH*7MQTC5>mV`AH}?|bdGi}1JY}b^cyNp( zs3VAe=_HXaDZ}4C@=WBI^_vV@w;aC|W^+_~vcRas_&rhp99$pA4oEJeRmsG7uX=%` z6GhE;_?DTCR)D!Nb0ASPe+B$OTvi}#sBpJd;DdCI5xuRrtD;m^2sXLpeQrQW*?MoM zTWdbVFX{dmjd+*BNG6c}C(OMx3{&Sb;p-%=Xky3O7lo!Y*EnNWpcpVaT<>dhF@cBw zruUr{V_+yP+4-fyz&^aSpN31$x@lX)N+zGRaaicJ+hmDTWSwaEJ!MP4#bf<-Wb{ER z(QWm-lHZ%xYeXpCDOgi)mNdFXF13+v4Gp zMEJsYzK10jhD)qgtzo_yH#WfnI}+o4-ms?Z?rrW%Bm`J21zq=RXufto{V2C;+>@=dWcw<2kdJoQlZ++o#M-G#QaXDVN3sq z8D%xjU<0wN3dA~lm4(ffGf}=2-cq`^J25`S5M)9o6HHC|*YaDqdWHNV7ashsSjw&j z;^v;%50ZX95Rk0dbT1vYzCuK93Y?QHU?j%7qyU?_CSEr*w1R*fXaucRmHz<55Gi zI2>fZS$j&3CG<_LQk(@OOb5gVxPG??ql%PP(mLsoFhszK)^fSX0?Ztx{Kh%Mjk4uI zKD8dknAtF0C5MFT4)dhsDNoG1#ACi{eMNd8JapMv68S$(o(m5srNG9C>Rjr+Fq=um z?dn;5@IikVsICjg|; zli!~pmvVMWBFIO)|1s~yG3`!;eBGrt zj0ufQI>S7(+KNLo-#|n~y(oC%V10#@PreBKg?MvL!*wY(6-IPUff2nK40~%)+(n6k zV7@KSGW7zZtlGIk5Q$N?v>lj3Y+@aksfIG5&l1!YUot%0yKM2Y5fc`u(wT=jK!B zEHH~to(!SnP#lE}H*s21zl8$B(mzM0dw9uH)^)Ecy4bq!aT_75lWX)`TiM%>d4K=y zF|6ITo?STfd2rKh>`n(%{e_NW4#&!|v5ExIG@uIh zMpw?T9$hNK!!Tjt3@l)*Z!kP_;S4+#pPahiJRDtEDsoNEin&GU$2V{V4VY*PhA19o z>?%#@r*eOv4P@@5>_ad)`b>Lmjt*X!Y?{YxlJ|5Vl>ONC47Eo>^k6{=rHUrhyx9$Q zsWyKrMgukG6+GFaku$HuI)_nn+PEz3j_>mszMK(BrXhruI`qvsxq@Db_(x*cjXb@G zxANnScpl6>SZC36(VNNXFI;HK4tT&n7#0{OF*h}|h5o{c&Kake)IAn{Q|immJnS~} zVIb?RreUZx7q~?aSCOynluk!4ofI!oV~UeWIV)}JXvbqo2KL8)Pz>xHT=Y#jBVk~Z ztlNzBf&m%07$Ve!n*^kpJ5YP24XS&se?_5b>-5~L)c-{Vv8+uEuahcGbYf`vP4J-=2$XTBJ!3*QKEf^yBO}%^Lk@=I}7ceG-D>e0S+hV;E%r zer#JPfEoW{V)i5spxVyL!Zhpg9N@gGvX;eSR(4s-a^CyMK5peZb}w_rPNqE@v{mOm z8(@zsas2)k*+#gGuvte5cx4ZN_(tIq;wM`L$mIYN!Z`2sn4O|^wC%;0e(@OVdHnYJ z>lTgnO2cL7R>TEG25n80+QiaH{^?l+w>7xSwtPWbj~L-ul=7uBGnS9C?jktQ&~+AKS8zHPHRQkG1aHd z(hne?)p9G!Ky|9;zM01oVqYD`r6>3$S?TmION`0yNFP9J<@vawE?99;58s~d2wosc z*N@a8EY(20of&C^1})tR-Zk(xHE#Ck)lZ1McUJauYJ0x?tZdI};)iXLeQOI>zWyti z74>syxBo_DId~yI;XZtA+EIz0t;493C?Y`^N^`BuiMHX=1p!xe{_>H5#LhtU(gi(l z!AFG~7-j}Cyq;?G0)M^{@B!HfKVxWDelMGhIlx`kZn@H=`%CEXWRz7sStQec}s-Aqh zMpVNEj?jdA2iAM+^^)|Br@{Ef1W^wHX+WgiV7P%bpQ2hl*Z{w8|(3>@)mt z@xNrg-|C<50yW79h7c;NNmtXG&4f#lOBZzX{G9W7$jTY!Hc!-@pGYEXUg5j#6v%HzTfmZy)ES8 zX;vYvJmwx9VN83(os(WlIwAMr+;T#40Y?(vzwvrZu}pxH+#9_f~J^EqY|$$Z@cf8Ebi zS+PoKd7HNoLG@PShqjrP*78dVLIu^5r7jPQP?1Ci?-^4tc4@5klr}m;S>|v(I!vre z849AjJ=SRBmm|U(E%I;?b{#dLCBhN9!wsjRL8jtdiL6(xt)IjB zQo*YE)3OcM(G}XJ8d>)>SFrA9(iiM2FT`?YyWy&+xlP-2mAtH#m)Y`CY|8dp5AH*d z*w)i0Q@~Wnn3J^LZF89idvRpE|G}I1$qb#`t&zrj$8BS9h~Gw+KO`vcD;S2?El7cn zB&f!RUkRT&?bUYLSKk(h4S zn?q#-FNY_`W_C%SK?NFsgj9VzC=J1F|M>Brp8>Id#(Q+oG0>*1f8B3lei42(UFl4o z1@2`H+^s)THbJ3LRwuF%*?yT|?o{+>Q^%Dd~kP=ELo1V3xSIj?xHF~%aB0^7w z55I~8kva}+w0uA}EAldScw?T7^o>9L$xnWAGXQLMm7FhAsr`)d^c(QJN8&EJTDL6b^YUsrqbAE~I7R|`9Hv=LM6LNXZc^vdi|SNN?VJ#Sf5-9e@?tskB$8>R zlf#WC_JMcWXPu=c$S zX%wI9r4?jf6GNXQ#a&jJw}#2vYwgRkarkSzBRt8xM7M|N+fy$w*S&u~HJdkN#^vDG znos1EkORNTo^56E*JER3g-pz)s2?k9u_vo0q7{ip=NZSK*^@Y0K}O7-Dfw_*hry($ z7Jw{E=7B7~qIxCBGO@4$o{VgJKbMmOU^r;4J#sXW92W@a90-gyUI`+UaeL9JBiRHI z`ePLz$P_Fq#K&HI*&k*SBusK@iV$E(^vk_g!Z&1gB>$%SZhKRR!JMidpvrHQQ%dG< z7bUbOX3ryTQ{z%>tfg<(4j}f}?0GU{x~r@491-6R#Lv>6xEzXP-P89{^w`eU%ja1m z7KrxwiL2&$U4Lx)qaoi>phF56QB|ct@g4ehv@SW;k7{C_Y=NkUfSJXP5Qj8z{&!G9roGjZ&TF=@Wdcwl+Im zLVkvMEdF^*Q)u~WaXk3XBccCAUwD8xq(}sj9Fku$@@GhnTOqwIBK9lkli8y+7bpb~ zI#RIUI6%Y$9XVM3V@nsWa1Iu4%&tVdu|`BR9K0f>x?+a53n_-z7S-&w-mB$2cBDG>p6CBqAZnm2{OP*@)Nl&yNc?;E)*`}LYkK8uHqy3^CKlVslIw1~289Mi_ z1HsXfp+R1g!uCLDc%p;cJ@Fq)Jf(+$E}?Kig|O0l2zoWtkb8vk7p>1i(iK8k46OXn)F&?aXkqt4HGa z8>XTGiVS+$dTm=u&qr{IQBKMl*3!er((rK$AA_ac^c%r%m(Nu;!XhSB$Tovc zih=MA^g-gV%b@eLJ__n)LQjk$CnmiLj!3tpzkJS`pj#2GjpIddHs? zK1d}JG+9mu!NW2i^hbXrP0fm6;{xmM56K#0PYf2od9ekVNLJC2T3`DBVqS!Ev!sc? zR4ZZJ)v0lbmQ&_LSFxg#@Zzv0fz!bLU&O*yAxtPsDYaP)S2m84^1a*BH19sCvU;q{ z9D}-mv;=ze6veF@DP8~n&cI1YdE;PxhAvFN@d||hm?e^L0FA>Kf2j9uZ3ddtTqQrv zmZxFLNRgCAL!>RAWpiiCgA}6UY%Vs;8{i)>UlD2(l=&=1UFLg3@E?u9eV~v=XCn01 zS@O>a(Y}_gs+N;2DUFEdf(}Ue@;X_c1gt_H<z33Vrs zx^Z^@c_)&CK?^BpxEno^I`PCnKZL$p^?T4^H+1b%{Z@xv$stagv4f}X$@6H{lGU3f zt&$UNJ75ZOHM2IcRZ5;p>=M!d*9)7z(Ou64N84v)dpU$kM<_F~E8fEquo+&HwSCfx z_Hqs!h!fXlV1=%y8CjtN*7KPC%XtA%2&P#o^eGlcg8=vcSJdXm;AfoAK7yXlzfb_Q z%f`;u$71J~`fYo`6G{B^S=jlb`es`ng$-H1K5F?0>s!AS4mq?OyUt)zI~8CL76^x& zWNc4K5TEBTW>f9j zW@|VHDVb4*-}P=HstTEFg-Y?qPW~ZwO9WDnot=X~*0|q@jdc6WaI4f4%OiYt`pk<~ z-lBYnvscbHOybV2yZiU6vhfkynRqesPY5Y;^tBI4yG_FMt!Q-61G zzmmUCT!6pv#c}(^Fu$$l)O^n;Dv!4;)O^q}-;-7FL?;`9NrYVKx>JhDf1j~8K904k z5xY6_S@RP7DUmm5Tka6+CQL%0njfS}^Nuk85*zptx!4YjxZQeUg=wfwP(HlU2)DG& z4mbiJn6qXIwJThCY~=3YTp}+LI^(UW?NC|%45fMS*O8I$HA2y1SST_$w{@MU-K2@rP@EgkKa>l(Wb6 z5(XkKwI56`A3LFAkS1hpQM=M6!v!Eu%Cy8h}Wiob;8SSW&d^GPUxMd||n%p9$DUtciDdTro8*merG=? zB82+RPv?hY{G9v_LZY0Osn9PK`uZzu5Jp@!tp}OugQ{2dXqb9Lbc)m5!cx=QwZ&ZN zsg(9dzb3y_hl68*#>)%%o5o*JPf(Rs-SI?cPvd2Ifu!U+MT|iu-&UgAA8jB|CCNXk z^LdCNRa;Y!3>h^~k>H9cQdBv&sPa$R<(&iNUy<^&8~o;0431p?CkGzEM^Vfc4_oj%=&>-_02RjpxuOeXhC?(((%$-@*5lGi14ZmNANs9hQQ)@HN{L%w0X_EFnZ(Qgz&0#hnPR>#l9$M z|7Ink93ve)9k9`<%HQlcpUOXWh~fYPv@0Q~ztDO40vW4Yd;#C~oBOL6#aN$tA~YQM z-vOJ*VB%-$ayIX=++Xj-vtuV723AW%+$!;>;%F-rQ+zpCl|#eVh5bZSuymtA4Q!6! z8R3h55j>ULESdSsCmLmqxdf>wYb*#2|4ptNdT7LNrWJ5WH!X8Prnwt`5siax^Gn(E zblP&%|8vOjvLiUn_A9~IMR}I^V?IgVJq<5+hI%nVOM;{r~s~ktXhI&a5voV*h(c^-6?xtzn@^q9ot6iS>%{Kc3bpTo4|r< zF~+H@q4_!PGrHNqtA3f|SX-Bw`2MjYM%}!^qP4F&Y8{T8Wrc+!ZpviE_);dPj^486 z`36MFakju|T}Rr5KVWF)JmJIkSg(AQqqDBtNJHQ%1*9>9%9V&^yf`>AEE`qs zww{4hkt2y1!sS5P0uEOI@3=z0qL75Th~A#B)^^1>zxYT9@3`B_x`4oN(Qu3t!$V5IFd8fVaU-;fg7K{Iz-?vLx%n1S~N z13i)kR9neb1~vGx+v0!hL*=-}6!c8_;N#HAlWMCIp+)WTUS(87M8Bs(*-E&|3S3Rj zVTcvs=cXF2uPO5BG;S36G+dESkV&quDcT7Gi?u>KNtpYciSfg4M9)zNZrE!DoBCjI z56iAmNA)O00@;gvbqBe)MYUHAPaZ1pFC=YnsYn={DE#$P1C|&Y)vOv>B0le|V#wivz zF0&rJPknA&+$nN>?2C8g!^hi>Cd$o`XOfR9BwD51{AuR_|fm%q;YQ$|DCe za=Oc-{xc7n`}LA}g$E-q6_o4;A1p18&O7s9qMe9%C7!~AAfKg?gSjPJ%cGt%4@z3U zR|p%{=c;mO>j*N$1O*E@_8Fy!C_yGNa=^6MXLb&mum3u5O!8+#;suIK!Eat$Lr^v% zvf;rAYF*{3A_UtPb#q3cFNVCYrMK}cvCr%+&qMZSnB#N^d+ck-c{<{YlJhipV`7gH z=_qLFZF;`s`6?0Oi8&TlzxD?9nZLCb^}Q6s3h}op(;KS;Ee@0KVS8d(KmEfPI9U=(FZR`K6EQ-v7e*|zTRpGzn{g(} zXS+Jjd=+14X6tOznUE}UM*B-yktOMqjxb^OcSK%JYkxUo#G-WUqf!FBOLP>#h_bH$3=S zD$?xmqA6Q10a$A3h8b9r4CyX+gcv30vZr;4f?8C9Q#_@$*M`Oeu^vDcyGkU{0Ev6MbG&>%)45_4Uq$Utj#W+u0(7%OmcHkEl>2;8 z`+x7N&q=IlFz#5Ps#`K@alMEhhvOh_EW3}u;92@Md8@y&Cl%@mbKuCLsWFYbYFRP-E zmfYhFnRVe^_C377Q^B!VUxJpSd6M~eb)m-*Jh^{O)!8TgT1vmF7xy%S`akjIGk^U; z3IhN-6xL?`0$cN@3-ME{wEb;#+m8;&`~qI=BtkeKl3VS*EW*l~aC zI;U>F4br`50b_FB-G)k+=ggi*^lp6mT zYa;%fA8qMTS-9BvHPVuomX77f}!_prN6$q zn4l<(ES}NJVhXW>*LHbHhGmkDY_}*Hc<-@ecT zBeIqF9}PxiW9&HHNnCbxeZ~-67R~=CE`x@afF}k2>1;5df}$g{gh57L{U|Fh17OQs zS*nPOZ}KGkr5}-Ta@KU)g26mbjS0Fzu2EpHY?(t%&{_hojmFOuj zQy9^uFs&FlECA82{qrNTn=r1l$!|}xNIh3f&uY`W<_Ge8Uh?^p^Wo%AM~%NPj}v zy_G88j&}<5{ch{bodQt@)QZ1PR4SEl_-$@5Q!aI2AIz=KMBtHi!?95){6^hF>?(cJ zBC4|DkD^A0+QbTgG7IWCn8klWP6q3iZOooI7an#P`V^KNCPAV~EE6i;F!NwSvHb_# zLl#c5*3K4!Q){_Z)ilg&R-nGyf#roN1#+{#`UN4>9w-!b73m>F;I>RR-u66; zbX1vp%xAo29K=O>QH=Lo$UPKhtfhblHKHea^$hEbvk2j24pU*Y$Z5R@2y-y9GeYIwN>WuU^YGwE3eTLd*Ye$8peBxQ0)=cfYcY2u}Npp zX$aNLsUFKHDM81{#WlBvwhFBAFCOKr!P0KGbt7R)72RM5?@x3llVeO0XWTv5K*cWg zDk6YJt~q!V4Od%SQuusaUJO`4ubie5k_TQe*o~ClBXqS#=xXwsr1EfJj(kn39Z3@q zq#SZob89NIkM);7lC+@g;~I&QhKW%J2O1k_gm=zP+97b~_RXiWWHL2N87$l1BhLip zWHRvTZY~V-Lry)`$YG^3He0+lIE#UKuh3{sr>I;8G9z0DO~+jNDAO_X6Q(2C)A~>9 zshSe08P-Zfnz5`kN7*0T7eTv;&SkfBFH^c#^3u_SzfLh3p0e+#(_1B2FiLu*^#xu= z1(Q}_ZGM4?`w|mmz^-3a(yPbHKf?Zy04B&91(VsPg2Jx{C7o5Un<%C~Rb&F8jqaI5 z(}^mN$6Ny@mXxq{zw2q98~QsAJP6L~JJ5;Rl0M>$$yJSk{Za%{fpH+$@SL)C7f z)eh6sOU%44SdXnBdF^0`V7zu}3qvyTbdrlnx+$B=O*avi*gkAP?hvLEmd`f;2dSwa zfZQZ3;M%~h+kAyRe1`1d>Q92!BVS* zr&wofp;|4O)~`RG+9xXQ+s7{!kObwL+9$`QeFJ^&vL0h~lFYvzt4g%&5COn!c7@X6 zV_Oo->f1?xoUsO~lYw!j*nWVq@fO2;7q-$Z@Mn%T|5-*vJsGh}hE(&*PpBqZ?PN{K zvV@KF_I}6_fIOEWk~}2R$;=&F{X@wCEp@uW2-AG+g(-%eO2%pTQHV+C1&Fainsx1 ziU9a0vfmkJ*R%Gw@&cLA#i|gKeVf4jM}DkWH@f9hYQk;JphQK@db;wNJG!OssQt?kfdXT65P=Lw1k+?=JB z27YX})q8-o_@s1pSwp(NOuFxvGnVcvT$k+HA-Z;Bf7d{LT>^vKKiZjO`CiH||48}c zMO8yrAE0G4CB5-fp0ebbehPz7QIH1)wOt)fC(FQGph)+}o$SzdjK+K&Jeg&mP#pFB zh&*{Z`NelQ>z%g;!5hHVe^{!sd>Ei}++nG3<~)5ix5CA;tjPIv~E3dq-v`HM4kWl_ntGkAgJ5zUi$y&M=~?#@?M_zd7tNbpDSTt zx^p0K`r=0na4yU-d~eX)@x&x{Q+MO+*Ok}#?TdQ6Mf*MwnFdtaqtJrUN_f0SrD2sV zd_N%3I!3V(a%ItaJ&tqi2BE$$6lZF??|z6d_I;4hTF6ch$pPuQU-cWCxS`frYW%{C z^xbwdnmtI9*n|Xon-DSy;v7+DLVEC-u800a`PvuQMxd&jxJyFsthp=*XASu8Gr+k5 zoaN3zxcb~iFxQiLfh^wv^W~DKE|)w-wEN0Y8U`!;Yk=CPQ)iC~NXAMoMv5~;txned zko)JS)vI2<_&{sRn%Z8cm*)yR=6W?48EY_XBvSG99*JQ;?3b{Zrk9AbtsDElhyz4l zxrL6ve$9@(*p2;0xMGGM!v6byY_R{dbsqL_7xtTxSlNxyhSgyIEj)2x?5}6b^nuO6 zuwU?b>Z$(}_G}pRzVQ)p&;8&79^S)9f~}XrD6yurmMG1OwfqtD8Fgk;LvB$CX-JSVSh>IZ2P_U$;y@s+uCbl(Z{v;Zjm`We;_1FH3ML+JOx?JMD|YHe-FA;Mj#uVU z3m{CAlMAk>BRGW3$!|<8uIXH6Smi8Z@~VoZYf0f+U85=GJ@6ix>@d{LwJ?9-gc6IQ z91K2IT~nE#D7StVHu+~wpw+Ap0>E5qE@m^Qkt(TXB6&d6NKL@`9q~y4imorIiQUbi3UxAWERD&t7WC5;l{+21ZVrGvA)m#3V05W8%J09MbO*V$+};kfnGOBNY}M_EHxS*dV5`EI^K_d48FvLqxw#x9}u@W#HA(RVk?e!_X3 zYL;qQ9UQ22<*)zP*1dSBkSxD+1RzgP+W$XQT)-S&3f}TP!Hi98i#FB8(kFfYDb$zF zzTWvCoNAVO(I5hNE+AWaJQQ<=4Wf!yY}^(T{|}`JR0SU>$gk{3%p?BbD^Wyx%?AG+ zXA?8=y(kH3ww~JQOkpzZi9@ZS?WrkoLiLnbbff!CjDV_;x;|8SLFu9u+9!2ht~(ZV z4zt9rg=5~7-~*#d`7`WTayls8r(4p&7RdFl1#|(ax`vN>*@byjMz}3Ll*v>w2uo~mDowYHO(@Z(gSfgf@ z8+kL}#vCgf z!)Cd#6!Uwx$Gs?6EVzGle=%A)fEnh;-tQ5Z$3NtSO@xL3@XpHZCDZ_cOE*24FnmC z#^0bTFO=xt=;fs*uX}#tkGdai*r43+U6K6Jq4)?wYr=NpxYdnT|5cg(jrbsYNA^2B z?Z=e#%uv1#b*sH;ubiL}G0u>C%z6$jpF7BTZUPfW-N;PQN|}kHV_<%oII7j0B5!eN zaK-UPyLz#x4EoJu+Y(lOsQn!2s;tgSOab~G3>?V>G(g9?@-)p9oq`bI8+3HA)1_3jMgty0 zxpF5zQ0w}dTcjZ888O3pF1vRQL&v_KNytp`C$dRwytMJFphUkIsIjVr~9fdM|DI}Qvx#0HV(?|fysejat^<+ z#9Ap2>8%gg0i9J`tacWcYIfyTGAr>iw`&gdcMVjU{C?VCnG1Svp8L(_$=#Y_A$%Y@ z&ny`qsoYC&m|j>~gu?!GYur}nPZs*}@fI|>G;_G9ZF#yW-|D~Ke_eNbdM@;P<{H<_ zGKclx2cHcwpPP zX*oaD-0qm%hn4&A7I}oKc1$~;&IdUHA9dcqF%f#*hrG`gjryXYQBOdlo`yz^?M0)E zKlNXQzL$CQ-KS5r8lo{ooVf}>9*j8E0ziCDMc+N*)W_r0Bky){S3XoaN8V*$!MNv3 zM39wW+trA}InokryNF-j2B=A2UY>6t_8SQQZIKF10^CPO;|I4(-mcEnjF=IrHDI1rzi0)Ou4#h;na z6x-v^?U}*!o+)5Rt8y^Oahpj09XZfa0n3h52O}@|_KOl@zgWL=5;JC}$QvZ&Ui6rB zr5;?FR*sEN+}_7@hy*i9)Z1u-J%fhl503yN`K8C~NvXVUv!`W3s6dcN$7|8#da6~e z>*wLZ`N-*VYYs=mr#*z|V<8xe0{{$0J^*;DdOiRTJPLd9#j*_NMo&PS*u~cFGgw9- zqx8_6b-)um5I%bO17rqb-|43!#JL?lti=6>YIS=mW>3S6E7#J`vQ0(aq;){RT6w+? zJ!hSvGGiGOs^%))rsFT}uW2@e@S9*z=ZkB2x^x-cXbS^lM}bdmJbMdK5!tunmvL6a z6~}G=H;BrGZQHR=8a4E!XAeC64Fa_Y;Ft*CAeAmydrL4xeLf z|EJnb9Gab4OrcF@EA0bWxBchRPn)KFwfb>6n#l^7f*e`^X{S&7m6+}ZrfcOM(UiHg z|E!tmF|2!!JrV}#k=Fgqk;Q#yBS5^b7YnhhAL+3tytgTD1T(wWa0A244Es8fqgPe; zGu6I0VIKAPm3dTR!nEp2g8i19?mtou2Q0NXzmM0=lXF-3er&JrhxPhCq~|*w&LaO1 zsxHy(J6OTi?TM-=B*(E;O6gd?xQk}N?;jC85 zs+WYa?wB+7Wlc3Z!BoN(fip{vpv|J(sS$R=!FQ*{^J9CQjTnW$v5%})5v$cK(@GUG z5PuK3%OCy-sr;KPPPbH!@lU@zsoclJX}S1=i%aHXQnz+L>s!_3ZSTe;85Q=nsy{2M zy0?R+BbwunOw%_0=aSrThtj~_SgCEy0f!@OGp2+Cab|CL8da~MnU}z-;`t}pWLpvIg;3WeKNyqMS93n|AXLeX3nZ}@l1OC0?K=83) z<(Y!uW7F_Ds={-|Xku(<5*aG*H%tJ<29>a#KV*uDS9Lmawd`Z*i^vo73ZnEEqRt?@ z0f#cY4_5sLhsjYVYM4?KDP4y-D-ptrBNPMmxKSqLxAm?c9lwyaUR7JUC#>{5s+4TD z8=kV0t8I5}l{_J3L5Vk^EKUs~gb;VPsp#RRvb0k}`~x^s%lKE$Kf;GPvg-y_Hm0Ud zz_WVzvKa+=1udaS>e@htz@Hhmoti8zL$M_rj}(0>i0<(rk?^pOn9TYALcl z5j2ZRG!{Iz%vj3JSj^Gua*d_GodR$QJy-H_g5LSZSa7AMWE}szvGivwRTJov!A$c9 zb9EqdoSmM=V5TvcSK>pBQ|7bovkNqiD#r1I8Ap{F$I2LkQ3T6_Q)Cct7cl+~IHqko znxf`jxR8Iv{39|rT*^N(E`-bZ7mlXvfVD2KQb55p6P^%!aKO7ak3bEQAADfIpZK=i z>Sqok%bWUJ>%*qI82VwHxyt~-N=Ivnh_-l_tX^AG3TTrrEsAFoUi0I7k6Mt*Dms9jkje6M!(eiB~>$NzHQ3Gaww*Yd!r{${_USmbC|x zE54drQ4f;diV{>!m)-EZ#EixjJZCYQbS(>lu`gB4idM6t)vRbWE6SEnRkNbiVRG>W z)>Y@Rq!$R5KThRf`OkawkA8B z$qporgSpl)S8DjBYM5&cbFE>nHOzH-VBJ6ucTzQ)?qkby(|wR{X1X=rbZg9Xbru!c zfGIItCWSn1RYsW8jZv5=a!AFtc0Xh8Ze4kjhiAg0kz5j9)%$q$HG^mOdn5@N*ds3( z`?~Rrj1@?7dj|zuF9+NBHYC_~L=FMZ>x+Q#FZ4yg&7T+nulmm+;LxiMhJc%U5bzIY zc5mo&|5F>9%{*T#a>7ly6&cI718(N6Ie5Ddbt2|JBSKPkcoCT_re*bIcg&PWlafZNLtV?a`pWmz6;Xr6gg@( z2(RgRjzmzlI~gy^v4%J8Reu;D|7lcv9^z6E6ff1m?sSdC<2r{Eb!}|M9d7v*LkYl} zG=@}D&If0u7Jar54n1FJD8_4}bQgT24e~(x-I8)Zo0XOYy0gBYRXL*+v4l5Z>~_w# zAI_-Pf-9l~JW8*m9b`LC3dEnA{|@0KhuhAH%277ha=L7S8Od|OU-q!`K2|!ffN}b( z*=0%v_ysKZb%TO!vix#W8~u!J7mUc`DW5gN-P<)>l_ zP2bQe!*o9(qnqk6x>pXu=wQ0k`74^jXs{2suU+PmD(y~pU*QGzE20p)AfR_FMJ z1cl@0yTrXK0v?SU*10|I%Dc42RJf5C6_#8?Vh&R}Z5w(8BX!{^pi3cl$ts@Z+Z;i? zg;uF0D|ZUJp$h=m>3_I~YmL>ZU&y1vt*h)_{X=5u8+A{5whs66moj9jx;JpiCXEl& zOt_J@>pk(K)$^VQ{oSEvdY98B2u9I9Jgf1b*v!d0-yQRy^45?{Lx#y_o#B^jOunuB zDGdo)?7D0@X@^?6Z+dsi+z(zPWu-_rn(cZa_zXG#_n9@P+(X?h{~@BgQ+IGmq3dnA zuJ3w4VRYzULh4>$z%DZghAMqnebnj7^yg(OX+T82TLPngVH_=d0BJ_3#55iE_TMRl z#FI^xX#*Dy>O^dI7wNhm=&j$w@PgM)(OfjFLvpj#$lRa)eoxkFS$t8xsvSyLaK{gL z7YxrdF~K?<3gRWnJwq@)^oSOT;p+x2$rR_VtQ)vA!tO|IvHU6uLgf9lBcX+NJr;BN*3_}^Kx zDB@=v@Q6z3H2K2o*jRreem1K7Wx?dnwb`}voRRXvPOhqxTSvV+qeW?8=MOppqit!RK}!^*y5hJOaZR(NraXf7EMBV@_A9p zQshN}5{5W$Q&a%C^av*j;e z4nN>nFfw@^XdlZ=r;={(jlx>VPlRw%C#MnqVSjjw40?&6ptQEhqdq7mqZR4fAYutO zT4B#myez_)yq(xx9(^WKk(im-iWYikqL_fcL}bxWaz`wlZmtZp9@AuFPF1Ouq~hX_ zYAc$`68{vdxVkLy9sb&hZ}7J~aVvl86Dj`IC6Zkfc?q^HM2g@H8sfEJ+vVm*IM7o5 zvtZjiengY)0kL2>)cxj!?;g8Z-11FL#}??LM9Wsxlq-`}b(39D(-i-_QyV7b+N#b$ ztK31mpWMA|Vn^4i{6r{Ham~!ck+F(viW8$KXjju%IlU$^gt{}4#)|3)#kJczCk&Sa z@S?#F;RVLh%IB+Kl_g>l-UO zf^E+YgTJE=3B{a9B@fP=7*OIT(&-%f`aTog{0p9-C#=yEkD##e5y7^9;fkItL|&^b zbpL$DJLbU^T#l5-D~sbp`IuN7Y`u;vU6D#8=b5m;B{S$_qWY-h9KVTWwVXA<+gBk^ z2XAk$Tor6POARAkf7ZqdSBokpHm*JRK%qRS^2R-x7-VPL@z~nM^KD~zRF0SynOuoG zCoh%C#sS)RiQO46i^Df2U+4)B5>6Jg@VB)r{St$}urLy==Ez4nqGyao$s}F5^C~Hs zl=1!iQtbk_)6-t@)W7kRGj&cy)ttl$x%Eqov7G^>-!Wj4{+9Y2A<*mL;9fjB*|;%N+W_hTsFMl+vfwr1YWvGC%82 zP>;S5mOJ1L>5w-Aexn0JT){y8HFo;)6-O&c#ZY1CudC^#*;&*sD*aQJH@4 zq)(6wT8NR9iULQR`kn_!_jiA}J)k%b`RdaaG^hVEXiO z1$)zZ+z(CL;+}q|=F<5i+W6?{5R-11II{#kpF^9q8iof+uFBoZ3#AjbhTI== zmy9PlCz!`qz6(io3ju%T3;6B_9JA6rjxc6p^ogg|3oIhtxfQqb8u|;9>;7H4!Muwh zlw4!-Cot~@A9za8ea&vT#bDqq1_MVcVx7Qx@Et9u>wX=?dv&0$uw>?XFu2{f2TURC zS;VVeJv{zB0XRo_Aq$;GTL-n#% zVnoP2lT1l5hp@q_a=7#O#J47ZLmNtB>S)z14d=ZZp;p;6JNaI?bd39rD=;zu^# zhL9*}=@;`2s~gO{sO&a^oq6!jiHnjYtxi5m9!GaSTya$fD!^5puJqU5=SoxqcR zip86FGUicgKa$fRiHYRQ=M^7SerizVrv_DyJ^*Q~|E@@*kqd-xEG z5^G_E0n*cu`)PF`Qu(_@Pn$hi`MX4e=I-xW>;6Lb+WoP?WB9Y|^wIC#H5_-pVa2#6 z6cmr^NIYU^S7*N6%}L_pxlw&FIkH|+CKmIaN`w*4-5Zy@_6B&j(e2>wvTo(lUcmpw zcR&me;t`)YLcw@YzLV=$ih<_VX$X&M1D**6m30Ro_XaC>fow9jNt9W|IG^VBh`$TX zE6{=BUUa}}d4kL_4?NwQ7^G+AS9tUQAKQ(LoROF~ZFU`qd)>Fa@#OrQ_Fv&X)S%Be z%wF}vR@xjC#vZ?ocno*x=mQXj5q@9g%-ah+?LF__yAyo+c*=ll>W3)9Prii%#>Wz# zgKYj<=ZaEo+_tGW>9ZxvIX4V(wgE8rUvA!$^*JEu+9!A73L~45J5dXM@S9{9lECW< z7m|-jw`$5VY;~8vB4K4e!mX*{<5hsp0%>5Ab49<85)aO$l zS}XZR?@waCM1N?ytdCu)gTRt^y$xeduttTK^IGq7mi)`lvY)>BDFi-+!2c`+q*#N& zgbS!4$f-tV5MoF|?%JQAok2mhziP^lm+H=k&HH7}-;uwwT(#sV5mD=47MX&_ycA93 zL{r<*zHQH^Z86jONV;I6?`66<9Pm<{m=Y zHa?^wblzZ6l*N51GHz#PIQje{>3ZYuZxM$R9>&cA!qRYr2?w%K@@}m#r*$O1NsdMS zvbCux)G`=}GxP2pM{a0&si0*;{&EH^5%P;ahDF_O2E$Q3-st-nMx2^q)#+iQat@Fy zo6TrFVBPXHPA%R$2X$L-Zj}F{ar>9Isfi6i&!y}ZL?u;tF-D2;OtOQPkw3=jNGX$; ziiWG}>i%1dD}xbWzeAV2B)E`Y40$-l(>fNL!_>3PL~2m-I}p=nIkQZp184C5=LUdg zJJ0d>oqSlSS>;a0xak3_{}yQ`F{f(UL#xvT1t!}@X0WEd@~b@SHhx{M+ur;1LrYo^ zqJdYQ%O|gzq2)2Oh;w1_eo0$wr+>J-`68uq8h+9;rE(&Tizj3G8Jvf8piD$LjFMDO z2HWDOBY>*_5_7&3pEM{p;U@pq#AG zLe}>n^k^TMdv!c2*YU%*eniKkKB{9jo52d>;N6pdE4TIoPF;GCG+wz~S{DGL4AMJm zdl3G|49L#_1cEA|y-5$=-RuiXJe2AiuH+@N_og0fy(}MacrcGR*9`NfA4yvUL}PV3 zG@qIS!9%xv1PD(3C=m2rSD9qZ@jx!gW6iQ&@KH^V^(lqUey9odUsfL*y=;J9vcIbI zsDh=((v7bZqaT#bo7}Fnw_k<6oHx-Na^5^Z(!bB{*Q3#h%a6Q`&`M$fQmrg?_Jea`!Cq z@bCbsyx?=6ma#e@U;kUZX#9gwhAW9e%p_s=>mM6y9ezZfOM{$wb{Y)+Y9S=Mpq7Yl zvI`J@LAv=p92|X?hs~3=>}rQRwy4obRU03~Q}gmwK7I%1|Ckb96xLP@Oiaa68soJc zG>h?tC{}Bj;w{EYDtVKO>2u0Bi%P`~b;@&B->f~0;04jb;bev3e)Jr5EL0yMMum8j zn4tELA?d9=R$)=aQaXea0n|F?TO|L2a&&E3Vpyt&Me@H~o;k#+Ew}owtz5Na5K)t3 zad50oeVHwL#V}OIB{TJhoRq=kZ481r;HDb9<=c$Nix=yAjt(G!p!qHOh=w1tn0}FB`^2VWk#MP1=f@KdCC<0>qTGd zq{MVy^41LdFRo9xIxrg={PZU4+?^4(#u+4(Rdqo6zqnx7V+qcnj_|K!;+(-q`83UMr#;tm`Wn<$>HFmGxuR*i|i|O z?^x&+TZ=Ie_SZg^a9=)lsC_?WMAI0N<;(yoP+y~ip>B*{e+H#_?>OWe)xMoB=vbF$ zuMZb!7erEFUzv~nT%&3=+tMKAH+jHv+AZfd*0{%OIVCu6O8@K0%>W3;Mg;kpMFDrv zzjZ5s@E}vg9cp;*Sv=iW+mQrwg=yAG4@_Od2bJk; zC%2UTH52t)J2tnUt#pA}^W)ULjd2C7Wu_dYDJ>37oyJyB;b8Ora&`mZ3{MtnfB4z| z*)_e4AM3qjvWGS!wT3_5@Im+^Dt2l6-SG9iLL%9$63JdCY4?L3>qk*9t!GaXSu49< zm8i07sw>|MuDF%Pl$LU)@&}5p$yz8Z@Tr8Ao>`Lhz!JRm@44@ZB^`9G+|i2jbE+Z+z?2rDih9n@_uVa^cuzCyp49dAuJxD5nzx^s^Z)N<3GSmN+p7`fS(zFYgCUNkK~7cs+hlJto73@=kA~QdgDF6Xm$8u|5|%~wb%4hrvc*`RHX|Syr+Xs{ ze~)?%ov-qY53RwRDHlbqkrRY4C|<5U4P_P&Xk$ zU}qnL1=E(5Z=slXF1O0XGBEZ@OP^bR0mHZ3`s+{g2eX_7=+W3!6d7}vk69zYED9%> zDS%qSjN#JqKZZJ^a|wSc$=`Cz&-jvBT$;LIeCH4ODw${;5DZh#5)@=&2A(F%80wIV zOG?dL>vz${l{_z|;nKU)9M})*{F+bQSm#3#?B8SH<5Rb#M_B3EWM1Cvd24tYmt`%0 z@?cgUKRFG%j_qx74s&SlNls%q>)Wzs+XnAw*V=%CsJLp<1*NQ)`$L-UhOs!fM+%9> z4jOp7Z9LGqiy@lr?OwyrZhG}Bmp{C9h~go2C*&X|=e0O6zaZxa$?P$n+=gA&g z2ircw7Yq4U(Hb7s!U}Qe!tW(q;BE$xou*`pH}9S)jArO{xwQi9TBF}B=IM5p`XHmN z^G0isRJk^KMMOuWtn6&%-P|xRn-N}!&ic<0ho}!6)O#aPb#DY}H3$TyM~>O-i*(L& z45`kY{Mjyin|OOBWvI&YBiz-_WX1!7ZQtOV58qhB1Gn)jyE;oLH%`Jhyir zt+I=}ZK4*C4l|#})^?4hL`3`Xdu0s3Bg5068J`7{jAd@lBg2zd6UEV75}f^5qQqoo z{)E{99u08&0bDT|#;vo6KW-l%v#Wi~V&|?fGn6aI>fEj{%@Z>SD@pP0Mg%;c=V@5_ORSezfOuBt+?$zD-%kKEhci zCELU_a}Nb?xt0q)^Sqp|2ZA3ktMq7rAlH{)N&3OyzP7n1b^;IP!aonm`yv0nyk|(> z8a{u`zpw4}{^|RBT>m5gzO>uBr{B8%nXVyuf2+EsPsjZ!1U`kp-xdT+s)(Fvn(}aW zK=*Oa582LjrN%N{N@#}jCo)7JiAVyBP@bt`N)t(p(?x?~Bl6r!FD7nz*;>75U0``R z>S5NLog@T>Wa@E0_ggR6U?1rlx)Xs$eyMQL#?*AApl2f{h);PPB-SV?!g4-+>Bl`c ztsJ5?^)Y9OEiDNR*P+jhrKZZz=aAGNiAo#CW_H((;`zRWG=aC zfV9cn$`JIo-rl|As13r$@YFdnYND7F&MSfrgYuK7_XRI$X&ev#niUU=?D`C$up%wr$$SJflfm~j_50S zc}A-E5$M}IYxI>D;~K{LG*8^s`5*&4cy6s8XXPV38((jGvbg)iU2y!~)9Wj-RimMpAM@>} zzU|m^aYH#Rf;&fzAL+p-Pl3siFV|t)n-(#I#yE`!=MRIyU2#g+Or>?~9 z%;=|0nvt7116fi+ z`9Z6v5rJW5CetkfX5X3hT_BT1QkxHiU%8A=KxjI%=#0X1o+>6MmF)+?Wj%8BhX5$| zU=x{jt&?*w;Mn1q(~{B9Y43SE&p*GcGe#V@<0_7Y_n4cWx#}RDpVxPi+5(0VYa()(ev%~=6N37dD${Gpo8?aw5Kn#)jkTMeeCSl8(6+`C4C&sed79_ zwrO_1#WLg?vKF>bbVnelm-L;MmseN2YGoP2?>65h)nlbU87@P3$xTx<)k1$6} z^oZ#?j5(f*&Tp<@l!Pis&u30e`{9?Q{%$>A{6l&^RX*GO3|ZPtiZ+vO?J4)3YiRS3 zo)m4dhR3I*3YJaW#lHMS#8gwjW!g?%Rp(A$;qOXs2JVGd^n>>;<=EF7a}H0>B2ms} zaa4b6d{)Cg*m9D6k-f)1h;r}cG>1*ER@<}wkVl%m{gm64kQN8NnK`M~xOIUFjpUch z90s>vRpnKJSU7iIHZ#CHPIX*NvmVb@WZ&SZGpxidzDwsoSadA4gxh{;y;M#8{$j%4 zmZtYp`HYJYq?e$Jo zouYG(?@zAZ9kGh}P4U->%=7}Dp=k5v(b>fDJ#2(m{P2d~KW}&*dUlG8B`pdpYoU zQV7c@Bh$TJ5)r2~KC|WYyW%ta1B9S$XuWL+zWx~XYFOXu^oQ&wXj?e|$gibLsXgxl z{3UsL{jjFvB*5KRhJ-iUn?*etm&dw>yLz$7u-hLCb99pu#*Pto(Rk@Uhv% z&UU!(#i%0RPpaMLSb6t*-w|ocjdY)hFx~=mf)Dhcd{_MB$ydcsWO7Q>`E`uLY8*nD zml*^Gy*5JCMa;eR-&8AmmR(YiMS*Or>n(flON{V9i@#RQu+&t%zGfGq-*YRBl6iJ9 z-$`6j=$^pu;L1x1hANH8)uVVUloRx~xJu-b8K!G`^^Y1Fj}~7|YxBZt!8ylvUo|$L zbJRNN+H7|{k8wjixH5q#4O)x&^s&TvJcB5IMa2AXYD%jNKFlpC7MTbM{mYbV_=SoI zkO@wMoD%TLxh~+#)3&kfO!J`NY5xU^d9}fWf z54Qdziy)D*xR;}q%GH3um(!Fs;`16=x%@S*3MsG5i4(gj5_wC=j;DBj#LwWHm}&SI_kablv;i zT+Htu@*6Ld0*jOdfvX2|E7u(svmT0&;iOc`k8Y$6wN$ z7nlxaYq*KCyR3r2iD|ZTHqyfO_<)v*w!|4gsFZ9VizXSUB@m4_ax?L?W-tpjVmaF? z4qY*IimG{?i<)|qztbYVjRUVLR;rpQjs2N=8J z1$L?$lG?<-nmVgx$weSWvcLMjxTKB&BpfI!31Lqvi;ACMM6;bY^jW7Z8O8oL%_{u9iFT85TR>R!L=JsB-^A>h2)#t|Zu{M24tTui5(RldJ0#cjZe=6z9Mv+$@ zQE0_OO-$2$^ys1N<$@9~fdrPZNP0?>w3cV3W90$&A4hZBlrtw^?pn6~8~KT!sqs2x z7Ko{C)qHxsnYmGk=V&H7i*2?&UKU*0Sa8^a6OyOX`i3P(*y$-DpC5AG4H!jfsB*}n zKiMhHcd1$qan(?gT0G8TM5W{4Inq=Qh&mn0lfR=18EJsIq8KZjqo$WB<~o!E=gRR+ zMxZ(Qj(zBlXagXYk9Y?0PE$)JE?D4A1 zb$%UY$;sineEhfYtWO*L>p>uVj>J;VH;AP1062qOdH$NNDR3W*EKvx>cFWmrRh%7I z(p2kMaJPV6xhX!A!=ib%DlkR&%JYq3yHr=0w@JrCW#v)lYGjz- zcYAky{2A~QZ=U~!2aPq18p2Sa`Y74!bQbMg?=dFkjrU`FVu&G2^;8>Q6I}VFg5e9^ zAWk87UQRYQC;Ciz0wUo0_J*5HCt{|8w3yz8CT!RkC=uV7_&|(fU z@Y2G3ug8`%P4thrVf-0{vg5mIP`(6%kJU_~8C|Yi6Gv~~t&m8rHN*06nx{$VUo)w4 zP2%~7kV#>xgxaxX8o}n7aM(qxGCdpY=G;GE^4si9?uFg2;fmYHd2wc5u=P*8nf1A| zQ!AyNCpo)U)QdXqPs3qFHij;PRi+;xgg*@O^agUsMn3~%Y-`3VFW7y^V zo6LD9%=p0fsZda+7bVXIQ?T7JuXCKnAQ&g(-0ZN)0lnG%yT3>L&+&|Bf#T4 z?Og;i9E^1)E@B}tuozkgG+WfZ58VF+tUP#^f<&>%RY)ic+5NjvcmhBKb31G0^z~~- zZY3+>3fuW6d@T;%AcYoD|5SP|a_r#{AIMm((@{Ha8!3CD7YtW0m#44g6fjuzVuw&K z_6Q<0$EMFC!f9H-?GF)WML!>YuwP~ZgES2SaP7Db8t5)K zTS)^o>GS%9AIt}Tv`m2hNHn_2I8S2*;pNT6H=BaXtb|bo#i7!0+<9x%1?4PydTGzx zHK9F26S?Om7-8YBtb{Wfs#!TrgzRiFr-FKC1x%pU`F!%Mg0M#;#3*pKXf@9Fgce*B zA8Dn-{W!$xC3A?qV9nj(_@SOG(&w^B!%m)3?#vzPB6XK{5>DM~j^{8ws|4{jdy^K$ za?D3+N+CH^=f}`-$RQ=hvn|~1mY!h@BRLK#PpC~Gd^B~dz7iwA;n4lYkzJGzsYX$; zGn!5W9_9||0k-k+7~fiY^z|qlLY!ysP%9iJSg-5;^#c|@ahiX}gi1?6oH!S27em?X zmR}|{c7pwd*>S5Ijhfmeth-t?qo*K|d_cAD$nbo;`LbgfD(y48J>2qqmg zRgwT?x!}K|vUrn?tHzYyNLAGsl%V=K zBRjX$-TM`iUI!m|MtYDI#@v{iRe}|y#;lAF)1oO}J(zou6D=hGUDs4y`Q^OeikQ*m zJyKH4+|8<5$)#mdNa#UNH_>b!;f%z2^CYjCFLOz&B8~!yu68I==xkT?X>ByUsDzS$ zujTlg6AV6(Klx|z(UYA7vV&Dj3fOosGW072((bGeS(V!sy`WR7Mi2ohC4J?l!p&g% z=AlBvK~dyh9DH>0qdHmFs)Bg9YgIT=>8#0|4p&4@EqZX62mj;0fGuQ|#197sR@8jF zce#+u_WGI-E#!6nGq){gb=27yp;hl3=~X~v8dNK$Q@Pw0T{cJb&dX^*{3SGA1GJsJ z_NrG0oaMxh4-B;mK$CobD_bpleil#gx7TzVDgAAG8!1*J&nwi6eu{UnqS9^%oaIE0 zFEqBDROEy=?S|SsPU**w)|H8o6W&Yi?0+gBfO>jr=JAF46X-maqQU-^KxYv@B9gdk zofoM3NzG-A0AbQ9j5%}g?3&9ZRC9USzSLtD3$Qiw5VHy1@-1Sff|4&}V?y5$0-{*f zVuZZF8Oy{T=d0N!&{);aF}HKYN06z!EJejI)SC4LLxVT`2mseQtMvkkix=ZZ!!@JM zzS?nX$QKs`R}0Ev57VIT^LZ@loK3U17epOZd){bQ%r1^|2$@<8yiJTN3Y3b%#M{WO z&67O?SV09CqoHdYO_>U)J=ATLogV)1xh8>JVBE%F+tL6Jq>Jw6lAT?jN#@>34=5_c zc%)Ywt1Hj00e9&aU=*4bk=BFhvv@bw@TyFVb9&h$Yn`(LF;XwH_%odGhZ~mpnx-pt z)=PYe5+%yoojzLm>4I$!4$8|r%b9t4Av>B}d1!cA+vCB>C&!20962PPIAQ8MzlG*( z2=>uML-Jv&XhC`82!H?Z}nqVW396WuaOG>KF7A~MxGxRd_b&|>7Mk< zS%N@8X?ej3In!EV81tu~dfWD;Te2J5wl^Q+Jv%&Yo*hM)(jYjc0ot~Kd3jYWlaGK1 zIDAzy5~WrYXjCR4EI$(MRju_Q3x-v7MGha$M4#hXkgQpmi?0PNi3MFXlMCW=By8@` z#p&AQEkKA}U)n7%*v{uo7#jIwPf>2)=EJC*1rkyT>LpXpn{>9LH4Nj`-xMW^`w5e^ zn4G|Myy;Fm)T9JXoytQ*x>03d;wxyKRNI2Q%%I)-eqoD+S+76^_tV!RlWegYo;6h} z?s9&+C`xY7B(Jsi^vYm}!=7G?#UxAMFmEI(tF_U;@ zhbFN{T*lOt`q*Mf;w8EIR=W}-{CY@e1E-prQZtwZLDm@5%}657I(Jz>^OzbSG-!EA zuC|rXqn>=ea!GWUiu;|UIG8Afbi5ev?l()mfs5}>Z10`}@b~JBFb%uGn?tB)4wq^n z{!4RUCHl?*&(wA9uLgN@UI+W`oGqEry>ZlNEGedv-LUK>B#bX$ zDhRfY2Nf^|I?s34nNc(+QWHvrbMoCkKHI(OIEAh;JE_Cn0rOf{Fb2)NHs7AyhD9-Y za-m0|lTT|=m{xtuL!;@UUog3vEA*s(_K39smQxC)Ew~_>d{mkVqnepqp4f;Ei;yT?YVnWNO<@3Ei=IV@$cU@sDcP3JSPnS zts7$L78PUBPeo2C%p518gVZW5aJuMwW5mk0cs?IHPh}DGQ1aqaMt_iuoie(gvETeF z&36y_G*d`qi#w4)E2-g}z61^C7DL%oXK0F{Z=EBVY;ENaHMw9?rZ0Y&2~N&Uun$T6 za0}5?K}l`uhk}6Vu~Q(R5d#S|Vj%I!8quR(BiHjSdB(KI3R#J-qRm-(dbc*`K`!F3 zmn~}K3)-AhbPF_PtT_L-H(3KSLDO-$r``w zlRlYQe1MgMA7#FLfa`r$G*fkeC-mmH16=1#g9e!qKGTzH9&1d|YpVv4HM^>ETW?9h zI|{9Mg@j)@snr)Vkj*lK{O_iEc#|h!S1!&&D;ff*MhF9|2Tg}#ub>Wva+qTEPn;od z!1|noEfEUkY0>i0BcMO*@~v+5q;ycT@b#U#(r*}Suz^4%STY>=oH__Dj_}^R> z!v97-Vs*8tt2vAhIQE%$AW_Ihui>2YP&8H59x4CovBB22AR64hdcu3z+Ehb;r?zTnR#;}9gsR0(Oj&%Enhai5$mwNbF`J6w$7SXL_kr>{6Cx9wWe zfP%x*my=vk(!~hVj=N=!(KKD&Ra0CL#~*PCj$c_)JCI*#eSl<1V{encSI_g0Ub zgqi-OX8IRv`kuagzxf-GB`*8K^Z$yOf8{5dKVu{xHy$jza?}5Urk{qR_Sk-YZ(V?M z&i`Eux1F^yir}W|3eUxptVQr9L8zUY^Cs>)sBM~e#!~aQ;Vm6YHBsUDO#;_ZTa=k% zEzesO=av&AfUvM`AQ}=J9(@L@i<5%4oBIXEZRY2R4) z!%bw)7Lz1N!wI>kPA2H#VEIIpvB*Rm`4MsYMG^pF>?6xB?#RzhBl&GZ#QG)DC=kMz zcN5ufNvvYV?|ybff3C{m6J)p|;v_IBe2||wF8Dx|vI`AnoDt{x^33U8R+%coqaHD5 zl1!;Ht(05iBb9G04U((z^VYa6sjBg*X{Ds&<*jrx$;8%C7g;tX+-Q}~ev@33^WC?; zNHs+Avb{q^he*X$qZXZn9|~cL-cWO6b7qgSeu?abDtj%jdWkCjZAs zI{#r&7Bl&Hz^eRUF-d)AF`-TF@CG!W_)$I{^2;K=lo=+MtwAJ!j5+m%8~`P4alXSD z$5R?cD&~)mo0Yk&ob@%rSnoaZMMOiJ(7xm=+>BO>KrxhOuWmPDrvIO|rAmoA(I$;>k`f+k}?cB9>}njSzdlN%sX zu6NTUur0QJsn>X2F3j^!$-R6mbH$#mhGMBNnG9bUJh0X7Ab;vU*5NqdXQVg+EgU}4NdS-S?RBDoC8PxM8haoOtCKx0k&r1A}vhKy>$UQdZfa%H< zJ+=qCOb3n|H=5OHm&n>ZZB${HHz~$qaP(*u_5Q37l{{3(m~25FYJN~PCNm;Zd3EU$ z;xezsnd18KY+h|w_ys44>BYOZ_e3tOM)B^xVKGhglF>SEV0OcHf`2&pQ31)*{3!K< zl<0C1TVHHdPFEc%yt#mAaK%m>kW5&RSV%oMH9{01ex>EO+VNzN?v+S`_sW(Y-5Zrg zdZ=_(`Cj?DmK}7fkNjw4QlHYy%5c`SWSlrc=F3KT4pKrS;f63!DRfX>WcY+YYyRJ7CYg*!@AD;6eiezo|7^bf+b{Tt7r~O^ zg;9re*_@saedBH9(Ix!GYPrcRD54|}Sy;=>vxza0iYo$%BP8w-AcEh36E2TdR5eL2 zloyP=>9wwWLUOoA4<5D~{%GR5p$??5Clv?ib(3a{~(ISyZ>W3-)@yU0x8?X)^Mu z;Ml^ITybHkI1LMf=mpfwiMhIHk7W=nCE%Z0tks*Mv_Ku|J^7v$p9~&6!lV2c3n=d4Yb+RPC)6fg z)Wi>}lL8mxxZ&Dr>Ij<3wLo);keVTXb-HLUkHZK2?DI$I;ny*C`d|zuze%4_XLgg8 z;$KIpBI1k?cyB4tCwF5|^|@W<7;K$n9)y`G1PLGhY9?}Sv7l1szMM}+e4xiw5OW3s+78hE1dgV& zN~6wAK3K(ST?CAefs&l4R+aWDCba1yW?XL&4*f3}@UiH6uqvWWuHnT+!6N1jnFXE(xgH4i?5 zfPOiA1Wr@i@OE_79|o{DFc=Oa7{%v6I4_im{fym)_F1gPFdd%<8LdP_QrkJ@h9kKn zuM!^$w$&K85Zov}<=%_4ysnmU)oS^bq0|dTL{r}r&?dgvDR$8EEAdjiZ>U1?*10ScIUpq@9cSy^w;C$rrk>{z_)9X#v6}LNlBKgvwk@LIkZ3 z^9e!r77UUGdNT$ucMxF_et_xZSKr3X!<3SLiv)VPdI3CtB+t`_`|ZQ`c~5M`OTqo_ zL_OrKnm_LNY^|IzuRZ6%%-P4XmAkiX?lv5w@7e4&(O2d~Xiu44F{6}tJdPC)DFqRtuNy}p%_TmGNO&fug z5S{vvow7?MZnz*8XMS8YO6D)G%FoR8-P0xLY;oHvgt#W=q)OW}KFW}L^degf#ZR0D z#qURm+e2&%&=fg{(5|XdcUXu)q^d&16q#mWylMrt$xz#C`p7S_ta2wX7`?^4^g`8* zR0HmdJH{O{j1y#;HTSQtXxk6oaw0X5t~Ze0AqX$QmDCdm=EVfz zJz}Px&(VgVoCXX)cVxy0%{@SYsUDzWlRQANM@rXC%^#{qn7Qt|O&18kC0qBJGs>7x zT02UtCW53=e6F${n4%@#puHlHggKj)%Bim z`-grx5l?r^i%B3NbkUE@1^Bh05IY*7-<-P5`P*1E8L*N4w*azIRi?M*Uf4MeO7U0Z z!A7w2u|lr!P^ZLj?H>)ptQ2;BBsQ(0T+lEOaPon@ZI9z3B{y+5IzeiWof#Bre=sD} zm!6E&zu7&J+o}_fhRMGY_?)gB?)_p%ySv$K#wTSRRF4ydx(K<;?h|QOXY3ZXjE_kE zu>L|Ai2DT2!QpqNiP9k^9e-ct(s)bhG#cI&nxNX>z!}!ejs=jd_RFVg$UC%6N;3gl zI5oGV)G}w(X2W2spgi{*Z%3bz*M)E*Dx@&D?KG*DL`1PX_j*qKd*pV^3&_DSXIC)& z1JG8Cgsu7Ak{01`dXf&odAAV`%OMmoAXaf|qTaDevF+XuM zaZb1_UjZmd!yt~RM!#?#ji#xd6WnJad zoPsl19Gj3BkMD?DLI-0??F3CS#KP=i5r#SJ2QSF};Wr@(jg{YD#K$$KL@ItN5|KD8 zd*cd2DhzXMxNmp1Q#Mm^vG{q$L#p$aW(7QdBOTEN?IPRB%ig$LZ>G$h&aZn<-C-{I zPm%JW=PBLEG-YqRt*5)U|7~|RGbd7U(!<{-x@-!rMJFEC?T>W)cM9{&nC3WAPaVQj681ajJ~P}ruZXmpY0#I^U|5oTaA;YhL_u5K4}Lo&Z(3^6nYtWo z-Hyv=V^uPC=1A<#^Gfx|ChMVg2I)S-gQ7}vtoz3CqMbS=vizz;VyUap-Cs3o{nTQi zsGXV@ax-hNw9Ffo%;Yy8hQBchnvt`_NN@N;ejZmB?()QfFVk7Xxfbo;RiS9|iEQoA zUt7sP=35Wp*MjyAx)xmi4qc17g@2jlTiWVuyv;bI?cf(UK5JBCr0vOI+XOk7Ils{o zl{Qx1Xjb)T%21nC4S1`XnI0*>5NV{9S2KY3QE4Uw3>IckpXJMt`{PlwcKhEo%XV~b z*|td*Ipe3h3DVP$8GsSZfa75_-I%N$N!Eo_H7C<~r2vw+Sp&)_`JhsZLvHdnLzvs` z=8R(9M}m>9wa$^@<<}kvsIk--8O+>US9ik}_TU|=asb}yjy=-{umPDcL5D>IKZrQT z&v1FuMTx5`t{oLanX}~52!=b>2iJ1~gpzwtjgL<5J#Eo| zQVD5PI5EL;zBv~tTh3;DrH`RB*63*ZCI!4kD)NG@chQfb`2}Pz-4%5nw}-w-09ko7 z`C5MBd$HpXJK#-6>NQqQQ@xK)@27Hdpdv1uZMUj&wgrW z=UmjFAW-c{t7{b*qORg+pBWw*ajJXGFn($G?B0Td^HM()j1ASr)y_>mSV($MZug%W zQq0Ct5y$R%I}rbz_qJ8pvFJ?$oNck=UN%sGo%BnL&Ean6tIXeI#k8M#Ib-5eHQLOU z*m1-lup>Ix@c^gZP~}%gEgo(+d|+RerPqaM6q#st9RiLvztH+>fjlJPT2gYdz1#pL zJ`{i3winTacBsNT4V_0rv4%~xmu)DI^^ejJ4`kQ)*%3Ug0ItaH;}`{{eG^7`tCjg7 z76;QC8#Lrs8sM9}KdB*3Wo-v^Xbn1VJ<8o*!m0?IRAfqFo%gpxyujAAX(xBDjPSZ=9Ss0Yr|yklUkb?ASeVT z+7Ui|IObSSTf|SO!%9!Tyv05IY|_9Ika8M*$D9tuEEI65t9o*PBS(CwGb^H8giY^B zeTJ?tr8dM_53YD0I+iKY@h4rBdTThE>L=9Nx`9$KOA7=ME0t2A zOeCgGOl*!M0$AAEa*Kffk6*#R?h`sM7WfjYTR0cuOkSj90JeZJszqoUbG`~q{k->)OEU(TVcfcecOu*Cs5*9 z22i69dd_`!459!H1X{{}km$cI?;cPYwL-fL5swa&_LVVtNi$(c@q{y#E%cnTBe>E% zDm9hb_O*G-exJwW+&AsLS>>3-x&0Gi^twTJ;eoag+dxgBDy(LoK)}8POd06db5ekt zSj*Hr(t%A4t3J8V$Zl!Ah;$|9%7h)SbgHn}}PdV5+ z19O}j ziO{y4iM38+lhGFO8(w*@mm1Mm*m4a!u;-L3C9ay|T3FwO_2e%o;H#*cQ8uZR-(xNO zX{>zIs3pqw*EJc7#_sQ-Yud+SVOdOCr9VRL-1)ls{HfyJq?$cUM6Fv@p{t!6y(jKI z;1jyqdAIk34$U8KLsvV6yfNpeQf}x8q7HlYqN|xpaw-oq*s~aH=In}-MlMHDH5nDu zvi{wQswG@A^A!%)p1@pwy?T?bx$2($4eLGI^_QL) zq5&m7Ydyju3ZA5$a&9bVL}EXKvf;8ws=k;^NS)CEMkY!lddMKd#$d;@JM_maX0sNk zMXm6;T%YLy6HWyC;qLyU=>bpv3*w93aCaY128d*1!ES5WbW}S81E#Jl#nVZ11R2OmdWqeSLZ90C;u7I?kFCZ?X$o!7Osd?e;`D@d61$};z065gO`-() zbj}9gt_x4@lI(1Ge%<1sEX@7>$B4d~WidQ8Evm@pV5(Bl|g2Zf35q zeye&BlgjHiD!JP#igbiukG!L5GxlPS+tk3_NxiupNDSj%34 zzJI~J?nk?&p%_q|UPKN02JK-J;ok4tJ%@@`+WABxm>1=KhmI5Ybtg&?F*FA0#X~Fk zQ`n|}_h9wLWgGGeTJi?ZD9DuL0>_cvl)J5{h{55Z;x5}Do$}OxwS0Vme@ro(Uppt! z&sz!bqprsgW{?G;QtBjO4GhbpyWSESMAD@@8Hs*`+@r_5t3pLAlG&$nW;u&gQyxiC z1$TC0u+^ybQ_W>;Iat6ZclY*pvdI|*Ve7uIaT3_%&YEYuL}^>JJ-IV5cxr)o3S0Q~ zPH%xRpFC$h)I!(pk2;3ncvu@IJw**0aK7yGB2F4pAEIOk)rTlk=}~ebd=4L8?}hY$ zf&b`}Cg|1>|9i7rcN{+Ygk$y2yeVR_$J&!ssu^Q!++qc*Uw7Nqyq$%*j!j-q`eH&U z@B`Q&a+>nU=?2KD1v$N_SgIkf+BcHheN3j8>g0d?@b#aN6Fz}`K>?6Zjlh-2`s9ff$FAvXS_b18J9p^-- z1W&r$PnU)k9tHW;0(vfeG7b7eZf4HaMJm3K7PQ zPBZ9VpXXhN5y^#Xi~Eo5xO1(q3NTI@G6OZHad{?i?)z(K4@`c-2>ZC$7%6r7I2UNu zlOH{%tTz|pxOjg_iv~c>mJ_2D-@lXZi4jp}pb~b1_x zwMy@C_Yl!8d3RvJgri_>6?+b=d~bR{+i5^ca0hZP9oCh-&1&&da&pjER8kioQ0-(g zC2~q=l6qged{_jh%k+S0yqWob?7a(oROPkzpM*pLB8)jfe zCKwd~1vG6iV!ctBL6A#=lPKeM(B5o)dpVxd+S*f3wWqBjS_$_63W&Ap@w95ScE_pK zTIHgJ`G0@U-jf?dPfy$Pp3nQYpGx-Z{an|xo^^ZHv(`X9^L#$fw(}ur!mL%s?>~Ea z#!IK5B;HMt>d95{#Yz~r)X(-4awg2oCa4Ogrsg({@_^xNOU;-mvRPTsH6w=G@o&t$ zkGw^fp}CXL7eIOmxM)e&;YjG~<)(@gA-=QY)Ub2B996+oe*dO&@BULeJt|YxWpv^` zlHa4}uB$n{(j|3vo6QIZ5AN12juqUq9Sd-34p?_82CSHHGd%$An}+W}C|n~}nS;~* zefsmh)%pdjzWt6&r+yMKvTbei=4cWRdy_2n zdpfI+o~Cw9Q8H1lUb@dIiv|<&G%F5w7!qursWGq1go6*}8G!aVt64o~+}5CaV)rvPE1l^Z))S|u44|c>0@fj{oE7JdqA+`B&zxu4^3ZQ%EP8(K@~cZ zILX9H-CyC0FErU@(8Sze?1d(!-8xd2MzZYMP@L|_5(ewf-cU>!d6cVs2Uy(_t!}sF zoa;~c7=yAt-YoH^d;w$WbAv7E0C9FyBIb-}^bt&97mE`V{EVZ{cp@7BLV zG~A(`*U-%P!l`^+L-VS&W~g&ZXPu)viD#7@7yw{9Dd7OnA1gOIyRyi_Oa?8zjZopqjqgIA=z4%@)S`ba>kXm zT25doFbhr6z21R#W)k+P$aNX_%HpSB4P?woHiRo7sOw+m0B5mM`)%zCn(s?VxI*H>Au? zgze_V7@@)O;@`aG;doEXENYL`Y`vLC!yfx>uD&cz&nP?9c77ZPeK8-W)>6tWd_BvL zY{Kf6SuJjM{)X8TN>75tV<#)fr6jUAK_0QlF5;rD*?2y65hF4Zl;H+iHJZtBzj%OE z>rANHrfbr@h>WgDlWov&ZT$nOX61-zs9WrilI&EuM!dzlCw=@MF&1$i0yxYFx?Pbr z+p;T->XF_RY0q-uhTf%Ku~Zul&u%dnqkC>vQOnuR7LwcUUa|h04Bw|%!x@qof^K&a zFV6keU(k^bn~8Acuy)c`fP$oX^d@4m(3^|RE2njv49EQ5o#?u^8PrI}00lSCZ*(Is z=1w$%neIfJ@3?{ZccRTaLB{92JJDI>jeXXj=?R#%Dzcb9(qOuWnl_l89?ZpG?nj3( zKiSEJqtW0ZJ}rC;TKI)dT8K}NFG!{eZb=(jm_DWRUBjksBlSsYx-k1$F*XAB<3a(b zaQSHnn8=w$M0=Lu;al%Z2$H}l_X5xP56QYtreb;e*5mh#jri}Qe0*kL9$?=DomcTDx{oLR7>NS=ZoX52L9)Y{7$n~h zDWQU?c^QR42qv!$cE;?OQk5?0irI0eiP_;5;>H=J3O& z)W~ZmNjNkZt4n?!P{k^Dx-q{yWzJRsQi3m3j``kw3c&P9Px*8Ue2v~tm)>NvOZfGb zU2_}35;8BX;@P}4i&)@y*QpZrTF0}yx=}2aLi%DEv)#ZiCznT4r{DE@NzS-S@!U#8<%$eD<7of1K>e$UE+G%Nh}=(j`1VdExPEppuE z$~VjPDwhRxSfcC5o=oMw7?S+;j@{f;eg!^>>{K%_3Lqq(rO_avxCurRRzKA@aOU9x4?Oy`Rl(s9GNG(`MTBV!_XZT2$RfA4ojRx#7-l2yDz z2qd+=SeFpm2v2Xi7N|;ivNLToYeXpbw|{1zkt5t3clb~xM>s{zJheRrb;^!ssqlCK zmX9bFJ7kK^jh+-^ z=8#nkh1;AI-AAP?#Ih(3yt!+SQQm+%NGb}vXiAAFqfwF%d++YW#fG>%?|%J5Mvrxo zxH29-n7A^BOx@c$WUW(*ZhRoUg*^9NDhK>!>wESE-t4t;v|)RT&fdiB)YMF;YTSMH zooaFC>?xWn)z|>6XPtPL7Hx`0Q={AMhehSkyT+wh_86;|yT8tl(If z_eVKY7W#y$?-mb@4RmXX@!D~fJU<-5;#{X|q+H+C<)1+3<)8YfZbTAW4vrBzfg^@g z@l^BY^h?a2;nVnIn?SDIFL9RFA>&m=YBpIdd9vZwtg~A7VW&z}@|p1cKe^S$)`TB!^6sG$7V&%&0~hAWWBMQXds^rY>c; z^&w}Iv6{4rE&HP1j}i}6-&nO8Zkl5Sclq7Iy0@k3F3QG})7*dc2Uxd`pZe%j1~=2`+{4d( z37T!=2pxL7sdEi2O~CrvCL>@^u5xa!$_m(%M>;<Ai`G5GVoS&99L*1zQePkG-%&Il*wl> z=eS}-X%7b(A2`Lv7|lyI##!di@Cp10r7q9yc;0U*O?xSjpwI)OLn?nI!3+# zyVIZVh2$$Y zw6mS`gp|2*E$vBm!;xkRoY)Jc`H$3Zp|4+U5&U5S?iQ?m@{ zBM{!sVaw$4j>Bt_zGVwuPd=M3MaKF6(0TZvVRku<= zja(LQ@NE7j>1)W5HP6&IOEsp)k0uR!(6KAmoa41v=ALpQ4lD$NKsU83)>LO-m*{oG zdtK#GXvtpt30afIl(2J6B_-KKo#$v*zAish0{srN6Tgten?vr)-STv4E&U+l4T`~3 zVGjwNWLJewB+EUrlnjHqRAL5iwO*}9#4f8<2h|@dmih$@lfSXMVDzAoXnc~5r<_l% zPmrjJf#<2LoXCjE-167Nb}(P{z4g19l8}SC+mgJk@14p9IfC8luMG>+q5S&_9#z!S}@pCW3!^1ObyMHMZfR1^~pC#h&`e3Ry zH+AX7jLVpKo_`hb_q&wsgNR=2`IN%Kvz{8T@@{^m=`U~zn1#T!==lViB|7sZ?qW@4 z6v8a$2F@QBR``R%5vi5XVHv6gQx}j0xqH3+|3ST@oJnJ;Pzf@k?=;hbYm;?}esf+TO zj)AQh)97{+FVVnd?JF#QUxH160ZOM?wi6;|@z)IUhxH(!1sY>Jp5%qs+l17#6LSyS z--Z9}{)|{Itng>%ueH2~!9(C9Ynqu;`sI(9)1Xf0VQ3M;RCbj;ga&b&@ZQHou8oA; z6<}$R7dG_vl_VGH)6-RdNiv)jdO|JvC9vgCd=1-n)#aMm_G2i zYnn!6>@iE}LiXP0vjUxoS^lj19HK_Ln=*u-vm!&Yu$>o@5*q`b__F@57ZsEqQPCs2 z-}QMw`^LFxzWBOL2rQGb`2z)hf%HhPm8&JUd+xoD=iaw_mY9GxFJSvc8GR|}d@+ih z7i|4jxyWA7T6@hTI}-lA7Y+pQdaA|{L9_`aBBRtLFPPvj`>sk zdGlv@1AjX6iB3Sk50ejlXRI+&(@xgNnysmmoD~NG_V2u3(mP(`$gB&3W zV)Pu1T_yj24<~d4TcTTj&pMM91?3!NE{-BMR*FIv2K$wuIT9LM87I{tz8eu4mA(?88zs5YKsb`OV~0@uU==o{voBpAmF+itowqO8i^G(9!=PVd$ka zkw1q;MDrX+JkoQop~~j`XN=d?GdjzACO^6KnZji78I;)B&tSZJCO0Ru1&`FFU(wM< zH<7{b^jLFV!wK7(Su~1FBX;|}7a@p!smxg?$gXq;<|HQTeX9$-tUI}@fvRBVkT+bX zTZ#&mx~?F{-Sg>#T~U=>(y04LDh~cNk0)774hvMr6*cm>%FLWNdi6R&$=y zM5~8!dYz6|XpV{)p;&;pIN&&ppV21oxa;TJKGHRZ<1X&l_-mD#k(by)!c%i1IzqMv zV>a1oPQV1ac`tY-ldOpo#k{vCREcMFU~H@wj5up@2(H9)DC)TY1*;S4LfEZc*@Tkd zK?Pva4K|b_;a{1%?|IXoUoL$fXGsDcqEUbp)`xguNoDpeHhSo7VD)DSLA%aQP0#rA ztW!_^O4QQ0oA5gAEbWmezx3tOMix_yae8B%MsbZ_G)zXc8~b40%5!3@F$T9df$s#3 zXNA72k9v!<^$^yLY@=qnn{j&XGs!I432Sc24pJ_T5B z>Xj}7sd{<^l8wH<^yz*8{4J4Hmd}0?gDht3=R;NynfxjDiF}mD{uBtM;{9kwgpd|a z5t%mmQlE0~r3JsbYME$U9Q3*?sH*pmNd=0g&ayX^f!uj#ZoyrZEVchieIbS=@bnmwP4qr7-#mIJz za%%LRO(vNt*lg(W?Q{y^N!O@f9uDc4-W)p5k{~^?&3YVH_ayurjNj?q##0BT$vT1n zZFfg#e!@q|5q;oe-v{Gn&m7kK+49#q;%w#=I6W%du*H9K7+=2v1H$Iz7%P1KEdN@= zsJ5*60s}MKTsZyKv${HV;^m}7?Xlr529Bvvp31=qQ*|dBIG#^wFV=@_mpv*pVkcR1 zvez_A?GX`+@{|nWTAE(U!{Ojzr!LL&+SHQw+(I5b@K!_1o^}q`LRUS5AO7Nf1T`U^ zSv#}qmmRM+*w63wh{?Hr9}KKtZ#K|ld8ETYZZ%si|H^|+ z43YWgbmM^t4?LG)G z7O@kv6O$|Omv()GNYrCa#&OK-_AZ{_NDB4a{#16ii@LO-xdS@0AwEMF;*#3zo};~< z45IfyolcJ!Kxd9#I^k&OnsEEDe!jTEY)<3daTteQv!gW#tsJC(Czc*Dh*_%+;&zBk zJ>3g_D8embZD`a*{oEhDNh*uwCt>*f9YYmAFrTf~PYFS#8QHl1VmF;zK3~%ogK^9q z06P^d=LCDBXW%4^gaN^6gn-HR0iDl-UAU9!quaY&`gX_gt{1UBMivURgzgai&mAn< zS$*&ab~>g4AB6A%gNdCGG^eInLqP-#(8ZGkA{ugm|h-`(zs1!rt9@ z2wBOWqFNyws^S7FcIdZp6Y{p7F*2kd?%o*FL;`o7cQ5J4WKuIc&csWBA;2p*b$XTb zDXX=WUdPRh7YpX`{$?oY{4s6LKEFMGT;5`BCFnj4yMJ*B1eb{o=dwq+$94V2U*kg- z#@^cIx;stb_>oAw{+gR{tTsj8vQx`)I|{J!F{bQi5joX%4!B>Yl!q8Qxd^90TCGO_ zub@9X4+*$K82b!b*!(V3kxuK7OiDSLkF&4$ij4n#*D7V_dMfWU)f?5Uxh2tc z(7|f7m~!s z5%wS@9!Jx!Zu+LNe@sU%ni)Sr8zF{KVPAI3uq)Y{ZUe$68`Ff}_fUU}7TBG_``%b^ zj(L~q_!r0t-x!o+Gg>iidSbUbltSt(=zLeK2a0aK#!rQm7>l|44gnrK(b{~m9i(!| zhx-EWnfTe-z0ULTV$q(ByyI({ZL`UJR6n4H8Yk_V)*RQpPxbb7?zXJzc#NHzF-WdJ z{%(_;7~0Bi%j(BHSev2A(%{%_MnEtpJ4W;2c1&>P(oWXa^EzL4(R*HvGS~ln2plq1 z_m8h>Lv-WJ&b}u3Z!=gBK_+!iQ~P@Re{Zzi#qXXMZn9hQVOHj_?6~6|zPM8vphqXO zu+|Da@1D*3EK>MnfORY5ZT5&{OeU+s81Q!^b^`zAEt-(H;^9;mQM)YsJ!y)LdVO7c7Tuy}bj^Gk&w(VsEqeCtVO-El z@|k5x(jm+S@yMlCsZ9O!wMqPb)OMEU^ymc=+)V$6Barbf|6W5Iqp7j@_fF6632_Ac zUgjp-n|_jDzD6Y#iSGmcwg&}|Afiw72EmGr4^X+=dCDhO!2Z`Ct$Z@TPayCK1U`Yl z-xUHnoGj#YrMyIEl?26s@tJ&KWeUtlMD#HTIn72p)z3d#Nlp%&_MWK%7Mm8@h$s;?gNmp0s7T$gkxiqn_Abtd5QL6qgnav7Y zi?qG5dC4_7UTb3xD3#k3oF7bA`E;fDT&c+gxG%)>r2YRR@|g6Rzd5$%_5w$w9U*Ra z$=mEj`xnIY!Rog)*5BTei^9!7$p@?3?MH0suitiJUq9>iwUiRb{3)Dy4v9N(EB|cs zc{wox%qu{iJNu2jSeV?_w#CO8i-F<*eS;%jXNO4|@6LXZ^MLVWHNr4sn`A><67zIG zthSB0{?p3^&E&*7;sXpM)9gHnIkACW#KLb+-RvWdsr)kb{a zmc)G3;D6n~{k5}8a-1#cg4M&#dlS0ZB+8QOXoA#fy3F&BxFrs(t2`Ad+<6%-ITKV! zY^*w5e*rI-7Ff&SIv%dVT9U=gEw3<%WFn>9=fi1`s80O4I=(Y$0xPHaeK;;`l=Lw!uWX1_3XB71=U z+u_84{;We1)HVT=5(kbmE)2w}O&-yq$Oef6BjP88ofV3$q1}PCFUizkM(>hLhr` zQ)r?3oset^0%gpQsCngSKr>V6o_9-25 zRG}gL7y-tGxI%jmR|2y$zc5y)BBc0-AjHQ|H|Us3TlgU?yzUVE`nOv6Mbi~(l0{e6f$nP_8y~2;c8FPT9)@~AS-jU_dmnpXnlOEo$8$WetB44(}5{Vp(EcIyJD?Y$4K5?um{};`|>!9Q#%ZKE}=;t#`EUCxm=FzUI z!+KSP+LviE|J+rCbg$iqZ|!76Y#fTkms?xq-^>Oa=r~VMMZZ?;&tcP9w?2+7Hjyc_ zZvA&2c!^ohy8ZilW^e2H|L|;5hgq$6>2Y$Vbqkh%9!-xnX#uoTH{NnElYCsu100-$ zS*P5I^|m5GlP@GZ<|+50rHaov8{Z~e=eUV^ICA0dZ7Xx5L(0NnvsS7!8D5`_( zI+?mkXP=gB0tiN=s<87@(R-nXmq_ZMd>18^>hNdC;V_aS?p{uHsac z(}0$Z9ofd8D6W^dqQP_%2Qu-|-qwq7c5&J|4~r7(3d8qC8`eek?o;+vI+%$qS5*nJ zJRb8-yvpCN&L!;EDf7ZL+u|oX2>~k6hB*foM{DcN4tHF?uIbUopX!PA@lzCT00bkk z%;%oYLgp`qUogJpf)QMYlOPdt-j>a~o-dHO@$kd>nS^+k$jPx?`RcX=O1)+CG9J8x z>y%!&Ef2ky(L$-MuyZXzVyDzco$q=J#F-##S!J&lWzZ6^x6BefKvk7wkWkMMFf`L6 zR~2~)eo0AdM`u~Z>+YKUH^S@=Rn;XS(J!aqvCov`+`IR2!6(yJ^N!VWE3a!7jIeGG z@nD)yk^6v=jH83Ubd4ik7=$8>v#p&%n_(38;@7%2ZYQ~N4coPfck=r`3eWyv`LM?7 zgv|9MB}$ryX!TDe48#UM8Zh3vl~Q7ntkS zQRk9yZS`kkms*cZ8P>c%e?flB*0>@V1UU`RTp~^$(H%3j)Pnq`H4DlY z_De1(r%43Yt+64s&PLYw7Z2)oqDFw+BZo*H@pz7Z9MUj$dc{uYGh?F-q z00a;AjQiw+=22#DQ_9`*1H#p2;`q{i&um2>Y3$4R{DESmJi>$81(REa;s#?eze0eAT4DD6~V;;G$TWJjIWTI?fB4SZesycXG$g+4$ITK+*m2l=o0A z6zKhX<;{GLU+zyMQ&(@Td8O#43$oL4>Sk)VqcXb_`^uJ%c}$FrTi6$_OBz0f@VH{5 zi2aqbHmuGmksqa@gFRl;{$( zXoAnco9x{p5GFTR`R>n*=$tS zEuIfFZ|F?4JMw3eIYLxa2>ldm&*{EEBKN9(6A@(A$B*q|t)5F4L?_z~hcWFe!3fl#_As919&d9z zY~30=-&vvI+SQ@av7z>sP#HgR{CCL^Q7J=ZHTKK}M94JvC2vu%ZsSfK<=y`8IdUURWpK!lh57Yr#-<4Lq?~tvzw)X z^J$bSWTYZ{?>d#0WYCn+SQR zW7l<;Y_5cn%<2?Ix=A+7>hO}yT=E&h2w(dyr(`odvFi8RBvy6ZE4XVvmxweb&OCo7@% zlmF*E$j4mdHu!lR+aN!hjDt8P&$CAijHxC|R1T$2pS<~K2pq=VREJ%qby=rfB|K&i z6x}%(uKtM-+iIQ4-VIcJahTN_(I}gJEcZ8P@x@{1H2CTZ49e)ts0!lrp28fTRUJe4yfmu9ULm6>6ZgAN zO+0O=KSsRD%%#Y*%<9v75Dao-qaM4Go0jfPZ!4$ZwTQ(gXF3cA`4?5NFbs)n6(VS)P4-@w|hX zj_u5WQb;hZ-qUfhCc(jetd!qI9c6t&DN=KI%4qE9@lr0VR>?6UWfDR7C%{}q*5xq5 zt*jw31{{Lum4NfeKlHZK{L6CcXP9~w?w!mX|C?yT#L0+123wz~(Q%IU(*6Nlw) zo_JiYcsWX(j6-9;kTnj0FY`q{79ma4{e6s(AHAjip z6q;517np((Yx|043+&{PPwDU$zmLD7^Q#5T+^TPVjpr5;zngV%mOvi*3oz^y%&3LoEy@?h z$;?HVF~%L9{(z#O7!2Wsn8I^jyieXEd(wJdC{dG(kD zSB!a!eBxEBS2Q;_+ljXK$oy@SY^r8FAARmU|3^Q1jz=uW41rXYkHpG{tb3zy&^!E-nv`kX9AB8a zEyMA__{>2L53kX9^GxAkLFet@X>QGeu{y#bzSdpBVBE2)!OHaD9+{+WW8; zVnu9r>pl;o)QvDL9Lu%hRmMwZp#8bA33g4#!tswq2ju3s$Gq{O=E#k0_{!o6x8o}k zQvXS2Ut3v(v{84uqgK${mWkr7IW|Yn=i4g|yh4$iw$Qo8AY>V9wFB?3wXK|ZqJ9QC zf1cFw8glT;DJO@MOG=a12FA2W=;Z(kL^3C8UKULDBbW;gi!fJ-!TrDH=N7m`$)1or zOoYY790Jc}w%Sio=ZvoXgyn$%injA|(D^OtpsFq#5-ZNw!>TSD8ZU6a@gMJT#Ux}r zK<8tEz(8aBm#fBJ!a#(P0S6X(}oT2dns}FKw)p+9M3hU7eEB36*jajlD z4u2fsj--@S($6CZqMH}PM7_9(xW~g{vP>jo8V10u_PS$j7y}I!2q}s2SN9pY>iIZC(aUYsb=BtSGUlFc)X< zMMb&s>TJtztp1~hJgU7hd0|Dcx+xGZY)ot|(XVKAQ)&EI;pKK1hz=rSe@M^q8kg8e zfPxDRG?p-+J(DYPWBtuUxde^T1Yc~fbT%)lCt=*vw)NFE&CmL$_3qT`5XNZCYSl#4 z{L&wBq5cJ25zY!$HI>KDP)u9d<3ANmHkERo#g_SEh5N|e+A`nKmI+laDbVq!5*xNTG!Fj2S|vk)a4J*@m0u)ae68(Z z+saVMxsy3sSUI^|>wO`kDqX!6Fo%;5Y0g3r1C2)~lL(%F zVVw7#e~fb`-s%JPOsXh}^-E3y9d@`AA7JCaR3`bTFhaZl4+N5j2S!jvt}I&4%I;1X ztDa*yk*gV+=fVOnFwPeC>%LgH`epV*(D|Uz zK5-JcLLQw2@^+we#0Rh+${I;c!;8g*B#3j)=}DOnavmtkOfnW!Y^fr_)Pz5YM9+sb zj3Ypm>~dx+WU2Fjsw;-Z^BYf`Vdyf1_oyu4tuBoX^eEaGuacp%VwK{ z4wdA>!EzVmZ=PJ9D^k*(SX4fX8388}iPOXrE;Slt)R|WYAsQMV$iGK&AD@q^7{*}7DjFUu>ylxwXSVEK zbb1eF3TyS5sn>O=Fn%)eORfw%^ii0`G~n}M9No6YUh>xEJ*~OVa(f`dOCN;{EQ5~> zV_x$4>n;x^W*C&%27jGV5l%EA_!$QK1S_X z<8juf#97@B=Vn=|3^ih@r+&|8spkTXoH#W-mUlaS>;#*^usP1P{ZS3qvcH4duThjfuk;I}B|zgiW4D z%Em2HdL_n(|D_H`e-$ zQkHAT5ocCO#JQG3kOgHC=e56+rO{JBP7EkU+OX6m{TbMn$#t@jxer$mH0hcso~*KaGhS5U zT4$q4dA(Eh-6wTelvq;1Bx`s<2Mfy3xtUPTmWku|Hzzhy%EPfZ?B~Sh0Dz~?>jr?G z%RXQ}+ub3jy$2u!H|=>=SMWxts_?-u!%RlhLc*a3nu+F}p$U?>s(6}MkqMNhSO1T0 zDy=Rs&H4+Q^aNe8>97+MZ}l<*ltGFJ~eS}-qP|6xZ~XVu*S)%76+>rlr8U%TTo_~^Ntqs$IVD%n5;J`m&gyz zC`fJ8y++?Cya+yE~umaQNb~hx&WK^k?RXOd6gUPTtkdYIhPDXm6Lw0Zd`M{tG8UIxZC22~=-}*-vQ+QRzbBjM(Q1)xBg~0$Gd(p|Pmbw; zc_q)}AskP{56sUPQ6UIAzL7t%{(&~=jER3x%ZqaN&euZS>geeC)EW0&#oR)8c{a_lwd_yn*P z@C$o|yVSBNWY9kThH>(J$NXI%c7{X}J0Q?6Al62m{f~W5?}@21Ka`A*u616O>P^GM zGkiyXiHnGfZ>@s^v`!Vlm_>T3r^j$Ob^L2z<^&1LQcEqEgXDZf4DPxsocwCJl=hDE zdFxzWL8RW#hn-s>SucC%&$UiJ@|)J4)}Hm3u^uU$Xg!jjThnf}>eLan-#BSS8rBPk zad56;@mox*rvL1eqRzL4CJm;B^G!+1R-f%?Z+3Y?G}oO5X_Il zv{J{9&@`L?0}Rj&M-0r67PIq6-@;+pzAqJVPCX1S#*>=H`;KCLOdbD-*8)APvmPlrCR_DNzA_B@OAqvhlcHeQ@n8tQLwG4Z z;Yws9fIbh#X0^QC4`HAhi*;Kx^~FL)JJwqDL*8ZiL&RBLK@J*FgmmuQ5VKko*i-q% z2U&@4nz=WXvBI|VLgM_K=)Q6M`;ys?$!wA% zoT!mWk%Q@APUVxVbmy2e8)`-_eO&ggI+@RP+&fRkU~w1)zsW9Ic8;~^uPq8=0ky5t zh9v_TD?n!B`Bv*4yr)3y`dVjtDGs;fw~zO$b^6yj+d&`?pSrED)jETrXpI~Bt0mdR z$eLG=;8)&F71WN63OmjB=_8XlI+Cgl+|7L$tK~dX9t41QzD=M_XLDvVcBU$R7MO`j zVYxM|yGc!W+Pr03Yj2!nJAV#ZkGz6|!>T8!uXLy`{b3t8&T35xL>lQfM%rVHzvhd^ zsIn2lBjfi^ZF|q8aryD-Xz?r>o2ozWoSB6{XVqU!Qzia>sde(AkZIKx4DRmH_P6}D ze`2b5<6$}=;8}MS<>=Pqma>}ntvhFecb&^4e_Az{B^gjVZ1>2N*){4IEbyd`|I;e7 z4N5%>wpxEoC2fGk9PZFdG+ElQ!CVtLeoK#%@!M2tulY3mLGP2lm%d|ub?v3kFfco_ zA(B{M60CX2x^u7w%6I_y@mOencdzW3X5zzUY*qOZ>EY2wq{W|(-ui=o?oMguVd}iz$C}Ib0N;(+F3%t zPI{FpzGPN02)&zxz0QOn!x|lNCX_|6YTJ7zj4O;4+AC^dFA~fH^X1D?FM=)Z-CD{P z&vt0`On+WzQ)SpAk;K{u)NjObV;6+1N4~CZ?ZgMmt(NI5U9HGg!Sk2Xx3fLk3mug% zTM=UeYIN0`;CS9%hX`f z^D5LRV`R(W2~?}mvX{;dVOLzcY?AYvu)}Qz>ya1G+UAS4sDCqc=wWMS`PreW%h^uy zAOiDiou_(lr{7Utt84H4jzVVZ zlrhOWH}b3Feg4@K3Y5jBG`7C9XwsNAYwfedaJL?9Z{5B8m~d*668`MTDU0`O%&ZG1 z+RDO-H*@1}BSDJ#?+I3pD2o+0I&;E}r@h!{_j@7TuTcm2o=9P>-7Yv8S6hU&e&I?F zeFMZ=t{t7es`aJC{q4=6++f;Y#2@?c|Ekr8-$31Sch>r#LuNhj-O}i)aFcN5>EAm1v5`JSTGXmT4t@O z4-B|zSeTJGZ|f|19sljc(*U6 z>@;S8G?X{H zm_5AHz4*otGONwbUa@f{fawv;1u*AZTxDAG>fi-fd*#Yevp-hkwQx6NF#QCAS@ZsX zi}$-DoY%bn$2wvRlwljTn)k1am+1$JS(!6Hr~5ni-=6#s<*=6fEgtWGw__F` z@TW{xc3i}hS#;5!kTWOW-m@VPyTOQ#&8u~WkfW1bW@fGVTt&%(kqj4YWSs~pJ_-AB z+&!iV=E3tn2vHRfczr1SNayapq}9wBVb;bW=2vQ`M04vEiNcL8$4yjK60_)sdo|znePw zNkgAN;1dY^4G;)iI^C8BRAsHP^kZ_XmHzeyqy*EQ@=sf>FY=@LF^?4`B+i5!{D7Nf ziCBI-^v#_ns<+O~nFmLeOoXwCh$kFi$+}l(e5*XaD(CYk_Shx4kIoIuaO#ReGL0>- z!UM4sG8j8KXg%5%s>v^J3P$mq%WzTYm)P8tH34#a9W?dnG(sZ5Gq3}nx3pb$pt+r{ zD0C$;N=8qwciZ7657`wM;_+BjV6-%5xa;(*{gI}hL?p?U{~N&ASyeN}02nJTF`+fA zNAe;K?+{IeLzQtW$p~elU9NcuAi3)vhG+`dP5f$1&acFfXXrF+Sk{EZ#Sb(jpIrLe#am7LOHRM}q%T88Kh<%Fu9C$5YP4wl1hgghoRAj*VnCnr4^kRULkLrQkaLFias zM}?KKPc`3?w=%}-4HD!paH6ubV)73s3!Mq0?SAqw;`X7cMV##(V4}H)E#uXL7bZ)( zR~1bCs_HR*oF}nG3p*Q`n93jIb%PPwZ(BTXCJdCu%%_eyD-Zr{%q;9|j3&cn!6Yk0 zAP08iH2m*Z{6Uh4^Tn~@+rnxXmU~8n70tG*s39OD2El4T~U>^#}Wx3hn;7( z8dkITsBrZU@1qG5N@q`Cb|IHC?NPbz^|J|piyIKTV5Yt9?L0g2My|QLCo3D=eQvqz zY?9Z^{VLpwqDZkJX9(d+mM`QQe__PQHIna-Vz`C>s~m^|CF!?%2*V3vf#&^RTR6FS z|2Gz%-Ms&M@$nL;huw5GA|@v5t+CUsN9&M#b}vFPjbP{A8ncjljJ-5abzNa8p3bsL ztSbxEtY5l{e-OaliY6Z{FEw-IJXE7KCq#Djjg=V8IM0)&biy(3dt2&KUP%6CbQKZj z=y1a^_?2LIk4j{zo&RJ`b0))1tz@H)RsW|5ADs7r=2-N|QmksRVb;i?NLgDMhNtSn z`1>jwVRISaJkNeKw?22-$~ikBh8~ETc%(h3Ejb}(*Ssr*V4M3Ep-FTtlsN4Q(`2st zc>?~QIY&r*h+Oq;+LIh!FQ4$n>Uot`>MmZTE@9vAbcC%%7IvI0U^So{6$Kz3(uKmQ{C4wcpn)TU^PnAdeivm=0=af z+ZL<|o62fyUa{^x1*W5kZNR#P;n{;l#JRpC(%{9P2+KHh2Va9mnNOYkemya!g+Cz~ zxgG!@)}yucHQTK_D<~CCEDOU|kK{42|9mTvqj&JXW6=k$sM%oM^%Tl`&GzL3gH`d* zTP+Xq3yv9aepTzdtrL&BTG+-a1?Z9!LVd0ChIXcoR_6V^;Ewlxkq`F^oM~koI(*6=aaF#F#NE;|Pl{J61 zS`>KL*^ynN_0o<25@zXjz8CSJb^)o(kP`EOGqefGu@4BA^CCLl-B>2#6RmmEfYiEE zCa?5l#E2g+>Tbch&;07LVAX>rW;&6~`pjkyQu3lTyRAD<<#opu{Ns&DCAblF^6o2$ z1GZf;WsLq7=Gsr|Yi7s9;4ux~(YCGrj!7V65>Lx^vV*H8LnIEBxf^bfQ<1Xo6wOlJ znA=nye`amp&H3#^2w)pi4C&DuNU>j>Eq<2g)sAJ@4@`%QzQ;Ks8y>J^+NFxoa z)Jo8qGqZY?>G>qK19ul%3;_z^tx|7#*UKDb2TtR4MP8X+u?o`@|&19HEoRYu6Np@y(Rf0Q4Wb~X|72>LX-13L7bJoBQ z0qH$z9&*_)bvcWP2mI%VUnktcBBrR$03@8g0dlE#-VhATMKU|TPc_A|<4B+1^Jk^` z>5&S5sOb@%g*j~YhMz{o_F0~DeT5-RJ_gDD_1zCSwGeT++>n9qd5I}JF@PKkGjxm~ z0-SAw+wGDN_%yE1Pr=lsx#{CS@-wJVLNgEK#%}S&g`2*JKLsbbse*@#;J!FYEednr zx*0I??z(~R!vKF7fwL-S*jLMS#seq6PoF6!baj95^?jK}a-ZrOMh99`Xdk#-qAIUx zkYQ@U)WZC9li$1TtldaS=hya=Sh;c@$d3)MlMm@tdWhB;@nJIeU#_g;d=G4fXA;L} zr#t_?19HN`of_*~(AmH(_u3zj!6#{2Gu>z%Jh&lg#dFieT|XnvyGkoAx*;2<>`a1f z8-HbbY&U;B(FF1wo5tP6ezB?in;#1+CSZy6NbWfCKU*>|hy=f@H2e<(qg^Ix#o_wg z)8U3+weDFyJbS*J9KAA}S%>dS&94i$_enQPAMOr#~j@jxj%YxlOq?YzN5VA%{cfPqGahORAIMSOO59(YuTdATkd!y-$}@ z4wyTJC@G@e?=B-JBM!R9Ot9|M0dly(TpO?cieY3Ycu`DDS*0Gl%**Jp>}uNDWl}L- zOjfR>AA`$8n1E|t4#^^k2mf_umez|NsZ$08tFHMR@xW5S@?(rj;#LrpCVgh>?!|@P z&Gif}3G2;wZx9~W@FIVuh9Qk?cQ2hyT+K}Evt9+5&n+;YekS|L0I2BqrOz4RX)Z1ym?B2!0cSJdBz{UHU9g;KtXRXHy4VSZ{lIXre6iD6Zv{G@se zGlUSgaumeOT00?Fv(IWdn&-qV)8G!qcErSD#cO`Rg3?IGGlt6kF}&_~1>t^QC`4W! z@jzMZ8dT)c$Hd+mTi3-#N2MdAhQBxg#}ml@HJ2jU^aUm7%0T0wb;uu$$6Vg zsFs`@a4*DDZMCj_CMk7dXheGTo(X~GSdG+-Q6t~SYk;%JaDD4m4kMj96rey3XOE3F z<0cplHdwQ6=^t$j^&x9*yGe+e9%em?7ugQ?Yt%MxNWk09*yfWX4h5Dem$}zmr6gM0 zO&T6T!#w3KYWy(cx#=_{C7sySca|HZ=7v6(T^YriX2C}w_S$jppL+c`o#p>~oi)DNm^!nIWhMvgO zRtXgAZCnLRC|iy=+c_yV@VtywL=?p1E!6T-?7S$4y|%MbbB;JUnXN{`(|Yq=&#!wli@tifEExO{!1R%QRhD+$xBKu>6Xyhb8|E|N?m6X z=jtyrW>(<=`m1&JR$cKqf+C_3Vi+roB(KFrvP}X7x8x_4;U^od4wT{-mk2;Z(sAHEZF2+vx3UbFQ_@%6l|BO}%*3P$|kTFDO zK*%8dL(cDw-K6@WQj7$Nb*1V+KB(10;_qn$k%p%@^pVybb;ji;rjE`7pXIF;a4YXn zFs^q@>l10+gpArHbbsSW&o0w?toIsKR<9o_^{=;Z{`0KTRj-`74UjAE2ECSrjF!Wx0N{~%sV$$5&z875|fernMlLeJxcg>LkLGA9>Chy zXbU0f%Rt6cj{BV}4SPQqj(f4l-h^B`Y4k_zc-r2u_y%4XW8Kf3#hu<8t0K-7gy+6`ELtCw=Zv2BCobXB4v<;Z<%eKo z;`?!83_Hh(DE-=Ny0^rGORIM>c7-kjbbRl{{eRoRg%8zU@avQWqt3Qg~7nRcoBIb@b2H)8S5z#0 zv*V|HO)M$Qi34%NQ-dugaKGiik9WF9P_#p*3?{&+O!^)f`pp(G#6^o#6|bcR2=XL9 z!2gI`-F1}ll3lUG4c@A&T9PDU7nu6A%l)?!xB(F3EljeG>rQRyFPYW!3bbpbTdNp=t z^)DXQ3{OQsz5i#LN^1CHeATIU&F{heUGC+l?&FB(?XdGshtA$@B6H+KQu7NJUhX$* z+{<1sF3xeA!XIQheuo-Fb@yMIwL%2TzHv06s*fJLyGPuj%4 z9%THnHeXPLEQefz__#f4h1%Sr&7KJNI^~*wAqavWT%b%1zj$8}^9Uj;{3V(yn9Hy5 zy5ARYeTo7_{i(cOHU;*4z5Xe~CNNavI&GcT;8$oWh|yGH0(RE;+2IE7c2T5Ziz=pu zAvYBi+@t|*#K>$f(vzC;z6ZeWK=UQ4tsaKl#+9ob1;)e z6x-rg3KV-CU{aTyaVBljMfwLud(;RX8Y{t7_V;*EW@05b9XbBXNjvxxqQ&BAI*}7L z-A;}6FEv=Px}EQl+P-zo2=^2?&zk46}T3d_%?u&nnJ&tb|g3{=TWfofBu` z{AhCKJRf_l*0GQ+LH?N=bT;j&4`sX~a<&k5ySwtvgEDoq*}rR`vcugoT`KaDDvGR` z!#f+F5NC%tDdKicD0O3QFu8=dT+8@-?NV7ExD1tCQsov?(MVxC+}&#=J8fAr)Nk{% zGxp(ZT$%S6suyu|jUx-~TcLI@<@+3AiHO|ROZVYQSbK&2SOFz{+_{XR`uHFpHR>Ji zO_K;z`&RXX<;|2LYbiKX?l-FBL~HKkHRYtVy9=q6OtkSPO-yEU2;(2XltL@XB1}Q$ zRW!VQ>oksC#vbmx1#vdim^E0*P*o^n72Ku0B%nOMX6D=7MY{p?VS0hnsh7p3mxhn( zWpTG&lx@97FX0ArhNAmt)%O_je8idym>SDK2L#}F!gP>F2bkV;fMrZ?-4BkK$OWd0 zEu^75g1Tgh?A?nqIA9EKZ0?;m6y+qgW!#5C2;324cr!!j6x985F`Nt9@diRrA5N`% zsbwd&f^$3E=fc#)SF@mnmq_b`W0{~hE8ds^$}L{*$fqxX%Xss{A!4}SuBNc2kYOqr z_nT{CJgLz-X4ojd8ecf)|7$0U2+L+{* zuN&-i+sRH79B}pg<_pV64gY$u`l@NMdP1{{3Ha$%kA>xcjy?e-#@t+}Mq3?(ps)O@ z-$k#Ts{`P*^lGtRchmuv1f(DNtw@`XJ~L@(?7{n;sEolWGvh5J+vw^d>ef00D13{uR%o9oOJeTR{nC=yHO}!@iL801OnDP% zi}J^O`xBF_Md&RP4Y<(BCxgWB_dnyQ0?*NoUNgQc&V$Vg`L??|Q7`?+pM8t1ed$cv z(}&wOA=!E+J?yPH)ty$oHs-PBOLT}?&Kzz?`D>qI$U--(o@dnao!1Z^zT_G8Bm(Ia z;}EMJ&Lz!@aqNIHkix>fd3@*Y>N4<|CB`XEyUTNmLw?cj`XPH!j>d~*CY`Ul!j(FI zn}?Jwv`K8NBG=;;vpVcy@Bi=LQHQhN__5dOOyrjiTr{yby~|BICg>LZ>prF7*fS{* zh|S}|3P&j>*tU*RuwyU!9EyLccu%!=l(OElk~T|;;<3HC`ttZ^O@md{u~Q??^LJxl z;Qr*J!MqXnp0=`h5&s5a{Wj+YFmlT>6s)R_ztkA4S^Y!~WLra(LZq96nyb;p4;+Ep1j(si`TVF%90`lZHOKW_b8Jf&HahEd*KrG{ix30c?w$_y z+w3;K!f|F3k?=GS1E4Kt@|?QfSuQ0EtJw%C`mK9#c=OLtzH+jzKt1h_s$xf{IFbz| zmtpvxg+J7_7%CU={932U*$?XR52xz?{SFi$0czSu=m|N}$ot?`qCG2MZZN_==QQbq zOgl8XF6z8R^#IOiXnpf+o-vegoHU`17!hIN)l3h~8qUG27ff+^6vyl;P-w-6tu$@5 zC>E0Q0uGzfU98p)UJ@9+pesI3gg7BJrPf_L`NFE<2}HQ_8D-X^c{LkigS z|LlC+CO4L4r)+3Mn<+fsS#EQVS7uDuo4A!PKJM z38`Qur$_wCdP%a?r}fa%ef`#so# zYt`*${eNbh!SKz-5u4aV@MFZB>3F>EM(prW0CzX{oo@md1euX(EamXs>18#?F2m?G z?OcrM9;UcUuRD;5;26pDOEVknm80`}{0PEI;5SYDufF@L%3daH zmp`1aMJBPC+}M2d6r_UWja=WDHip3zrr86y-zY$h?hTj&0UzrWTR0B9vU**gw0tWdRh@mqBHqqU% zatsU&FAMaTHM*G%dX%|0PGrr-^kG@4^=uxvwBl#l+ZfTa>5%gj@HXwzzG-@xny&fi zrf2(VOiy!4x*+KM&f#Er2Fq`f*nuAI&j`AxkR9e&AbDf`X3u}1*mf?c!oBigAqIcj z_?ubBgDj)`S&R;l6`d+t1O-WVZ;n=?z4kih8ctLEjhqSTjII z#mZtco?uq@Y(|x?qIP%+?%4KW{IMr=Vb39EIhc8AVCB4#`kS0r;kzJbd@ryg%!Lg( zsN7fC!wam3+i`<2pH<%`xCL=zV!@_0oy0H!M>&M7#VjTR<}780ds_f|BPG(97rY&7 z6kyY0&~qj4gr}Ui1x~@W2RvK+J?>Esmh|CK#W~KRLT6?Xo3GF;F6qUR^NQRft`u;y z1wC}r8Qb7MF6g$jyb$hDUet4g9-kd_FIaCoA6TF3kGqcz^>NV7F1+r1S3;<=(9f>D zRspiZ5P?#a4?N?ukZA)iB;{2IuI^jE5IRyeI9}T%)_=UVNPN6%XB$_e&Ae4prVUeF z6ttcW{N~Esf1xRg)M>x-i6cy_Wee5pL@0+8EHayLb%}$qt+C6v-Sq<6YK+Sm&$&O` z`{zu@xA`2c`C&VgS#T~7Vjo=HcUC;ig9v&w`9nRXZ{}lL_TznBAN82Ny!!N-N3EP# zgeZ*v`q|DfjX&TWGGJ!-bRNQ);*t7<^m%IW(`S}=UqBSHlg&-i9=9yCG1&3}cFJIH zcW2Gu>e?9Gdt$U~`5w!`pghPBjsxR9g5wOzwt5(jqc9mWi3c#PJTGKDIw7yoM%S52 zoS}AP{%tAy%pd{D?n*GHls%H?<%1hDC?t@z8-DD;?8hGqvxRgLblh$*i(a2& zqrdb(_`ecn#~E;e@I4?lNb@DQU4=5=nxh4HNh10JZRi)y+E9BxrE z+vubVaN4Uq;l?6+)Euu*lmW??<3*_AgZPQdojHd0r4^r)FcL7M_f*Rm2Smh77JAjx zn}GaXCi{5R-#l6WvRMxfHpdfpG_U%mQbUfj8_mEtsBR_kd>kc~Fm?!td(y=dvb!17 z?|~~XpF<}#AI<80(hIsAW()M}r!Rb2q;CEOe2JD%^JTWJ$ZQuN>2%3#fB2Lqvk}5f zM+`k>w(k0fw_8Hcv+j)O*Jt}+J}iCdfj~$Vy)n7x^!o(!B6adNftg6>K_W2(96M~M zrj=*<*}=WL7Z>|B!zxK^*u^7tj(5o0usfOmCI1-JKO*)IxICfyQiEczp2harl^z4+ z4tGF&X%}}qj6|J190q?Et@#ty2lvaTVC0Sd*A9nO%YIDNBrUK0|JZvM_^7ID@qdy` zU;=>?Fkn=aQG-T78x7RNpw3BV$QhVG6tq|ou)&lTR0=Z^E04iRG~;2=wzjpm?XA7_ zwzjvo?d|pQs@3ocLF6H5#j9<7wLR&GwW0xhF#qq``%E4Pz3s2}_xt>Rzl$HqoX0-< zvG&?)uf3iZ^CjnGS480x-7q@hKf5CcvVF-(NU->Ee%%p`+;{^wd@t^Ye&;kjnopi& zG&i`63(JLcU&3wUuG#nW(q}-6v_Isg3;w17EiyL{P)iNy4;N(zv`Azw*#RB4^eMtr zW{f!B5VxuaX%THkJO9`pqc}q&u-vw>NDmYq-tUYZ&t#u$zap0b?lej)udsDi|1nN2 zF%Lfn4uL**4N(Razj8hh4v7Sw*Sg44-}p>T(tE#f@LI$$T?slk)^IFFR^+_DKooZ( zRe*5#;T?#Xi{xSEO#6QMfEZC;ds`aryr!sihuHKgSAfipuuTF>T;t`W^~v*DwP#w5 zV&>D=6(CzBk(sJKU!J^2DwLFmNK;%dysQDv?EfM8Z~oUMv8TQ~1%Xo#_@54eUV9ud zeGWjk(S&!2&=1!Y4Elt^N<33PKWwHiI`(t2hyB75!Y(l*H_CH%SX3|-uC2*q*Sof^ zSX#C_|4{ycIO-|m*PYI4?kobru&w7D>sxFIF9;_xR#~Iwg*@68l|XkhCGy{Oh+h|N z$T~`)@|omE0;nRz6h#RWM39(GR#lOhuoK~#07nC@#%Gly)uz`__IU?wJX`hOwGQq0 zn#jXcr?V0J(HjT;Dvz?i4PzvCC^5H`(kpUYsP)8~sIV_48Cg*Uk^R<&JoSw)lI2jM zRdLEkvX2SD!cuGE1f!)0>$ZuP7%e{ez1(QsDx=XSWOiAHJ698OXV88+^(o2342Thv z`JFSz!N%z_-L=ELM(ZHzAkeTVl{R>gVwqSIOYYh{qI8mxD?Lyqy0$#rI%%fS`fKiF znt#AA3fJLHMAjK@xw-jkZCZt0989FtPH8sr4u7$i_6vR`ssP!mJgAr80jrh3 zUqX$ON73Hz{3K7*ZjM>G0%fC^QAp&IcKN*VP5jnyqsAFonV_$X9L_TP4EKK3=+)hI^tbP})jgE;YIF7Wy=# z+fcdC%arqu^P|UUNVSmo$V+^W?IejUcYWc~UIjwCUnyQpv>j)-iGsGi@y>uiSHNM}pR7ihQXy2ZtE|7;AiY*b-fZHV!@GW8Ku97{w#V&sJP$qp{Pm_V3CP#+B zAdxwf_Yx5_N-3_>Wj#%+_ab)AzE>h>lrp=VSGF7i6LbLlNOHcVgyE0UYNS!;7Kk*0 zK}coShEoeufCfRXvCd>s?KM(f%865)Ag|cz$WcLNC}gLJ)ipU){5&_F(AYnkV@VW% zlcFenm}lh8uY+opMC0IJVQ!@AGNbh#`WH?R4VRESO3&n;?k;e3d~vGEQo8aBMT(|7 zXz%U%uDm+&*)^_Z6<|twK|Kx?Lqm2BA&0yYZ>S-iC$8W9S}Vn!S-FeLanjzREetnZ z(6_ntgp;&IqyuFDh4rVxMnwTpVR|*jUhnOX|9`3W-ACAAOs+WR-1ihW>D_Fdm-a>4dXQSoN5jqFOz1gbTkk#P4;QZm&XmAejDpI{ct=p@)P|J2?j|OL8 zB)LHrP!}*6+I4Q5?s_RRCxi6$}`+jGb0}40xiys z@=9rO26Cm|G|3x#$WQf0MoW;&G9%XWvJUS!S1J0kx z^QOd<;ULwN5<;}Gvq&zS7p(;^Ra$v7{qfq78GK8&D^8##m(rM(CAK#ASP-2$H~($? z-Ko<3Apo&+?YsJA6-vBmMeNUE$%Rq>;-!eNZU2dM2@9)m$)r?i0cH`8 zDWo=nsYN+v-d2o;&17Ar^W~KiGuyy4#o7L6IXQG%t|xtysA~U##b+<^DW+omxzx}~ zX$jaUK77AAk8c~lE$SGv>f1^ka~6I*%BCO11qJE0-}#eYDL93a-&C;=D*`jAatej* z);2zc^q{wx0YfXKM}+E%^33QgYMarSv+)dytRJabrcD+0YL}2UC4MYE7kiP$1LAR~ z{MkWDpHyB#>Qzal9QKZG%DrltJ zJu8L#QN<2p-ABYhGwm0lcWbT%Dq=p_6AwJxn9@*4DJb}BQr-&mCiGVAZ&^tEZnT)0 z?vTJd#bL;>+gleN@)5C0ZbT*-c{Vp0eHI1jvp$Jd!Up*weEh!W_{Ka|H#%e= zQsAmBeheP|TdJl!iIh56b`9yZk@yqvQ$}CE=b~eP+4UQF;0~%w(#;$P&@+_JQpnzt zYM7b@=ELW(nLR{X?tb<$tePr-6uB&1f!@+0;wlmmSCI%OrJ1yo4XPTmt+m5-{yody{$Iw1)hG6Bd|2aNu|bj;u~j-o?ByJ40r_ET#fddq zmdlMBD>lB&M^fC|g})P&bs;e+6`a5-Q}|_1FI;)LIs$Vn1soeMr<~JvHt@*$&3p_P zmuG?DYOVw{8W<8~5a8>%kyGIeV=eyGdz`w63OPDLLXHk59aB&F18x07b$1y)vj?@4xuIZ;Ynk$472Q$L8pcN4V^+!wNR1x8@FCW?P*O~T+r0z{JQyaVG^Y^NgTs66o!0p+>I@i8){tVtoS&H* zv~LfF_d90t^F{nCln0Z7X5y6`y3i~mZeS#jP${N>C85gCj5qET_hm`)_qhFes&}_<%aB~ z#bJA?KV-kDOpG^QNcqO2+5CFOx~a%1UhdvBz-Vpc6_QXSbu}}MmaklZ$NuDCZdZiI zrac`|#%qI&goAVq3#A3)%v60Y=Ap6kjkS|Tx3tF!z@ebMqB4EWu}*fzwn?Ld_7nHY z=9s?3zM+g)bW61Yoa4pJ6#wOpBZm-4*SJ~bJ`b0)3+zs@|oi3xo{*1(O{g) z)B$+iA4QC&mlUlOp&GQwT8oh{E@0P{I2S&yjd5kkDJ;)ykz{q-d}j5pmwj8Tp&#ar zPza4>3{-UuD3!RFhFR%ml>e-pjUoE3m(FiTf@_~V39h-TLU=)?`tMy8dY^I;8Y9}? zCZ1OQR(+dT_E$8a^|k#Lp1T!_mQ}lLVcln0_9A~`XC~e}%Cq4p%h?FM=;HdBscVVI zhUfyTb1+@xfq68HcE3j-ejKJ3xR|aSxT1pU2usvba+}r;T*DF{yc@k0S3HEB|27b< z_Kixx-|NMtHQ4tFs|zdH2`_t5{EImr$>;S^%$HnT)b{C|bSWVxNaU>Vs4;e0W>QId zC|IDJ{Ps9&2MNQEr+|t-p#gkk-oh7i&D`Q<7=W zG(y`ESD0-z6KpkBXzRpqV@<$li<~b4D~%G7)cAO~@gRQ3xkzX8w4A&T|Ez^mqsokR z(~FxDujNF&;lx|T`2H0cDWTCw!OlTKva4yoBV46eqsmzu&wrye#D-xeuIwvpzg&1< zC2VI2x0Z6pIw;8s+M`32fL=Q{4NvF0C;QqGWbkc=8K)eA;d0seTjFO z&C+mmP1kO22=;HZY*SyrI9ex)h3iwXa7lP;`bDs?>&ak=tzvYkgUPbIe)cx*#G?twuDpiApl$i|k_g%XFZs(>a;O6(u)Bhqn$&5mE*7&-K=+#apKqZ=Jk<<(aPoyrX&W zu9k3Zvr8l?)mS+z2wAF41wWB%sz@BXCvc=$qK*-~61To>ZwO~gXpxQcXDzIlk)1GN z0LljH%b1n+jg@Ib@1N#q`&+97MAArzpn}MW?L&_JuSkiFwKo$ZWs8}3JvW@#nL{?c zhek=qh`zxD3(`hlEay9G&KHj;jWNth(0^-v#|R@R)M+tzv^u>fRkQN2f0aV(RN&X^EP^d8K}lmdx){kCObaWmIAO zf*CNm=9z`*B?{9q_X(nddhEwC=QqhgI}cEL&HHOLESaDzEXfri$+um)vU0E#t&9$x z_{r#?CqGH`sY$u%K~Gk3wf+hPLp&Xs$k5w;D>bj&uHx66q*CQ<(sf@-1X?Wb@BtR8(K10z2xPOdQx+>-*;IW%lF3LD#?%Arg=C>t4h<*42amGg7iL)| zlWDLUn5u?x?rgYIF&2@6;?)Fo32Gxfg8mEe4ucPz#oa(NM9YGnC!&i8(pOLz^ow#5D&ujFWC^sx4(vImD_c zO!V4yyCcR^UW(Oq_q7lLfbFvyZS_2@oD5 z$&SR7Lp^z#k@z83!s-Z?{z7`5sj0LVS3)NCx3RnNgo&AFCYO|ks?IlB7D;i9$ywN? zrU&~)G4wl!1`FVHYuUPk_wWC&*k3_zFP4eN<8@{-NqJDO)|Sb9#_0iG=7HHwq3XAn zNItAA{3?rygo2g{7*;Sgz1y*&Y9W8R@uoVp5pqgZ2A{8adL@5qx6o; zl>N%e+w0u)(qYNT7?jl`i$Ok-8DW3SM_-I*W1xtt0-{D7W_H&Vm&FEgc2m=m_Nkws zotCep*Fo_9L8*lX2X_aG*?{MjMxs!L(uiQoV7XsJPrB8!MbZoV9o`r%4vi8G6)+x5 zjl&>wW)B0Q;#09%Y;(>bokDg!)eVn^HN}HJ%j^hN&egF2{_`k)LC6hUi)fcaD}<5M z2Q0F5J?kXRLSt>sxY8Up4sikz25H#8iqtGRuRkhrj8oSb z_C(AFUE~<8MCo$VN2btsVunM)I&|2INM5`1{-YB9E6>b(Pi@<^ZZ?OWorYbY&rY+# zXR271X$38rIJ}gdj(j#%Ih-rZSOz(3dsMBPz~u)a9*bnL3)Wy?4~}R|5=`X4864a0 z)O}CZim0tq6YMV?BEI;#PhZNUy+qh?W8IeOw~dw;VC9LzW3=2sll>rOJa8V56y?$f z&R*hmhmU|&SMxS-KN52JZ9%hf7ahsNN^1Y&ZSf!-fQzR9bJ{2 z0M+%0&aascWu2p@K>nO)4!R@?fvQ0b_H@%NP)Mj&&Gdh^JIW>K@lLEl3 z_GT)9fGWgi!-TM~eG6&1gu$ccVa3UMi{Sv+vsKHv`6DPL8h6lQowV4OCa12=U5O?f zzRVThDN^8fZW{0xn2W)G8IGWGpI(OTt@!o}mtlOT-AYAT1tm;=5()a!sY1OTd{Uut}(Vtcw@&1*xDtf|oB4bfI1H|z{EFN{No#~`O6EdRr z3{65H(VX=PzM}|OFz?`r2^cDhz65Nb-b%=D@Q~U<1fW94oSYnN#Mn115ws};&c>?V z?TmO*40s^u>iKRbU)}2uHBXZ?CyJ!5<(pKcF!I>PF*471K!U4)lDL9`;v0+QPEnez zd624|a$7mCbgt2|1ZpGIw8rFFs*v+pU%~WfGi#LS^2{xK59=xJTod^;lJbh0kthAu zJFjaxyzN%gq~yHzT>0ajl#I0dWxD}@ESSrS|GC7Yc=Z5d=(A!*^jR@#xrp4Zh!xTd zI}_BQ%U%B@MIA6uOyx)3F+8Yi5rG}IA$uj8ReFdlHtCW?IBHPyq;j+M1+GvI#FyDQ zBG`sIM}F)(PRhRx|1V(CxXW0pHz65%YDPV4TOCn)U?Ba9ipNJK?eu}ed6xZv@H(Q} zmQB;l>s4=yb2VSdu?!;IST=kKJ%@%+&BmpCLmNt6=)93bG|<|zfC!F7q8A+rZ#B`6 zJs}2VdQ0!RR1usXm&W-}9$uV4!3LPmF7*%6$ygQD)1Jvz1dl^`5Cp!^jq!#E#i4F2a9mf|E&kFBLCg8T5@*BY>67 z<82RwVO{NPRE}>i`$2Z(j7kP4UQUltn7nS7t2Cpy zWS|o8Ag8UGCk#CHWO9xUB^MLEqW0p_9PU2J92&8F3SI%955uLVObclh`RV#Si{Dkc zb-m0DN7x}oV)hUYHB*BksG2n1zP(cRT>OimqE3n}yTIT>4qG70y*D>^<|HwMlK7OSfjS7fQfvt@G=eGfbeZO;qvcHP;LN z7;8JtdLZvRNc@w$mFwQn$7-TP*rm~zfcf8#`4r<@bB-yO$) z9!HA1^oDlh$(E>n=lJXjC6bZbSMu<>qmUKsvZz8Cm7ZwN#(9iX=G;&GbyO86QzFjO zl#$M!h%3(aA5KP`7`}Bb!dJmkLD4`z4I}Yd9;C&USaibGVZ72uDckzt;S6Xg?@y|N z>8E!6xVBN2(_X%}L&ey~8f#wW8bXEOWz7yQvl=(iehDx|p1MARyjHA%dhLN&<$jAS zs&?^UYe73Uf}6tC9nq`1gM)_;h+WYXYz+=BCJ75#3BvJ;T%BP!O9v3xIuCvlZb#XU z?{U0@C)4#Kf)(Z4mdff_@v=v<$~Otq2l>%BBhsIr(I+uJFT+%xYB!Gahy;AMGj@VR zE_AZTZL!O6KT72f{B5C*StA86KT~A;dTE>Xo58BN#WK0`e<7X?#+vVAH4nyH?)sL~ zoXXcjA_=o9l0Pa+JcZU-`Nc*{n3AMW%%^$H$hk7Epd8W%;<<=)`+yjg3h@f2>T?LS za@%hT`DV9@vEn>-#`_sKhGtP#W39B_Pg?{w6p;jWN`zV>KaXJDTr~F*qn3%6{ZTQ^ zlB+k8iqAy=&gZ(cv+e=SA?qcDn~Gkug$yh^V*A&&RlFX~DU;bz-DLz1U>p#L! z!GnJGXTP$cHY9vPT$+|`R=V`j(Zd|^z+6IY%#clnOIB__CX6#wnAPeEGPS-lYth_C z`_i~hu(@iTP$|Lr-pDsXM^MLHBB-;P2JN@gS3wfxF?HW53-~zUz$NYyRJv94_^2uR zYkG8281hOJNL^fH)hSD#QPf`dEd}AO|Kt=do(?iGwAGA8A$X5S^V4Pa4xZuY;IPVf$U=HY*S}vmJ)*w}jKNO#8R})*DuQKDJo`&%gl`E&?Qqm7MTp#JZV| z%oeNqy=5=KsVofI??JWaqqG)%hVmWJnqD#c70_wbE?TqTN(tVprWD04fIi2$;0RFO z3;qRr<9icS8zm&A^_ zNn;w_@H-D37DVH~oSvwDPP9FMWH)7d1&1!J&?{yAg{_IqE{!SGa(@`C9Jw)}o6@T7 zGTQ1J+5EVXC$ep*kt<*Czjfq@2^&?dFnuHXKu39ED{(w?&mmc(VFXGo^haUb#o`hn zoV=v5)5k(rNi!B%8@3cmha_5>vt+F+jICZ&wgN~jDhno?5k&L7Ca3)%Pj~^6(a8#q zxRD~<*?wCHsHWKVnlc*2 z?VRu-Ta)+7O}aq>1uGTy{X(=vg`KPN&<*EEw&4xKgKoqvI;Q7fc8?<346XNN&*mgM zjoNs!^jWM2w^dfpFNQ6hFZ-R^fL1R@ODkK+0a_KbkX^8+gZXq&G=eAYn)t<^L)ZGq zZu|Bqt1i*q&H_{-OUgDTbJ2|ILUmZ!0oi)7K_)El?)v1dMa~=e&Sa|)w3L3Sr3RFA zOpV?tfB5x&y>KPSGUZ;E7?^fLq04`rNTzk)Au#e}b~PuLX=w^zPb(38B}~ELeJW6a z@*R1>xek^p%~nm63%%fVlnbc7Y@_in26FCPEUf!&Vr(+gN<1n4A1Z{`3&Kvk{x7&u zg(KBZLS;NlD!EV&AlO6Pt5|UH@OVosK1$VGsXCPIcG`y*GOVsEw z2*Go0IQkAVF?F~%+&C3y52J0h{urx)Ki4nlu9SfJW_;2}q%wG zow_=}bzLu?p`A-jc=C$~v+Zph@mnq{M=mHzQpG69!A?mF$Gg(P;5!l(Qx7ZCuFiL2 zP}5aFUD<>cTCKjJ=qpk*)mxRS0#qk%_-b7bs^Rsc1lM)nwGEymzb>XW zkJ0k)Qt2-RHL}CV78M3Urc{a*jjQK7cmNn)Rlf4IK9*{-;gm$7#4JqL5 z@pX`pK#so;45g^4EdJ*BC7|eMX&6q~651g6XFloiDGMUZ{U-1Z@j&ro_ZTe~aSi|4 zL82b6s_q_Tw2tILmVGB(6G$7a+7VA=iDO~1g%Kt1;=Ix_ap#r|)5*-u=6g3<_Rv~) zK>UNZsjK3gC>sz8$GP6YOHeljs7AZHKJX|7!uDX4Jym>@cScbz>W>A!tpS9A<}cZNJY5sGTrd94O|6~LJHeZA z&_&$Ql&+mzr797P`7CBz>qX3Ig!Wc_NAa@7S?)?0=4al5w>Y5AY%2bpCN-M>Jl;e} zF;!U!qat2CAQQr?yQ#+}rl_6HQ|&o;dql75*=j%Cv(=L4Dc}DaB`a)_CEwK~#^{a8 z|HEZ}ExqgN*LBKPT{j_kx}{Pu^WW7|Z4N2>qtG+Fzm1m18L=jtL3?O&(y0DST}h9g zT@DSRuX45?gxY4~sj6ep@jQG#`$)xQ^#g^OSXm4f&GE0O#!hWO41}mHx9~ZSsW?fG z&>_nvpQD<3=KFi3FH-hz$}@XQWvKeI#mg{foHUcrFBaoCWqSX28{40%;1mQ-LEsbw zPC?)l1WrNV6a-E|;1mS@n;{UvK}`8nOz};>{!`YfH``(KC9m-xap?*-9*NkwR#JOt z5D+q)yy-#YS?YWp)Ig^M=^DuPQ2~qcilS^LFZZPA?FgcNvD6(cN zb^lCtDkdu!T1n2Et6j|tG8O05(W1rFPsBlzV<=vdSfJ8kgRypiD~U)Pxh!U>+)|y+ zIp^zSUazB`Ha0eKGRE5Q2F|p)7H7?C=oylAW%$kaeSF`!v?PzuOB}g8Ho!{GDND@l_Q?gW5IKtPXpZy^Y#3G8ln=4IM&{K%L@$D0N!T zI#%`O#W++GEXGQW*tn(8LOYyWF$TpAuyvX)4)u6%plDA7M{uPc$C zrsN#_px(a>Wrdu^67Nq~Hi*Af#+p_7{&J&bslK|zXt|9mU_24K=1*`LUtToMXdT0q zgmx1QP(q+YJF)~O#j;TZ?~7t#gAW+TaTJEmJ6&W`A-pqy`#@x-Qeb%B0?$%FgB9qh z>QW(A(Q=zdi1>2c!W?vPMJDYU+-5@a;ycJ%E`n)l75#nmm<7M22V%+QSYxY)&+Bj z!5TCWafB4wNWaWuK@VDe8K;^mzm+)3_im?U{Ko3{kzR-=WqH?lw15-G8m;5_6?uX* z(5Fw%mA?=ll4W3j-f|!*pX5+9VoxoSNP5EvW_F9Wa7jTuZaX}XTvjVU#7wkU^rObc z&&o@3PXf?P417@u$1xpH%44f_av45IKD3qgfhN*BAFvv0N(o$0I#;PeY@BjTm9d;$ zcR7wsM}rx!`blhOy+p<;-*YL8Uusk+ z)x`8!RdYret6z5?xoZraqBy6u{az9}X-oOaIk!a5P@3!C0xq>I_BcN*6k23AH$+cX8Thja11R8K&0AvEaaw6qIF>IC4pB zkUL8Sf#C|hp+*n$O3|#Q#I)g%3lQGF=u?PCZT2&R{}>R&6HI;SW{9h))Z2zk>!%;N5XACnPrYqFw(Qag1jCf_?IXUQB-Qso+PG z*kMpJ1uc=1Kgb{=DYS;NfaZ(;A#n0L2j10a^E*K>$g!BZ^VULci!oz8baqT1I?K-B zG`%5$WJ*O4&bsrM9*hU0Q1UpfNIW=cO>E>B3aLZh>tPR%%~63UWf!ZrMQHp1{$9S8 z9nrc->g@8*9KzE7Su3+$6cT4XxT?fc>hIor-X^n+{V43yPva$?wxEI1q{eqYdF4~y zf#~x)vkj__R^E6^Y-!lO*2lUb`t(jVU-C|iEzA4w{KPs;3p-Z5$`*Ew&=(?d4@_(Y+=fW+)Cy*ijcDxo6+jAq$-dhBcVI;X$hvvaBa3ESJf&d)JDmjt5Bgx<6^ zinpBe!LYxubAedy&h>b6znu$tH&Z>=xlQ@IxjpE+y-JG@zUFpAGW3E%%oz)Kk5i_4 zvbr=*`x`6yBWwxJ7yWfzx#&b)v7FbGXPdi=hEo$Y%T}d1f#@vRKg9-8ZFi0M0%84z zZYnZJ5s#joRZ|U%0+ze2vd`+0x&2EHQuIX?(n~`$AZjXQX~=xZ(rAuw<8YH*9X-4W zM6=mh{=C?k6YoHM`-J{X&8SOXgteOA$KHxWhAuL&x@no$E#jpC{{(PqJ)i zJ%|CPs7v89=8Vghayc9JSG6OmE>dOxIefu+=9Rvv1mDC8#gOk(XN&PZSwy`#(P4so zg$WC-+=*D8yYCdl(bK~6hO6$Ggd@W12>v$E<GL-o@}>t-rfEZE>BI17n(&A8_W((ir7nw9)2R#sLx{=?3tHw)LtIl+CvaGf)G zrs5bWD$ofKoWny-P6OyCb+T@EIX@#2YL-X9Fd7=*+(yhSB6aCtoy!t(5EH(X@ViZk zNbYd5jZe%K#y(x99;VOLKWsA;(M(Q2wi&r&o8d=;T%7IWR};VUF)k7-OFc&GKdO#Q zErJ`&#=?cuPc%31?jCuUXkO%r-R*qwHd#_D789~8C>#Zw5Ch;aw9EO^5*Yvni?(LH z+XVqLTavSk((JgLZ;~}a@D+3rQUTs5OjCV>wHVfmZO4MSAluX;$486R2bMjg$G%!S zQxrsU8S~@XEM?W!cIujQDyP7IvozpTb*CWkzZU{-er>V{OMH93{b`&d-Y4K!BAwGb z(ijb6xFT1oG4ZZBQE}VA@q2U^W|TP zXb9@eE_SQ8$VhZ?EoOOQmJ_ir)*@iafAPb?l3AcE0$gOb z_w(#|{cPN)-Dgs6mwr}$z59%eSNYrYvw(7+5f+PQoAk4w{?>KsOy#fDk1hSVK9o`V z1^sxYuEF)-OXYX!$Fs7PbkZoDoGV}RyJ(hlg42?po2dJ+SqdY?XyZrTb15;}ZqS!< z>~RY`!ljIs0&;#-pX;NeTVQ=}fhV|hpSJg2?(Hq`T<_BZTuNp3N9>YTbrE3CY|3m` z`4JLFeaqhL3Na^y?NCUB1m+p%-HZr7rz@;c4_=oCjoYo{0*-kL%JF#%1lksq8f$~k zl^JUz&y77{J`etNWlZ~YtjQ`Fkd*GA~+ zRXaT1xTj#6H+??&tt~4#&4)Fh0a_n=q!41z;VejsGftha!#lvUy-ut}L1sNbD|vUB zq+3=9o?Os?;mIq!HgBGDDr$0;iYt06q_#X*jXT2usO_>VEIWVeFNtgo8OhD;)$&{A zKeNYT8To;s$C+`fNM_G|lyVX{i3AM$<$yj5u~A}c`AMm8PkVj|fMtgm=6);Kr^_c3VrV3< zeVGyG9sgMt1b^{Y`df5^Y(?b#D5-ddsDXd&AIhqWB% zR~HMLE-ApPXO}I5Nk^WeyR7!8*;`K9W?;H*>qTR2xHx`vK&-&79Vf%QX-oWQ&Qc$> zs2eNs3t2G`;;86JIP6F3O>)wUvstPk&zX0=oI0kH4!WI397A4jW94RIx%LsnBij>4 zhC~YzM+O8%_=yHLBWo?Xogi!L8p6F@Hnp?70>~x+i!f*FT`j^Jq zKU1-Oc0U!z?>^0AABp{Q;#lsAM<}?xR;1k?snnUA6tNt=%nBv+VD3H>x}1OZz7K`M zeE&IqFf(W3l(Fc?ik}o-f9nf@m;Y1d3{&Q`93#e}h<%wv8npjx+8+wW4~fssK|v9K z_O{0k$^18vS5BgelD$1pdDnRah6D2Uje(#&(VfG$RHkZ= z*-uyO+tiht*>w2N75g~3nf9i`ca9GlKi!1&ZK6FlSPc~={7$fXi_tQI`YMR*BSkXp z)d!50Ji%LztKzg~H3aR?abVhQ8pIyj=4=@DE(trTx7=xL2o&acoHK@ekm-6Ha93|x z!ib2D1}a{djqi!Z0L%QsF=c`*+`N?*EUnn*y!O(E%w_ej?>rl{I3t*vmIH6aK@HpL zAH4iwCIiw`|9a``iOj80FC`+_XGUwO9_A*z$SM9ACbR|-9k)UE)w#M;^_1X#a%+(% zCYbyTz0O|OjOv(leopfC09eKbw%Zww7RKHlv4N^MOV1SA(IAL2UkHdf+nhBAYsvg+ z3sm~^5ATI3NsV}(A9F)B!`?7h1|)2V(=z8!X1&~||Lt!@hyV8SioOZHu7S#$xRI*v6o;cNkC6jwTB4A0ZpR*%| zP^8bYsOYwj!CG7hEl4BUl@-!{fEDs~`VSS@*l!hy#!hD!D}z%)h@lkaisKmP1Yr%S z*y9A=m%s@4Q>hY2C&Wb%|1Jd1otX!PumO;HO0q#z{i4KONb}CZO@jSd>*o?{?&pO$H|5123GjTVey}^;)&Xtb} zr&vF?BUGB>4Ec9l8@7k$(nb2X)A{Ak4=el-44{4>*cVUs96O}&1Zc?`yy@iIRG%67 z`!4Z^E0Qgb5t*=v3t9bg7PDX(aX{th2Q7myxc*Av3+l^c;``2SJv|o42;qjz@tH0^ zhVu5!oz>Wd0e7s4-XyCu_7iJPgAF z@a+|5<*d?S(PA?bEG?Gn;SwS58K>o=Ly}XB4<_asEh#?0p}nP5edsN4M5-Q<649dW zKv^JL=mH9{(p3NQ&Tk7!U};mH18sF z#p5SJ=G(ptzJ8D&t5Kg%wCtt8@LpvkLL=ksug&Lt+PbfqWAB=|TxRz2cyQ)kdE7M* zCTzR9k_r`Vr1Ku<%YF^Y*ud=}Qv$&CSRo-!=^g$NxHQLp!L zp*rNwvky4VZw?V$ro@F!rXwAvYc+N~u|T&5lebomg$GK8#+%j8ES*qw^F+emD#1#2 zbU3fnKn_CzEBX0F+d~rts$F8$k@(WaBwAqfUn zzb_P_&bK`f;5$Z0z=oyIe8Bd~u6O`)P^UN3Jb3AdH9&! zS(6I-Gv7FTv|^udOEP@|@y9;d1M%3f%%1cRk`hp!jnXuJ`k~BU>P%2Ue32fem-Y5r z^^Nb=+n>QndGV-v`IhC?4Nkl~5W@bCE`DVJ92`mbdV5MRoH94p6WMe#FkNCp`$&l1ddXXzb$TAuk zr}yG;^=|BJEF7RSk=dj)D|@v+eJMmM-F;reZyki$c_9LKKv0UCxv%C+okF& z%R-l`w~I@$l7O|uBYQh5(9B#{BA)*4YgYcXW_Mt`KUzbY!ZI^+zd$W)-}9LKBm;gD z4O-#Gdqh%GpHxrrdn}LGnAQY*nWrt|r+dxJm!v~!7I>%g$WISt!g(JtjFu`0NY{A4 zCu17NZ`k&hipWGt)0Ip^x$5j0kt)1cdA0)el(#f&|4O}NRmg{jc%cF;s9(exY$f!1 zWNP{dIF3w1gMA=zq%b;wC3bZ>x8kMv%E8b~W9_GKrky78!a;nIX(+>?>70s}B&xdJ zhZMUa)@RM5oV$0(+(>J!s+Hxw$~i^RrImArMT=M{m2=#6a@yfTtcjxBSU?lip-zqs zk0!Kxq^y-_SgjN|{yomRZcc<%nQ1VZQ|ER}g0J|G9|>PEX)aALqCL*7KY~unSAEvk zD!%%~trWmnFU}8$%+4zA&;jB4E#-Hw(<8{%4#V}-yP^wPUPiw>(WR8rDyj@+*-M|78is>{6F<9MaZ6Y!xtuk|KqV#y0P4$W?7XZGXEHcpLS5kJRXw8kQVb1J4$YSQBZU!QC$=v7Kfzo5 zeVo~;um5j=fI5#|e}hOgt~YNm<-8dPRe;2tg#Hw=4?9z8$Q$5<>^}%2`gssKY#-(z zy=>QD6<>uQS!G5_(mx>Z0biGuBgx7{zo1sx0-f1DSh;dov_$Q)D~F3TVUP3tJ1msc zh)+_BY_^I=uJs2iqvb`>(}<5y5UiY76y@(-MIz?d=6DalEIF#CJ|tqcuI5kA48}Wm zE8e+&32`@Hi0xBEc@dA$b^JgrQ>Wmf%xp(d^YJ7pi#imFqzlG1jdC!@fx_lcjibmf~ z>pzLG_os9SReD9R6I_qY%%>^^yhiH|K+U!$yQ$H-kP)OWq5~IG6OF4{oE#eK`(?RI zo!AwJ8}IN6e;B+vt0IVA8ObKY{pq3tq&Xu4vNf=wORGvgN7H3`W(C*sra{Wt`3|S^ ze<=i6s{SNZ2dkEp8Ed}9lTgLMY`zu2;>mWTOvz(!6S+(5vm7l2LnHQv0~D5+0yD%g z2I;XFm4$6=(OzJR>;agT5p#pZv)f$tip&%&V5ULMBc*JoqTQWIGc!hBXWGU3EQhL4 zV%%kBI*1|R4_4Ey)luH7{Z6X2cV`;r5(;{danA$vfJchOSI_l8@0Mbq@(}gRXKe?U zr67?YkB4kHHKX)HIm^GgfGn5~E4Ea9i&+Ql_`t?U5=qBy=jnRc&9L25nAQn^VN-fO z|0ntUMn12|(ECdj3MOP(PrZPD0Srvegj!5DH$xE8;1~Z3!^G;_9-AGTO zY1N0yY#*@jJgyJe=2Y9N1M;qa2h#b@5L#FCPkLtOj~7sZAW9$eMz9L1y+#tfF>OqE z-}qoMby30p?&zFg<();*8~H1zq)D8T?o`|#@kS5ANUdOT_^~EuaTreCDx{86;qa!- zl>@J{{}E_Ha_L+_r28Hr7?4ylG%-n^o_0Imdy~^sW~;{d#a8XsTg{GW0gPV<34;W^^bQdHPuZ?mSB(2E zMSKGj^XhoW_rvVlEjbVEhh4B+Rz>-(&)Z~XUJmK{nj3JydNYtFx!0nIJF1PMEnKkds(8MBCoLLMr=DbZSWoua&rS5?Qn6$i!6 z@bj$4YoXBLlK7LOpk&C*g_jEZ7T37Jc!a2(W>xvf5M$$500Z<6rn1Qr1bT`lLLpAK zs)osHb&TTmKr2;?a0p?6Xsd(+1_p#ubM_!IW2rSO{l3tOii4sdnk#L1?V@z9{d~k8 zX{GAQ5IfHd5ix(ZyhngGCMN*oH#T}puzvU%u;KBnV4F7fSOUu{4I&_nH~YUA!{cnB zoMCT5N*P<`sdjD0g{3y_fn+6eT@7vr6OSSv=5d*$;=8D0=!-D)=g^b8Tg z4-KXQ$5eUec2%}BTUPBmF(2x~F4;{8IfA~eOZE&%OI3~E_-Z?Wxx9lAM@yfVT)Aor z+@Dv17|qO$-6cXEs93nn`F_p28E~Vu{VoD#ji`K3&s+Q(M>Cl^hEH18h&@@e2_*Gy z7%cDVr8FVRhV0`|3D zBG?XJQW~hd{hS!ibi{QU=Z|5Qy-SS=*vpc|x_3u<^5M-M`W?N(#pNZJ3dWqXur`u$zrBHAW-?(fABO$V6zb)t!4%a zL-hG-?$&W995pqA@iOKyy0$94m*ys#By!YIk^fjoqURUdG328rj zYDkSJrAn#j<*%u3rAKm-5g4elMolNKRdOrfm@Br#k8tDs^vZWLZj(mK83NfV7OK(m zATM2rTlSptCFe^ZX|H83fCA&^Bn?+uLL1PL?si^$f!#b`y%B?AsoAnW1rgirOr-&? zOXRvnUt1!VgUao8hV2t+>I=dIjd2?z>- zu^UunaFXtLo_bbl{1mnCbk0v7W--RjKUSNIvmb;q6MLhli2`4$E~n4()1)RklzeSt zJVi+0I*SUhzRLFKM12`-B-R2kwg~$UfA^+Kqm$Vg-nyZ8XLy?H-ksr5xsxTBP(`v! z@aFrOw$z9lcqkw_=c`9EPzO1c_YCUkC%ZG%clbGE(_CVT*PobH7U;TCw@t%Fi;5GT z%Kw6@*tUuZm=ut%Ut!}z`Wy1 zd5^pQn{KJLe|`D=KhGKPKapEJHRk`_5D@NBS?R!t{UWft|_bNmco@et4g78 zvJJB0b5{MXh&?H2$J-z=!7BA`#V`ox!E15icOE#JA;@z2Dhok_-`TJem7t^+BNL2y zQ9|mm>&nIy$)-~4Ex4nsYH8_82pPM0)uQqh`A<^7V-q4=SyqWXRqtT_Zg2*sn=?4N z%#7Hti2*0j8l;HYOmo&vSmqZ9lokPkVpPByCaL`9YXuxp@v{|})RqZbu606UdjZ#= zp=xTdC@3at%c?Gx%CHs2+u2wnVehTfV)nwTh4Ow85cG#>e`p#Hh;&2&PzZDEX<%5_ zABMGMKa^RBo})oo=e4Jl*_+0wnHlV?dQ~PmIi)Odcd2J(M9o~{u5!;xWUC^kFssLv z8mn*T2W|(gz6K zIOQq(GwtYrU8>mj{#l$UK&rVMIhsY6+a*)t*Apd^BUeCN_)-3V^RSDK@1_En$V?O- zX`tBF3x3H23i3(`hC2XF?vJ?z9B?caI1US3RktV#cTE6XB-(SiD01iHdFh*ORVLS2 zin$@Y4Z8G)l(Du}bt>dvjZ`X<`c~;HR30V;NZ4LLF1{sfkgxwW=3*xTQNL%}o=hbC z^^M5yUc@oAu%Rh&^jPdtGZnxjlAec2`o|d?zki4XY3XJR_c@RM{G-hF+5o*0;SQ!! zQc#jx6DAy1U`i2i@jF952{_d2evSTx8yWhL_?6Ys{H|L*ATL+$l8W}e;v!2-C@g;v zC;U$-ZO?oa@IE=;i6rOmjU*R!M(i)Zs~)vrA|Io7CYqp%9TAKVVb-TdswP{}%FMK& zT^H1`8k0FPPVDi6D5LG`ERlMBeXV%5U=IFlFgXoOc&Ic^O=(mx`XCZavd-Oyw51yN8VXUo_EUiYSuF_swiI2k1 zqYg<=m~Q`uGXP`)LF7@K;~(KlS&sGC z*X|Ry;2IxzGhc$mH&qwTj|~zGGFrv1SDwi`g;VqKvyt%mbpakXOtxo;-T1!fX#iVk zPo8m}c~q>W4@kC#7scr47EkQ7-YBH|Wp<9fmBVs;NhBgj8lG`p+y!mZJ)<6(vGiHE z?6{aXtq3m(R+-;fRe@Cwv)cGI84gDGpRKpQuhwv?@H&gMY4K&xIMZV{h3%n|sXKPH z#HwiAYo$hAXBtn=csZxu4!&IEe9;z7j-Gw0t4~H=F2Y>upDQrR6SIjnzLDt5H4iD!(_~q&m?%DO&+$HK4XNMnA_LhgtQt zhbTZUHk-`49V&=D=EZ8ndmfg!)x>+hE>)9bChwJThwXc1%pE#*eT0mL5{V~ zXFjA8fKOi`HtZuYW{h6%v`R1HCTY}Xq%T^2w zCRdgvmyVN-xX-)4u=M|*e5Lf#%D*IHpIfmnVjnfDW?))o|It|U0LmxXuNq{(nkl4U zuBl8LmA$S~j7IEtLMiLdz4{F?xb)lahwX&}SUSkwM^gzt%pBLMQPsqki*fbMKKmWZ zu8y9a2^GheV?0tUD#&x6LvF9?uh=J*8f!z!*fPN?6=Tc0`4uyd9%IYF%J75$Fz41{ zX*oqKE!m8q`($D~l!*isi0@n_c9@=U9$te=_X zH9cmQ_B%wT*^#(gj4Y>=#SCp^Ii)O1Z_)J=&06i8Ybhh>Rf zuKZ{q`WImvmYiOqEiLaVb9US>mR{c}p+7xl!)RHX4`%}LV`6G4U!ys>o8@|6uc_tN zdrd7L=woVmpE9+)m3@D^x)croQ|rqDm9e7O*_qmjTww3ofgK-04p_iYz)FQ+G-{hW zLYP?ItxPOyOLGK-s98c@J zdP~lVLK7xr5u@UNG~g|z&0JKpH<^e>mvI@!TB?#?B@f#kC{eoPZtWG9TA|t()In3` zVh!Wp<)oiQm!z;t+&ZlW`^GY3XWxGQ0|gXThV96JlIk;}r;#yC=<+QdYy`L0m5@=& z1NU^T8esp**YK@a?(K56?olkzAbmITu8&ls(Tf#4n95zw<&^DxB?Jzc4E(s%|!C^<_H#pQKDD9+brY zC{aGbS%aEYZ+0?)5u3!&tl!T!u;&RQ4R;D>ltau2pPYq~Cdz;S?CB9M`3aN+5m73G zm84{k4)`VNeVL$N()1JXz>>tsvIb!QjMj_6@JLntT%*;`m1WPy=K7`Bd6B9$kI*=& zFuLnzL0rUzMr1y}y6cE+K(M?0_E?3YFv8d zzwj6qCk`efNdtEr+Q`B{7ay_&QPx(8p)q7hDFm;9l^AkB(joyML<&Z6~$ScqaY}wvA5&RF;8f3>_G)X zvesnTi{y!+NRl473l&bi9~4bAP{lH9Ga(g1k%nvgd#pHt%uIpIyNR$DW2T@S;6>2| z;OFO{=UOQJStRHbr;~CMl|RkS+ZdN<__sbFfa*UA=mcCQOv{W?f2u)^;-?SDDB2mt zmBJ)(37>SLfdmB|6rZFLNvY&c!Oo&!8##Uybn8XfAY&@2mm{P6fya-QE_80X^Ie&j zmOI_Kl895xap_NFx)_l==i^o1--cAnni0Uj6||@Y6BZePu`ZO`WTHOET|p8Js?X&d z#)(UW?~=pgxy^?&^%R^d868^Bg|@5AgMv@N)FK>sIzp)xnP757(0P%h+mXg^$_(S0 zSM^Ob$!7^zR1V7R8^`cQCi%fNhoR2t@l#TTH<=he9}k%^k~t_>&oHTvxGA*wQ`9!2 zGY4mVInDSa*WB%uX+s}lCXKd#e6Q?Tk;Z>fOSS4>RO_Rpb(L{<`^J@S>%(cC*-THE zl8W4hsaNP@?XT=t1C$ zrt?_ZjF8U5x z&D#+@Gb9ZLQ{f!hA~t@*MZ7bl_o@6dFX=;FV?WZ%m2;~i(XF-|h+*BybQ57M0$7&l z^||i)jc}xsz0SD`*G#=!G4Y;DD!08NhJc?5BMW*+0m%8`B`Wvx*;eCf^`Ldfieb*9 z@?o%gZ+5kdz2+2HeT`U?mUU;kCJN`z_LqZ?^s>@mm*iZ7jx*hV6$$_O{r}x0+))1D z$J1}^o#2vieUro1FY8{mM|Ha8_c8Zg>>1_xBm6q&AjEVjx+F#ECAIOR_o7Cv*mn#Z zz=%Np%x%+^J6($u#U1{I-uZ**IzN9*rcjr0XYr||kU%p&v9zTx;Z?KQOMOwD$41EH z>bZ74cXM`5`;*{nf0-r06$jP4gun`rabanp(eeP;5URX`Ai(0&X5UU$SV5!=lweyh z6@xP08Fa3ZOyin~aaY$FVD1=A7{On?evh`XetVLE_FYO4i81clm5kB-mTpkd3|o<1 zx|F44%6lHseMNhJN+!~~M?U(9)$%J@I1|47F-kUyPZS|bHJ~is$y)O}v+0`9GDTg0 z?D3n1P?BD1=58LcUG$O|+3I&X+u+fTqnsq>5)Op7y`=1|`vAoi(u|O^{`-@p-&5pK z)va2VtxCfONa5gtnTSU$=5{-wrQJ%2XtdTdJ!W^X)Qg7J%7gnm@2>H1Cmtr|w`Eb0n+cc=x=D!@7%X|MVMl;>nO4zr=q|0)vFaP}xds z^M$J4TJ}7VNm7@*d8eT=p7z@FI^k5blvuaIz6nz^5`MWYA(wWZ$^nOA_qH@9I%*#i zKE_IUJITK1%M5gPyQl$kx$!V3Q|F0h5&&P;r*M23aI#Xxot)b?ND*ZPu+uqoHwArG z@{2_sH93b7S8X34M_WYyUMulYuCaPCclDAw5*rt>Dt^OgoyMcYz>Fw%ry&=8!Flo; zvBCba;%R^*T7=aq&`HuPoQ2Az{&{{-IsJqD zkn+?BwL7=Rj*@;!=DMq%v7Gpbbn59T2%LhzUkL#vPjHPsC47EB6H2XX7KV)zgJhqD z8Y+DoW>O+ru)>m3nbV>CnJa(L^AOHT{xmyFUlU=G(fSP}o`@2B>I>&GLgLEPggiy* zp=4clj7{Lt(sG)O*o|fOO%ai^286^ymkqGn;GFTUJ!M|7eEG-Nc^#Ve$y9chn#(q9kP5$$YW9cQ1KDU zN-Qc-o{Daxncs?TiQoA?VLUjgMP#FV#))jln&(LFvY}RHi=^e=?hjZ0X4%W4|G-m~ z?wa=Q>OU_Z$F?B@6Z^MHQKV$r!><+4LUU{T!pRtQ)5lDtn> z!srE*#`ZpihHfTpZ|5)=yICTpnI!_JS#oMs`Yh6G2is5yK3q4ZMH7eaL!}p38r6H()#=iV`16(Nuo=Y)m3k zLmoft-HgiDPI^?!u81usNnmblsYEP}eL`6a6UG+ptKI2x8&}jC_F%GHm)Pi34N^G*nef zj!nT&G&jZFo9;1M&f=y!L`u_PaE_9_HRfv}39E!$5iU${*J?%6)A|n0T8*`Sh-usJ zz64=M{Q3h{9;9UFdTj9f{=s zab}PahS9CmM;d>uh6!ZM)NL3kY;#(EDS`Qn)~Z3$Uj>TiAysNV$$Bp9TTHU^#&SRm} zBYbR;{0R|zikJLfi$)zj@^eQNe1c{W=}rl6=rpX-ye1ChJ~;`~WM zoU<1u27`m0JS_^Ryi>&ZYZ1EpDAf9#&r}w{NwQe_Bzbp;fBg6JopEdXhd6xZv(pxBg5Cvk+`)Q6;*OhQ`vp-$J zRgt{#EgmHX69dKO+P8R!oUXP$!fBL~D5Wu?*yB8|?x=wec5ua~lk4t)Lu@b`RIHc;0pOwAu8HK138 zSm4i%G;R~@ua#IEvM?s6insBDgHO9!5Sy2rO^ZHJ-nAq9PDVV(qzAg)S-D5_Qh82l zl{ry+u7FVfi(9SM%;>bHQ1yaI1nOKK;#~Z^ys+~25#7G8K3!U%&RmxA!d%sY9LkfU z5bQryJIP9H@&&7%WiLoG(jD2}1E4|TX+$-W0xs$0%TCj-8&CFX$gg=mM+CG2qv+2cx=im66cK6>2V)+l}Jr;*Bvew9=wY|klD zkv8@?XJ7vz%baE3E^Atey5;cSt`GlD&F4%%+EyZ?OsDlQKml|;^6$g!%$+?aat_&1 zab{qr>|SKq^L^dHORXZKWfFsTclMw?@6w6x#xC1;!^*R>JJlY9G$B2-@STS<^77<+ zx1`=x<69_ucR#U}66U)Av}ase>1Js!p&f7!jm1_Pg2L@_UW@$&2oA}%Fwbp4v;|5! zEync3lvE z9xZ2)d7JON$E+%Hy2>iUOHCxL${KAD_*)sW@2E@hMO^kolMerGD_!rjS}QTp`k1?{(2o>kG#IN26AYEhOhe@>J+tP(w($tF-3 z?gv}OngE>W;`(SN`l;e9&2XyBP71Z}6S}goh(Dq#`lF>Je$h`Lo+_a`^KH{Qyf4oT z-ZezQ9C_6;+GhoX8+3AMt8rh_`z3|=k<^%mM#E#YJVR}euZGqgclm6!urq*iU{)0O z4CbDVoAk<3&2!laqyqMSGp_?Rd6of%240HaBHnGLHw&-d+=b}c&G7AF#JK{fodS{u z4Bj-D4lh2ONzA*{`cs#5Mns>kthFyH0HiJ^85nS?VifmpoYN+B8= zQM9HqqfmhaCsC${vF=a1bz56m+uho&ZM9l2u}To+DiF1{SgS>A>xm;R^%C%c^M8My zb0#DRuKVlm@4x;1^d&iG&gD7J^L@V0_xawxD0$6{F5%Ofp-qRFA-siBv3{f~XZDS( zh{1&)e1^nlnHlmbiMKz$xFEg1mN*K|b%N?aiiayZglbwCr?epUx|)=SoEA=L%+fr+ z!A&$cmEFipQ{sRbils|8%67}th>>QQ;1r2MwaZ=huUHJ1uaj8QPXYNqSwj1yZ=XQm z?*{_Z*NmoS7DrRl0-h>CO2RHfmXwZc^ojM9(m`%X-+NR`7Ar)IH7Jr23xsiKK zNGIi{l#ZmoPOgyT88sK!Rql%?4`J-M`_`qWH&0CupCEw?R~@+h3C}mBE*zh_u#BRJHa=h# zM!2p^|C>B4n^G2?nq69GGB;ZC7)x7a);;4fB1Ij1tj~z1ECzSs$Y|=qfR(y%jCT$iq;XlrC8{5njHwweWncak_&yNra4`et@%nj-D+U z@>VvIZiL$@8oA`H?9IethI%4ZqXzIU;D=+WDyJREHF9)lTds@Fm@3c@b&=5^aa^UV z9PjauH~YuC{G)_PHs&9c-fu4CtnU7c_z;~ceU#pEr{P5+<&&PwQyjST@7U9>Ge-5T zfw!`m(`y`j#OQ<*d5b)%8EuN3u#dQE^tAdVpZNgCI!Z;5Zh-Pp_6tfv93O0Em+FY9gi0Q2rMq>h zuM{^~Luw~U{Po_3Vv<@HD$Ajoxa%e0H#X8K+Utk#_Hoq=JE8jVbBQ)8bB^bpOD` z*f1B~XHGb~CHWq#)t2DOD&CTFD^pe&wbSwFQAVS-=1&8sr+-j>4~rX#C0fv<{6pz0 zboY+~qXmE7FAvu_N0-()mKBML=YTS3MkukQUBo_uMwm9opA0+cp=z+BTqFYTWZ5g7X$2_i7POy zoz8wDIVEs21(=_56Ym%h#v0)*f^u(+5APsuFzaqRABE3!wsL_sr}6pFIE$@^^|S`L zk4iR~V<y8hX+UC>?4jjNjC)LtQ*%GA zsb6aX%P1IY4hCNFv!n~u@>A59(Fr<{GH~0*qnv8ecGVW?IHPbzom@!#r9-n&1G|(t z74AISYfdl3TiL}PriCf1~C9)cFPM4V}|#lZB0+}}6K!IU61 zkBVp_$FF!F=iAxXEqm4m;}=?c)(&W8U&U{*;}4^+j_NSx>d975?WFuf6(gt~5T6+B z6_QWx16-3b&x7!&+!yxmbL~BgQ1~TR(Or7rYy&%dZ<=6Dm-Wm}XL8(P>lr73K zCqKaWW0T2v=|A~f8F|d0j&~bsksoY-me@-}RCFYrA>cRD$V zrXRZ%qC<4EGv#R9+{;ERJevd&xeeUpH}UwY8BfBC76+o~^Rcn9&IPGE|DdI|pLM$4 z48_~~bMUv*bDv~65<*FQ%pL)o%_8D_&*OI>I0~ntH4pyy&DCi+$%8GDn)|vtx0d+2 z8Lx;R+0bBBy>6wZ8Y!hL$JH%z_ zlUJONoa7vnJ|~FLk#5P-jBTC{=c zV`hN+({0VI3by6W2fBCcd4mqzWM+|@MP*}chg05Zo>__r~mYUX7l(ocvzH7 z%wxz4YMU0yU0@?pc9bn{t$ETE9*UQuMFHp^tIp5IofOG~*ZDQmlt_`EUrD}3T^*`E zCjh`StmL3kaTa?tpT5Y>UV^DcUf<3c3Nz;Rbrk~pNk)ya&2=zDA_;`ul|2Fps*P># zwPZ7~H&j=6!#6MMO||#t+Men_J{b&2`JlmLW8rG|Kx6ymD=!=GyuIu!4I^wj`*Q1d5vmE2!kOx#TioaA38@MfO-+p-XB^4` zRSU;2*`X!LOEjkS>-F>Ftb_ybndI6gs|fyK5CxD7josm~)Ez<=rxyCODQCi}4OuEr zmzpx)shypg0&>)XBvTeSwe@6d;8)mAO|Eci=hHxH$|R@u3ivb<)7t58X^p!J*Jz2< z+KN?$X}M7so!WCLLSW~n#f;)VnH9tzPcC1I$s_6IQYXs|=GDK}HSWY)f@}$+NCb4s zV!nIbMN!tMg$gPHWnB*^O@mBWot7@7~!;zu*KH*~v+}^Wqb1 zr*Jnlvy1cO9?n%~`0nJzfe*;<#yKl~%p30MN_OJRT@>9=C|`=a$_1gNstn=91YG<@ zWq^y1#FOqTthth=WMkk|;-~@nltm;B!=bWp_k>Qu#a2<0R)vNO|)r>1XxN&Stc>RBEGn2G@ZP^nHXQT29UZjc4&o4Qd1 z4hXX;()QmSDQxuPB-%_ZU?2+_$aNu;fT+QCt`32H3WBPBh<`e6bzD{Y`7(+~`0*&Vua|#;2(aSPFC#U4 zy7E|Q!IuS^ZU#Fo(uU)$iAa9OcRgp#lZ>Jd~Len8Bfb8bD*oe$F$YS@UwU*W+`)$lQ*{b@c zlo-qK6&gGHY?2YR)DRM+&DgZF{~b_H3jwA1MiBqFXc}?G*MB5K?;&!d1hJ}uOWr`l z^hA%_OIv9{E+7&l5tE{cp3yIe=0r|>3 zz8Tx4h|8oXOt5`67i{NPqmroS{AQ=x z&+m6)F2A4nnOP>k-$hX9=MyjZo$e0lUFkB4IgzGj;cz&ToW^Ko@PT2=yZ@c9#7`i) zBC*6!__XJ$e&R~dDMOA?ZxoSE2 zHEHAQHTGu%6_8QX`8m1TZZ+zHSE_w?+irzp7!?fZiMG0Tf2Ake+gjr4)<@+fIN)j` zklxG4c|ubskEX5e^>gGYx!3QZ)w-0FE@MrQHS*wA_xq#)@Eh_QS%{NVR>^EIIc#;4 zgckYlGM$-#{uJxmu+|sch8^X)&#VVBN()=aaYMC;YF=&#Jcj3&UG+?2U@UcP zri|4M%%>K&R$P@hJeMEC!Mn5fa(s6T9hDD|dv741Hu&J}X2wvK%_&JvA5%!E;FuSm`^aP8up^w^U)su* z8baYK*)8XlE|Ta(qP9xb9Bw`@N7K!L;7vP0x*WZ;ozraR1(Rt;#)POR3mr^IRFf{?FAeeH5qFj_l^!SJS3EuLIYcPry*3?17&Uhm|mICS9ME>3O=uNA;BA; z=Oaz2=_TC;Ix?|rVl|v!;_m*b7eMkH55QBP1E(hKZ!1fJH{HY)g7d~L=*b%I!Tt7< zSmRplhZrDaDJ3106Uhs>H;}cLX{kXU-i&uGv%{_$<{{}qZT*?AO^LH5USLaD*Xs3W zmi{!j>%O)p%XTRMsVmvFRV7Pqk+P|iuBc;PxtN-&FXt_tkON)!beLUKVih^UdVU@r zvCcN>CnM-5zj1bMRgL6o9l>>?b=%#Oe*FPd3v`e}ZYv*jd3sz8)DBIi*!~R~@ zUpTj9oXN1OZ`@TFAK`8G-g22kY=&6|_y=fDc0Q#Q(GVjsy~2hx_PfG~)9RF)W1E|e zfzKw_>?l7O&rs7?_h+HjCaYn$>OO1btrGP7m6wZfm_S(t{LabJa~F5@pI!MiCLKS< zaPXTO*wlsp9)ji8UvhdOK6XMMqy?kk^iiZ-c6P3bta1ac6)y?>G3ZrqJLfmJql zI)PR;*wI9?Y>)}DLm8eVN~EyF_sS2oWjM1&DygfngI-L?diL>{(**MtnN)7Jv^%+j zA+Iplej8^|=ciigiuKr_sxpfIE|?WUX;H${iMRBg&fK+*`*!go>^lOwmw;HQd;PXY`}^A|ecHE@^CsDQ(91keBKYLa{53lZtRay}>@{+H zkdn7KQdJgQSz$yoZ#H3k>+{3Gjq_m&fw6nE4>DCifq2vhJN`NX@&P=* zf|$H3F`{QpabigFr4Mv5Q@s48ykZPLn*u|o7wU04xh$;8#4_gYX2g6Z6zu38Y??6B zf_$aWvHksmYp@>`5Zpb)3Tn(k#?coyBs$cfflxLEaG3uL?2hB-Uo zG?+7khQvQNk(6A~7Gl1AC>98kT{fvK1Ex+uz|{_Hi^Z@Y-EVT+7d3esv9@Jd4c!(#{j))-LgY zaIp_M8O%(X2LtA5=4v8=$uTVUce_7AW@eUf6I)6+gd!;9Wo7O^0K zcR{fI8YSq=DsYCiDoT(by(=g_&Mg1TF@Bqwe}{{?`ZH9R;*sMkA+}%C|0v);{Se)#u7e*eey6M5Rm z&-KKMG=E3xhL@uos&_II5TfcXu5JcPk(miSsou?{9cYq*Z5i$x3iz^lu)jbq^aCq? zrQ*B6_Ph0{f5rXDTrVu?TY8OIMq}6$|FUyh`>thk36&_nSqwd@D&wF+A+iQNp17i? zwgfgBjVLrH8$ZPv2Q3SygnhPDx?Y7>z)i{6ldNnP1t;?IU2;9qq137|KF1W&C_QT_YE6Nz7BQG zCm58j%qqi~FX{xO>!?HYO9thdGNt=$SL|bi2|Q!vZ|g)3~yaL zl!DC^Lod#ZR%r-TUm5!IeEfG+d&DI(T`8(|z1^8P^^k8{#Tklk=IPLD<1Sld-QaiA-pbT^L0OC`Qri}n?Nat*yu9!g2xvRU3Zh&p${QVPysFy)EHGDf1=~;L^A9!fiKeRL63(wVyYjw8921|;Cbi3S%ln6K zUct6tjI3MSr%vnh*?ZaE!xal5@y~IVS!O%8+{0_aT`2B=Y;uKurA$pQsq=2R>tJ_v zF#~qovg%-Wbusf9?%sB=ySkVelQr>QCW3K`yZWiOnVv4Qq9@ZWraNDsp*jVg)bDM=V99U6>12O{5e}0~!3B>KNfa_&JpL61|=FxK6PG_aJ)ZD+oj`fChb{ zriq8z;IKYo{Plig5O>27XbI4J7)!jf+kJ490(yJY@AcJ}1k4?>jyB5lQDGsy015Pkc0GMPDOI~g%+j^v|nXU4ZKLge~X@PX<%Rz>w! z(dVScPVw4wPp84hcpt>`R!7vS%acheJ|b(4X4WN8!F0rwR_{qJy~aFxq6p;xgxo_zsfH^eIjc1i$RT!0&7 zAex+1O2yu{wQYP_@yM+$*}TN4)|L-YySKLN%S#MuZFxU0KG3G#_8;u@jQ8Ci{O%1U zES<_~_06Umk0TjQkMlK6Wk>K)?sPm;zPQRPHE=V_|DsmI8Q7;1#RP}ROAB-QZVtHLAJ>*f*_!LpF7bi)rXf$;Bmki3|KN<_Z!dgtcv-5F8f~Jf^ZaqLiw%%C%u=TVzXgMrrq> zB*yfBJ7lMP3AdtI2=Faj5o$|xbl1RfWIoMjZ~m0zLL{j==gEg#b?ek;wK}=t?Ks=q zsn2O`d0F7>2~WCj=aE}w`8v%=Zjt@}v&M)&EG_Z4SFhUi{D|{aA~G&1i8(`*J{4oB z<+$uG5+1Y6?Yk)pPJU`Rk#y)^#Wi|vw?OTY*ij~BO$z=KU_I!%hXoz=c;(GYN5uVjW1MKY^* z>%=vHc#4wuaTL4?ugE&ua22r{PR*DIR^y68xQa<6i@)BKIes=-6X6OFLl9I3brlKH z+>_2SuDyN|)=dXV!g>`NS`$`iB7}`|uZjF5DX$k-xIfnU2`|?9nN#p&t-;SX;Fv!2 zy7~G6&->kcd-I;5q}bxVcN*^%X)9-qUv840fu^|SnoM}xVa-Dgz{0IwPNa3?_iyGr zQu%%3vwW;cqDQLLbp44mr9rx}O65?EI6E_+BTjRk;xw^&r9PCkkGM=P#VjWQ{_T&{ z^doVH5QrP0Fhr)IIvaunTn}tSQQI=0Io=tijcvjL0N+HO!yX zjq9xtnVZc7{`hu;;Ql#EiOuC6caqIL8uQH-w31=MI`7ooR)Hbe{Bkng8NJT5m- z6Pns5`QS^RGYKs-R_*~-4pFN8V2wX*biGok`snnb6wd~mJdDAwb#Y-NeFN1atHm;Lru8&G~x^N>AGa^oTsrtauulCR3czlGE0js#jH}PpEr6qH<4X_ep z?vAI^8S=JxPvnAX4*>1gbKNDlT%bL`vpqu$vHt~dKy;_ZdD8ebYwjdD*7B7;=>YsC za!(nk9-$~^;Gii14z)s_)5_|p;X1nq}vw{vF4kw5>4E-#`VRz6T zxOCo-tB=f;6Y01<_sj?jjLvR50TPK^I(6r zbj10*`zb(O10Lvy`f`~0y{`B7Abxw=wd6WVq`<;_A|-r0e*FKnr+ocrU1}PxBDt7o z&*y3R>z$w%R!T1x+WBoviHuy?0Wl(y91(6ZRlOqS?6oRtQM|oJW+%Ax;5Xjj#PjM<3}zqlkh^cO5*+++~3{rv6!s{AIr=vH4LHE!L~ng z5lH#_5a z*wu!x!cZ`6a)1 zu?7wN=}w9Hzp;HbT*~fdJ+H0CPOmgA25Yc;Yt@D~? zj(WZLt*oYZhld7%wtcwpS#^d(kFy+Ah_`f3nqolO1{uuZH9pQ*gxz#*Zb zE#)O%cRzp3fgl@?&`ajywoBxF))$texq(bgu$@rcbim|G4`Zud!_UN9v^$V?nG|*N z`oq<9pRvCRN?8^6o6*G!J_rx)9qPi%1ieKB8`_F?ziX=?gXujza4DyBJw|e4$&nbm zNw9d%C^umoRD$id(5B#NSR)gWPjxDrk?~S6(q&$7ZU5mW9u^844Ji4qL|@B?zJTWEMKxGh<=*oXv0i)ZX)yo!zvYbgkJhOh6I5 z3BGu~^8Po_w*P`OZaVQ)4V z*)VxUWN1l-SgpcRXNBY!t8&P)V}Z)Ie+N|3V;eym8g`RM$@kM6j8%zGd$9cm({4Tt zN?A004rAEcbhGUYZLPdY!g4g=UiI1=*>rpmm8Ks@X#Y!o0{Xkvy^yQUUO7MvCQ5w9 zoXkKo!<>(dq$B0bh?h9Fso*J%ZSxs>vjqBG%oMr7_WQvKsUKVEsjSPh(le0nYf$>H zp<+N@w4hV;Nf39JcL(y4U!M0CPnYpqc017ZmnL!JikeG6aDekbn<4Lbt_HukCb_d9 z`4ax7SC*`KsbJW~A$9XSQcImCAq?7qI&5h;L)FZY!Wf4LMAn$I9qNxNiyjG3|Gv_A z{Mo6cc8so6m`_KJEkV!j1^d?=g#oKMVC{L)%5Lk$N$SC;YUKi z#F{z5-6Z%WM6~J-QM6#&c)eii z>7djy0I8`5Ne!lWSb_Z#xwx;Jyl!$ zW`%lCS9>DGM~C8rm)Fh9E7V-okWn`^ya97>>sePNEHd-);%4_4*VA)pg7JK8WQ*9~ z-u9|geBP{U3o2lP^~RsWh0K`tO^Yx_@b$(`o?2*jzESTCCJ$fvXSDutbZLD^yRRw# zCV08Q)sPgepvpm}PhnNY%C4K5n!R%`@$|r;rouXY8x~}8ZNv(*6rGtv^1G$Sfm_{Q z1Q^WW=rPi_Z+ELpw0>Ycx_huNa--u6Y@{kvAt4ImPU8#C2k1brWwOmOd^C&q-OYr$ zW4b+Wj@`J2+?A!x5obFBl$O!cf07zAKDa58e`P}kkHMM%Ie-xi=FK82-;^-Rfq%ph zq$1Dl*K6A?J z+KTTs=oC#pDm*X|Ra@QsKgvwA)jj!DJ&|K5AmLitO&D)#8k7+*Qq{R+R7rDWjs>V$5ayP5V?3${LOS-M( z%fFAL&YKsl`mVvucFC)_tY}WXG^%_*F{kO~;Dgn3fa?0hQZDR_I4`25ScdONT_7f{ zANeLu`76N4Z<<_LI3iI8iiBaKuy59cr#pqku~Rnm_b-E=fKMo_sM;88e}-?0q`%Hl z-?6f5qscWSdwiS}h&z_tHKC`b>UY7mXT7eKscY?57!Lw~Wcd!!1}B2a?;)1qv19Nr z*tQjb2#Tj!&OeFQqB|w2^Je9uvJbC3XBL5JRa=AY0-eIMrB^5Ftq#@ldD>~^2IStc z9?PikcOg%SmM+_gHS!uh)kMEnJP3wrhO&=i!CtBS&E0o%q3yIoRGC-+loYe$9Mv?4N?-*tWV&W8TR= zd|hXLp8LxM6!A;dlyoadz)DUZpWnTfp%~V7h*|FU^V7;gIGhB#?pF7#&r6HE*UZ!N z+>?63Hv9#5rSj_jhkepE6?m!x4;CsQ@E+?z@n4XU+r+Q}nt zEkv!k#z`0Rv!);&;6S?4$SJJ$HLXhm*{TFleVcf`OwYsqJbVO{P+B+k|93~o>M-_s z4gf9|jC8u=M&MaBK;G=NY!>afDXpn0{z`^@-gxG1>cjFA-K?u1yG1cZ91xF0$qgVx3_gJkOSmC?J%Ko-Y(U zufF%fjtk9&kZz90q}o$6uUJVK&I{|xk;ceskT=L__e(4o^WpB_nKLX*TJrDm1Ae)6 zk=Dm9-N9=kUC$JS>6*+?_%xYk6VG>V<$kXa^8`PlRX^PbFczN0iA2n+sXceYJ)DTw z!UI*OnMK?L=e?V&_TSWL=Az{1XM7tWIUXe&@?&GAk2ATFAK@aqMt1DwI>{DI&@C9@ zlZ##&!n0z%$_?{ zux9TweCmmP9#v*%f3RE595N5D@46>L|2G!qgg zk=FJ$og~qraD^r-P-1!&u=M%!$xxiPqW2cdn4>oqs!L4;s@qIGR5oB zsy;n(%#G=c`&lV)VooW0co$Crarfmdo|+Dup!%scv)cB(FTV238)UXJGh=#iYnOyK zoyMG$&M&oldSTDlFG3tJed=hY$m0fx}~jTO-6(|1Xv7%EH(w(Za) zRsBBLww)8J3Lig0RP$h}Nj^$koz&^ATo9XGX3TQv87ZdXbSko}Zb>%VQ#~($;z(Nj z_#mp0%*hn;w}IzF*j!OIW18iqqEM<*)BFBe)E*HVbXYe3#^}J7cMaE&|IpVjd!8E{GCK zEn)`P9$qpDSv6O->T2%R%glcRQ=BM`Ri;*PK?SyJjVq9KLcY7`1LH`cY?EMPgDk`n zs1(N5$-^XpT-*|EeAGiPFYT38`KYwy_{@&yDSe~m1mo^NPspu~UiWl~L1!OkS_T{R zNXEjn+CsfjE7h*X5R)}I>kBuY?m0Y2jFGRyhaDc|;U+0ixo(r!l^NHHaPX#Eb;(!V z2)`u&5i1*WvYDY?JeywdN_#jj& z!AxP3GcAlW2ui@GpqQo@j_r&e3f(2L;Q366%{mpa+UM!G(-&r!37<6shj1o+2{PGOp-g!os+zjFTJ%QJlx_}rv%m)7UXT1qNxMn83~%*jx!CM zpLFBXMeoq{Ggc|t->TPdAE>>`FHcRTn%qFbNX60QdK5w%3bUP6)n!}^2Uq^cEEl87 zxZglrYiCvtYe0aEoPOCIt4<-lN*fPa!kez=q^Bm_8f<^bbZL0038Htub7wDXVma7+ zBwPd(J3Yl-KlmqrDgbfvC(|GL`YBWwRfd)Ojl-rNs=v*d6LU}JTe2)L4^#OTvlmU} zlW7!)C;bjG>AC?6Y=j`Ai=o~9_lyV z{A7Q2!GMH^N7_32=3R4EC=Nq1+$4Jd|^`tf!t-FVac3 z+i|K7i~QI-Xu`C(gm6g^Q1&s+i#9TPuG9iscZ>usTL{ zW{?{EqD2VIXm`~#PbH0t!<%b^;Cze++|dT%a|rGsG(`pcCzVLidk65K(1(|qFPt}j znsv6whHAAk6dgsTbTlN8qc&ABnazqOp6~v!8O4vE`cq_49korZa0qWXp^$WlV&3SN z_!DyX-id;uF|Een&#FPyy;fyfFSZ<}8s=W`*jDrG`^D^QpQTl-k{%B(#?ylg8sg2^W_+s2$PvPy3^Sop9+SqTleTi?YKFg-gt z$dg3t6weBUlGKE-k>+ky)|U`ZjT`pO#{YUvtg<-qwtrKP);UcfaNN+TM(EA+;)Pbx zn6bSKj@Et+mkG}A#HEsgS;3oL8wjr?X$$!@)|g+NoOFHO(#w^r zI)ZU3Q3#80o(Y^T#u~Nc1tZMxdiR68C%2EE)t$027f+7BS6qz&D8H&JF$BmsxR7LC zGwvet9Xaxpr-JQqcobl$|WdP|bT+CmcQ4yd6JTG^77W(4eYWU9T}Fuv#*ByjEIixKk5;#qEXF@Nww z&c$z&vSF%iQ=uJD6WD-RM0pG-6wel-?Qc=cS&tmU%YaRrBIf&fz-}lhc_`hccg$m; z;a)z(++IoM=T)2v%$_r;?JQrxxWxb+hpi)8h5aKDP(=T!f%w__S>gRWEf7B)nAh_` zJ`23V>W@GM&Z{JP|32Jc;r$|8@LQU|gwP*_%zvdygN^+pdtune# z_PkCO&*h_s<#oTWcB&rT$QOgjZ}T2Mj2@rKX_xZ;nP^w^imi+KU-we(&p>Q3&G`QJM|gF+P?~gnh87H0(iDIz znRp1N;LpI6^r_j!5Ah@$#glBzH;Odq6qS9KB*g=^(q?Wl>3A*xK&i&Z`#p$gzd(2J zxH9h;?noM(mj}zl=F!|kW7E+ifwhc}hj`Q<19B?hMp)uO@acePf2 z#~;WZ{r4)fyu8wrKzH(iTnxQZfW(}^9=Ribqw-;r;4D>NVr9dVRA!M>1D`Kg$@hoGPv>tSKF+7GIoR)~wCi!(&m5h*t{M*B?5Ku=cgD=fg99^j zZHas4HYq>r8hRm`954_g})O zxrQq;YI1YBx!F?Uqq9L_A!hqhV=VT0C+>-K$35M+ zow5U}N00D$o5-B=&V*f_ueEb68pQcG+sHIk=bP8xwqq^TFOe@(~_<@pw=7pi& z3vBKA#sk*9Qo7f4(F1=T;eB{9A2u#ZUWYE{r;;fi9!!cA0B6e{(YGtnGPjlP;52yC z@6{K|7{$`JiCI*bgs8ADuSTn;1rkJPuzA=a_rY(G0HHIEhRSc1C z38vGgMX&wLV|qqkijikavMp2XDa>NVxoX<$u+PBw&0PweL$F{tukIR==X|4#m)MR@ zC3j>oA&OsD?^J4afN)KbS@`k|58KZ5E4UF$52x(%Wr5Vs^cohj{@}gcbaOwLho~Fu zrQ6+MzZctKPCH-UM;AIJ-M|60FO;<9%%q%ewaLHIW+GSwxDcPvQJ>PW+&@iS^&qufEhx2lSR>3dCk zO1#}XxhGN(2~2e&1?AJ7SOE-;4@{;_n`!)#+?-5y&Mk;BYvu0zusCBZIo{NPw-4uq zoz=#By}`r#`wW}mtto#HtrdZ5uw+lO zWvFB-yig|TefQ&rY4UM9+v(5D{uxdHLASwS<~Zb@ zlG&T>o}lknE~t-_n$zork7D1&*CB#Scjbavo@>ODuTk%jq)&Z_fgnSUY7GljmOoF$ zegm^tsg{9U)tx8c71LvXy?ZDj4pMRnIJq7NZ@K|$A^(L1ofKl6ofnXH%y3)!G*Q^q zQZ&W+Of?*+VBRqXfC^7T?gjJE&3g^{->L@D&=;d92)6B&=7!svQYCGWMk3;l{wDZB znEAtb#T2f%u~auT1cPO#pw^y5r6dGwOipWDgqrQio%#A$4*wtz= zz0pl_-J9Q)zP_*hB){nf;1n^5!N#rTy@eRWtavKV_e zUh!s(v9#BmNX#sxH37_kU(E&|3=fDo7ltqwRZpc8YScMrVlo;o#?Yj_yFGtTHoL{I zY@|Tqi)dkxkeiyI>4EFr5s-~pf$k#)(9=f0FtRC8VWTfMw>|(KKtd4E1VvKS6r%qp z5z)$jl5GJTm&a|(aW&3Hv!Re>52J4VusMs?LYCiO2^fXYv6e8ii8%co#cLS1J!-lQHn^%N+t zj#S>{89_`5>TMmDaL4p-&mJPsd({mGbn6n+EmQ==$}5*bKXrqq+>kD|s^Ek605i)? zDSJSsiSPL+Fq{e2wD-jXp~7BWI~WR_{>MHjF!iv5pul-dr}>tq9x4=~;wePDl<0fX z33UlLSG#XR8mcFDSbRnoo?;fD74%rsV8ZmxQ1Q=kMuaOayI9e4MUVUmscWQto3|JG zC@>rpxUkTyztmM_;T2bn^XTGt_Np5`!OJaO@m=TrBdeFCtXJw!{+3p+S@}K{@Ymo$ zs3m*w*qN^nMM&(lssaa6p_NOiBgP^w*N`>Q51Fx5W7J+*+NyIyRR~hhO|1_IMPX_F z3Wz2@NM>I;gu-Z1ndHEk`SRd#pSxWeio|$`XmjFIa&~X!S;H)ePXd?SYYO2$rxil< zM6^h?uI1-FrF~db>U`A@LTxyER z`vCNpwYQ#~;+Dhw6)pG};GFo@N37@^Bo4ZwDR3-~Vgz&!8rNo`->x3=kXW#$R5feO zuy%hOzBgOBAdslA8@(uC;-}zZJ&LNl9`Qf0j8HD+7EsiNj<&8WokTnN>+`OHqk&z~ z)`QZ?Q(N(|U(tWUws6g#GEo^6-J%-g7autoyY7295@V6`f+oLZ9Pa~c4V-Oho?G^& zFvH`uuZ8)ym=K3dL*u-lV+F}sNtbR9l7l(s0a19plFz}b%P2m{^qqd&+(DhwRG9XGl5 z1An(AA%ADY*#aiO4-7M_^Tyq*&Ivj7zCnfkY{0NyHXt?oK&+&v<{Mzuo9z9J$@}RI zAiI&NAeW`bihEP!am&V2m4#;(P(%bmO-X% z?l=C*H(CGWYvy+M++($+Ow4^yAK@DnW_wa_4H)8mUfah0PxB+>-a1d5=@$2Q-`bPy zK8%I{%q)7-$)`At7&Gp_nD0&tkukD!*(lWV$KRZ#y!^@XpKkALdDC(RaN~$*dg}2x z`)j}ZP08y9OkOtRp~iZZg zw$Ed_mAQmxRvr2o-O8NJGq)Z38Qsbp$>(p@GjdPa=st5DD}}+;%X>{){yYAn1rAA? z!2XUvu7s~j_Nqj$5C#)Mq~xwJ;3+GN6k>>nPE+5|DWXWqnxvQ8N@tnAw3Rma$NB!T z**^+=dal(!3M}Fh8ss<7_hp5#vRw5(QYYPk>J~Z!@JW2aPMuSdV{TH`aGPbKH{Gv) z!Q(II_g-0Ku6XhV0?Ci6aDz%04Y-~#*7Vq69L)G%W(;=a6-Xa#A}nlIVQ(-y^^4Am z<<&9ZcY3$~d#``Y)AjVguh&Ct8OBa?*$-UGy-xQ(t$yjIn}<7ZPVS*!BfWlIzTEU{ zAqT@5@~VL}E8Rdw-d8z~4X;xoiRw%Y7A)5pbu#6U`7iFFgx60Me+{VGngY)9nGHkL6~LDL5hrL3b$* zx8Pl~ra@nZSxK%9vEguS$t^;!Rccyem-21C*}=II?6{<`WZ@;$kqK+AJ=E~Ni_+T$ z4eo1sGuzt*uZJSmUJtzqvHNt1lutfZyf)UKCG){x$Ne6hOwFLRB{fx42B3HId*N#Q zOXZzcY`~9$nmKwx4C{x9MvV+5^F*9;jt~&#ZYm)E3egjW4L*TgjVBA`SD~OMM=amLMz+Pc^YKoZ{>UQN%sc?7<2gHIQJnwV&G$3in zXCp{Pd7xS$?6MtuZJCZ7QiT6V%>v)=Cr(7tkpWrNi)WiQtjlKj7F(Ns*Q*~PRM`93 z7PJJs-PbFj-v?Sk5x_QI+{G%!*D;(wG;a{#N`2yNe;FN&L6VmMo6danB~&|-A4E}6z&B+alzT>7hFdGW!VOy>l$lf848Dsiwj+6T&& zmd#R4)mP4^M*S#st`9MEP+d+x4XgzYvzE~%8wg>XPp&!g=HTl5s>hcMB&ChVlthzm ze&RKG`OUIayXj;j#&lr3sMLSp3eVQCPhtW6ceYmAWgv4WU0-$y{$ycl zTH!*~p!_cNq2TJs=p(D1SaK3s9AcwOXlisZG<kv={UR?X7)53&ql0AD}5B}jJ z2*cH8ydnsm{xAnuAEvnR^@r)q!j_{ng|h)HbJuZ#z9RHHM_>8eM@-&qChvp~69w}j zh>aGTc4#f{_0{?LIFv{7;&Tl5(qqjoOw5F_AJj8B5>QOKafmGe{aP1e9Yf*uy%l=D z(RWf$PYMSgJNLbOc>ec_-3Na4c6NQ_y?i*5E8Z(!U-;fnbI42b1bvqm&BiDZp`Ilc ziJ$2K(*lPg{z?dbLjim|0rr}qD*>fhF6Y0jeNj^f{?5`Q+ETozW#@%tg<*s``4PNn zEIr2O)@bS)WUtV!{c~>h19Hne;GxY0%tfzOu(snuJ>oA;_a%foLCJjWU;qcu%X-lm zVkClZ(jwr7X29J&OA0X0tKP2z?d{$Ech?s_bz#9;ns|zh^4zCb3Qy7HE1u%*r}7!| zQ^PakfQq_ktykUd;z+s>6XSMw+Gq2a#JK7@`rz3!+u{mvpao1mB=v-iu!w|&rmW6(_YN6P`>F0*#%a>^NJotann-%`FAaG9*9-Lf z3w{HKQqp^z>IU`-rc0?-_S>6G$8+Q~zQCtv_!IauLToa0)u)_rXWpi9G+*sb@kWafe|D|keY5A0 zzH4ni?ETX30NUrkspdm;-N)A1{^puvh7W>LuzekuThIE}VEZGSNX-{)yI1cR{hb{Mc3g}LlSyN@XRo<V>dUh zg;)?RXENI0yA8t+#$k-VQE)Q#msNDG(|YD5%L$WYWlbVv4O?TS!Y0QGxvVz2_YLi} zh#0{=O63sRGxOjh@IB+SM1VlgWD*nO3}sS7#78;Ry~!gkD#N8Q@n;!Av^wO`*Auq$ z6Q4yBh;o{-_JrpZCXU5-Vs=y2)Y#H7cIA9KLCMeOy4Y_}%JUe} zM3YX@bG#Vt8Cb8{01sR7A6VB(_?xq?-?5qJdkyL0Msu=cj^pz-SKwFf)EBqFA{c$+ zZ2DoA(Feck!yF#U0cQ3g*fyhV>c3paddpO8Lzd(2_h|o+TDf?icKgy{({AhPqktA! z#TTO1d5E5+fKf6z?NJ+ z6#H+0%Ce!vFr%6(QB~QO_>;H-J&g|+=Yk4v3jD>|a*U@^1Ot1$qZU6S$qJ46A@}V= z&`Sd->~h+Z#+-?_N$>%Ww^ANr*&_NW0GX6>B8?PqlGFKZpC{qavsceEa0Y{X^j4#* zzu8LzkQy8M&o%ti<`3~WKY5x7Kd6qPm+Z3;KFr*jp~%LKS$pPzX6;*zS-WaxdHf&x zcfm6)3#EHa%j4C7L-9X{VCFnT#uz)}YaT%}o8IGO!qk?MV*+~je{o!3NeKXUi+&)Y z)}ICF#{sY)dN+LuNw?R^?mN9?&ok`8KAVNR_OIPr#JUvkXR}C9PrVw_fyz6eAW?!= zHL%)fRezMuX;n|h-CyY})s?*XMVy6nh8**g$Mk5?^oKYEXKV!D7xET!3aY>J7bVo} z-)F;-=wd7H$I_l(al{D-3sSiIs>>ioJy)3R*kvDxx@-%F_Vhs{HKMApz=od9RlyVEq)svW_LAb&YHdstxtaP-zO0G z1OlHx;1dXZ0)bB;@CgJyfxssa_yhv~S3*GX!6j(fioF`Sxol2GOmQkDo9#qmsdIM6 zoXZhx-=R>5vmF_`PPNSb>@GE#$!_%=&X9Cbl6CUD+#+QRZ7durP)%C(xFM$t>VPpfOCLPC~gE31%6^plr&z4?JQMIiCB4M{$J{nvZ4 z;T5Dk*0uR4CwO%uuPP{Tw*JWV{#?z$Fu*r`4jP9%GPvWPDixR)qVbu>nK7nt zr1g*yid9pN`VjBR;r(_mK4AH}R+|31N{=6&X|i>fEnnQ+^8WUDgvbZmeh2`iRby*W?jt{>;5qz4vsMxhPV3>YWuMykZR_?U&1J=XI!?-#E$;b? zdOLn!uH*L|(D6Zb>b_jZ?>nI5y4TzB?$7xhpXK*~j-O{fye&JnP$$`gKX1l!(Z z%A%xf2U@CSA^FP<7L_DN`i$M#F0cf*zg_tW*W`3lwVwk)Q+4fsA!xRJ)(6e! zHEM58&oV<}jNRM>G(W$Wg8@y0&IFp(y5kfD{Fj*1vAm=?<>sB-taD0BHRSdpZ5wGP zEO7kGtxAl3UmoW%(l3QW=O>MZeN-ZymhE6@MLk#oYX?$xHUGhe3ORiTjmX1TrX7B(#p5%%Tlnc$xX(c|4fA0Te zY!gnMbccVnjjNH0AGZoH*V>MuU<^6F0E)GH0-a(zESkH&Q?pGg%*QaDWQ%_FQ_~f@ zvCBSrYzsfKV_)JmUi!5EQdxHF=gdn*C0xniV8+{zde02f6_TJ7?K90R!9lO`)W!Pj zS$_XsHxH7+={q{f7R}Rx1_-0fE8O|2*H(vqw{Ic|v9rZat}C;?bdjAs@mzDW7YIMm zPw(dc(KP!1SMt{X69$#bfAkzvp9l~@lr;H_;6}=A=c^$xBNZ|}_~`WAGnjv8T3PGj zk$LeES!+z|;!%V`y5D?TgrYz+kPIYt?(wha@njWF>Eh$Fc1iNONqOXz@ z!h^(r^&A;^Hw%18VCT+~(}^Ho7D%%GLYa5H5kV zGS+aI%Zc5#lhOsZ?H(USBa%~?R0E)$Z*c88AWPP3K{h@jS?%51;;!SK@>ThuORj7F zSn0X`=IIx7n6ciXH73bdBiy$yWIi?! zkr1d_HgCym&iR0Qt9#W^Y_G{>Hc!E@;o%$=!wj~M z6aS{c8u^AoIS+edA@|F#-FvR+9mu`8f!v!L$Z~HWaN_so26At1Aj`dh=w5Ch)qK+% z$j{YBkFENd=_Nen9Gzr~PU;=Vv;U_4b7!J?q-d%C5(D`e#s7zVBS-HJ7?N_vFhdOQvioBcYcYM!6N}an5R6)j?PSHQ%Rk=H>$3X|3KpR zcKVi(9!Q>rpF5iZ8Wgz%xPLuD&3w!}eIE;$JQSX(JbtJLO21$9299K?$exQ2fylx% z&An)CYYS=hB68DY9CFCxE{hrWMxo~1|<$Xvh!H(}s{etV-zw!%! zMVvpo7u@x>ikns>_YRJaN$wpQ4<`2xp}x=FqWHjw^QR0T(M#4Z1);W0iz%f&BtAh; zb5@in>RA(x2dqbFFfVg-hrHpmzg+x9t+nm$bH7E~u;S9WsfCjs9gU<|xv(NWqV)4|$vZiDTdN5;b=JGad2?W9vJx z7jAOzz{Cl;myYfG((W<5G>|sB=kXE?!|NP_cTe>CmpRg2erb6&ONPHo$A4g_9yHxc zJ*dv69$d#?l7I)>{+%`y1iC8`)`-sxK45@1sUZI8NdrjG?afSS@62qd_h#k`&%K#l zKV@z{kjPwSDWjZ#QF)IVj?b!G7>>`hq|n>q)`UL5ePaiGw4CY+4uz9OCyun8TkbON zY>%Was&Jd%QW|DnmUdZn!xxJyfbm7Ujp8;lE%zCIc>%joHvbrJ| z*{yu&tP3NjD`jxVh@$>V`nU`7@BBH#KlrIZMN8c8kbxERw7njGF{4zB&Lbv3ZyC{LIMr@*r;a0aS2bgG z{?c!#cy6JeB@rQIyf}N4Js@1M>|)A8?1~T9s^8|Gz67sqV6n|TuUiyD`mNqU8K^L< z|JntypMN-r{CLKJ;^UkX4l>{ik7XZbL?e|GvfAvM8>%P5_%W6Vo&LVEp}JhSzCO8@ zzgaSXrK%^TlxD2DzM}SGN?jn>ov`fO%y4O*x49=?=RpE^GoglcfHD2c@#G=>+oZd` zjaWKgG{#A+=jex9Ut9y}k zzA)dKV|{53E|ynF+FPP5ZwaxIJc$86x29RWQl*# z1;pBb^Z&8;F7Q!R=iYxp0t}b1qk=|788zA<*rK3K2BNKQpspg zgy1BaaWj-Ew)XVK>9MW0Js$hoqEeM`O%SlMr-ERbH*hbHC-zmFD%1%%n{A#aZSN99e#*8 ze5yJC^3UBjhpUZQEN0R!PD&!G**RY9*!bFFZ{K?9W%7_^()Yts2FnI~?LO>fELu_}y6Zr|arEDlbuQH-bB1q!$Ib%>37v}-# zRwF;_Wz9(;yhO}%4dnFFmjI3}`Ju*|mh6M8u~s<8CdTBZ(RrU+oVYakmD48A?x?yPu#?rc>IG1sf-0UaoFJD`Sh=>>+;U3!2|PiiwBJriXC=Ld`} zM7T0Rhh-S~x871?ZmuPC2J9RH{Q2*#z8#Kxm1gjQt3Gbo^`fr0Z_aYK--Y zpk(Z~eW~uo6o!yE>MHR?x%goDnnUQkn!-_u@?zyixd1l+teDu~WT>|SJ@EzSvd_>W z#vpS2v2i`@r`~3{M;UFZ+M6nU&dG!^F`z*gy%T7D^dDqC=P)zV1u&SE8~~V#k{ax{ z>!-46#DE|&34VeuznGz;s35vWq>^j+wEJN`E#p)8qixaTb!5ytlZ?TIZ?S~WbM~J5 zptEL=!K>z>>9VI^9dF| z5mr}KI59WBbuYd3f@~&7@4BT=7J)WBpdJL$?IdSF`qR;!LE0|^&94mm{|TDs&^JNz z;c16}Cg4&C$$Kq3ZSvS8GY9h38C;Mj34Ia)RB?uX4m@3Afa$FR{{4zb{S09 zjVppw;*|dwoKX=7+20d#iMM9UCGmLGrfRrQRBw>;1o#L-W0)3iQ*vTLZm98wL7~JA zXd-YtdWJq-@!;VOwlBW_OCW$g$|MfHB5OHvl2?chJnBDVId_lgHtJ#V#K-vU{M3=7 z8m)$(Y94uq6!Y6h5Xs%DzgM4xl83hi6T|9C8)L^nu14%|FAA=K9%cQe>&O5(`7l-!AdVfTE z1v|{8#HGP2yWZ((Yz?dTEw2w=^PfEON%|iFT-5%3Byj}+V6P_t>>R%vG=AYbhFMA6 z_$IEDjAFL_sSS&6z7TTsb)pk;GYlqf^FYk3p97TgoWGo5iYV7)w|GmMcw0u zTr!x`zQE5B=pV{Ivr8mTs?(H$RtUmZ??o{H$Ao!lQVMq?(;$3ZTx09gS9O}1Jx=MZ zCQq;kG@;Kg@#=hE%v z&J{3*&??kzkKyBuXsrAU8E-^O7)7#|yVhh%LNjDB`gz(=H`}$!K zdroo0{!{SE;FN#%efJ+(iz*wo*IsOP?98zJHGJB>Zq%%HGOj3*zc~#;C11yl&MTS< z9KsU{JU^VMEeI!L1=gUD^mnA&H(!!krqZu}GE0ezpgX;M3+O4Ve=0%hCcwt|ZR2w5 zVw?ehZKJdFaxb3C@J#yYI**u2ll&8S!SUOMWgQ&R=U85u!byVwoIzd8+-+ksHjsR~Q#sMZFyjevwI8>@^HxdyiuqCy zNTE}see@6=3zeJ`wD((!f1pk#r&e~7x413X<6G3qQHQ8sB15)Hz5=pexwZ{j(`u-r zo+y_!_5WPLIR;B6`sSZqVXu$a1o-I-DroQcp{h);j>MaY;y2MZZ?h3Y&MrOIT4ZpZ z{X4aDHfVt*2s?xIrP1ifFmb{=fN3C}di5XOF@IZm7vKAI8LYIHKQWNmQ9obqjD&gK z!Jot5PA)l@1>Xmwk8fGOP`PvXx|OdAIl?1oZ+p%0k>vOmCwomBs zK%;4-)0e-g!{+QZYq57`Ef%eDUVybk3WY;mii@5M!>|S@n_OB+>ov2-cBDFbw z#vk?w3fq?q8~!RP+9sZ^hIL{DwKa67<4pzOlKdLWoZo1rqMNFCxfN1svoG-}Fb^uo zXzyNN6Cd@su-J852_c|ckhQ!#ztKo=R3qG(EzaKcpQI&vh;d=Kgnh8R24}b29-XQW zk*~ZIwQndU&`d*&4JkWbQJ|SvzEM;gmhoO8Dan_~5V2#NDQz`a0r&KaPC zs^TYpTW%9~nCsbMJ`aDlq{v#lg&szl*FzX_)tl{$4%w+1bp65?M4}wO-6I%zkw*R% zan$MPeM^N6P17rgix{ylhCk61$^hZkq1vq0) zh6_CW5?|#Hr&mWyveA!O^+xxo-M3pRH)>zti^6Dgg=MwxGH zN6h9H=ZbZj9fPT72TO+*T8qwO9OCU2!8#jE&rHX;{cFnp^LQE!pZjfu`DUsV zw1suHgn2FEEz9}yl=su{{UkrFu)hw^&#K?Rer=C9$koIwE7U!fkq3iu_mXnuw5br8 zUEcnt-TJ>TvnTJE<;pu)0dwK59vdc(GBngl_PD|>G6t>;*qg()(C@dF=y<;`%(~Z7 zK0(U-y%AR!4UEqEuzMEEcHyZ?laYJskIc?yMHqdSajcF8lV)EURz)tV6x;r<`rT@Yx&}hXrdAioD4%H zex;-9|DaxTeDrExrt4>Rbp6YwU+BBOMk-zZX*|>QNqUkd?4wGt^FGl#TyJlkd_%z{!&u<1I6WtKcy(H`>4HMqJW+{?v-(n1Uq{G~Xg6f&AE5 z$lwTSVhdLrs7u+$#XsFdGUtWkwFOYtl?AbPrQzISNc2Rv2>df51_aY%eUU^Tyc|RK z&MqtMJ@04UtVVYW8Pc{P$Nq8EE$)9rw2Z$~E9o*9ylA3|?lAao3D4>d2>YSJupdB; zR{bcx);%r#d5-j%`8D}IS-{_n)4;MWT(0E(fz^a=5q`Y{mo6=J$cdLsw>)*xbo1G(?+8|;p?6o4MXpjxF zS?r4cqZbYZaVGc&#!}b&DzB6Et;$(B@I&MQup(WbQDx%flR(*dhTJI3%7+-Z?%Q$; zO>}hX4=2ie&izQ=6?$B9o;pLX6M176Oc4SSFXP)yF7IHYv&F=SaYHP1@Dw&Xm#$=o z$Jf?Qn|dJm{f{mF&rurJtoTP|kOiJ#%eAn zHM;n=2OAzkr?63KbHeI%l(2b_0aA4tn*opE#bNUdY*J-v|yM&j$>RlbLR zxB!GPvK5U>0qAv}$M^7kBrph}W89>wbyFG42f&j{yxHXF0Sj=3HEN8tyng}z^gVXS zGjL+l&8^kcX00qQPp>I`$yyZREp-q3CCih4*dHVN_=s2;qmDqv_Jh-n|Dbc}QFKUi zC;iJ#!x#l$_s*x^@Yb# zvxy)7tW({0Z@N|Iuh(M?ghRrls^!g(DkAGf^OEzapmb%r7iRRxNt%s%f}UI zu|OP6jxN2qpQ7}RAVNj2plzInr#D3G9--nY5kxX#4+?M7*Uub^fY>f+r zlQ*(7ya@0}3#vFuEH@yKwUT3ZoG(nMtf*a>t%VO0IF>v7)l`2Of`8)efXmVg|HL9Y zFO<9rh1`gu%3!p_A0AEu4a*%g@9T*s08d4;8=uCVmoSl+@3xmme&px7IIDWuU8 z!r{aOAJlC=ZpFA}I;pX~O!&`nzV*2|S&2)bP?~kK-t7Ego=C*4Y$&V#LsVnyo_6=z zDfk$7i9M-CZxEYqu-Jf^Z3K~#Z7si3+d(|h2Z5DY=8a>dK@&zBIm87VE4%5$OXi>A z8HqAjE8{NEi&^ek2e1q_4Bu`z3Y(q(fWa!e?q$?f#@tv9)9FyCWCkuWFXt(2PXohp zF@Bm19s1jz=RT|cXM7IBFDFmz?bh#_H&fzJ{v!=pW;^!I8Kq;V&bdDLR2oAL!|x2) zn{meMDxK~aqu5kf+=sHSuSyL;StJmy{xpoJ+s@qv$03osmv6;j=iZIEXkw4|S&!vT zoRP?#Ydto0YI;4U_>W}3lNlP(t)|AuPxoimI{oMB+2Tu#ogT6tyM8L#4cAu*(+#)B zPX_Ws4_vo~YjnVpjV4F61lRZMqkt81X1M@Jac^w{2vLt^kU3xMamJUXRlkAu0n!`2L>G%aXZ6A+RE>q4OI* zGAvqgoJKuZ1s!q{o(2@LLzOUY+5-gQoRYu1F?5Ug$0yoqHl{_Fr=GH_sshhE2|1dcmZKc z!qt0fVS^DLIhk7%5z?>+DKKJGo_xgFs?JBfJGEet&{ z_u24AFQDTD0+#f`c2OK;qDxLm3+R8GTKr#il>JLO8)}4JR`m4(b5a^zFeyVWd`Dy( z_7@`hv)F27*78=|lyFeOV2xoihe3Q02BOX?E%~thU6<1Z$~=khI+>0()>vDdYXdG~ zTR1+T8%Nzrb04cYT_Q};Fek?dn9J5q-vABsCf*(FyVN>bs?dwEoL*xCW%cjQ<*FKZ z&}Ry?-KdMxW@obsJW7EFb7RLurOPqkQ7`FHCEZU_ULBj+=#g$l;nhjuW(3qZTdebC zG!jK{tBX!>WmX+RgLgx`@8Dg>&^a8pNaH^xtNBzCE~q(K?Ea4PKwc<{ppe$hSk8^zlcnRdAG$`{~InAiR*_EC7L^e4{*;Y zy&nAWVaR^hN=ntgY3;b31f^DIpx=SqKdxbrHs4w`qPdzqGRfwdUM@!vkiB5b& zK<;C7WVSd@|Eev$B5d+v!hrC}8P)egjzOd}O*KXaBJmAZd6)u;u}J*K`uQv3Zy0~Y z`~^5`gX?o{2{w-{qMJlXOpHCtAce$~B3}xWwcc7ew%mv^*ZD)GjDz2n^5BCq)B$lL#umQ$R)W`NOa=DmEZq zY7j#3k)XhN+g9Y+qUQ#Zh8yhi8Hw>>{>r7)5KfHu4c~yHpYm{mw~}v)_YM6Kz!d~D zvsGvG$G3cx);@7-<$5wxca&QGX7Pt62Am8Ug5ImjlLMXUPQh)6rA&Vwq&j1Q~au5^+Y3z5jf(PjdB$s`5r@_ABVQj{`SPhyGjkH4b&FH})|9rw^xZ=ylBd4ipr>m2na zYI?2|Fg$!W-G|9bJZ+>DAUR*nDXMt99m*|$vp6#=c9aTH&F^Qrh~amCQYVDae{8;N zaqg(zDYc?R_|E%;~wfx`~D{~P80f*3Tq8=)(sJN zcmH7F1fzS$7Iztn$~0Mg_eyK24hV)->ny0;XRe03>7n=(S^f78EQY^@% zFP77yeg$Br2P*6y+{m7q-#aTf!M;XI^9Pke(L68pG)&6u(L3F}bl zi3&>SiGo9}M@Mu{KzgFnyu<5%;QoH#{2>bT%Lo;VH|MzCSUSCn(+}>l*Y8Zmx*7e6 zQc0#R$Nybxp6CDW8dubfvO>SN^8|eSL6L}j{Lbk{Dju$uH>opu!T+67@PDTiu7t?P zTlpf!`xH_F39rj$^BsXBw=l1<9d#*#krxFx; zasK-Om5_mBN`bN}mv| zXx;f8UP`_z0y1`Udf_5|B@Djm6F_0V)Os54RC7t}X;srb{^`ZBUyH8A+k%rfRhVF@ zho=oUpr2EKb%{Z}c(M^o-N!q$C(5D#1=~tNMnD;s*?3de6ki4d`zdvrhMj$G!{V{R zmRY9$u%EdA=A;)k>MgNQA6pfggADh38IJ6nK_62$q!%txB9-3jR+_q^g2TDf=p{$q zGQOs2^ml$bcv;P5qkGIP-C1)XJcWNRfILbLxSF3Q1^@}CzK5~0KlMn%U3mKpll%*Q zf=@Kf>*i*1?d&fn=i@4)36WNfG21s%7wK}n_hw#J+t``D8Yb-Con+$>!@#p$Oe#Si-v4_c3~C!AmA zpe2!l&GVF&hdHd?}lF_IB$vb?OPHo>Z-{Kn(Ne>9#Z>W6U7*p(rk9&<>5g+{+30XB`bX+ls zr)QdZS^3j>Kc?pPW-3fG|K--SM=2DdneH9U+~X#`YKr}^siT?7F3qel+340ydPwJ$ zc5dd+Q#6{eThq5Xn)xALywMDC6KhPdsg*)l4CS5II}c@=$wM3c^pMVbk!stAa))W- zO$q>%GdkKB+0jO`o0#vmF(V=Qb7f-jvLXrg!e^QG zTUHF>8!v4M*D;wrKHqtw8yl{9Y(9wu1Xqdi`5O5Zt@&BI4};qeK_B_U_I1$QyWEYO zypjt*A7^uVSC`HFgHD@y@*lm;+L$iWjE`>nL+4e0ok?Pr3-plAd!5?c#qv!(nfa#xE9|RY)exy6uWE{I zGl^z#Wa!d=-3n=^S3#3Im^SB5Gf8nh>pwF;ooKnP_;nc3CZpAn5l>4@G$c5}1c!UM zbiEbb8P1u=u^lOfa;+UttT>zzLaq9p(kJET1d-I)*>gsOtH+OEY&qkhGEsF4`Vzr> zd;GAH@groyFuvH?lf9e!^{Y|bH{rr*gbXP&);I3y_xV?EQ7K;-KSD#QxGd61&|mwJAyWiy=KU`+3J6faOrDv^6E;nVuQ)U%T4dIvm>oEylBL5@W#omrpk!h33W^E$rBxsq42 z=^8%OgIq#$FpcBuXLiRB{6`|zGX99P`vSVXhOwNw&c`8TE$+qslUmc{c7t*@8v-K~ zp$xyH2PUq$<|bt#3&d}8dpN$*d1hai9{!fsuzg#x_#=qZf?EerhB2NzQMci+ zM=n0~Vx}vmJ+~`^O*?euB~t0iztehqSE8mX4=csa`$#D+MVH&rm2a8Eser|hq?fg~ z(c)$2_+Mx8&_<0O(s`phx8Y3GaL+ec^6u?uV;Nt(;htd5i#%hn3Wbk*cg+J zy89^}46qal1@dncSsyH7G9pxoB4GSBD$9e)GnF~Ts>vQ->wLLQ4|W~-@jPvwg(;n* z-De>or?>kombJ70Lz8Ejo_D*?59;~P?(-vhe#L!$T+f@$^Z3cmeXMbvJxTp)5C3hm zAow`PuzC&2b&xsgvl;lAK?B1>Krgg+*WpTI4-ba$>_L{#WhP$!Ea-jA7y^yAkqt`Y z^U;7E_|AUD34g?X7e2{B5#-RoIDj64yU0}foPLxHC#MxW?FYC5=bO`E55?C|3v5#^ z%Ree&-6tL^;9u>t%S+DQ{hUW-Up1i}t4#f!_9@#ePY>z57cS_ul^61o9`GlMv6Y8< zg}^E$I*%qk!26$HDc-(N?tG_D z5y*HM2X*LxF?X~l&eJz30U=+fAGo3LhE?U`i@H=v9|Fz~cbm?Ho%`H}N@tP# zFxiQ_4^_^s?!#>78|L9QFlxHySV=hA8pSM};CH@cw%rzIkh}eS&e7&!qtnm)(uMzS z00)fcz*hr*Mlo0m)sL^U0_TY(YJB_w&~*`j@*F%Vohl9JoTeVR3v@NIRPiuDtC(=d zz%2=F&4u#zU7BCX3B(fI5v#n{#HdAo$BH^z>0 z&eVcWO!>&gE1mXJ#|=ivVp{9mo&OE>(;1&JH@@L%yj*4GrdK#|Td{M_2OX>4=R9@i z2kFFZ{!S~tuXF6(%xB`aTC|MaT&mRi=fm3?Z@!sRxxafkocKm1JI}9$f2z9$?70Qb zor}$SHA{wW-BRrQ$ZUFT5$>C4x%!mpSdIIMmEN}w;uh74j@4w#O0#E`1mkNo;m}G zJO_-g!|C5m1z4VxN!4>(sBw`AI_G*s$_?IKhFt#ph0DkvG?sHXNWw0v%x@O}u}P`p zM>WdEy^N{ALDI42ThE~VvL1rzXkkb`kV5FLZKVc#OztYDSMZco!8j1hqD!-^hA(xe zYHN8995B&bxjZo82d^BpEMLl^b_CSrrgoH>f~7ATJ<$Cd$6t;0l0P(R8jHYqLnHP)pD&mkk)4{QT<6>Kve5o68)`mX=H~d+yhJG)8=x5q=Iqua z1#@Q$OCK4fDeS4+z38l&AtnpGj52X(%Plfv3ZdFC8Aw>mk5wIVRB5zuI;ygs-Ly|x%jI6q0$XjXlvsnT)MgYL;HeF z9&vS@hT{=L+a}@8Tx)j;9=Sk!9gz;8(2*SsXB2Sc<4G7RCm8x@`&=A*Aq9Wl8GRX= zrC{esrS0~*dV3-lEdv)5qmLs5?rL9rVLkCTkTw6ZtWxP8Zipr$FRU}pja&=Emv8Fs z{9w7(0ZJ4vI%nM>wF%LRqD~HXxi_i{9a>7znm8+p*sT%SF3UTY8YF1NS*aZ3ZmX&0 zV)?AP861|4-@B~%GJ=zom9DC}1c`E^G4I{v z%p8r#7GB^PK1SI{37R4TiQ3Bk5nZOxi2%uvZty*XP;aT#7^F zTU2|caMecV+7~*$D4WGWi<9WBJ|9!Tag6FlsJIr5l`D=gXG9Z24ck+3afJR+=~81U z9&r^uGmP+P;i%x_IRc3ldd3}~Sub+b_&A?kB@c|KPYKyOozs4qhS8zt7J3!HLa+s6 zxB{VSG~l+D^o|{&0J5udOE=Biox+-y@1>jYlwq%eL{)vQeK-(_0UP@Yw%CK}3BZ*u zFUAqGmz)akZ-F>yEFWao-zoAS^L?0oL6LpQ(9%}IhN+$fdCA<_pq`Cwq9lnq4=|!DRp31;^ps*>$MBqCzF1 zBmK_%5l)J;Gc>>fPOK|9-sW}oqCHOpz&v@;p4XBs4|VHvP2AEYI)=myWA~1Lp`Ypr zEn>PA-`^c)0MO_tEaKwxcGkycXYn_1w01!#M4=`XnjbR86Al!xDk-yfgi3yGrqjI} zTgxvPgzio+U>UM!6sPj{Z$Kyk6dAn%W0%1$kY{E!zTz7GVPP?yAsbtl>5Mmr@zPjo z6i2G^9A@O#xCguFAVcgVrhBB1IoE^n^XQ~wEndLVsz~1ATN1I47A;w<(KTIxtFJvo z(aD5kAG3qz3$_m#|Wzx$xpp2OsmZVf}La4%YpQ$`))29b-#7zLwbH7 zR${HVD!2blXF=u$#P=C&JvMRJ47`&xN^y*R<}=KL2EAA-R|^@{>V6bZu8~oWR|p z%wF3L4FiXL;{=CSQ{pEv#cF%N+G4eW=?IK#Ni9v))7P)iYkYm2O6BMmB z-CA*$a+JRK_y~TjvaO+#_)?x0^e+>|v(c>OFEJ)2I&}^vHMlUx%BJ&(8vD0o2E?p_ zK(VGV>zM(qhn5ARed^|3h0jW~WLF?!O*=0Xf0#~%%Nm;I_72&mu3#Fw_@+*7p6l2M zFl+j^)EpIjLWQJa3ohGNO3^$We;f{9%U?exd%rg;FnkuD$^gS)kFe-SYk5}ReCz40 zp7(lVU)6dj5DfP~aCTP^3={y}ebWw#f#ohJMjZ|mEPoa01d(=NXu%%_AnU&RcLU_@ zk%s_?foVh2e0Utu!m#!95uG4w;D8ldB)%Reo?o#R-48Jg0jzFkFb6x??6XaL>$>Pq z7EoH06-@3otA{0B5-vz+L^i@3h~3T-dl#3o>5tO)Kh+y_w4d zgxW^uyCE>^R}WKrpG@r-cNxR31FMHY`_YTg`Ox*E>XCdu=UhuzO`Vib_3py1ei5qP z0H7B#Qg^Fa@lSi{8GPsBM)q6l+k66aO$^r?b?J*S$iKg&EQ5#Vhjbbgm)U=D4dhmk zUnfi@>lCGSduPN>ck%xM^_I^aIU9PhDOk71!(-g!!}dhK-OVr|uyUH{H_osP6Jj9w z8f)_E=5mqm$$XFWiMuY>*wJF2kl`pVFp<>WtY+Ba^a$K4HEZQJuWiVatY4{c@^M{RGpcSFhutrlhT`QvN zai}PIuzlafRn2SC(CBm|iX&3&O+YZdpBxGb-nB!-ydc_M`+1(cw@NlQHF0<2m6wlJ1UOjXSoO*60jxT*c3KmWE!o0bP1gZl{_kl zN|C#G!6~k}0r0?{vya>CwxCeSPPS2T>rL<_z$iBdljU7or5!El>E3anC*Whw3)(b0 zruA$Jca5vTHQXJE95Cw|e(~k*CN+kY&ZV?Wh>c(-7el*{oW#!PGGf}koVI6Wj;dK| zdX~=XSvsm_VNdH}_M_sTeozw=*`}Mvp0mJ6*EVdQ>vO&Pr=JN|ukM6^gw-3~oqKlO zt=U^d?ak@MiRy+`*%9kRAhbbwi7h+Z3H^m zCU|e_n+R>oW#HR@`8FMC#tF66&?*Y7%fY2N`BV^U-9*}<7DJI)U#tjsIhf^WI=1pW zvk<*SkqT%<$b$8NHQ~*PS=Cw!?s7cQrKebuW)YGAMsrrinXJC~L^8F+W5Hq3^g8P~v@rg-if<{x9=Eq)=(XM91h1Id@UNd69pm{cbuA2CS2 z%f6A;&w@d2hwOF9%2P8PI*kqu-%j6#p@`$grQ!8}Zk=i{fOd!hL6?33;rYG16CsrY zzZtwW!hRc%C5w+{_Zm;r@DD`Kn%j*}x0{=bQ&#)6=GTVC6QdXIw0ON4rhJCSEB5pm zU0J**ipAT{W%2eTfJt9pik&9j?j%3H0brSjJqpK}bPbkwosV9e5-orL+61m#ahbb& z3|IE}(ORP$QpN4`?S=yZaT#kNDx@JufHXkt;EbqnMpWq0z%8>!3&ma4g`tdXDjHPV zlna?S!2dPM-KggsdZW7K*sCLQ)~U&DG|6^N)NE68-cHrN&7dg=&}Nqaz4*(254{Dk zu+h1d5H}(~(;`4`H3TT`dQQ$j5(7ffgI|j5r2$N(NZl=6*E5%vvUFui_ zMybYM`ku8Yo3kwhkA$n3yIZ=<$AV*rzst$0jdHQsD6;_2;!+)}U~U`E zVxuq(=G@?codRYG2zSTR+1BC@48RYyT`m%pbQ?|nL+Vu?A^8DoZ%xr#YMU$jyYB?M~xT*6NAE@3BY|AsZ= z?KiO$mhXH^^>u$>X~>>Sd@r$VK;5X*U|gf>#F6O|3Hmwbr-&F$z?^XDcew^-5sa+# zyRs;_>8P;nMS{i$*LS6eow|iInE{xzWjurvO4CycmHm?cgJ9c)w0=K!6pD@5*;pp?@Os;eO>OID@HS zi*q_f#1)$?#rLkYy$3nv*09dWA=|;F4=myGBQD9Oqi*#FW*8+UnEBlv#0N)#z0q2_ z$|xEh=rtJm4n(24zOHz3uC;W{@Rw`+A7MqmrR?|(!T9UYVO@KA4YcBCrLP0>z~u~k zO>?~gK%D@;v?<;+LUWK}rqsjV0<&ys2B_TOVxTHX=_ep%PUvkFs z$-W>rL`MYB5D-MvUJirtlKfSzz2dKDvkC$*wvmFtZlRST3i9fAoGJU#5DJr8yNfs> zf9IxBW2qOhy>hmST*gbsUD%ZvaB@GvFWMyP$h}vy)&&S_+$qPPCxjxq?lN0KR@o+| z-#O<^m?Tmu!Bx9qsT^%g!l`BLf_JBM!b+NHxQ{ZxvwioAt(J3MRU9`7qjCR9HtUBn*7~ zaUFd8yUcxI+#ob=yCi%+lW;({)+{-ttY6m6p?+Dv<@cuYep%n=Zz6v$@E+pt4W6@n zhyE`+yPMCKliR&}5A)xlGySW+(zLJV|I3*5^Nsyb_!q<*wS#P67x|*tTlpbh5>H@!W&Z?^-_no#^+vOFi_PcL?-5OZ8^Z@9zNtd=weF<;6SWV5cE@ zF#2uB&}HDUV+>2SD~ulbLuQsi(9Vx}JIuLz%ZN^B*e^8fchPXmfnd)&!$ZUQ1`X#Q zgoeLA`am??pXv^QhMznApNNKMEcx;I{j&B%`elto8+;dk$4C2RZRPi3{+dX;j`uI{ z@aMyM|2O4=U&isxp6IL!G|X(IZy<{pjOtefno#z~7@W!%V->M0u#7MH)iRb{tWU75 z%=kJDo|5gXvgGJ=rwN~Q?_V$g=?+kfI-LOu|&ad@z;3-I%i}S@r|!kS3%73 zYS72w?*>a|75Z-O7qy2DQV4a)z*2pp_Pgyt@nH0-t*G6y0@Wz`utgB_JB>?Rg{g70 z-{Dj1Nz<0mZCAs>k&+8lNp;+(7upcrs^5I`?vnZ;nK*?D5)aPQ83$_WlOC}AM`8g{ zSSGY6T|*VNIImw|uy5n{)X{ESFJK!fk5RTVKK*B9V=Vk`&F#VBuOCr!WH4RUpQj_G zRlUiXQ!NwBGRSuRr<7f1+Os3-Y@PaLqmtDW>k&%U_JtdmtT(+~AqS}G%1RW*gbb^I zi83b^sCXbbeh&z|&bRYc43 z>OXYL(z2XLsyw#4DF`^qdOg@Jb{er?@-hb2crlEf;3=7XZ=G}x-GfHO+$R zqFzQUx7jKDGNOmXOc>`g2R7F&Wk|y~(_0@fbuaY>v5}>x;W&R@`2ocL1Lg&_fw}#I z3qPSqUCbAJl1W&AALfsK506|P;kG!9mw%EDJ^^`#%wrw$;4A2pE15jEQ1nb_P(dhB zRbw7lB!hf*WsQ^5>%(;GscPPyH;85VDjpP&K_KuS=d)+xY2o?S^j9_TgE|+XbM6v# zlQN>{Es4rm&J;AE<9m8q4bP~sR;07xwOv5Cwe>0UWy&C5B)*Bg|9vw$Ig~t$CGpA8 zvh>*Kls&l%y|mLDJC(q}tkFZnQSZ>n$N=ndJe1~GehP-qiUo2%B`Q&Pc@{PwN1>#*K0&(A4%< z4%9dvxfHmj#}#LA2>L%kdjTFQ^3M4Mmex=Dmedtw&5l)ts}~D7l`Ph@O2|bx=rt=I z;)RJY80nmo+tRJlZqJAo?oo$6#cFoGFYA3)_e-)E z^3nbN!T7$kE3(J6L7=)-l6Sse8P&uF}^$NTD3GIlQd}%&6 zBO-JcaO&CkzHYHXcOM3Zg{>7k23qmgRRtd0b!Mn9t-s*|(6#D+$wP1@pJ)Q8MynA~ z*tJFR_mH2yS9^Jc&VgN5{fXsMhHlI}40UVHsVMzxjZZdQKAb_IuM4_=vR)^MTRRd~ zR>}%FPu4=$lG-$=Egea33dd7^s-F9QaM##nb6lncMLA^XD=OV`&asqf{T@1VoqO(X z@Ih{uDKxVTy(eGmc>ve_);gl&aWIdcxi+N%1nQM^KeIAjRhL3FYgU3cdtAd9pH@YQ zP}9iFcGG0;d|Zgn+kS#_>DI6n-HI=1vt$zAY0-$7D`Eju`op$)Z+!xV$aWmdC3}nG z^SM~(N2I9U;){3}Q_P*s=NczZcM5yDSGhQO;`_2|dNJL^1m?|tTDSwG%OUfJ^L5Bf zWYRV}tG~nrWK!YGDqb30|~znc2pJ@H^3 zN9il1c>~7Y?10vWwYSz~4Z1Bc$Qi2PergaVK?=%=9j>mdX(clIp-$lD$FvZmg9^Nj zm6B)*~uV~`vgZW%F?2pd< z`n-bA^v|l_DHtXv$&3O2kH67KcmeB$t?+>E_d!_0(x`R!KZ*%Z5aGncK#Dcaqa7@Y zD^kr%R^x-z6SY$jg>dW?ufwRL%qv3WI$d*Xr1TFpJ>9BqkW?0T_X~W1;v0{^&+EAU zJV1PFN48xm;@d)Syo_3%FTJ)eZE_8bkArk(lv|wtAd5UNn?0_sqy~0MOcn`+7Q=?o^x8R5@GoZQ!M`pPLI+fmvlFQsC&_xZ~_q#U=bB)OJ7)gDpIn`f$ z`C7wZ<|@J2aX(*87@uI`2P$M*7-)dOF}ub2_9eU1Qbm{r7*Ivv2R+lwh2o)mG$!}* zM3B5A-T7se@2msSKXwKPZEs(z{$U<6CkZ4!9%Ng;$EVB=D1;WMtZKcDPg*GTdo)9X ztmWgY>^-F|R{hsZ0`aQkeYyj zq^`+Y>aJ_>uuUs)^jp%E#gHDoN`7e)O)QgOUy-I;oS+XQaa`UepZLAhDod|uhUljIJ3y|>Zr{5&7%kR=nAh#e|g08XtH{7 zoZF+Qp8I({vM`h#l&_enTU&Pz$t;QDuTL{@Y3=R8WpGd6vV&v@g_+q_{qsBqAIa9K zvC&y{{)f!lrn|RFNh2%0x-m59i1-^lE!kEM%6D!@VAT2m1q1+Ma2oN7?{Qrz*)dXH z4mX5{1+4ql!6InAfs9_l?fHS?nbTt3A$&gS*Xf!tkoG`KAP()gUbVwggIpYf(%wf~ z!zTrYg%_sboMpv&h7%8MWo@tc5gilER~@6vQj{CZU!wG?m)k3=K8uIU_GG@U6o)G!u|#1=W}(a^ej{mggqU7J5Xr>bAP-bXAXG%cqXDRlD*Br7pMjfxUk*4BxpT0uaGOoYk{`rt80cvO1_@YrI4_b z`zXsdKLp!v)t!{ozW*4E|0xiRZ}bOOrMi=vEnV{GQ)eoSX^*nxCE2Odg2p3iuyp&p z<5BkWSu3+k*VOb4rtwI(s#~aZ`+OX3Z(s_c)kWI$g;?))dyl9+8->59{UMd+;vg%T zcWxiTdL9w6`xi>H$_v(+^Na*|VTs%VTuqDdO#ltO%m*7tYRsG@Pz=y9ckl)JaahF8 zEfjOCsBFj<4UK8R1KMiSMcJSEohQ?pq)af?U%No0gVxGQB8NueYyG9KSc_hOjB5=K zHp|MYKaYpZ1eytEt5?`-oyv`xj+Yo#Y;5SW)DQMNdVZIUT$*i1BZJ;SSUSkouZcde0Z!%j<<>_^*UUf|ub`#_c|m=o!0wD?T1khI?Wd=V9 z;NvOZzDhgOes*QCu~f@YW<;y`l_88GM?rYC+fy7s3AuMgXs%r0gD#46E;W>HCOT21 zbU*rwV6oQtm%K^5l?P3d4#~_UIuEbaMC>usbQu}KcI9k$B0?YPyfC~^DG>tYH^xZ_ zvLK(Ej)EDUuKJRve$ZV`l+S22KWCrVy>}K74ejUA2QRra98Ek>SfF`=L=uT_A#vG} zQ#|2nz{KKRB{pdh-+|9slP}r*ekx*33wA7to|>469PvCxwAA9o9%)ZDl zTfk27KV@5k0_4A4P1g)ItR?z9Q1yRSyd7<#aD1IFQu_0^no@eT7J%McPkf35P`cs5na3PUJq6>+rJwXtt zeuAr){d@)9uQc?+eVSHN(;r$l7g8!YddWFVU-E<}M)lTauBS#dU{Uxq3TLLrY5ka@ z@#cbX>Arb8TJNDOhoM!U;NhSJ|I{i`q3(j8saEXCexvw#g?Y)W{_@@07cP<^%ACCw zM^rvqcV0v5g7)9&*2lvy@!N`+$hWM;cdK*B>jUm=FCTw~^ZI+cakVl2%WN>`d7dMf zZAYpvW;aOVgX?%$D>`79)`W-Di_l1K>c5%#_0AR;i!KYc%BXLc!`iFu8~-{rAPg^8(2s5uR-;WFWY+fD)g#3PM*_wVH7?l8jPSF^leiPX{i z^crsXg|mW*%jrhI&%q;HP+S0~2r2?Z{#EM8oCAQk=2S3!g)EmNsIFAc@Q!XMVc2Dv zBRmCFR+|rbnE9ZA*Ro)&`hH;caLJ8+t6rw*c=uFu;&<*8@FRXTWw5+NDlaI4CZdeq zLHh-Kl4JxLP82l{m_GOnC13)IDctMb9M0}b+Bnt5mFKJpmIB%N-Gc%!US`Ye_3HAo zV#!xAZs);^_pvDO#$z_g-5+TsPV)z!)EYL6;~gHXL3R8~H!or|bhE-<=iIom1ARVf z5@CS5yDDS{=n(rl)1gh;V2_i@xr~m97}X1g-$uwpDvTZH;q9*EWz$JYa`Pkch=G~h z#prgQSZD2>Pfb$iJ@L+&Wp>46nZQ<=-oV9{+J0@GM&woiiRiSP*-^w@C~M6^k$^%T zx0t_r1Nl%%)ri~S`&5l^_dAT_Q=PB%ld=3Q9(?SVpw%9rHLUOom+|XrA9G5(=WoPl zHhJ(m?`h!WfkA`=MISUBHOobpCi+n`EYsI;(z{7{z^bs<%R4I5=y&S3N&4ZYXYvya zG93v8OK!lRXKu(^yp{?X4$JDLisX!dH7KM8n&b|mPb#;}mX`#s%I?@$mgw*Qxb6)_)dCS^r8yBdH&Fab?ItkgqET&jbYYnovtDX?N>A*NZNW{OoqZpV3Z* zeL;RO87kEA@aQMKvyvC#)x>4$hCcwT)!!E7Rq}1aZ#zEtM6QOK;kdbS*GhHatDZg6 zfh;gjNPvh#3^$eT%5d`_{p69F!li}-;iA*GSMMTN)6E7msSBJNo%d=3!Y>vFh#%3; z1EhQ40&8$UFNrq)!lqoOQx8p77}#0c$DpjTR{UfrY^*r;`%0LOV0$mC)x*0jo&~{MPep zhzmW0lS|D9UDIR#VK~62YRf7uQ%IcPE4+%mdQ#&F@>&ZUh?6%`jS8g8j*8lSvvngR zdZT+UHe6$;@3b67(zQ|#bsBu>-Y869Pj9+dTROOmgCuct4Hj@d=%KZBm>F}K$?ToO z2%rpA2en$=94x6QiV$!;IeJc8UKZ!u>@bczS_BP{xx=ru_^`p=P$5pig2wwA36iV;5_nY=snTPLN?v;!X5jPu8~AP z$NE2zPk+R7=dmcg8gC`sLf;RTJ{z(oyzUW_Ya|IOpfXipN`W>ps#OG$Rc~~2s+Nj* zs{5-|f2y)^Z}~J_;%*+odl@()b2ctVwq-m3RoLbE63AaBxs>K0Vu$&VuIU~v-5VR; z7Nm=P>|im1v-Ijj?!AyQj9^2}vF7}-gOmB3ZgvxjNQk{tVY8^3Vvl8H?uk-SYQZE* zE~Tr2jW-SoCT=XUCg59qLUC6-g2^)^#)^CCMeuP*ZQzd9-DampcX;btQ;1soUMMT# z11^#G8a$>;q{@h;E(5_%wrJiVU>wt|*u}Zz{F-n@serK|Hi)c~4Y4^J0>v^vPP*

    a$Rf{_pZ2s_UNn#IyD_io_`<1 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

    d=P?kvP4h-HOoeZgQZ3q8Ox+qfQ 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

    ka!%Q*WCoIIh3;-HCri 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 ParseArgs(string[] args) + { + static bool isArg(string s) => s.StartsWith('-') || s.StartsWith('/'); + var dict = new Dictionary(); + for (int i = 0; i < args.Length; i++) + { + if (isArg(args[i])) + { + if (i + 1 < args.Length && isArg(args[i + 1])) + { + dict[args[i].TrimStart('-', '/')] = args[++i]; + } + else + { + dict[args[i].TrimStart('-', '/')] = String.Empty; + } + } + } + return dict; + } + static int Main(string[] args) + { + var dict = ParseArgs(args); + bool errflag = false; + if (!dict.TryGetValue("i", out var input)) + { + Console.ForegroundColor = ConsoleColor.Red; + Console.WriteLine("Expected input arg `-i PATH` to be present"); + Console.ResetColor(); + errflag = true; + } + else if (!File.Exists(input)) + { + Console.ForegroundColor = ConsoleColor.Red; + Console.WriteLine($"Could not locate input file `{input}`."); + Console.ResetColor(); + errflag = true; + } + if (!dict.TryGetValue("o", out var output)) + { + Console.ForegroundColor = ConsoleColor.Red; + Console.WriteLine("Expected output arg `-o PATH` to be present"); + Console.ResetColor(); + errflag = true; + } + else + { + Directory.CreateDirectory(Path.GetDirectoryName(output)); + } + if (errflag) + { + return -1; + } + + using (var writer = new StreamWriter(output)) + { + var schema2cpp = new SchemaToCpp(File.ReadAllText(input), writer); + } + return 0; + } + } +} diff --git a/server/tools/schema2cpp/SchemaToCpp.cs b/server/tools/schema2cpp/SchemaToCpp.cs new file mode 100644 index 0000000..d52a7e2 --- /dev/null +++ b/server/tools/schema2cpp/SchemaToCpp.cs @@ -0,0 +1,180 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; + +namespace schema2cpp +{ + public class SchemaToCpp + { + private JObject schema; + private StreamWriter writer; + + public bool Error { get; private set; } + + public SchemaToCpp(string v, StreamWriter writer) + { + this.schema = Newtonsoft.Json.Linq.JObject.Parse(v); + this.writer = writer; + } + + + private void FileStart() + { + const string @namespace = "dsp::data"; + Console.WriteLine($"Writing out FileHead with namespace `{@namespace}`."); + this.writer.WriteLine(@"#pragma once"); + this.writer.WriteLine(@"#include "); + this.writer.WriteLine(@"#include "); + this.writer.WriteLine(@"#include "); + this.writer.WriteLine(); + this.writer.WriteLine($@"namespace {@namespace}"); + this.writer.WriteLine(@"{"); + } + private void FileEnd() + { + Console.WriteLine($"Writing out FileEnd."); + this.writer.WriteLine(@"}"); + } + private static string tab(int index) + { + return new string(' ', 4 * index); + } + private void ForwardDeclarations() + { + Console.WriteLine($"Writing out Forward Declarations."); + foreach (var kvp in this.schema) + { + Console.WriteLine($"{tab(1)}{kvp.Key}"); + this.writer.WriteLine($@"{tab(1)}class {kvp.Key};"); + } + } + + public void ParseSchema() + { + this.FileStart(); + this.ForwardDeclarations(); + foreach (var kvp in this.schema) + { + CreateDefinition(kvp.Key, (JObject)kvp.Value); + } + this.FileEnd(); + } + private static string UppercaseUnderscoreSplit(string str) + { + var upperCaseChars = str.Skip(1).Count((c) => char.IsUpper(c)); + if (upperCaseChars == 0) + { + return str; + } + var stringBuilder = new StringBuilder(str.Length + upperCaseChars); + str.Append(str[0]); + foreach (var c in str.Skip(1)) + { + if (char.IsUpper(c)) + { + str.Append('_'); + str.Append(char.ToLower(c)); + } + else + { + str.Append(c); + } + } + return stringBuilder.ToString(); + } + private void CreateDefinition(string key, JObject obj) + { + const string key_allof = "allof"; + const string key_properties = "properties"; + const string key_required = "required"; + const string key_ref = "$ref"; + const string key_enum = "enum"; + const string key_enum_alt = "_enum"; + const string key_enumDescription = "enumDescription"; + const string key_custom_isRequired = "___isRequired"; + const string key_custom_name = "___name"; + List resolveReferences(JObject jobj, int level) + { + var localProperties = new List(); + foreach (JObject allOfObj in jobj[key_allof] as JArray) + { + if (allOfObj.ContainsKey(key_ref)) + { + string refpath = allOfObj[key_ref].Value(); + var res = this.schema.SelectToken(allOfObj[key_ref].Value()); + if (res is null) + { + Console.ForegroundColor = ConsoleColor.Red; + Console.WriteLine($"{tab(level)}Failed to resolve json-path `{refpath}`."); + Console.ResetColor(); + this.Error = true; + continue; + } + if (!(res is JObject resJObject)) + { + Console.ForegroundColor = ConsoleColor.Red; + Console.WriteLine($"{tab(level)}json-path `{refpath}` did not returned a JObject."); + Console.ResetColor(); + this.Error = true; + continue; + } + Console.WriteLine($@"{tab(level)}Including `{refpath}`."); + localProperties.AddRange(resolveReferences(resJObject, level + 1)); + } + else + { + var properties = allOfObj[key_properties] as JObject; + var required = (allOfObj[key_required] as JArray).Select((q) => q.Value()); + foreach ((var key, var value) in properties) + { + var propertyObj = value as JObject; + if (required.Contains(key)) + { + propertyObj[key_custom_isRequired] = true; + } + propertyObj[key_custom_name] = key; + localProperties.Add(propertyObj); + } + } + } + return localProperties; + } + string enumClassName(string propertyKey) => String.Join("_", UppercaseUnderscoreSplit(key), UppercaseUnderscoreSplit(propertyKey), "kind"); + + Console.WriteLine($@"Creating definition `{key}`."); + Console.WriteLine($@"{tab(1)}Gathering all properties."); + var allProperties = resolveReferences(obj, 2); + Console.WriteLine($@"{tab(1)}Found {allProperties.Count} properties."); + var enumProperties = allProperties.Where((q) => q.ContainsKey(key_enum) || q.ContainsKey(key_enum_alt)).ToArray(); + Console.WriteLine($@"{tab(1)}Found {enumProperties.Length} enums."); + + Console.WriteLine($@"{tab(1)}Writing out enums."); + foreach (var enumProperty in enumProperties) + { + var enumerationsA = (enumProperty.TryGetValue(key_enum, out var ___key_enum_extract) ? ((JArray)___key_enum_extract).Select((it) => it.Value()) : Array.Empty()); + var enumerationsB = (enumProperty.TryGetValue(key_enum_alt, out var ___key_enum_alt_extract) ? ((JArray)___key_enum_alt_extract).Select((it) => it.Value()) : Array.Empty()); + var enumerations = enumerationsA.Concat(enumerationsB).ToArray(); + var enumerationDescriptions = (enumProperty.TryGetValue(key_enumDescription, out var ___key_enumDescription_extract) ? ((JArray)___key_enumDescription_extract).Select((it) => it.Value()).ToArray() : Array.Empty()); + this.writer.WriteLine($@"{tab(1)}enum class {enumClassName(enumProperty[key_custom_name].Value())}"); + this.writer.WriteLine($@"{tab(1)}{{"); + if (enumProperty.TryGetValue(key_enum, out var enumTokens)) + { + for (int i = 0; i < enumerations.Length; i++) + { + if (enumerationDescriptions.Length > i) + { + this.writer.WriteLine($@"{tab(2)}/*"); + this.writer.WriteLine($@"{tab(2)}{enumerationDescriptions[i]}"); + this.writer.WriteLine($@"{tab(2)}*/"); + } + this.writer.WriteLine($@"{tab(2)}{enumerations[i]},"); + } + } + this.writer.WriteLine($@"{tab(1)}}}"); + } + } + } +} diff --git a/server/tools/schema2cpp/schema2cpp.csproj b/server/tools/schema2cpp/schema2cpp.csproj new file mode 100644 index 0000000..0eaee1b --- /dev/null +++ b/server/tools/schema2cpp/schema2cpp.csproj @@ -0,0 +1,12 @@ + + + + Exe + netcoreapp3.1 + + + + + + + From 05845567d9ec8d1a8369f765de144f6bdb169c33 Mon Sep 17 00:00:00 2001 From: X39 Date: Sat, 27 Feb 2021 01:09:07 +0100 Subject: [PATCH 02/98] submodules --- .gitmodules | 9 +- server/extern/json | 2 +- server/extern/sqlite | 1 - server/extern/sqlite3.def | 281 -------------------------------------- server/extern/sqlite3.dll | Bin 1958912 -> 0 bytes server/extern/vm | 2 +- 6 files changed, 5 insertions(+), 290 deletions(-) delete mode 160000 server/extern/sqlite delete mode 100644 server/extern/sqlite3.def delete mode 100644 server/extern/sqlite3.dll diff --git a/.gitmodules b/.gitmodules index 30c8aab..015b71f 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,9 +1,6 @@ -[submodule "json"] - path = server/extern/json - url = https://github.com/nlohmann/json.git [submodule "vm"] path = server/extern/vm url = https://github.com/SQFvm/vm.git -[submodule "server/extern/sqlite"] - path = server/extern/sqlite - url = https://github.com/sqlite/sqlite.git +[submodule "server/extern/json"] + path = server/extern/json + url = https://github.com/nlohmann/json.git diff --git a/server/extern/json b/server/extern/json index 3be6ee3..176d8e2 160000 --- a/server/extern/json +++ b/server/extern/json @@ -1 +1 @@ -Subproject commit 3be6ee35258fbf5eba61a6194fea78b0e7afacd9 +Subproject commit 176d8e261a00dc27bfbf334e12d50572bf43fc4c diff --git a/server/extern/sqlite b/server/extern/sqlite deleted file mode 160000 index 40803ca..0000000 --- a/server/extern/sqlite +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 40803caa1d622b5f824fd00906672a425537016f diff --git a/server/extern/sqlite3.def b/server/extern/sqlite3.def deleted file mode 100644 index e30c214..0000000 --- a/server/extern/sqlite3.def +++ /dev/null @@ -1,281 +0,0 @@ -EXPORTS -sqlite3_aggregate_context -sqlite3_aggregate_count -sqlite3_auto_extension -sqlite3_backup_finish -sqlite3_backup_init -sqlite3_backup_pagecount -sqlite3_backup_remaining -sqlite3_backup_step -sqlite3_bind_blob -sqlite3_bind_blob64 -sqlite3_bind_double -sqlite3_bind_int -sqlite3_bind_int64 -sqlite3_bind_null -sqlite3_bind_parameter_count -sqlite3_bind_parameter_index -sqlite3_bind_parameter_name -sqlite3_bind_pointer -sqlite3_bind_text -sqlite3_bind_text16 -sqlite3_bind_text64 -sqlite3_bind_value -sqlite3_bind_zeroblob -sqlite3_bind_zeroblob64 -sqlite3_blob_bytes -sqlite3_blob_close -sqlite3_blob_open -sqlite3_blob_read -sqlite3_blob_reopen -sqlite3_blob_write -sqlite3_busy_handler -sqlite3_busy_timeout -sqlite3_cancel_auto_extension -sqlite3_changes -sqlite3_clear_bindings -sqlite3_close -sqlite3_close_v2 -sqlite3_collation_needed -sqlite3_collation_needed16 -sqlite3_column_blob -sqlite3_column_bytes -sqlite3_column_bytes16 -sqlite3_column_count -sqlite3_column_database_name -sqlite3_column_database_name16 -sqlite3_column_decltype -sqlite3_column_decltype16 -sqlite3_column_double -sqlite3_column_int -sqlite3_column_int64 -sqlite3_column_name -sqlite3_column_name16 -sqlite3_column_origin_name -sqlite3_column_origin_name16 -sqlite3_column_table_name -sqlite3_column_table_name16 -sqlite3_column_text -sqlite3_column_text16 -sqlite3_column_type -sqlite3_column_value -sqlite3_commit_hook -sqlite3_compileoption_get -sqlite3_compileoption_used -sqlite3_complete -sqlite3_complete16 -sqlite3_config -sqlite3_context_db_handle -sqlite3_create_collation -sqlite3_create_collation_v2 -sqlite3_create_collation16 -sqlite3_create_filename -sqlite3_create_function -sqlite3_create_function_v2 -sqlite3_create_function16 -sqlite3_create_module -sqlite3_create_module_v2 -sqlite3_create_window_function -sqlite3_data_count -sqlite3_data_directory -sqlite3_database_file_object -sqlite3_db_cacheflush -sqlite3_db_config -sqlite3_db_filename -sqlite3_db_handle -sqlite3_db_mutex -sqlite3_db_readonly -sqlite3_db_release_memory -sqlite3_db_status -sqlite3_declare_vtab -sqlite3_deserialize -sqlite3_drop_modules -sqlite3_enable_load_extension -sqlite3_enable_shared_cache -sqlite3_errcode -sqlite3_errmsg -sqlite3_errmsg16 -sqlite3_errstr -sqlite3_exec -sqlite3_expanded_sql -sqlite3_expired -sqlite3_extended_errcode -sqlite3_extended_result_codes -sqlite3_file_control -sqlite3_filename_database -sqlite3_filename_journal -sqlite3_filename_wal -sqlite3_finalize -sqlite3_free -sqlite3_free_filename -sqlite3_free_table -sqlite3_fts3_may_be_corrupt -sqlite3_fts5_may_be_corrupt -sqlite3_get_autocommit -sqlite3_get_auxdata -sqlite3_get_table -sqlite3_global_recover -sqlite3_hard_heap_limit64 -sqlite3_initialize -sqlite3_interrupt -sqlite3_keyword_check -sqlite3_keyword_count -sqlite3_keyword_name -sqlite3_last_insert_rowid -sqlite3_libversion -sqlite3_libversion_number -sqlite3_limit -sqlite3_load_extension -sqlite3_log -sqlite3_malloc -sqlite3_malloc64 -sqlite3_memory_alarm -sqlite3_memory_highwater -sqlite3_memory_used -sqlite3_mprintf -sqlite3_msize -sqlite3_mutex_alloc -sqlite3_mutex_enter -sqlite3_mutex_free -sqlite3_mutex_leave -sqlite3_mutex_try -sqlite3_next_stmt -sqlite3_open -sqlite3_open_v2 -sqlite3_open16 -sqlite3_os_end -sqlite3_os_init -sqlite3_overload_function -sqlite3_prepare -sqlite3_prepare_v2 -sqlite3_prepare_v3 -sqlite3_prepare16 -sqlite3_prepare16_v2 -sqlite3_prepare16_v3 -sqlite3_profile -sqlite3_progress_handler -sqlite3_randomness -sqlite3_realloc -sqlite3_realloc64 -sqlite3_release_memory -sqlite3_reset -sqlite3_reset_auto_extension -sqlite3_result_blob -sqlite3_result_blob64 -sqlite3_result_double -sqlite3_result_error -sqlite3_result_error_code -sqlite3_result_error_nomem -sqlite3_result_error_toobig -sqlite3_result_error16 -sqlite3_result_int -sqlite3_result_int64 -sqlite3_result_null -sqlite3_result_pointer -sqlite3_result_subtype -sqlite3_result_text -sqlite3_result_text16 -sqlite3_result_text16be -sqlite3_result_text16le -sqlite3_result_text64 -sqlite3_result_value -sqlite3_result_zeroblob -sqlite3_result_zeroblob64 -sqlite3_rollback_hook -sqlite3_rtree_geometry_callback -sqlite3_rtree_query_callback -sqlite3_serialize -sqlite3_set_authorizer -sqlite3_set_auxdata -sqlite3_set_last_insert_rowid -sqlite3_shutdown -sqlite3_sleep -sqlite3_snprintf -sqlite3_soft_heap_limit -sqlite3_soft_heap_limit64 -sqlite3_sourceid -sqlite3_sql -sqlite3_status -sqlite3_status64 -sqlite3_step -sqlite3_stmt_busy -sqlite3_stmt_isexplain -sqlite3_stmt_readonly -sqlite3_stmt_status -sqlite3_str_append -sqlite3_str_appendall -sqlite3_str_appendchar -sqlite3_str_appendf -sqlite3_str_errcode -sqlite3_str_finish -sqlite3_str_length -sqlite3_str_new -sqlite3_str_reset -sqlite3_str_value -sqlite3_str_vappendf -sqlite3_strglob -sqlite3_stricmp -sqlite3_strlike -sqlite3_strnicmp -sqlite3_system_errno -sqlite3_table_column_metadata -sqlite3_temp_directory -sqlite3_test_control -sqlite3_thread_cleanup -sqlite3_threadsafe -sqlite3_total_changes -sqlite3_trace -sqlite3_trace_v2 -sqlite3_transfer_bindings -sqlite3_txn_state -sqlite3_unsupported_selecttrace -sqlite3_update_hook -sqlite3_uri_boolean -sqlite3_uri_int64 -sqlite3_uri_key -sqlite3_uri_parameter -sqlite3_user_data -sqlite3_value_blob -sqlite3_value_bytes -sqlite3_value_bytes16 -sqlite3_value_double -sqlite3_value_dup -sqlite3_value_free -sqlite3_value_frombind -sqlite3_value_int -sqlite3_value_int64 -sqlite3_value_nochange -sqlite3_value_numeric_type -sqlite3_value_pointer -sqlite3_value_subtype -sqlite3_value_text -sqlite3_value_text16 -sqlite3_value_text16be -sqlite3_value_text16le -sqlite3_value_type -sqlite3_version -sqlite3_vfs_find -sqlite3_vfs_register -sqlite3_vfs_unregister -sqlite3_vmprintf -sqlite3_vsnprintf -sqlite3_vtab_collation -sqlite3_vtab_config -sqlite3_vtab_nochange -sqlite3_vtab_on_conflict -sqlite3_wal_autocheckpoint -sqlite3_wal_checkpoint -sqlite3_wal_checkpoint_v2 -sqlite3_wal_hook -sqlite3_win32_is_nt -sqlite3_win32_mbcs_to_utf8 -sqlite3_win32_mbcs_to_utf8_v2 -sqlite3_win32_set_directory -sqlite3_win32_set_directory16 -sqlite3_win32_set_directory8 -sqlite3_win32_sleep -sqlite3_win32_unicode_to_utf8 -sqlite3_win32_utf8_to_mbcs -sqlite3_win32_utf8_to_mbcs_v2 -sqlite3_win32_utf8_to_unicode -sqlite3_win32_write_debug diff --git a/server/extern/sqlite3.dll b/server/extern/sqlite3.dll deleted file mode 100644 index c883b485446d874f427c0022e1d05b46fc54f9cf..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1958912 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

    34$tRwn`HRLOj6UP2|Q6 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 z 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

    oYvD8b~P*b(R# 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

  • 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%0A)6zK459Mo_R3%mW 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

    GBRpSH@bL!Z2}Jv<-3aDQ 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 z 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

    a$Rf{_pZ2s_UNn#IyD_io_`<1 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

    d=P?kvP4h-HOoeZgQZ3q8Ox+qfQ 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

    ka!%Q*WCoIIh3;-HCri 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 Date: Sat, 27 Feb 2021 04:40:02 +0100 Subject: [PATCH 03/98] Shelved everything and started from scratch - Added SQLite3 --- server/CMakeLists.txt | 79 +- server/ReadMe.md | 6 + .../sqlite-amalgamation-3340100/shell.c | 21388 ++ .../sqlite-amalgamation-3340100/sqlite3.c | 231756 +++++++++++++++ .../sqlite-amalgamation-3340100/sqlite3.h | 12237 + .../sqlite-amalgamation-3340100/sqlite3ext.h | 663 + server/sqfvm_language_server/CMakeLists.txt | 17 + .../jsonrpc.hpp} | 181 +- .../lspserver.hpp} | 486 +- .../sqf-vm-language-server.cpp | 47 + .../sqf-vm-language-server.h | 8 + server/sqfvm_language_server/sqlite.cpp | 222 + server/sqfvm_language_server/sqlite.hpp | 300 + server/src/git_sha1.h | 2 - server/src/language_server_logger.cpp | 55 - server/src/language_server_logger.h | 12 - server/src/main.cpp | 23 - server/src/sqf_language_server.cpp | 326 - server/src/sqf_language_server.h | 82 - server/src/text_document.cpp | 474 - server/src/text_document.h | 329 - server/src/uri.h | 638 - server/src/util.h | 28 - server/src/variable_declaration.h | 47 - server/tools/schema2cpp/Program.cs | 71 - server/tools/schema2cpp/SchemaToCpp.cs | 180 - server/tools/schema2cpp/schema2cpp.csproj | 12 - 27 files changed, 266987 insertions(+), 2682 deletions(-) create mode 100644 server/ReadMe.md create mode 100644 server/extern/sqlite-amalgamation-3340100/shell.c create mode 100644 server/extern/sqlite-amalgamation-3340100/sqlite3.c create mode 100644 server/extern/sqlite-amalgamation-3340100/sqlite3.h create mode 100644 server/extern/sqlite-amalgamation-3340100/sqlite3ext.h create mode 100644 server/sqfvm_language_server/CMakeLists.txt rename server/{src/jsonrpc.h => sqfvm_language_server/jsonrpc.hpp} (67%) rename server/{src/lspserver.h => sqfvm_language_server/lspserver.hpp} (95%) create mode 100644 server/sqfvm_language_server/sqf-vm-language-server.cpp create mode 100644 server/sqfvm_language_server/sqf-vm-language-server.h create mode 100644 server/sqfvm_language_server/sqlite.cpp create mode 100644 server/sqfvm_language_server/sqlite.hpp delete mode 100644 server/src/git_sha1.h delete mode 100644 server/src/language_server_logger.cpp delete mode 100644 server/src/language_server_logger.h delete mode 100644 server/src/main.cpp delete mode 100644 server/src/sqf_language_server.cpp delete mode 100644 server/src/sqf_language_server.h delete mode 100644 server/src/text_document.cpp delete mode 100644 server/src/text_document.h delete mode 100644 server/src/uri.h delete mode 100644 server/src/util.h delete mode 100644 server/src/variable_declaration.h delete mode 100644 server/tools/schema2cpp/Program.cs delete mode 100644 server/tools/schema2cpp/SchemaToCpp.cs delete mode 100644 server/tools/schema2cpp/schema2cpp.csproj diff --git a/server/CMakeLists.txt b/server/CMakeLists.txt index 2c990ff..1deedad 100644 --- a/server/CMakeLists.txt +++ b/server/CMakeLists.txt @@ -1,73 +1,10 @@ -cmake_minimum_required(VERSION 2.8.12) -project(sqfvm_language_server) +# CMakeList.txt : Top-level CMake project file, do global configuration +# and include sub-projects here. +# +cmake_minimum_required (VERSION 3.8) +set (CMAKE_CXX_STANDARD 20) -set(CMAKE_CXX_STANDARD 17) -set(CMAKE_CXX_STANDARD_REQUIRED ON) -set(CMAKE_CXX_EXTENSIONS OFF) -set(CMAKE_MACOSX_RPATH 1) +project ("sqfvm_language_server") -# Enable multithreaded compilation in MSVC -if (MSVC) - add_definitions(/MP) - add_definitions(/wd4100) -endif() - -# Add the filesystem library if we are building on Clang or GCC -if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") - set(ST_CXXFS_LIBS stdc++fs) -endif() - -set(ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/output) -set(LIBRARY_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/output) -set(RUNTIME_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/output) - -include_directories("${PROJECT_SOURCE_DIR}/extern/json/include") - - -option(SQFVM_BUILD_EXECUTABLE "BUILD EXECUTABLE" OFF) -option(SQFVM_BUILD_EXECUTABLE_ARMA2_LOCALKEYWORD "BUILD ARMA2 EXECUTABLE" OFF) -option(SQFVM_BUILD_LIBRARY "BUILD LIBRARY" OFF) -option(SQFVM_BUILD_LIBRARY_SQC_SUPPORT "BUILD LIBRARY WITH SQC SUPPORT" OFF) -option(SQFVM_BUILD_STATIC_LIBRARY "BUILD STATIC LIBRARY" OFF) -option(SQFVM_BUILD_STATIC_LIBRARY_SQC_SUPPORT "BUILD STATIC LIBRARY WITH SQC SUPPORT" ON) -option(SQFVM_BUILD_EXECUTABLE_SQC_SUPPORT "BUILD EXECUTABLE WITH SQC SUPPORT" OFF) -option(SQFVM_BUILD_EXECUTABLE_FULL_DIAGNOSE "BUILD DIAGNOSE EXECUTABLE" OFF) -add_subdirectory("${PROJECT_SOURCE_DIR}/extern/vm") - -file(GLOB sqfvm_language_server_src - "${PROJECT_SOURCE_DIR}/src/*.h" "${PROJECT_SOURCE_DIR}/src/*.cpp" "${PROJECT_SOURCE_DIR}/src/*.c" - "${CMAKE_CURRENT_BINARY_DIR}/git_sha1.cpp" -) - -# Get the local git revision hash and put it into a header we can use -list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/") -include(GetGitRevisionDescription) -get_git_head_revision(GIT_REFSPEC GIT_SHA1) - -configure_file("${PROJECT_SOURCE_DIR}/cmake/git_sha1.cpp.in" "${CMAKE_CURRENT_BINARY_DIR}/git_sha1.cpp" @ONLY) -list(APPEND sqfvm_language_server_src "${CMAKE_CURRENT_BINARY_DIR}/git_sha1.cpp") - - - -find_package(Threads) -find_package (SQLite3) - - -option(SQFVM_LANGUAGE_SERVER_BUILD_EXECUTABLE "BUILD EXECUTABLE" ON) - - -if (SQFVM_LANGUAGE_SERVER_BUILD_EXECUTABLE) - add_executable(sqfvm_language_server ${sqfvm_language_server_src}) - include_directories(sqfvm_language_server ${SQLite3_INCLUDE_DIRS}) - include_directories(sqfvm_language_server PUBLIC ${PROJECT_SOURCE_DIR}/src) - - target_link_libraries(sqfvm_language_server PRIVATE slibsqfvm_sqc) - target_link_libraries(sqfvm_language_server ${CMAKE_DL_LIBS} ${CMAKE_THREAD_LIBS_INIT} ${ST_CXXFS_LIBS}) - target_link_libraries (sqfvm_language_server ${OUT_TARGET} ${SQLite3_LIBRARIES}) - - target_compile_options(sqfvm_language_server PRIVATE - $<$,$,$>: - -Wall -Wno-unknown-pragmas> - $<$: - /W4>) -endif () \ No newline at end of file +# Include sub-projects. +add_subdirectory ("sqfvm_language_server") diff --git a/server/ReadMe.md b/server/ReadMe.md new file mode 100644 index 0000000..9dca228 --- /dev/null +++ b/server/ReadMe.md @@ -0,0 +1,6 @@ +# Build Requirements +## Windows +1. Install (https://github.com/microsoft/vcpkg)[https://github.com/microsoft/vcpkg] +2. Execute `vcpkg install nlohmann-json` in PowerShell +3. Execute `vcpkg install sqlite3` in PowerShell +4. \ No newline at end of file diff --git a/server/extern/sqlite-amalgamation-3340100/shell.c b/server/extern/sqlite-amalgamation-3340100/shell.c new file mode 100644 index 0000000..6f4fee8 --- /dev/null +++ b/server/extern/sqlite-amalgamation-3340100/shell.c @@ -0,0 +1,21388 @@ +/* DO NOT EDIT! +** This file is automatically generated by the script in the canonical +** SQLite source tree at tool/mkshellc.tcl. That script combines source +** code from various constituent source files of SQLite into this single +** "shell.c" file used to implement the SQLite command-line shell. +** +** Most of the code found below comes from the "src/shell.c.in" file in +** the canonical SQLite source tree. That main file contains "INCLUDE" +** lines that specify other files in the canonical source tree that are +** inserted to getnerate this complete program source file. +** +** The code from multiple files is combined into this single "shell.c" +** source file to help make the command-line program easier to compile. +** +** To modify this program, get a copy of the canonical SQLite source tree, +** edit the src/shell.c.in" and/or some of the other files that are included +** by "src/shell.c.in", then rerun the tool/mkshellc.tcl script. +*/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code to implement the "sqlite" command line +** utility for accessing SQLite databases. +*/ +#if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS) +/* This needs to come before any includes for MSVC compiler */ +#define _CRT_SECURE_NO_WARNINGS +#endif + +/* +** Determine if we are dealing with WinRT, which provides only a subset of +** the full Win32 API. +*/ +#if !defined(SQLITE_OS_WINRT) +# define SQLITE_OS_WINRT 0 +#endif + +/* +** Warning pragmas copied from msvc.h in the core. +*/ +#if defined(_MSC_VER) +#pragma warning(disable : 4054) +#pragma warning(disable : 4055) +#pragma warning(disable : 4100) +#pragma warning(disable : 4127) +#pragma warning(disable : 4130) +#pragma warning(disable : 4152) +#pragma warning(disable : 4189) +#pragma warning(disable : 4206) +#pragma warning(disable : 4210) +#pragma warning(disable : 4232) +#pragma warning(disable : 4244) +#pragma warning(disable : 4305) +#pragma warning(disable : 4306) +#pragma warning(disable : 4702) +#pragma warning(disable : 4706) +#endif /* defined(_MSC_VER) */ + +/* +** No support for loadable extensions in VxWorks. +*/ +#if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION +# define SQLITE_OMIT_LOAD_EXTENSION 1 +#endif + +/* +** Enable large-file support for fopen() and friends on unix. +*/ +#ifndef SQLITE_DISABLE_LFS +# define _LARGE_FILE 1 +# ifndef _FILE_OFFSET_BITS +# define _FILE_OFFSET_BITS 64 +# endif +# define _LARGEFILE_SOURCE 1 +#endif + +#include +#include +#include +#include +#include "sqlite3.h" +typedef sqlite3_int64 i64; +typedef sqlite3_uint64 u64; +typedef unsigned char u8; +#if SQLITE_USER_AUTHENTICATION +# include "sqlite3userauth.h" +#endif +#include +#include + +#if !defined(_WIN32) && !defined(WIN32) +# include +# if !defined(__RTP__) && !defined(_WRS_KERNEL) +# include +# endif +#endif +#if (!defined(_WIN32) && !defined(WIN32)) || defined(__MINGW32__) +# include +# include +# define GETPID getpid +# if defined(__MINGW32__) +# define DIRENT dirent +# ifndef S_ISLNK +# define S_ISLNK(mode) (0) +# endif +# endif +#else +# define GETPID (int)GetCurrentProcessId +#endif +#include +#include + +#if HAVE_READLINE +# include +# include +#endif + +#if HAVE_EDITLINE +# include +#endif + +#if HAVE_EDITLINE || HAVE_READLINE + +# define shell_add_history(X) add_history(X) +# define shell_read_history(X) read_history(X) +# define shell_write_history(X) write_history(X) +# define shell_stifle_history(X) stifle_history(X) +# define shell_readline(X) readline(X) + +#elif HAVE_LINENOISE + +# include "linenoise.h" +# define shell_add_history(X) linenoiseHistoryAdd(X) +# define shell_read_history(X) linenoiseHistoryLoad(X) +# define shell_write_history(X) linenoiseHistorySave(X) +# define shell_stifle_history(X) linenoiseHistorySetMaxLen(X) +# define shell_readline(X) linenoise(X) + +#else + +# define shell_read_history(X) +# define shell_write_history(X) +# define shell_stifle_history(X) + +# define SHELL_USE_LOCAL_GETLINE 1 +#endif + + +#if defined(_WIN32) || defined(WIN32) +# if SQLITE_OS_WINRT +# define SQLITE_OMIT_POPEN 1 +# else +# include +# include +# define isatty(h) _isatty(h) +# ifndef access +# define access(f,m) _access((f),(m)) +# endif +# ifndef unlink +# define unlink _unlink +# endif +# ifndef strdup +# define strdup _strdup +# endif +# undef popen +# define popen _popen +# undef pclose +# define pclose _pclose +# endif +#else + /* Make sure isatty() has a prototype. */ + extern int isatty(int); + +# if !defined(__RTP__) && !defined(_WRS_KERNEL) + /* popen and pclose are not C89 functions and so are + ** sometimes omitted from the header */ + extern FILE *popen(const char*,const char*); + extern int pclose(FILE*); +# else +# define SQLITE_OMIT_POPEN 1 +# endif +#endif + +#if defined(_WIN32_WCE) +/* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty() + * thus we always assume that we have a console. That can be + * overridden with the -batch command line option. + */ +#define isatty(x) 1 +#endif + +/* ctype macros that work with signed characters */ +#define IsSpace(X) isspace((unsigned char)X) +#define IsDigit(X) isdigit((unsigned char)X) +#define ToLower(X) (char)tolower((unsigned char)X) + +#if defined(_WIN32) || defined(WIN32) +#if SQLITE_OS_WINRT +#include +#endif +#include + +/* string conversion routines only needed on Win32 */ +extern char *sqlite3_win32_unicode_to_utf8(LPCWSTR); +extern char *sqlite3_win32_mbcs_to_utf8_v2(const char *, int); +extern char *sqlite3_win32_utf8_to_mbcs_v2(const char *, int); +extern LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText); +#endif + +/* On Windows, we normally run with output mode of TEXT so that \n characters +** are automatically translated into \r\n. However, this behavior needs +** to be disabled in some cases (ex: when generating CSV output and when +** rendering quoted strings that contain \n characters). The following +** routines take care of that. +*/ +#if (defined(_WIN32) || defined(WIN32)) && !SQLITE_OS_WINRT +static void setBinaryMode(FILE *file, int isOutput){ + if( isOutput ) fflush(file); + _setmode(_fileno(file), _O_BINARY); +} +static void setTextMode(FILE *file, int isOutput){ + if( isOutput ) fflush(file); + _setmode(_fileno(file), _O_TEXT); +} +#else +# define setBinaryMode(X,Y) +# define setTextMode(X,Y) +#endif + + +/* True if the timer is enabled */ +static int enableTimer = 0; + +/* Return the current wall-clock time */ +static sqlite3_int64 timeOfDay(void){ + static sqlite3_vfs *clockVfs = 0; + sqlite3_int64 t; + if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0); + if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){ + clockVfs->xCurrentTimeInt64(clockVfs, &t); + }else{ + double r; + clockVfs->xCurrentTime(clockVfs, &r); + t = (sqlite3_int64)(r*86400000.0); + } + return t; +} + +#if !defined(_WIN32) && !defined(WIN32) && !defined(__minux) +#include +#include + +/* VxWorks does not support getrusage() as far as we can determine */ +#if defined(_WRS_KERNEL) || defined(__RTP__) +struct rusage { + struct timeval ru_utime; /* user CPU time used */ + struct timeval ru_stime; /* system CPU time used */ +}; +#define getrusage(A,B) memset(B,0,sizeof(*B)) +#endif + +/* Saved resource information for the beginning of an operation */ +static struct rusage sBegin; /* CPU time at start */ +static sqlite3_int64 iBegin; /* Wall-clock time at start */ + +/* +** Begin timing an operation +*/ +static void beginTimer(void){ + if( enableTimer ){ + getrusage(RUSAGE_SELF, &sBegin); + iBegin = timeOfDay(); + } +} + +/* Return the difference of two time_structs in seconds */ +static double timeDiff(struct timeval *pStart, struct timeval *pEnd){ + return (pEnd->tv_usec - pStart->tv_usec)*0.000001 + + (double)(pEnd->tv_sec - pStart->tv_sec); +} + +/* +** Print the timing results. +*/ +static void endTimer(void){ + if( enableTimer ){ + sqlite3_int64 iEnd = timeOfDay(); + struct rusage sEnd; + getrusage(RUSAGE_SELF, &sEnd); + printf("Run Time: real %.3f user %f sys %f\n", + (iEnd - iBegin)*0.001, + timeDiff(&sBegin.ru_utime, &sEnd.ru_utime), + timeDiff(&sBegin.ru_stime, &sEnd.ru_stime)); + } +} + +#define BEGIN_TIMER beginTimer() +#define END_TIMER endTimer() +#define HAS_TIMER 1 + +#elif (defined(_WIN32) || defined(WIN32)) + +/* Saved resource information for the beginning of an operation */ +static HANDLE hProcess; +static FILETIME ftKernelBegin; +static FILETIME ftUserBegin; +static sqlite3_int64 ftWallBegin; +typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME, + LPFILETIME, LPFILETIME); +static GETPROCTIMES getProcessTimesAddr = NULL; + +/* +** Check to see if we have timer support. Return 1 if necessary +** support found (or found previously). +*/ +static int hasTimer(void){ + if( getProcessTimesAddr ){ + return 1; + } else { +#if !SQLITE_OS_WINRT + /* GetProcessTimes() isn't supported in WIN95 and some other Windows + ** versions. See if the version we are running on has it, and if it + ** does, save off a pointer to it and the current process handle. + */ + hProcess = GetCurrentProcess(); + if( hProcess ){ + HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll")); + if( NULL != hinstLib ){ + getProcessTimesAddr = + (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes"); + if( NULL != getProcessTimesAddr ){ + return 1; + } + FreeLibrary(hinstLib); + } + } +#endif + } + return 0; +} + +/* +** Begin timing an operation +*/ +static void beginTimer(void){ + if( enableTimer && getProcessTimesAddr ){ + FILETIME ftCreation, ftExit; + getProcessTimesAddr(hProcess,&ftCreation,&ftExit, + &ftKernelBegin,&ftUserBegin); + ftWallBegin = timeOfDay(); + } +} + +/* Return the difference of two FILETIME structs in seconds */ +static double timeDiff(FILETIME *pStart, FILETIME *pEnd){ + sqlite_int64 i64Start = *((sqlite_int64 *) pStart); + sqlite_int64 i64End = *((sqlite_int64 *) pEnd); + return (double) ((i64End - i64Start) / 10000000.0); +} + +/* +** Print the timing results. +*/ +static void endTimer(void){ + if( enableTimer && getProcessTimesAddr){ + FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd; + sqlite3_int64 ftWallEnd = timeOfDay(); + getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd); + printf("Run Time: real %.3f user %f sys %f\n", + (ftWallEnd - ftWallBegin)*0.001, + timeDiff(&ftUserBegin, &ftUserEnd), + timeDiff(&ftKernelBegin, &ftKernelEnd)); + } +} + +#define BEGIN_TIMER beginTimer() +#define END_TIMER endTimer() +#define HAS_TIMER hasTimer() + +#else +#define BEGIN_TIMER +#define END_TIMER +#define HAS_TIMER 0 +#endif + +/* +** Used to prevent warnings about unused parameters +*/ +#define UNUSED_PARAMETER(x) (void)(x) + +/* +** Number of elements in an array +*/ +#define ArraySize(X) (int)(sizeof(X)/sizeof(X[0])) + +/* +** If the following flag is set, then command execution stops +** at an error if we are not interactive. +*/ +static int bail_on_error = 0; + +/* +** Threat stdin as an interactive input if the following variable +** is true. Otherwise, assume stdin is connected to a file or pipe. +*/ +static int stdin_is_interactive = 1; + +/* +** On Windows systems we have to know if standard output is a console +** in order to translate UTF-8 into MBCS. The following variable is +** true if translation is required. +*/ +static int stdout_is_console = 1; + +/* +** The following is the open SQLite database. We make a pointer +** to this database a static variable so that it can be accessed +** by the SIGINT handler to interrupt database processing. +*/ +static sqlite3 *globalDb = 0; + +/* +** True if an interrupt (Control-C) has been received. +*/ +static volatile int seenInterrupt = 0; + +#ifdef SQLITE_DEBUG +/* +** Out-of-memory simulator variables +*/ +static unsigned int oomCounter = 0; /* Simulate OOM when equals 1 */ +static unsigned int oomRepeat = 0; /* Number of OOMs in a row */ +static void*(*defaultMalloc)(int) = 0; /* The low-level malloc routine */ +#endif /* SQLITE_DEBUG */ + +/* +** This is the name of our program. It is set in main(), used +** in a number of other places, mostly for error messages. +*/ +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: " ...> " */ + +/* +** Render output like fprintf(). Except, if the output is going to the +** console and if this is running on a Windows machine, translate the +** output from UTF-8 into MBCS. +*/ +#if defined(_WIN32) || defined(WIN32) +void utf8_printf(FILE *out, const char *zFormat, ...){ + va_list ap; + va_start(ap, zFormat); + if( stdout_is_console && (out==stdout || out==stderr) ){ + char *z1 = sqlite3_vmprintf(zFormat, ap); + char *z2 = sqlite3_win32_utf8_to_mbcs_v2(z1, 0); + sqlite3_free(z1); + fputs(z2, out); + sqlite3_free(z2); + }else{ + vfprintf(out, zFormat, ap); + } + va_end(ap); +} +#elif !defined(utf8_printf) +# define utf8_printf fprintf +#endif + +/* +** Render output like fprintf(). This should not be used on anything that +** includes string formatting (e.g. "%s"). +*/ +#if !defined(raw_printf) +# define raw_printf fprintf +#endif + +/* Indicate out-of-memory and exit. */ +static void shell_out_of_memory(void){ + raw_printf(stderr,"Error: out of memory\n"); + exit(1); +} + +#ifdef SQLITE_DEBUG +/* This routine is called when a simulated OOM occurs. It is broken +** out as a separate routine to make it easy to set a breakpoint on +** the OOM +*/ +void shellOomFault(void){ + if( oomRepeat>0 ){ + oomRepeat--; + }else{ + oomCounter--; + } +} +#endif /* SQLITE_DEBUG */ + +#ifdef SQLITE_DEBUG +/* This routine is a replacement malloc() that is used to simulate +** Out-Of-Memory (OOM) errors for testing purposes. +*/ +static void *oomMalloc(int nByte){ + if( oomCounter ){ + if( oomCounter==1 ){ + shellOomFault(); + return 0; + }else{ + oomCounter--; + } + } + return defaultMalloc(nByte); +} +#endif /* SQLITE_DEBUG */ + +#ifdef SQLITE_DEBUG +/* Register the OOM simulator. This must occur before any memory +** allocations */ +static void registerOomSimulator(void){ + sqlite3_mem_methods mem; + sqlite3_config(SQLITE_CONFIG_GETMALLOC, &mem); + defaultMalloc = mem.xMalloc; + mem.xMalloc = oomMalloc; + sqlite3_config(SQLITE_CONFIG_MALLOC, &mem); +} +#endif + +/* +** Write I/O traces to the following stream. +*/ +#ifdef SQLITE_ENABLE_IOTRACE +static FILE *iotrace = 0; +#endif + +/* +** This routine works like printf in that its first argument is a +** format string and subsequent arguments are values to be substituted +** in place of % fields. The result of formatting this string +** is written to iotrace. +*/ +#ifdef SQLITE_ENABLE_IOTRACE +static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){ + va_list ap; + char *z; + if( iotrace==0 ) return; + va_start(ap, zFormat); + z = sqlite3_vmprintf(zFormat, ap); + va_end(ap); + utf8_printf(iotrace, "%s", z); + sqlite3_free(z); +} +#endif + +/* +** Output string zUtf to stream pOut as w characters. If w is negative, +** then right-justify the text. W is the width in UTF-8 characters, not +** in bytes. This is different from the %*.*s specification in printf +** since with %*.*s the width is measured in bytes, not characters. +*/ +static void utf8_width_print(FILE *pOut, int w, const char *zUtf){ + int i; + int n; + int aw = w<0 ? -w : w; + for(i=n=0; zUtf[i]; i++){ + if( (zUtf[i]&0xc0)!=0x80 ){ + n++; + if( n==aw ){ + do{ i++; }while( (zUtf[i]&0xc0)==0x80 ); + break; + } + } + } + if( n>=aw ){ + utf8_printf(pOut, "%.*s", i, zUtf); + }else if( w<0 ){ + utf8_printf(pOut, "%*s%s", aw-n, "", zUtf); + }else{ + utf8_printf(pOut, "%s%*s", zUtf, aw-n, ""); + } +} + + +/* +** Determines if a string is a number of not. +*/ +static int isNumber(const char *z, int *realnum){ + if( *z=='-' || *z=='+' ) z++; + if( !IsDigit(*z) ){ + return 0; + } + z++; + if( realnum ) *realnum = 0; + while( IsDigit(*z) ){ z++; } + if( *z=='.' ){ + z++; + if( !IsDigit(*z) ) return 0; + while( IsDigit(*z) ){ z++; } + if( realnum ) *realnum = 1; + } + if( *z=='e' || *z=='E' ){ + z++; + if( *z=='+' || *z=='-' ) z++; + if( !IsDigit(*z) ) return 0; + while( IsDigit(*z) ){ z++; } + if( realnum ) *realnum = 1; + } + return *z==0; +} + +/* +** Compute a string length that is limited to what can be stored in +** lower 30 bits of a 32-bit signed integer. +*/ +static int strlen30(const char *z){ + const char *z2 = z; + while( *z2 ){ z2++; } + return 0x3fffffff & (int)(z2 - z); +} + +/* +** Return the length of a string in characters. Multibyte UTF8 characters +** count as a single character. +*/ +static int strlenChar(const char *z){ + int n = 0; + while( *z ){ + if( (0xc0&*(z++))!=0x80 ) n++; + } + return n; +} + +/* +** Return true if zFile does not exist or if it is not an ordinary file. +*/ +#ifdef _WIN32 +# define notNormalFile(X) 0 +#else +static int notNormalFile(const char *zFile){ + struct stat x; + int rc; + memset(&x, 0, sizeof(x)); + rc = stat(zFile, &x); + return rc || !S_ISREG(x.st_mode); +} +#endif + +/* +** This routine reads a line of text from FILE in, stores +** the text in memory obtained from malloc() and returns a pointer +** to the text. NULL is returned at end of file, or if malloc() +** fails. +** +** If zLine is not NULL then it is a malloced buffer returned from +** a previous call to this routine that may be reused. +*/ +static char *local_getline(char *zLine, FILE *in){ + int nLine = zLine==0 ? 0 : 100; + int n = 0; + + while( 1 ){ + if( n+100>nLine ){ + nLine = nLine*2 + 100; + zLine = realloc(zLine, nLine); + if( zLine==0 ) shell_out_of_memory(); + } + if( fgets(&zLine[n], nLine - n, in)==0 ){ + if( n==0 ){ + free(zLine); + return 0; + } + zLine[n] = 0; + break; + } + while( zLine[n] ) n++; + if( n>0 && zLine[n-1]=='\n' ){ + n--; + if( n>0 && zLine[n-1]=='\r' ) n--; + zLine[n] = 0; + break; + } + } +#if defined(_WIN32) || defined(WIN32) + /* For interactive input on Windows systems, translate the + ** multi-byte characterset characters into UTF-8. */ + if( stdin_is_interactive && in==stdin ){ + char *zTrans = sqlite3_win32_mbcs_to_utf8_v2(zLine, 0); + if( zTrans ){ + int nTrans = strlen30(zTrans)+1; + if( nTrans>nLine ){ + zLine = realloc(zLine, nTrans); + if( zLine==0 ) shell_out_of_memory(); + } + memcpy(zLine, zTrans, nTrans); + sqlite3_free(zTrans); + } + } +#endif /* defined(_WIN32) || defined(WIN32) */ + return zLine; +} + +/* +** Retrieve a single line of input text. +** +** If in==0 then read from standard input and prompt before each line. +** If isContinuation is true, then a continuation prompt is appropriate. +** If isContinuation is zero, then the main prompt should be used. +** +** If zPrior is not NULL then it is a buffer from a prior call to this +** routine that can be reused. +** +** The result is stored in space obtained from malloc() and must either +** be freed by the caller or else passed back into this routine via the +** zPrior argument for reuse. +*/ +static char *one_input_line(FILE *in, char *zPrior, int isContinuation){ + char *zPrompt; + char *zResult; + if( in!=0 ){ + zResult = local_getline(zPrior, in); + }else{ + zPrompt = isContinuation ? continuePrompt : mainPrompt; +#if SHELL_USE_LOCAL_GETLINE + printf("%s", zPrompt); + fflush(stdout); + zResult = local_getline(zPrior, stdin); +#else + free(zPrior); + zResult = shell_readline(zPrompt); + if( zResult && *zResult ) shell_add_history(zResult); +#endif + } + return zResult; +} + + +/* +** Return the value of a hexadecimal digit. Return -1 if the input +** is not a hex digit. +*/ +static int hexDigitValue(char c){ + if( c>='0' && c<='9' ) return c - '0'; + if( c>='a' && c<='f' ) return c - 'a' + 10; + if( c>='A' && c<='F' ) return c - 'A' + 10; + return -1; +} + +/* +** Interpret zArg as an integer value, possibly with suffixes. +*/ +static sqlite3_int64 integerValue(const char *zArg){ + sqlite3_int64 v = 0; + static const struct { char *zSuffix; int iMult; } aMult[] = { + { "KiB", 1024 }, + { "MiB", 1024*1024 }, + { "GiB", 1024*1024*1024 }, + { "KB", 1000 }, + { "MB", 1000000 }, + { "GB", 1000000000 }, + { "K", 1000 }, + { "M", 1000000 }, + { "G", 1000000000 }, + }; + int i; + int isNeg = 0; + if( zArg[0]=='-' ){ + isNeg = 1; + zArg++; + }else if( zArg[0]=='+' ){ + zArg++; + } + if( zArg[0]=='0' && zArg[1]=='x' ){ + int x; + zArg += 2; + while( (x = hexDigitValue(zArg[0]))>=0 ){ + v = (v<<4) + x; + zArg++; + } + }else{ + while( IsDigit(zArg[0]) ){ + v = v*10 + zArg[0] - '0'; + zArg++; + } + } + for(i=0; iz); + initText(p); +} + +/* zIn is either a pointer to a NULL-terminated string in memory obtained +** from malloc(), or a NULL pointer. The string pointed to by zAppend is +** added to zIn, and the result returned in memory obtained from malloc(). +** zIn, if it was not NULL, is freed. +** +** If the third argument, quote, is not '\0', then it is used as a +** quote character for zAppend. +*/ +static void appendText(ShellText *p, char const *zAppend, char quote){ + int len; + int i; + int nAppend = strlen30(zAppend); + + len = nAppend+p->n+1; + if( quote ){ + len += 2; + for(i=0; in+len>=p->nAlloc ){ + p->nAlloc = p->nAlloc*2 + len + 20; + p->z = realloc(p->z, p->nAlloc); + if( p->z==0 ) shell_out_of_memory(); + } + + if( quote ){ + char *zCsr = p->z+p->n; + *zCsr++ = quote; + for(i=0; in = (int)(zCsr - p->z); + *zCsr = '\0'; + }else{ + memcpy(p->z+p->n, zAppend, nAppend); + p->n += nAppend; + p->z[p->n] = '\0'; + } +} + +/* +** Attempt to determine if identifier zName needs to be quoted, either +** because it contains non-alphanumeric characters, or because it is an +** SQLite keyword. Be conservative in this estimate: When in doubt assume +** that quoting is required. +** +** Return '"' if quoting is required. Return 0 if no quoting is required. +*/ +static char quoteChar(const char *zName){ + int i; + if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"'; + for(i=0; zName[i]; i++){ + if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"'; + } + return sqlite3_keyword_check(zName, i) ? '"' : 0; +} + +/* +** Construct a fake object name and column list to describe the structure +** of the view, virtual table, or table valued function zSchema.zName. +*/ +static char *shellFakeSchema( + sqlite3 *db, /* The database connection containing the vtab */ + const char *zSchema, /* Schema of the database holding the vtab */ + const char *zName /* The name of the virtual table */ +){ + sqlite3_stmt *pStmt = 0; + char *zSql; + ShellText s; + char cQuote; + char *zDiv = "("; + int nRow = 0; + + zSql = sqlite3_mprintf("PRAGMA \"%w\".table_info=%Q;", + zSchema ? zSchema : "main", zName); + sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); + sqlite3_free(zSql); + initText(&s); + if( zSchema ){ + cQuote = quoteChar(zSchema); + if( cQuote && sqlite3_stricmp(zSchema,"temp")==0 ) cQuote = 0; + appendText(&s, zSchema, cQuote); + appendText(&s, ".", 0); + } + cQuote = quoteChar(zName); + appendText(&s, zName, cQuote); + while( sqlite3_step(pStmt)==SQLITE_ROW ){ + const char *zCol = (const char*)sqlite3_column_text(pStmt, 1); + nRow++; + appendText(&s, zDiv, 0); + zDiv = ","; + cQuote = quoteChar(zCol); + appendText(&s, zCol, cQuote); + } + appendText(&s, ")", 0); + sqlite3_finalize(pStmt); + if( nRow==0 ){ + freeText(&s); + s.z = 0; + } + return s.z; +} + +/* +** SQL function: shell_module_schema(X) +** +** Return a fake schema for the table-valued function or eponymous virtual +** table X. +*/ +static void shellModuleSchema( + sqlite3_context *pCtx, + int nVal, + sqlite3_value **apVal +){ + const char *zName = (const char*)sqlite3_value_text(apVal[0]); + char *zFake = shellFakeSchema(sqlite3_context_db_handle(pCtx), 0, zName); + UNUSED_PARAMETER(nVal); + if( zFake ){ + sqlite3_result_text(pCtx, sqlite3_mprintf("/* %s */", zFake), + -1, sqlite3_free); + free(zFake); + } +} + +/* +** SQL function: shell_add_schema(S,X) +** +** Add the schema name X to the CREATE statement in S and return the result. +** Examples: +** +** CREATE TABLE t1(x) -> CREATE TABLE xyz.t1(x); +** +** Also works on +** +** CREATE INDEX +** CREATE UNIQUE INDEX +** CREATE VIEW +** CREATE TRIGGER +** CREATE VIRTUAL TABLE +** +** This UDF is used by the .schema command to insert the schema name of +** attached databases into the middle of the sqlite_schema.sql field. +*/ +static void shellAddSchemaName( + sqlite3_context *pCtx, + int nVal, + sqlite3_value **apVal +){ + static const char *aPrefix[] = { + "TABLE", + "INDEX", + "UNIQUE INDEX", + "VIEW", + "TRIGGER", + "VIRTUAL TABLE" + }; + int i = 0; + const char *zIn = (const char*)sqlite3_value_text(apVal[0]); + const char *zSchema = (const char*)sqlite3_value_text(apVal[1]); + const char *zName = (const char*)sqlite3_value_text(apVal[2]); + sqlite3 *db = sqlite3_context_db_handle(pCtx); + UNUSED_PARAMETER(nVal); + if( zIn!=0 && strncmp(zIn, "CREATE ", 7)==0 ){ + for(i=0; i<(int)(sizeof(aPrefix)/sizeof(aPrefix[0])); i++){ + int n = strlen30(aPrefix[i]); + if( strncmp(zIn+7, aPrefix[i], n)==0 && zIn[n+7]==' ' ){ + char *z = 0; + char *zFake = 0; + if( zSchema ){ + char cQuote = quoteChar(zSchema); + if( cQuote && sqlite3_stricmp(zSchema,"temp")!=0 ){ + z = sqlite3_mprintf("%.*s \"%w\".%s", n+7, zIn, zSchema, zIn+n+8); + }else{ + z = sqlite3_mprintf("%.*s %s.%s", n+7, zIn, zSchema, zIn+n+8); + } + } + if( zName + && aPrefix[i][0]=='V' + && (zFake = shellFakeSchema(db, zSchema, zName))!=0 + ){ + if( z==0 ){ + z = sqlite3_mprintf("%s\n/* %s */", zIn, zFake); + }else{ + z = sqlite3_mprintf("%z\n/* %s */", z, zFake); + } + free(zFake); + } + if( z ){ + sqlite3_result_text(pCtx, z, -1, sqlite3_free); + return; + } + } + } + } + sqlite3_result_value(pCtx, apVal[0]); +} + +/* +** The source code for several run-time loadable extensions is inserted +** below by the ../tool/mkshellc.tcl script. Before processing that included +** code, we need to override some macros to make the included program code +** work here in the middle of this regular program. +*/ +#define SQLITE_EXTENSION_INIT1 +#define SQLITE_EXTENSION_INIT2(X) (void)(X) + +#if defined(_WIN32) && defined(_MSC_VER) +/************************* Begin test_windirent.h ******************/ +/* +** 2015 November 30 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains declarations for most of the opendir() family of +** POSIX functions on Win32 using the MSVCRT. +*/ + +#if defined(_WIN32) && defined(_MSC_VER) && !defined(SQLITE_WINDIRENT_H) +#define SQLITE_WINDIRENT_H + +/* +** We need several data types from the Windows SDK header. +*/ + +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif + +#include "windows.h" + +/* +** We need several support functions from the SQLite core. +*/ + +/* #include "sqlite3.h" */ + +/* +** We need several things from the ANSI and MSVCRT headers. +*/ + +#include +#include +#include +#include +#include +#include +#include + +/* +** We may need several defines that should have been in "sys/stat.h". +*/ + +#ifndef S_ISREG +#define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG) +#endif + +#ifndef S_ISDIR +#define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR) +#endif + +#ifndef S_ISLNK +#define S_ISLNK(mode) (0) +#endif + +/* +** We may need to provide the "mode_t" type. +*/ + +#ifndef MODE_T_DEFINED + #define MODE_T_DEFINED + typedef unsigned short mode_t; +#endif + +/* +** We may need to provide the "ino_t" type. +*/ + +#ifndef INO_T_DEFINED + #define INO_T_DEFINED + typedef unsigned short ino_t; +#endif + +/* +** We need to define "NAME_MAX" if it was not present in "limits.h". +*/ + +#ifndef NAME_MAX +# ifdef FILENAME_MAX +# define NAME_MAX (FILENAME_MAX) +# else +# define NAME_MAX (260) +# endif +#endif + +/* +** We need to define "NULL_INTPTR_T" and "BAD_INTPTR_T". +*/ + +#ifndef NULL_INTPTR_T +# define NULL_INTPTR_T ((intptr_t)(0)) +#endif + +#ifndef BAD_INTPTR_T +# define BAD_INTPTR_T ((intptr_t)(-1)) +#endif + +/* +** We need to provide the necessary structures and related types. +*/ + +#ifndef DIRENT_DEFINED +#define DIRENT_DEFINED +typedef struct DIRENT DIRENT; +typedef DIRENT *LPDIRENT; +struct DIRENT { + ino_t d_ino; /* Sequence number, do not use. */ + unsigned d_attributes; /* Win32 file attributes. */ + char d_name[NAME_MAX + 1]; /* Name within the directory. */ +}; +#endif + +#ifndef DIR_DEFINED +#define DIR_DEFINED +typedef struct DIR DIR; +typedef DIR *LPDIR; +struct DIR { + intptr_t d_handle; /* Value returned by "_findfirst". */ + DIRENT d_first; /* DIRENT constructed based on "_findfirst". */ + DIRENT d_next; /* DIRENT constructed based on "_findnext". */ +}; +#endif + +/* +** Provide a macro, for use by the implementation, to determine if a +** particular directory entry should be skipped over when searching for +** the next directory entry that should be returned by the readdir() or +** readdir_r() functions. +*/ + +#ifndef is_filtered +# define is_filtered(a) ((((a).attrib)&_A_HIDDEN) || (((a).attrib)&_A_SYSTEM)) +#endif + +/* +** Provide the function prototype for the POSIX compatiable getenv() +** function. This function is not thread-safe. +*/ + +extern const char *windirent_getenv(const char *name); + +/* +** Finally, we can provide the function prototypes for the opendir(), +** readdir(), readdir_r(), and closedir() POSIX functions. +*/ + +extern LPDIR opendir(const char *dirname); +extern LPDIRENT readdir(LPDIR dirp); +extern INT readdir_r(LPDIR dirp, LPDIRENT entry, LPDIRENT *result); +extern INT closedir(LPDIR dirp); + +#endif /* defined(WIN32) && defined(_MSC_VER) */ + +/************************* End test_windirent.h ********************/ +/************************* Begin test_windirent.c ******************/ +/* +** 2015 November 30 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code to implement most of the opendir() family of +** POSIX functions on Win32 using the MSVCRT. +*/ + +#if defined(_WIN32) && defined(_MSC_VER) +/* #include "test_windirent.h" */ + +/* +** Implementation of the POSIX getenv() function using the Win32 API. +** This function is not thread-safe. +*/ +const char *windirent_getenv( + const char *name +){ + static char value[32768]; /* Maximum length, per MSDN */ + DWORD dwSize = sizeof(value) / sizeof(char); /* Size in chars */ + DWORD dwRet; /* Value returned by GetEnvironmentVariableA() */ + + memset(value, 0, sizeof(value)); + dwRet = GetEnvironmentVariableA(name, value, dwSize); + if( dwRet==0 || dwRet>dwSize ){ + /* + ** The function call to GetEnvironmentVariableA() failed -OR- + ** the buffer is not large enough. Either way, return NULL. + */ + return 0; + }else{ + /* + ** The function call to GetEnvironmentVariableA() succeeded + ** -AND- the buffer contains the entire value. + */ + return value; + } +} + +/* +** Implementation of the POSIX opendir() function using the MSVCRT. +*/ +LPDIR opendir( + const char *dirname +){ + struct _finddata_t data; + LPDIR dirp = (LPDIR)sqlite3_malloc(sizeof(DIR)); + SIZE_T namesize = sizeof(data.name) / sizeof(data.name[0]); + + if( dirp==NULL ) return NULL; + memset(dirp, 0, sizeof(DIR)); + + /* TODO: Remove this if Unix-style root paths are not used. */ + if( sqlite3_stricmp(dirname, "/")==0 ){ + dirname = windirent_getenv("SystemDrive"); + } + + memset(&data, 0, sizeof(struct _finddata_t)); + _snprintf(data.name, namesize, "%s\\*", dirname); + dirp->d_handle = _findfirst(data.name, &data); + + if( dirp->d_handle==BAD_INTPTR_T ){ + closedir(dirp); + return NULL; + } + + /* TODO: Remove this block to allow hidden and/or system files. */ + if( is_filtered(data) ){ +next: + + memset(&data, 0, sizeof(struct _finddata_t)); + if( _findnext(dirp->d_handle, &data)==-1 ){ + closedir(dirp); + return NULL; + } + + /* TODO: Remove this block to allow hidden and/or system files. */ + if( is_filtered(data) ) goto next; + } + + dirp->d_first.d_attributes = data.attrib; + strncpy(dirp->d_first.d_name, data.name, NAME_MAX); + dirp->d_first.d_name[NAME_MAX] = '\0'; + + return dirp; +} + +/* +** Implementation of the POSIX readdir() function using the MSVCRT. +*/ +LPDIRENT readdir( + LPDIR dirp +){ + struct _finddata_t data; + + if( dirp==NULL ) return NULL; + + if( dirp->d_first.d_ino==0 ){ + dirp->d_first.d_ino++; + dirp->d_next.d_ino++; + + return &dirp->d_first; + } + +next: + + memset(&data, 0, sizeof(struct _finddata_t)); + if( _findnext(dirp->d_handle, &data)==-1 ) return NULL; + + /* TODO: Remove this block to allow hidden and/or system files. */ + if( is_filtered(data) ) goto next; + + dirp->d_next.d_ino++; + dirp->d_next.d_attributes = data.attrib; + strncpy(dirp->d_next.d_name, data.name, NAME_MAX); + dirp->d_next.d_name[NAME_MAX] = '\0'; + + return &dirp->d_next; +} + +/* +** Implementation of the POSIX readdir_r() function using the MSVCRT. +*/ +INT readdir_r( + LPDIR dirp, + LPDIRENT entry, + LPDIRENT *result +){ + struct _finddata_t data; + + if( dirp==NULL ) return EBADF; + + if( dirp->d_first.d_ino==0 ){ + dirp->d_first.d_ino++; + dirp->d_next.d_ino++; + + entry->d_ino = dirp->d_first.d_ino; + entry->d_attributes = dirp->d_first.d_attributes; + strncpy(entry->d_name, dirp->d_first.d_name, NAME_MAX); + entry->d_name[NAME_MAX] = '\0'; + + *result = entry; + return 0; + } + +next: + + memset(&data, 0, sizeof(struct _finddata_t)); + if( _findnext(dirp->d_handle, &data)==-1 ){ + *result = NULL; + return ENOENT; + } + + /* TODO: Remove this block to allow hidden and/or system files. */ + if( is_filtered(data) ) goto next; + + entry->d_ino = (ino_t)-1; /* not available */ + entry->d_attributes = data.attrib; + strncpy(entry->d_name, data.name, NAME_MAX); + entry->d_name[NAME_MAX] = '\0'; + + *result = entry; + return 0; +} + +/* +** Implementation of the POSIX closedir() function using the MSVCRT. +*/ +INT closedir( + LPDIR dirp +){ + INT result = 0; + + if( dirp==NULL ) return EINVAL; + + if( dirp->d_handle!=NULL_INTPTR_T && dirp->d_handle!=BAD_INTPTR_T ){ + result = _findclose(dirp->d_handle); + } + + sqlite3_free(dirp); + return result; +} + +#endif /* defined(WIN32) && defined(_MSC_VER) */ + +/************************* End test_windirent.c ********************/ +#define dirent DIRENT +#endif +/************************* Begin ../ext/misc/shathree.c ******************/ +/* +** 2017-03-08 +** +** 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 SQLite extension implements functions that compute SHA3 hashes. +** Two SQL functions are implemented: +** +** sha3(X,SIZE) +** sha3_query(Y,SIZE) +** +** The sha3(X) function computes the SHA3 hash of the input X, or NULL if +** X is NULL. +** +** The sha3_query(Y) function evalutes all queries in the SQL statements of Y +** and returns a hash of their results. +** +** The SIZE argument is optional. If omitted, the SHA3-256 hash algorithm +** is used. If SIZE is included it must be one of the integers 224, 256, +** 384, or 512, to determine SHA3 hash variant that is computed. +*/ +/* #include "sqlite3ext.h" */ +SQLITE_EXTENSION_INIT1 +#include +#include +#include +/* typedef sqlite3_uint64 u64; */ + +/****************************************************************************** +** The Hash Engine +*/ +/* +** Macros to determine whether the machine is big or little endian, +** and whether or not that determination is run-time or compile-time. +** +** For best performance, an attempt is made to guess at the byte-order +** using C-preprocessor macros. If that is unsuccessful, or if +** -DSHA3_BYTEORDER=0 is set, then byte-order is determined +** at run-time. +*/ +#ifndef SHA3_BYTEORDER +# if defined(i386) || defined(__i386__) || defined(_M_IX86) || \ + defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \ + defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \ + defined(__arm__) +# define SHA3_BYTEORDER 1234 +# elif defined(sparc) || defined(__ppc__) +# define SHA3_BYTEORDER 4321 +# else +# define SHA3_BYTEORDER 0 +# endif +#endif + + +/* +** State structure for a SHA3 hash in progress +*/ +typedef struct SHA3Context SHA3Context; +struct SHA3Context { + union { + u64 s[25]; /* Keccak state. 5x5 lines of 64 bits each */ + unsigned char x[1600]; /* ... or 1600 bytes */ + } u; + unsigned nRate; /* Bytes of input accepted per Keccak iteration */ + unsigned nLoaded; /* Input bytes loaded into u.x[] so far this cycle */ + unsigned ixMask; /* Insert next input into u.x[nLoaded^ixMask]. */ +}; + +/* +** A single step of the Keccak mixing function for a 1600-bit state +*/ +static void KeccakF1600Step(SHA3Context *p){ + int i; + u64 b0, b1, b2, b3, b4; + u64 c0, c1, c2, c3, c4; + u64 d0, d1, d2, d3, d4; + static const u64 RC[] = { + 0x0000000000000001ULL, 0x0000000000008082ULL, + 0x800000000000808aULL, 0x8000000080008000ULL, + 0x000000000000808bULL, 0x0000000080000001ULL, + 0x8000000080008081ULL, 0x8000000000008009ULL, + 0x000000000000008aULL, 0x0000000000000088ULL, + 0x0000000080008009ULL, 0x000000008000000aULL, + 0x000000008000808bULL, 0x800000000000008bULL, + 0x8000000000008089ULL, 0x8000000000008003ULL, + 0x8000000000008002ULL, 0x8000000000000080ULL, + 0x000000000000800aULL, 0x800000008000000aULL, + 0x8000000080008081ULL, 0x8000000000008080ULL, + 0x0000000080000001ULL, 0x8000000080008008ULL + }; +# define a00 (p->u.s[0]) +# define a01 (p->u.s[1]) +# define a02 (p->u.s[2]) +# define a03 (p->u.s[3]) +# define a04 (p->u.s[4]) +# define a10 (p->u.s[5]) +# define a11 (p->u.s[6]) +# define a12 (p->u.s[7]) +# define a13 (p->u.s[8]) +# define a14 (p->u.s[9]) +# define a20 (p->u.s[10]) +# define a21 (p->u.s[11]) +# define a22 (p->u.s[12]) +# define a23 (p->u.s[13]) +# define a24 (p->u.s[14]) +# define a30 (p->u.s[15]) +# define a31 (p->u.s[16]) +# define a32 (p->u.s[17]) +# define a33 (p->u.s[18]) +# define a34 (p->u.s[19]) +# define a40 (p->u.s[20]) +# define a41 (p->u.s[21]) +# define a42 (p->u.s[22]) +# define a43 (p->u.s[23]) +# define a44 (p->u.s[24]) +# define ROL64(a,x) ((a<>(64-x))) + + for(i=0; i<24; i+=4){ + c0 = a00^a10^a20^a30^a40; + c1 = a01^a11^a21^a31^a41; + c2 = a02^a12^a22^a32^a42; + c3 = a03^a13^a23^a33^a43; + c4 = a04^a14^a24^a34^a44; + d0 = c4^ROL64(c1, 1); + d1 = c0^ROL64(c2, 1); + d2 = c1^ROL64(c3, 1); + d3 = c2^ROL64(c4, 1); + d4 = c3^ROL64(c0, 1); + + b0 = (a00^d0); + b1 = ROL64((a11^d1), 44); + b2 = ROL64((a22^d2), 43); + b3 = ROL64((a33^d3), 21); + b4 = ROL64((a44^d4), 14); + a00 = b0 ^((~b1)& b2 ); + a00 ^= RC[i]; + a11 = b1 ^((~b2)& b3 ); + a22 = b2 ^((~b3)& b4 ); + a33 = b3 ^((~b4)& b0 ); + a44 = b4 ^((~b0)& b1 ); + + b2 = ROL64((a20^d0), 3); + b3 = ROL64((a31^d1), 45); + b4 = ROL64((a42^d2), 61); + b0 = ROL64((a03^d3), 28); + b1 = ROL64((a14^d4), 20); + a20 = b0 ^((~b1)& b2 ); + a31 = b1 ^((~b2)& b3 ); + a42 = b2 ^((~b3)& b4 ); + a03 = b3 ^((~b4)& b0 ); + a14 = b4 ^((~b0)& b1 ); + + b4 = ROL64((a40^d0), 18); + b0 = ROL64((a01^d1), 1); + b1 = ROL64((a12^d2), 6); + b2 = ROL64((a23^d3), 25); + b3 = ROL64((a34^d4), 8); + a40 = b0 ^((~b1)& b2 ); + a01 = b1 ^((~b2)& b3 ); + a12 = b2 ^((~b3)& b4 ); + a23 = b3 ^((~b4)& b0 ); + a34 = b4 ^((~b0)& b1 ); + + b1 = ROL64((a10^d0), 36); + b2 = ROL64((a21^d1), 10); + b3 = ROL64((a32^d2), 15); + b4 = ROL64((a43^d3), 56); + b0 = ROL64((a04^d4), 27); + a10 = b0 ^((~b1)& b2 ); + a21 = b1 ^((~b2)& b3 ); + a32 = b2 ^((~b3)& b4 ); + a43 = b3 ^((~b4)& b0 ); + a04 = b4 ^((~b0)& b1 ); + + b3 = ROL64((a30^d0), 41); + b4 = ROL64((a41^d1), 2); + b0 = ROL64((a02^d2), 62); + b1 = ROL64((a13^d3), 55); + b2 = ROL64((a24^d4), 39); + a30 = b0 ^((~b1)& b2 ); + a41 = b1 ^((~b2)& b3 ); + a02 = b2 ^((~b3)& b4 ); + a13 = b3 ^((~b4)& b0 ); + a24 = b4 ^((~b0)& b1 ); + + c0 = a00^a20^a40^a10^a30; + c1 = a11^a31^a01^a21^a41; + c2 = a22^a42^a12^a32^a02; + c3 = a33^a03^a23^a43^a13; + c4 = a44^a14^a34^a04^a24; + d0 = c4^ROL64(c1, 1); + d1 = c0^ROL64(c2, 1); + d2 = c1^ROL64(c3, 1); + d3 = c2^ROL64(c4, 1); + d4 = c3^ROL64(c0, 1); + + b0 = (a00^d0); + b1 = ROL64((a31^d1), 44); + b2 = ROL64((a12^d2), 43); + b3 = ROL64((a43^d3), 21); + b4 = ROL64((a24^d4), 14); + a00 = b0 ^((~b1)& b2 ); + a00 ^= RC[i+1]; + a31 = b1 ^((~b2)& b3 ); + a12 = b2 ^((~b3)& b4 ); + a43 = b3 ^((~b4)& b0 ); + a24 = b4 ^((~b0)& b1 ); + + b2 = ROL64((a40^d0), 3); + b3 = ROL64((a21^d1), 45); + b4 = ROL64((a02^d2), 61); + b0 = ROL64((a33^d3), 28); + b1 = ROL64((a14^d4), 20); + a40 = b0 ^((~b1)& b2 ); + a21 = b1 ^((~b2)& b3 ); + a02 = b2 ^((~b3)& b4 ); + a33 = b3 ^((~b4)& b0 ); + a14 = b4 ^((~b0)& b1 ); + + b4 = ROL64((a30^d0), 18); + b0 = ROL64((a11^d1), 1); + b1 = ROL64((a42^d2), 6); + b2 = ROL64((a23^d3), 25); + b3 = ROL64((a04^d4), 8); + a30 = b0 ^((~b1)& b2 ); + a11 = b1 ^((~b2)& b3 ); + a42 = b2 ^((~b3)& b4 ); + a23 = b3 ^((~b4)& b0 ); + a04 = b4 ^((~b0)& b1 ); + + b1 = ROL64((a20^d0), 36); + b2 = ROL64((a01^d1), 10); + b3 = ROL64((a32^d2), 15); + b4 = ROL64((a13^d3), 56); + b0 = ROL64((a44^d4), 27); + a20 = b0 ^((~b1)& b2 ); + a01 = b1 ^((~b2)& b3 ); + a32 = b2 ^((~b3)& b4 ); + a13 = b3 ^((~b4)& b0 ); + a44 = b4 ^((~b0)& b1 ); + + b3 = ROL64((a10^d0), 41); + b4 = ROL64((a41^d1), 2); + b0 = ROL64((a22^d2), 62); + b1 = ROL64((a03^d3), 55); + b2 = ROL64((a34^d4), 39); + a10 = b0 ^((~b1)& b2 ); + a41 = b1 ^((~b2)& b3 ); + a22 = b2 ^((~b3)& b4 ); + a03 = b3 ^((~b4)& b0 ); + a34 = b4 ^((~b0)& b1 ); + + c0 = a00^a40^a30^a20^a10; + c1 = a31^a21^a11^a01^a41; + c2 = a12^a02^a42^a32^a22; + c3 = a43^a33^a23^a13^a03; + c4 = a24^a14^a04^a44^a34; + d0 = c4^ROL64(c1, 1); + d1 = c0^ROL64(c2, 1); + d2 = c1^ROL64(c3, 1); + d3 = c2^ROL64(c4, 1); + d4 = c3^ROL64(c0, 1); + + b0 = (a00^d0); + b1 = ROL64((a21^d1), 44); + b2 = ROL64((a42^d2), 43); + b3 = ROL64((a13^d3), 21); + b4 = ROL64((a34^d4), 14); + a00 = b0 ^((~b1)& b2 ); + a00 ^= RC[i+2]; + a21 = b1 ^((~b2)& b3 ); + a42 = b2 ^((~b3)& b4 ); + a13 = b3 ^((~b4)& b0 ); + a34 = b4 ^((~b0)& b1 ); + + b2 = ROL64((a30^d0), 3); + b3 = ROL64((a01^d1), 45); + b4 = ROL64((a22^d2), 61); + b0 = ROL64((a43^d3), 28); + b1 = ROL64((a14^d4), 20); + a30 = b0 ^((~b1)& b2 ); + a01 = b1 ^((~b2)& b3 ); + a22 = b2 ^((~b3)& b4 ); + a43 = b3 ^((~b4)& b0 ); + a14 = b4 ^((~b0)& b1 ); + + b4 = ROL64((a10^d0), 18); + b0 = ROL64((a31^d1), 1); + b1 = ROL64((a02^d2), 6); + b2 = ROL64((a23^d3), 25); + b3 = ROL64((a44^d4), 8); + a10 = b0 ^((~b1)& b2 ); + a31 = b1 ^((~b2)& b3 ); + a02 = b2 ^((~b3)& b4 ); + a23 = b3 ^((~b4)& b0 ); + a44 = b4 ^((~b0)& b1 ); + + b1 = ROL64((a40^d0), 36); + b2 = ROL64((a11^d1), 10); + b3 = ROL64((a32^d2), 15); + b4 = ROL64((a03^d3), 56); + b0 = ROL64((a24^d4), 27); + a40 = b0 ^((~b1)& b2 ); + a11 = b1 ^((~b2)& b3 ); + a32 = b2 ^((~b3)& b4 ); + a03 = b3 ^((~b4)& b0 ); + a24 = b4 ^((~b0)& b1 ); + + b3 = ROL64((a20^d0), 41); + b4 = ROL64((a41^d1), 2); + b0 = ROL64((a12^d2), 62); + b1 = ROL64((a33^d3), 55); + b2 = ROL64((a04^d4), 39); + a20 = b0 ^((~b1)& b2 ); + a41 = b1 ^((~b2)& b3 ); + a12 = b2 ^((~b3)& b4 ); + a33 = b3 ^((~b4)& b0 ); + a04 = b4 ^((~b0)& b1 ); + + c0 = a00^a30^a10^a40^a20; + c1 = a21^a01^a31^a11^a41; + c2 = a42^a22^a02^a32^a12; + c3 = a13^a43^a23^a03^a33; + c4 = a34^a14^a44^a24^a04; + d0 = c4^ROL64(c1, 1); + d1 = c0^ROL64(c2, 1); + d2 = c1^ROL64(c3, 1); + d3 = c2^ROL64(c4, 1); + d4 = c3^ROL64(c0, 1); + + b0 = (a00^d0); + b1 = ROL64((a01^d1), 44); + b2 = ROL64((a02^d2), 43); + b3 = ROL64((a03^d3), 21); + b4 = ROL64((a04^d4), 14); + a00 = b0 ^((~b1)& b2 ); + a00 ^= RC[i+3]; + a01 = b1 ^((~b2)& b3 ); + a02 = b2 ^((~b3)& b4 ); + a03 = b3 ^((~b4)& b0 ); + a04 = b4 ^((~b0)& b1 ); + + b2 = ROL64((a10^d0), 3); + b3 = ROL64((a11^d1), 45); + b4 = ROL64((a12^d2), 61); + b0 = ROL64((a13^d3), 28); + b1 = ROL64((a14^d4), 20); + a10 = b0 ^((~b1)& b2 ); + a11 = b1 ^((~b2)& b3 ); + a12 = b2 ^((~b3)& b4 ); + a13 = b3 ^((~b4)& b0 ); + a14 = b4 ^((~b0)& b1 ); + + b4 = ROL64((a20^d0), 18); + b0 = ROL64((a21^d1), 1); + b1 = ROL64((a22^d2), 6); + b2 = ROL64((a23^d3), 25); + b3 = ROL64((a24^d4), 8); + a20 = b0 ^((~b1)& b2 ); + a21 = b1 ^((~b2)& b3 ); + a22 = b2 ^((~b3)& b4 ); + a23 = b3 ^((~b4)& b0 ); + a24 = b4 ^((~b0)& b1 ); + + b1 = ROL64((a30^d0), 36); + b2 = ROL64((a31^d1), 10); + b3 = ROL64((a32^d2), 15); + b4 = ROL64((a33^d3), 56); + b0 = ROL64((a34^d4), 27); + a30 = b0 ^((~b1)& b2 ); + a31 = b1 ^((~b2)& b3 ); + a32 = b2 ^((~b3)& b4 ); + a33 = b3 ^((~b4)& b0 ); + a34 = b4 ^((~b0)& b1 ); + + b3 = ROL64((a40^d0), 41); + b4 = ROL64((a41^d1), 2); + b0 = ROL64((a42^d2), 62); + b1 = ROL64((a43^d3), 55); + b2 = ROL64((a44^d4), 39); + a40 = b0 ^((~b1)& b2 ); + a41 = b1 ^((~b2)& b3 ); + a42 = b2 ^((~b3)& b4 ); + a43 = b3 ^((~b4)& b0 ); + a44 = b4 ^((~b0)& b1 ); + } +} + +/* +** Initialize a new hash. iSize determines the size of the hash +** in bits and should be one of 224, 256, 384, or 512. Or iSize +** can be zero to use the default hash size of 256 bits. +*/ +static void SHA3Init(SHA3Context *p, int iSize){ + memset(p, 0, sizeof(*p)); + if( iSize>=128 && iSize<=512 ){ + p->nRate = (1600 - ((iSize + 31)&~31)*2)/8; + }else{ + p->nRate = (1600 - 2*256)/8; + } +#if SHA3_BYTEORDER==1234 + /* Known to be little-endian at compile-time. No-op */ +#elif SHA3_BYTEORDER==4321 + p->ixMask = 7; /* Big-endian */ +#else + { + static unsigned int one = 1; + if( 1==*(unsigned char*)&one ){ + /* Little endian. No byte swapping. */ + p->ixMask = 0; + }else{ + /* Big endian. Byte swap. */ + p->ixMask = 7; + } + } +#endif +} + +/* +** Make consecutive calls to the SHA3Update function to add new content +** to the hash +*/ +static void SHA3Update( + SHA3Context *p, + const unsigned char *aData, + unsigned int nData +){ + unsigned int i = 0; +#if SHA3_BYTEORDER==1234 + if( (p->nLoaded % 8)==0 && ((aData - (const unsigned char*)0)&7)==0 ){ + for(; i+7u.s[p->nLoaded/8] ^= *(u64*)&aData[i]; + p->nLoaded += 8; + if( p->nLoaded>=p->nRate ){ + KeccakF1600Step(p); + p->nLoaded = 0; + } + } + } +#endif + for(; iu.x[p->nLoaded] ^= aData[i]; +#elif SHA3_BYTEORDER==4321 + p->u.x[p->nLoaded^0x07] ^= aData[i]; +#else + p->u.x[p->nLoaded^p->ixMask] ^= aData[i]; +#endif + p->nLoaded++; + if( p->nLoaded==p->nRate ){ + KeccakF1600Step(p); + p->nLoaded = 0; + } + } +} + +/* +** After all content has been added, invoke SHA3Final() to compute +** the final hash. The function returns a pointer to the binary +** hash value. +*/ +static unsigned char *SHA3Final(SHA3Context *p){ + unsigned int i; + if( p->nLoaded==p->nRate-1 ){ + const unsigned char c1 = 0x86; + SHA3Update(p, &c1, 1); + }else{ + const unsigned char c2 = 0x06; + const unsigned char c3 = 0x80; + SHA3Update(p, &c2, 1); + p->nLoaded = p->nRate - 1; + SHA3Update(p, &c3, 1); + } + for(i=0; inRate; i++){ + p->u.x[i+p->nRate] = p->u.x[i^p->ixMask]; + } + return &p->u.x[p->nRate]; +} +/* End of the hashing logic +*****************************************************************************/ + +/* +** Implementation of the sha3(X,SIZE) function. +** +** Return a BLOB which is the SIZE-bit SHA3 hash of X. The default +** size is 256. If X is a BLOB, it is hashed as is. +** For all other non-NULL types of input, X is converted into a UTF-8 string +** and the string is hashed without the trailing 0x00 terminator. The hash +** of a NULL value is NULL. +*/ +static void sha3Func( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + SHA3Context cx; + int eType = sqlite3_value_type(argv[0]); + int nByte = sqlite3_value_bytes(argv[0]); + int iSize; + if( argc==1 ){ + iSize = 256; + }else{ + iSize = sqlite3_value_int(argv[1]); + if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){ + sqlite3_result_error(context, "SHA3 size should be one of: 224 256 " + "384 512", -1); + return; + } + } + if( eType==SQLITE_NULL ) return; + SHA3Init(&cx, iSize); + if( eType==SQLITE_BLOB ){ + SHA3Update(&cx, sqlite3_value_blob(argv[0]), nByte); + }else{ + SHA3Update(&cx, sqlite3_value_text(argv[0]), nByte); + } + sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT); +} + +/* Compute a string using sqlite3_vsnprintf() with a maximum length +** of 50 bytes and add it to the hash. +*/ +static void hash_step_vformat( + SHA3Context *p, /* Add content to this context */ + const char *zFormat, + ... +){ + va_list ap; + int n; + char zBuf[50]; + va_start(ap, zFormat); + sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap); + va_end(ap); + n = (int)strlen(zBuf); + SHA3Update(p, (unsigned char*)zBuf, n); +} + +/* +** Implementation of the sha3_query(SQL,SIZE) function. +** +** This function compiles and runs the SQL statement(s) given in the +** argument. The results are hashed using a SIZE-bit SHA3. The default +** size is 256. +** +** The format of the byte stream that is hashed is summarized as follows: +** +** S: +** R +** N +** I +** F +** B: +** T: +** +** is the original SQL text for each statement run and is +** the size of that text. The SQL text is UTF-8. A single R character +** occurs before the start of each row. N means a NULL value. +** I mean an 8-byte little-endian integer . F is a floating point +** number with an 8-byte little-endian IEEE floating point value . +** B means blobs of bytes. T means text rendered as +** bytes of UTF-8. The and values are expressed as an ASCII +** text integers. +** +** For each SQL statement in the X input, there is one S segment. Each +** S segment is followed by zero or more R segments, one for each row in the +** result set. After each R, there are one or more N, I, F, B, or T segments, +** one for each column in the result set. Segments are concatentated directly +** with no delimiters of any kind. +*/ +static void sha3QueryFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + sqlite3 *db = sqlite3_context_db_handle(context); + const char *zSql = (const char*)sqlite3_value_text(argv[0]); + sqlite3_stmt *pStmt = 0; + int nCol; /* Number of columns in the result set */ + int i; /* Loop counter */ + int rc; + int n; + const char *z; + SHA3Context cx; + int iSize; + + if( argc==1 ){ + iSize = 256; + }else{ + iSize = sqlite3_value_int(argv[1]); + if( iSize!=224 && iSize!=256 && iSize!=384 && iSize!=512 ){ + sqlite3_result_error(context, "SHA3 size should be one of: 224 256 " + "384 512", -1); + return; + } + } + if( zSql==0 ) return; + SHA3Init(&cx, iSize); + while( zSql[0] ){ + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql); + if( rc ){ + char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s", + zSql, sqlite3_errmsg(db)); + sqlite3_finalize(pStmt); + sqlite3_result_error(context, zMsg, -1); + sqlite3_free(zMsg); + return; + } + if( !sqlite3_stmt_readonly(pStmt) ){ + char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt)); + sqlite3_finalize(pStmt); + sqlite3_result_error(context, zMsg, -1); + sqlite3_free(zMsg); + return; + } + nCol = sqlite3_column_count(pStmt); + z = sqlite3_sql(pStmt); + if( z ){ + n = (int)strlen(z); + hash_step_vformat(&cx,"S%d:",n); + SHA3Update(&cx,(unsigned char*)z,n); + } + + /* Compute a hash over the result of the query */ + while( SQLITE_ROW==sqlite3_step(pStmt) ){ + SHA3Update(&cx,(const unsigned char*)"R",1); + for(i=0; i=1; j--){ + x[j] = u & 0xff; + u >>= 8; + } + x[0] = 'I'; + SHA3Update(&cx, x, 9); + break; + } + case SQLITE_FLOAT: { + sqlite3_uint64 u; + int j; + unsigned char x[9]; + double r = sqlite3_column_double(pStmt,i); + memcpy(&u, &r, 8); + for(j=8; j>=1; j--){ + x[j] = u & 0xff; + u >>= 8; + } + x[0] = 'F'; + SHA3Update(&cx,x,9); + break; + } + case SQLITE_TEXT: { + int n2 = sqlite3_column_bytes(pStmt, i); + const unsigned char *z2 = sqlite3_column_text(pStmt, i); + hash_step_vformat(&cx,"T%d:",n2); + SHA3Update(&cx, z2, n2); + break; + } + case SQLITE_BLOB: { + int n2 = sqlite3_column_bytes(pStmt, i); + const unsigned char *z2 = sqlite3_column_blob(pStmt, i); + hash_step_vformat(&cx,"B%d:",n2); + SHA3Update(&cx, z2, n2); + break; + } + } + } + } + sqlite3_finalize(pStmt); + } + sqlite3_result_blob(context, SHA3Final(&cx), iSize/8, SQLITE_TRANSIENT); +} + + +#ifdef _WIN32 + +#endif +int sqlite3_shathree_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi +){ + int rc = SQLITE_OK; + SQLITE_EXTENSION_INIT2(pApi); + (void)pzErrMsg; /* Unused parameter */ + rc = sqlite3_create_function(db, "sha3", 1, + SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC, + 0, sha3Func, 0, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3_create_function(db, "sha3", 2, + SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC, + 0, sha3Func, 0, 0); + } + if( rc==SQLITE_OK ){ + rc = sqlite3_create_function(db, "sha3_query", 1, + SQLITE_UTF8 | SQLITE_DIRECTONLY, + 0, sha3QueryFunc, 0, 0); + } + if( rc==SQLITE_OK ){ + rc = sqlite3_create_function(db, "sha3_query", 2, + SQLITE_UTF8 | SQLITE_DIRECTONLY, + 0, sha3QueryFunc, 0, 0); + } + return rc; +} + +/************************* End ../ext/misc/shathree.c ********************/ +/************************* Begin ../ext/misc/fileio.c ******************/ +/* +** 2014-06-13 +** +** 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 SQLite extension implements SQL functions readfile() and +** writefile(), and eponymous virtual type "fsdir". +** +** WRITEFILE(FILE, DATA [, MODE [, MTIME]]): +** +** If neither of the optional arguments is present, then this UDF +** function writes blob DATA to file FILE. If successful, the number +** of bytes written is returned. If an error occurs, NULL is returned. +** +** If the first option argument - MODE - is present, then it must +** be passed an integer value that corresponds to a POSIX mode +** value (file type + permissions, as returned in the stat.st_mode +** field by the stat() system call). Three types of files may +** be written/created: +** +** regular files: (mode & 0170000)==0100000 +** symbolic links: (mode & 0170000)==0120000 +** directories: (mode & 0170000)==0040000 +** +** For a directory, the DATA is ignored. For a symbolic link, it is +** interpreted as text and used as the target of the link. For a +** regular file, it is interpreted as a blob and written into the +** named file. Regardless of the type of file, its permissions are +** set to (mode & 0777) before returning. +** +** If the optional MTIME argument is present, then it is interpreted +** as an integer - the number of seconds since the unix epoch. The +** modification-time of the target file is set to this value before +** returning. +** +** If three or more arguments are passed to this function and an +** error is encountered, an exception is raised. +** +** READFILE(FILE): +** +** Read and return the contents of file FILE (type blob) from disk. +** +** FSDIR: +** +** Used as follows: +** +** SELECT * FROM fsdir($path [, $dir]); +** +** Parameter $path is an absolute or relative pathname. If the file that it +** refers to does not exist, it is an error. If the path refers to a regular +** file or symbolic link, it returns a single row. Or, if the path refers +** to a directory, it returns one row for the directory, and one row for each +** file within the hierarchy rooted at $path. +** +** Each row has the following columns: +** +** name: Path to file or directory (text value). +** mode: Value of stat.st_mode for directory entry (an integer). +** mtime: Value of stat.st_mtime for directory entry (an integer). +** data: For a regular file, a blob containing the file data. For a +** symlink, a text value containing the text of the link. For a +** directory, NULL. +** +** If a non-NULL value is specified for the optional $dir parameter and +** $path is a relative path, then $path is interpreted relative to $dir. +** And the paths returned in the "name" column of the table are also +** relative to directory $dir. +*/ +/* #include "sqlite3ext.h" */ +SQLITE_EXTENSION_INIT1 +#include +#include +#include + +#include +#include +#include +#if !defined(_WIN32) && !defined(WIN32) +# include +# include +# include +# include +#else +# include "windows.h" +# include +# include +/* # include "test_windirent.h" */ +# define dirent DIRENT +# ifndef chmod +# define chmod _chmod +# endif +# ifndef stat +# define stat _stat +# endif +# define mkdir(path,mode) _mkdir(path) +# define lstat(path,buf) stat(path,buf) +#endif +#include +#include + + +/* +** Structure of the fsdir() table-valued function +*/ + /* 0 1 2 3 4 5 */ +#define FSDIR_SCHEMA "(name,mode,mtime,data,path HIDDEN,dir HIDDEN)" +#define FSDIR_COLUMN_NAME 0 /* Name of the file */ +#define FSDIR_COLUMN_MODE 1 /* Access mode */ +#define FSDIR_COLUMN_MTIME 2 /* Last modification time */ +#define FSDIR_COLUMN_DATA 3 /* File content */ +#define FSDIR_COLUMN_PATH 4 /* Path to top of search */ +#define FSDIR_COLUMN_DIR 5 /* Path is relative to this directory */ + + +/* +** Set the result stored by context ctx to a blob containing the +** contents of file zName. Or, leave the result unchanged (NULL) +** if the file does not exist or is unreadable. +** +** If the file exceeds the SQLite blob size limit, through an +** SQLITE_TOOBIG error. +** +** Throw an SQLITE_IOERR if there are difficulties pulling the file +** off of disk. +*/ +static void readFileContents(sqlite3_context *ctx, const char *zName){ + FILE *in; + sqlite3_int64 nIn; + void *pBuf; + sqlite3 *db; + int mxBlob; + + in = fopen(zName, "rb"); + if( in==0 ){ + /* File does not exist or is unreadable. Leave the result set to NULL. */ + return; + } + fseek(in, 0, SEEK_END); + nIn = ftell(in); + rewind(in); + db = sqlite3_context_db_handle(ctx); + mxBlob = sqlite3_limit(db, SQLITE_LIMIT_LENGTH, -1); + if( nIn>mxBlob ){ + sqlite3_result_error_code(ctx, SQLITE_TOOBIG); + fclose(in); + return; + } + pBuf = sqlite3_malloc64( nIn ? nIn : 1 ); + if( pBuf==0 ){ + sqlite3_result_error_nomem(ctx); + fclose(in); + return; + } + if( nIn==(sqlite3_int64)fread(pBuf, 1, (size_t)nIn, in) ){ + sqlite3_result_blob64(ctx, pBuf, nIn, sqlite3_free); + }else{ + sqlite3_result_error_code(ctx, SQLITE_IOERR); + sqlite3_free(pBuf); + } + fclose(in); +} + +/* +** Implementation of the "readfile(X)" SQL function. The entire content +** of the file named X is read and returned as a BLOB. NULL is returned +** if the file does not exist or is unreadable. +*/ +static void readfileFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zName; + (void)(argc); /* Unused parameter */ + zName = (const char*)sqlite3_value_text(argv[0]); + if( zName==0 ) return; + readFileContents(context, zName); +} + +/* +** Set the error message contained in context ctx to the results of +** vprintf(zFmt, ...). +*/ +static void ctxErrorMsg(sqlite3_context *ctx, const char *zFmt, ...){ + char *zMsg = 0; + va_list ap; + va_start(ap, zFmt); + zMsg = sqlite3_vmprintf(zFmt, ap); + sqlite3_result_error(ctx, zMsg, -1); + sqlite3_free(zMsg); + va_end(ap); +} + +#if defined(_WIN32) +/* +** This function is designed to convert a Win32 FILETIME structure into the +** number of seconds since the Unix Epoch (1970-01-01 00:00:00 UTC). +*/ +static sqlite3_uint64 fileTimeToUnixTime( + LPFILETIME pFileTime +){ + SYSTEMTIME epochSystemTime; + ULARGE_INTEGER epochIntervals; + FILETIME epochFileTime; + ULARGE_INTEGER fileIntervals; + + memset(&epochSystemTime, 0, sizeof(SYSTEMTIME)); + epochSystemTime.wYear = 1970; + epochSystemTime.wMonth = 1; + epochSystemTime.wDay = 1; + SystemTimeToFileTime(&epochSystemTime, &epochFileTime); + epochIntervals.LowPart = epochFileTime.dwLowDateTime; + epochIntervals.HighPart = epochFileTime.dwHighDateTime; + + fileIntervals.LowPart = pFileTime->dwLowDateTime; + fileIntervals.HighPart = pFileTime->dwHighDateTime; + + return (fileIntervals.QuadPart - epochIntervals.QuadPart) / 10000000; +} + +/* +** This function attempts to normalize the time values found in the stat() +** buffer to UTC. This is necessary on Win32, where the runtime library +** appears to return these values as local times. +*/ +static void statTimesToUtc( + const char *zPath, + struct stat *pStatBuf +){ + HANDLE hFindFile; + WIN32_FIND_DATAW fd; + LPWSTR zUnicodeName; + extern LPWSTR sqlite3_win32_utf8_to_unicode(const char*); + zUnicodeName = sqlite3_win32_utf8_to_unicode(zPath); + if( zUnicodeName ){ + memset(&fd, 0, sizeof(WIN32_FIND_DATAW)); + hFindFile = FindFirstFileW(zUnicodeName, &fd); + if( hFindFile!=NULL ){ + pStatBuf->st_ctime = (time_t)fileTimeToUnixTime(&fd.ftCreationTime); + pStatBuf->st_atime = (time_t)fileTimeToUnixTime(&fd.ftLastAccessTime); + pStatBuf->st_mtime = (time_t)fileTimeToUnixTime(&fd.ftLastWriteTime); + FindClose(hFindFile); + } + sqlite3_free(zUnicodeName); + } +} +#endif + +/* +** This function is used in place of stat(). On Windows, special handling +** is required in order for the included time to be returned as UTC. On all +** other systems, this function simply calls stat(). +*/ +static int fileStat( + const char *zPath, + struct stat *pStatBuf +){ +#if defined(_WIN32) + int rc = stat(zPath, pStatBuf); + if( rc==0 ) statTimesToUtc(zPath, pStatBuf); + return rc; +#else + return stat(zPath, pStatBuf); +#endif +} + +/* +** This function is used in place of lstat(). On Windows, special handling +** is required in order for the included time to be returned as UTC. On all +** other systems, this function simply calls lstat(). +*/ +static int fileLinkStat( + const char *zPath, + struct stat *pStatBuf +){ +#if defined(_WIN32) + int rc = lstat(zPath, pStatBuf); + if( rc==0 ) statTimesToUtc(zPath, pStatBuf); + return rc; +#else + return lstat(zPath, pStatBuf); +#endif +} + +/* +** Argument zFile is the name of a file that will be created and/or written +** by SQL function writefile(). This function ensures that the directory +** zFile will be written to exists, creating it if required. The permissions +** for any path components created by this function are set in accordance +** with the current umask. +** +** If an OOM condition is encountered, SQLITE_NOMEM is returned. Otherwise, +** SQLITE_OK is returned if the directory is successfully created, or +** SQLITE_ERROR otherwise. +*/ +static int makeDirectory( + const char *zFile +){ + char *zCopy = sqlite3_mprintf("%s", zFile); + int rc = SQLITE_OK; + + if( zCopy==0 ){ + rc = SQLITE_NOMEM; + }else{ + int nCopy = (int)strlen(zCopy); + int i = 1; + + while( rc==SQLITE_OK ){ + struct stat sStat; + int rc2; + + for(; zCopy[i]!='/' && i=0 ){ +#if defined(_WIN32) +#if !SQLITE_OS_WINRT + /* Windows */ + FILETIME lastAccess; + FILETIME lastWrite; + SYSTEMTIME currentTime; + LONGLONG intervals; + HANDLE hFile; + LPWSTR zUnicodeName; + extern LPWSTR sqlite3_win32_utf8_to_unicode(const char*); + + GetSystemTime(¤tTime); + SystemTimeToFileTime(¤tTime, &lastAccess); + intervals = Int32x32To64(mtime, 10000000) + 116444736000000000; + lastWrite.dwLowDateTime = (DWORD)intervals; + lastWrite.dwHighDateTime = intervals >> 32; + zUnicodeName = sqlite3_win32_utf8_to_unicode(zFile); + if( zUnicodeName==0 ){ + return 1; + } + hFile = CreateFileW( + zUnicodeName, FILE_WRITE_ATTRIBUTES, 0, NULL, OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS, NULL + ); + sqlite3_free(zUnicodeName); + if( hFile!=INVALID_HANDLE_VALUE ){ + BOOL bResult = SetFileTime(hFile, NULL, &lastAccess, &lastWrite); + CloseHandle(hFile); + return !bResult; + }else{ + return 1; + } +#endif +#elif defined(AT_FDCWD) && 0 /* utimensat() is not universally available */ + /* Recent unix */ + struct timespec times[2]; + times[0].tv_nsec = times[1].tv_nsec = 0; + times[0].tv_sec = time(0); + times[1].tv_sec = mtime; + if( utimensat(AT_FDCWD, zFile, times, AT_SYMLINK_NOFOLLOW) ){ + return 1; + } +#else + /* Legacy unix */ + struct timeval times[2]; + times[0].tv_usec = times[1].tv_usec = 0; + times[0].tv_sec = time(0); + times[1].tv_sec = mtime; + if( utimes(zFile, times) ){ + return 1; + } +#endif + } + + return 0; +} + +/* +** Implementation of the "writefile(W,X[,Y[,Z]]])" SQL function. +** Refer to header comments at the top of this file for details. +*/ +static void writefileFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zFile; + mode_t mode = 0; + int res; + sqlite3_int64 mtime = -1; + + if( argc<2 || argc>4 ){ + sqlite3_result_error(context, + "wrong number of arguments to function writefile()", -1 + ); + return; + } + + zFile = (const char*)sqlite3_value_text(argv[0]); + if( zFile==0 ) return; + if( argc>=3 ){ + mode = (mode_t)sqlite3_value_int(argv[2]); + } + if( argc==4 ){ + mtime = sqlite3_value_int64(argv[3]); + } + + res = writeFile(context, zFile, argv[1], mode, mtime); + if( res==1 && errno==ENOENT ){ + if( makeDirectory(zFile)==SQLITE_OK ){ + res = writeFile(context, zFile, argv[1], mode, mtime); + } + } + + if( argc>2 && res!=0 ){ + if( S_ISLNK(mode) ){ + ctxErrorMsg(context, "failed to create symlink: %s", zFile); + }else if( S_ISDIR(mode) ){ + ctxErrorMsg(context, "failed to create directory: %s", zFile); + }else{ + ctxErrorMsg(context, "failed to write file: %s", zFile); + } + } +} + +/* +** SQL function: lsmode(MODE) +** +** Given a numberic st_mode from stat(), convert it into a human-readable +** text string in the style of "ls -l". +*/ +static void lsModeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int i; + int iMode = sqlite3_value_int(argv[0]); + char z[16]; + (void)argc; + if( S_ISLNK(iMode) ){ + z[0] = 'l'; + }else if( S_ISREG(iMode) ){ + z[0] = '-'; + }else if( S_ISDIR(iMode) ){ + z[0] = 'd'; + }else{ + z[0] = '?'; + } + for(i=0; i<3; i++){ + int m = (iMode >> ((2-i)*3)); + char *a = &z[1 + i*3]; + a[0] = (m & 0x4) ? 'r' : '-'; + a[1] = (m & 0x2) ? 'w' : '-'; + a[2] = (m & 0x1) ? 'x' : '-'; + } + z[10] = '\0'; + sqlite3_result_text(context, z, -1, SQLITE_TRANSIENT); +} + +#ifndef SQLITE_OMIT_VIRTUALTABLE + +/* +** Cursor type for recursively iterating through a directory structure. +*/ +typedef struct fsdir_cursor fsdir_cursor; +typedef struct FsdirLevel FsdirLevel; + +struct FsdirLevel { + DIR *pDir; /* From opendir() */ + char *zDir; /* Name of directory (nul-terminated) */ +}; + +struct fsdir_cursor { + sqlite3_vtab_cursor base; /* Base class - must be first */ + + int nLvl; /* Number of entries in aLvl[] array */ + int iLvl; /* Index of current entry */ + FsdirLevel *aLvl; /* Hierarchy of directories being traversed */ + + const char *zBase; + int nBase; + + struct stat sStat; /* Current lstat() results */ + char *zPath; /* Path to current entry */ + sqlite3_int64 iRowid; /* Current rowid */ +}; + +typedef struct fsdir_tab fsdir_tab; +struct fsdir_tab { + sqlite3_vtab base; /* Base class - must be first */ +}; + +/* +** Construct a new fsdir virtual table object. +*/ +static int fsdirConnect( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + fsdir_tab *pNew = 0; + int rc; + (void)pAux; + (void)argc; + (void)argv; + (void)pzErr; + rc = sqlite3_declare_vtab(db, "CREATE TABLE x" FSDIR_SCHEMA); + if( rc==SQLITE_OK ){ + pNew = (fsdir_tab*)sqlite3_malloc( sizeof(*pNew) ); + if( pNew==0 ) return SQLITE_NOMEM; + memset(pNew, 0, sizeof(*pNew)); + sqlite3_vtab_config(db, SQLITE_VTAB_DIRECTONLY); + } + *ppVtab = (sqlite3_vtab*)pNew; + return rc; +} + +/* +** This method is the destructor for fsdir vtab objects. +*/ +static int fsdirDisconnect(sqlite3_vtab *pVtab){ + sqlite3_free(pVtab); + return SQLITE_OK; +} + +/* +** Constructor for a new fsdir_cursor object. +*/ +static int fsdirOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ + fsdir_cursor *pCur; + (void)p; + pCur = sqlite3_malloc( sizeof(*pCur) ); + if( pCur==0 ) return SQLITE_NOMEM; + memset(pCur, 0, sizeof(*pCur)); + pCur->iLvl = -1; + *ppCursor = &pCur->base; + return SQLITE_OK; +} + +/* +** Reset a cursor back to the state it was in when first returned +** by fsdirOpen(). +*/ +static void fsdirResetCursor(fsdir_cursor *pCur){ + int i; + for(i=0; i<=pCur->iLvl; i++){ + FsdirLevel *pLvl = &pCur->aLvl[i]; + if( pLvl->pDir ) closedir(pLvl->pDir); + sqlite3_free(pLvl->zDir); + } + sqlite3_free(pCur->zPath); + sqlite3_free(pCur->aLvl); + pCur->aLvl = 0; + pCur->zPath = 0; + pCur->zBase = 0; + pCur->nBase = 0; + pCur->nLvl = 0; + pCur->iLvl = -1; + pCur->iRowid = 1; +} + +/* +** Destructor for an fsdir_cursor. +*/ +static int fsdirClose(sqlite3_vtab_cursor *cur){ + fsdir_cursor *pCur = (fsdir_cursor*)cur; + + fsdirResetCursor(pCur); + sqlite3_free(pCur); + return SQLITE_OK; +} + +/* +** Set the error message for the virtual table associated with cursor +** pCur to the results of vprintf(zFmt, ...). +*/ +static void fsdirSetErrmsg(fsdir_cursor *pCur, const char *zFmt, ...){ + va_list ap; + va_start(ap, zFmt); + pCur->base.pVtab->zErrMsg = sqlite3_vmprintf(zFmt, ap); + va_end(ap); +} + + +/* +** Advance an fsdir_cursor to its next row of output. +*/ +static int fsdirNext(sqlite3_vtab_cursor *cur){ + fsdir_cursor *pCur = (fsdir_cursor*)cur; + mode_t m = pCur->sStat.st_mode; + + pCur->iRowid++; + if( S_ISDIR(m) ){ + /* Descend into this directory */ + int iNew = pCur->iLvl + 1; + FsdirLevel *pLvl; + if( iNew>=pCur->nLvl ){ + int nNew = iNew+1; + sqlite3_int64 nByte = nNew*sizeof(FsdirLevel); + FsdirLevel *aNew = (FsdirLevel*)sqlite3_realloc64(pCur->aLvl, nByte); + if( aNew==0 ) return SQLITE_NOMEM; + memset(&aNew[pCur->nLvl], 0, sizeof(FsdirLevel)*(nNew-pCur->nLvl)); + pCur->aLvl = aNew; + pCur->nLvl = nNew; + } + pCur->iLvl = iNew; + pLvl = &pCur->aLvl[iNew]; + + pLvl->zDir = pCur->zPath; + pCur->zPath = 0; + pLvl->pDir = opendir(pLvl->zDir); + if( pLvl->pDir==0 ){ + fsdirSetErrmsg(pCur, "cannot read directory: %s", pCur->zPath); + return SQLITE_ERROR; + } + } + + while( pCur->iLvl>=0 ){ + FsdirLevel *pLvl = &pCur->aLvl[pCur->iLvl]; + struct dirent *pEntry = readdir(pLvl->pDir); + if( pEntry ){ + if( pEntry->d_name[0]=='.' ){ + if( pEntry->d_name[1]=='.' && pEntry->d_name[2]=='\0' ) continue; + if( pEntry->d_name[1]=='\0' ) continue; + } + sqlite3_free(pCur->zPath); + pCur->zPath = sqlite3_mprintf("%s/%s", pLvl->zDir, pEntry->d_name); + if( pCur->zPath==0 ) return SQLITE_NOMEM; + if( fileLinkStat(pCur->zPath, &pCur->sStat) ){ + fsdirSetErrmsg(pCur, "cannot stat file: %s", pCur->zPath); + return SQLITE_ERROR; + } + return SQLITE_OK; + } + closedir(pLvl->pDir); + sqlite3_free(pLvl->zDir); + pLvl->pDir = 0; + pLvl->zDir = 0; + pCur->iLvl--; + } + + /* EOF */ + sqlite3_free(pCur->zPath); + pCur->zPath = 0; + return SQLITE_OK; +} + +/* +** Return values of columns for the row at which the series_cursor +** is currently pointing. +*/ +static int fsdirColumn( + sqlite3_vtab_cursor *cur, /* The cursor */ + sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ + int i /* Which column to return */ +){ + fsdir_cursor *pCur = (fsdir_cursor*)cur; + switch( i ){ + case FSDIR_COLUMN_NAME: { + sqlite3_result_text(ctx, &pCur->zPath[pCur->nBase], -1, SQLITE_TRANSIENT); + break; + } + + case FSDIR_COLUMN_MODE: + sqlite3_result_int64(ctx, pCur->sStat.st_mode); + break; + + case FSDIR_COLUMN_MTIME: + sqlite3_result_int64(ctx, pCur->sStat.st_mtime); + break; + + case FSDIR_COLUMN_DATA: { + mode_t m = pCur->sStat.st_mode; + if( S_ISDIR(m) ){ + sqlite3_result_null(ctx); +#if !defined(_WIN32) && !defined(WIN32) + }else if( S_ISLNK(m) ){ + char aStatic[64]; + char *aBuf = aStatic; + sqlite3_int64 nBuf = 64; + int n; + + while( 1 ){ + n = readlink(pCur->zPath, aBuf, nBuf); + if( nzPath); + } + } + case FSDIR_COLUMN_PATH: + default: { + /* The FSDIR_COLUMN_PATH and FSDIR_COLUMN_DIR are input parameters. + ** always return their values as NULL */ + break; + } + } + return SQLITE_OK; +} + +/* +** Return the rowid for the current row. In this implementation, the +** first row returned is assigned rowid value 1, and each subsequent +** row a value 1 more than that of the previous. +*/ +static int fsdirRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ + fsdir_cursor *pCur = (fsdir_cursor*)cur; + *pRowid = pCur->iRowid; + return SQLITE_OK; +} + +/* +** Return TRUE if the cursor has been moved off of the last +** row of output. +*/ +static int fsdirEof(sqlite3_vtab_cursor *cur){ + fsdir_cursor *pCur = (fsdir_cursor*)cur; + return (pCur->zPath==0); +} + +/* +** xFilter callback. +** +** idxNum==1 PATH parameter only +** idxNum==2 Both PATH and DIR supplied +*/ +static int fsdirFilter( + sqlite3_vtab_cursor *cur, + int idxNum, const char *idxStr, + int argc, sqlite3_value **argv +){ + const char *zDir = 0; + fsdir_cursor *pCur = (fsdir_cursor*)cur; + (void)idxStr; + fsdirResetCursor(pCur); + + if( idxNum==0 ){ + fsdirSetErrmsg(pCur, "table function fsdir requires an argument"); + return SQLITE_ERROR; + } + + assert( argc==idxNum && (argc==1 || argc==2) ); + zDir = (const char*)sqlite3_value_text(argv[0]); + if( zDir==0 ){ + fsdirSetErrmsg(pCur, "table function fsdir requires a non-NULL argument"); + return SQLITE_ERROR; + } + if( argc==2 ){ + pCur->zBase = (const char*)sqlite3_value_text(argv[1]); + } + if( pCur->zBase ){ + pCur->nBase = (int)strlen(pCur->zBase)+1; + pCur->zPath = sqlite3_mprintf("%s/%s", pCur->zBase, zDir); + }else{ + pCur->zPath = sqlite3_mprintf("%s", zDir); + } + + if( pCur->zPath==0 ){ + return SQLITE_NOMEM; + } + if( fileLinkStat(pCur->zPath, &pCur->sStat) ){ + fsdirSetErrmsg(pCur, "cannot stat file: %s", pCur->zPath); + return SQLITE_ERROR; + } + + return SQLITE_OK; +} + +/* +** SQLite will invoke this method one or more times while planning a query +** that uses the generate_series virtual table. This routine needs to create +** a query plan for each invocation and compute an estimated cost for that +** plan. +** +** In this implementation idxNum is used to represent the +** query plan. idxStr is unused. +** +** The query plan is represented by values of idxNum: +** +** (1) The path value is supplied by argv[0] +** (2) Path is in argv[0] and dir is in argv[1] +*/ +static int fsdirBestIndex( + sqlite3_vtab *tab, + sqlite3_index_info *pIdxInfo +){ + int i; /* Loop over constraints */ + int idxPath = -1; /* Index in pIdxInfo->aConstraint of PATH= */ + int idxDir = -1; /* Index in pIdxInfo->aConstraint of DIR= */ + int seenPath = 0; /* True if an unusable PATH= constraint is seen */ + int seenDir = 0; /* True if an unusable DIR= constraint is seen */ + const struct sqlite3_index_constraint *pConstraint; + + (void)tab; + pConstraint = pIdxInfo->aConstraint; + for(i=0; inConstraint; i++, pConstraint++){ + if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue; + switch( pConstraint->iColumn ){ + case FSDIR_COLUMN_PATH: { + if( pConstraint->usable ){ + idxPath = i; + seenPath = 0; + }else if( idxPath<0 ){ + seenPath = 1; + } + break; + } + case FSDIR_COLUMN_DIR: { + if( pConstraint->usable ){ + idxDir = i; + seenDir = 0; + }else if( idxDir<0 ){ + seenDir = 1; + } + break; + } + } + } + if( seenPath || seenDir ){ + /* If input parameters are unusable, disallow this plan */ + return SQLITE_CONSTRAINT; + } + + if( idxPath<0 ){ + pIdxInfo->idxNum = 0; + /* The pIdxInfo->estimatedCost should have been initialized to a huge + ** number. Leave it unchanged. */ + pIdxInfo->estimatedRows = 0x7fffffff; + }else{ + pIdxInfo->aConstraintUsage[idxPath].omit = 1; + pIdxInfo->aConstraintUsage[idxPath].argvIndex = 1; + if( idxDir>=0 ){ + pIdxInfo->aConstraintUsage[idxDir].omit = 1; + pIdxInfo->aConstraintUsage[idxDir].argvIndex = 2; + pIdxInfo->idxNum = 2; + pIdxInfo->estimatedCost = 10.0; + }else{ + pIdxInfo->idxNum = 1; + pIdxInfo->estimatedCost = 100.0; + } + } + + return SQLITE_OK; +} + +/* +** Register the "fsdir" virtual table. +*/ +static int fsdirRegister(sqlite3 *db){ + static sqlite3_module fsdirModule = { + 0, /* iVersion */ + 0, /* xCreate */ + fsdirConnect, /* xConnect */ + fsdirBestIndex, /* xBestIndex */ + fsdirDisconnect, /* xDisconnect */ + 0, /* xDestroy */ + fsdirOpen, /* xOpen - open a cursor */ + fsdirClose, /* xClose - close a cursor */ + fsdirFilter, /* xFilter - configure scan constraints */ + fsdirNext, /* xNext - advance a cursor */ + fsdirEof, /* xEof - check for end of scan */ + fsdirColumn, /* xColumn - read data */ + fsdirRowid, /* xRowid - read data */ + 0, /* xUpdate */ + 0, /* xBegin */ + 0, /* xSync */ + 0, /* xCommit */ + 0, /* xRollback */ + 0, /* xFindMethod */ + 0, /* xRename */ + 0, /* xSavepoint */ + 0, /* xRelease */ + 0, /* xRollbackTo */ + 0, /* xShadowName */ + }; + + int rc = sqlite3_create_module(db, "fsdir", &fsdirModule, 0); + return rc; +} +#else /* SQLITE_OMIT_VIRTUALTABLE */ +# define fsdirRegister(x) SQLITE_OK +#endif + +#ifdef _WIN32 + +#endif +int sqlite3_fileio_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi +){ + int rc = SQLITE_OK; + SQLITE_EXTENSION_INIT2(pApi); + (void)pzErrMsg; /* Unused parameter */ + rc = sqlite3_create_function(db, "readfile", 1, + SQLITE_UTF8|SQLITE_DIRECTONLY, 0, + readfileFunc, 0, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3_create_function(db, "writefile", -1, + SQLITE_UTF8|SQLITE_DIRECTONLY, 0, + writefileFunc, 0, 0); + } + if( rc==SQLITE_OK ){ + rc = sqlite3_create_function(db, "lsmode", 1, SQLITE_UTF8, 0, + lsModeFunc, 0, 0); + } + if( rc==SQLITE_OK ){ + rc = fsdirRegister(db); + } + return rc; +} + +/************************* End ../ext/misc/fileio.c ********************/ +/************************* Begin ../ext/misc/completion.c ******************/ +/* +** 2017-07-10 +** +** 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 an eponymous virtual table that returns suggested +** completions for a partial SQL input. +** +** Suggested usage: +** +** SELECT DISTINCT candidate COLLATE nocase +** FROM completion($prefix,$wholeline) +** ORDER BY 1; +** +** The two query parameters are optional. $prefix is the text of the +** current word being typed and that is to be completed. $wholeline is +** the complete input line, used for context. +** +** The raw completion() table might return the same candidate multiple +** times, for example if the same column name is used to two or more +** tables. And the candidates are returned in an arbitrary order. Hence, +** the DISTINCT and ORDER BY are recommended. +** +** This virtual table operates at the speed of human typing, and so there +** is no attempt to make it fast. Even a slow implementation will be much +** faster than any human can type. +** +*/ +/* #include "sqlite3ext.h" */ +SQLITE_EXTENSION_INIT1 +#include +#include +#include + +#ifndef SQLITE_OMIT_VIRTUALTABLE + +/* completion_vtab is a subclass of sqlite3_vtab which will +** serve as the underlying representation of a completion virtual table +*/ +typedef struct completion_vtab completion_vtab; +struct completion_vtab { + sqlite3_vtab base; /* Base class - must be first */ + sqlite3 *db; /* Database connection for this completion vtab */ +}; + +/* completion_cursor is a subclass of sqlite3_vtab_cursor which will +** serve as the underlying representation of a cursor that scans +** over rows of the result +*/ +typedef struct completion_cursor completion_cursor; +struct completion_cursor { + sqlite3_vtab_cursor base; /* Base class - must be first */ + sqlite3 *db; /* Database connection for this cursor */ + int nPrefix, nLine; /* Number of bytes in zPrefix and zLine */ + char *zPrefix; /* The prefix for the word we want to complete */ + char *zLine; /* The whole that we want to complete */ + const char *zCurrentRow; /* Current output row */ + int szRow; /* Length of the zCurrentRow string */ + sqlite3_stmt *pStmt; /* Current statement */ + sqlite3_int64 iRowid; /* The rowid */ + int ePhase; /* Current phase */ + int j; /* inter-phase counter */ +}; + +/* Values for ePhase: +*/ +#define COMPLETION_FIRST_PHASE 1 +#define COMPLETION_KEYWORDS 1 +#define COMPLETION_PRAGMAS 2 +#define COMPLETION_FUNCTIONS 3 +#define COMPLETION_COLLATIONS 4 +#define COMPLETION_INDEXES 5 +#define COMPLETION_TRIGGERS 6 +#define COMPLETION_DATABASES 7 +#define COMPLETION_TABLES 8 /* Also VIEWs and TRIGGERs */ +#define COMPLETION_COLUMNS 9 +#define COMPLETION_MODULES 10 +#define COMPLETION_EOF 11 + +/* +** The completionConnect() method is invoked to create a new +** completion_vtab that describes the completion virtual table. +** +** Think of this routine as the constructor for completion_vtab objects. +** +** All this routine needs to do is: +** +** (1) Allocate the completion_vtab object and initialize all fields. +** +** (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the +** result set of queries against completion will look like. +*/ +static int completionConnect( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + completion_vtab *pNew; + int rc; + + (void)(pAux); /* Unused parameter */ + (void)(argc); /* Unused parameter */ + (void)(argv); /* Unused parameter */ + (void)(pzErr); /* Unused parameter */ + +/* Column numbers */ +#define COMPLETION_COLUMN_CANDIDATE 0 /* Suggested completion of the input */ +#define COMPLETION_COLUMN_PREFIX 1 /* Prefix of the word to be completed */ +#define COMPLETION_COLUMN_WHOLELINE 2 /* Entire line seen so far */ +#define COMPLETION_COLUMN_PHASE 3 /* ePhase - used for debugging only */ + + sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS); + rc = sqlite3_declare_vtab(db, + "CREATE TABLE x(" + " candidate TEXT," + " prefix TEXT HIDDEN," + " wholeline TEXT HIDDEN," + " phase INT HIDDEN" /* Used for debugging only */ + ")"); + if( rc==SQLITE_OK ){ + pNew = sqlite3_malloc( sizeof(*pNew) ); + *ppVtab = (sqlite3_vtab*)pNew; + if( pNew==0 ) return SQLITE_NOMEM; + memset(pNew, 0, sizeof(*pNew)); + pNew->db = db; + } + return rc; +} + +/* +** This method is the destructor for completion_cursor objects. +*/ +static int completionDisconnect(sqlite3_vtab *pVtab){ + sqlite3_free(pVtab); + return SQLITE_OK; +} + +/* +** Constructor for a new completion_cursor object. +*/ +static int completionOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ + completion_cursor *pCur; + pCur = sqlite3_malloc( sizeof(*pCur) ); + if( pCur==0 ) return SQLITE_NOMEM; + memset(pCur, 0, sizeof(*pCur)); + pCur->db = ((completion_vtab*)p)->db; + *ppCursor = &pCur->base; + return SQLITE_OK; +} + +/* +** Reset the completion_cursor. +*/ +static void completionCursorReset(completion_cursor *pCur){ + sqlite3_free(pCur->zPrefix); pCur->zPrefix = 0; pCur->nPrefix = 0; + sqlite3_free(pCur->zLine); pCur->zLine = 0; pCur->nLine = 0; + sqlite3_finalize(pCur->pStmt); pCur->pStmt = 0; + pCur->j = 0; +} + +/* +** Destructor for a completion_cursor. +*/ +static int completionClose(sqlite3_vtab_cursor *cur){ + completionCursorReset((completion_cursor*)cur); + sqlite3_free(cur); + return SQLITE_OK; +} + +/* +** Advance a completion_cursor to its next row of output. +** +** The ->ePhase, ->j, and ->pStmt fields of the completion_cursor object +** record the current state of the scan. This routine sets ->zCurrentRow +** to the current row of output and then returns. If no more rows remain, +** then ->ePhase is set to COMPLETION_EOF which will signal the virtual +** table that has reached the end of its scan. +** +** The current implementation just lists potential identifiers and +** keywords and filters them by zPrefix. Future enhancements should +** take zLine into account to try to restrict the set of identifiers and +** keywords based on what would be legal at the current point of input. +*/ +static int completionNext(sqlite3_vtab_cursor *cur){ + completion_cursor *pCur = (completion_cursor*)cur; + int eNextPhase = 0; /* Next phase to try if current phase reaches end */ + int iCol = -1; /* If >=0, step pCur->pStmt and use the i-th column */ + pCur->iRowid++; + while( pCur->ePhase!=COMPLETION_EOF ){ + switch( pCur->ePhase ){ + case COMPLETION_KEYWORDS: { + if( pCur->j >= sqlite3_keyword_count() ){ + pCur->zCurrentRow = 0; + pCur->ePhase = COMPLETION_DATABASES; + }else{ + sqlite3_keyword_name(pCur->j++, &pCur->zCurrentRow, &pCur->szRow); + } + iCol = -1; + break; + } + case COMPLETION_DATABASES: { + if( pCur->pStmt==0 ){ + sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, + &pCur->pStmt, 0); + } + iCol = 1; + eNextPhase = COMPLETION_TABLES; + break; + } + case COMPLETION_TABLES: { + if( pCur->pStmt==0 ){ + sqlite3_stmt *pS2; + char *zSql = 0; + const char *zSep = ""; + sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0); + while( sqlite3_step(pS2)==SQLITE_ROW ){ + const char *zDb = (const char*)sqlite3_column_text(pS2, 1); + zSql = sqlite3_mprintf( + "%z%s" + "SELECT name FROM \"%w\".sqlite_schema", + zSql, zSep, zDb + ); + if( zSql==0 ) return SQLITE_NOMEM; + zSep = " UNION "; + } + sqlite3_finalize(pS2); + sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0); + sqlite3_free(zSql); + } + iCol = 0; + eNextPhase = COMPLETION_COLUMNS; + break; + } + case COMPLETION_COLUMNS: { + if( pCur->pStmt==0 ){ + sqlite3_stmt *pS2; + char *zSql = 0; + const char *zSep = ""; + sqlite3_prepare_v2(pCur->db, "PRAGMA database_list", -1, &pS2, 0); + while( sqlite3_step(pS2)==SQLITE_ROW ){ + const char *zDb = (const char*)sqlite3_column_text(pS2, 1); + zSql = sqlite3_mprintf( + "%z%s" + "SELECT pti.name FROM \"%w\".sqlite_schema AS sm" + " JOIN pragma_table_info(sm.name,%Q) AS pti" + " WHERE sm.type='table'", + zSql, zSep, zDb, zDb + ); + if( zSql==0 ) return SQLITE_NOMEM; + zSep = " UNION "; + } + sqlite3_finalize(pS2); + sqlite3_prepare_v2(pCur->db, zSql, -1, &pCur->pStmt, 0); + sqlite3_free(zSql); + } + iCol = 0; + eNextPhase = COMPLETION_EOF; + break; + } + } + if( iCol<0 ){ + /* This case is when the phase presets zCurrentRow */ + if( pCur->zCurrentRow==0 ) continue; + }else{ + if( sqlite3_step(pCur->pStmt)==SQLITE_ROW ){ + /* Extract the next row of content */ + pCur->zCurrentRow = (const char*)sqlite3_column_text(pCur->pStmt, iCol); + pCur->szRow = sqlite3_column_bytes(pCur->pStmt, iCol); + }else{ + /* When all rows are finished, advance to the next phase */ + sqlite3_finalize(pCur->pStmt); + pCur->pStmt = 0; + pCur->ePhase = eNextPhase; + continue; + } + } + if( pCur->nPrefix==0 ) break; + if( pCur->nPrefix<=pCur->szRow + && sqlite3_strnicmp(pCur->zPrefix, pCur->zCurrentRow, pCur->nPrefix)==0 + ){ + break; + } + } + + return SQLITE_OK; +} + +/* +** Return values of columns for the row at which the completion_cursor +** is currently pointing. +*/ +static int completionColumn( + sqlite3_vtab_cursor *cur, /* The cursor */ + sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ + int i /* Which column to return */ +){ + completion_cursor *pCur = (completion_cursor*)cur; + switch( i ){ + case COMPLETION_COLUMN_CANDIDATE: { + sqlite3_result_text(ctx, pCur->zCurrentRow, pCur->szRow,SQLITE_TRANSIENT); + break; + } + case COMPLETION_COLUMN_PREFIX: { + sqlite3_result_text(ctx, pCur->zPrefix, -1, SQLITE_TRANSIENT); + break; + } + case COMPLETION_COLUMN_WHOLELINE: { + sqlite3_result_text(ctx, pCur->zLine, -1, SQLITE_TRANSIENT); + break; + } + case COMPLETION_COLUMN_PHASE: { + sqlite3_result_int(ctx, pCur->ePhase); + break; + } + } + return SQLITE_OK; +} + +/* +** Return the rowid for the current row. In this implementation, the +** rowid is the same as the output value. +*/ +static int completionRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ + completion_cursor *pCur = (completion_cursor*)cur; + *pRowid = pCur->iRowid; + return SQLITE_OK; +} + +/* +** Return TRUE if the cursor has been moved off of the last +** row of output. +*/ +static int completionEof(sqlite3_vtab_cursor *cur){ + completion_cursor *pCur = (completion_cursor*)cur; + return pCur->ePhase >= COMPLETION_EOF; +} + +/* +** This method is called to "rewind" the completion_cursor object back +** to the first row of output. This method is always called at least +** once prior to any call to completionColumn() or completionRowid() or +** completionEof(). +*/ +static int completionFilter( + sqlite3_vtab_cursor *pVtabCursor, + int idxNum, const char *idxStr, + int argc, sqlite3_value **argv +){ + completion_cursor *pCur = (completion_cursor *)pVtabCursor; + int iArg = 0; + (void)(idxStr); /* Unused parameter */ + (void)(argc); /* Unused parameter */ + completionCursorReset(pCur); + if( idxNum & 1 ){ + pCur->nPrefix = sqlite3_value_bytes(argv[iArg]); + if( pCur->nPrefix>0 ){ + pCur->zPrefix = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg])); + if( pCur->zPrefix==0 ) return SQLITE_NOMEM; + } + iArg = 1; + } + if( idxNum & 2 ){ + pCur->nLine = sqlite3_value_bytes(argv[iArg]); + if( pCur->nLine>0 ){ + pCur->zLine = sqlite3_mprintf("%s", sqlite3_value_text(argv[iArg])); + if( pCur->zLine==0 ) return SQLITE_NOMEM; + } + } + if( pCur->zLine!=0 && pCur->zPrefix==0 ){ + int i = pCur->nLine; + while( i>0 && (isalnum(pCur->zLine[i-1]) || pCur->zLine[i-1]=='_') ){ + i--; + } + pCur->nPrefix = pCur->nLine - i; + if( pCur->nPrefix>0 ){ + pCur->zPrefix = sqlite3_mprintf("%.*s", pCur->nPrefix, pCur->zLine + i); + if( pCur->zPrefix==0 ) return SQLITE_NOMEM; + } + } + pCur->iRowid = 0; + pCur->ePhase = COMPLETION_FIRST_PHASE; + return completionNext(pVtabCursor); +} + +/* +** SQLite will invoke this method one or more times while planning a query +** that uses the completion virtual table. This routine needs to create +** a query plan for each invocation and compute an estimated cost for that +** plan. +** +** There are two hidden parameters that act as arguments to the table-valued +** function: "prefix" and "wholeline". Bit 0 of idxNum is set if "prefix" +** is available and bit 1 is set if "wholeline" is available. +*/ +static int completionBestIndex( + sqlite3_vtab *tab, + sqlite3_index_info *pIdxInfo +){ + int i; /* Loop over constraints */ + int idxNum = 0; /* The query plan bitmask */ + int prefixIdx = -1; /* Index of the start= constraint, or -1 if none */ + int wholelineIdx = -1; /* Index of the stop= constraint, or -1 if none */ + int nArg = 0; /* Number of arguments that completeFilter() expects */ + const struct sqlite3_index_constraint *pConstraint; + + (void)(tab); /* Unused parameter */ + pConstraint = pIdxInfo->aConstraint; + for(i=0; inConstraint; i++, pConstraint++){ + if( pConstraint->usable==0 ) continue; + if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue; + switch( pConstraint->iColumn ){ + case COMPLETION_COLUMN_PREFIX: + prefixIdx = i; + idxNum |= 1; + break; + case COMPLETION_COLUMN_WHOLELINE: + wholelineIdx = i; + idxNum |= 2; + break; + } + } + if( prefixIdx>=0 ){ + pIdxInfo->aConstraintUsage[prefixIdx].argvIndex = ++nArg; + pIdxInfo->aConstraintUsage[prefixIdx].omit = 1; + } + if( wholelineIdx>=0 ){ + pIdxInfo->aConstraintUsage[wholelineIdx].argvIndex = ++nArg; + pIdxInfo->aConstraintUsage[wholelineIdx].omit = 1; + } + pIdxInfo->idxNum = idxNum; + pIdxInfo->estimatedCost = (double)5000 - 1000*nArg; + pIdxInfo->estimatedRows = 500 - 100*nArg; + return SQLITE_OK; +} + +/* +** This following structure defines all the methods for the +** completion virtual table. +*/ +static sqlite3_module completionModule = { + 0, /* iVersion */ + 0, /* xCreate */ + completionConnect, /* xConnect */ + completionBestIndex, /* xBestIndex */ + completionDisconnect, /* xDisconnect */ + 0, /* xDestroy */ + completionOpen, /* xOpen - open a cursor */ + completionClose, /* xClose - close a cursor */ + completionFilter, /* xFilter - configure scan constraints */ + completionNext, /* xNext - advance a cursor */ + completionEof, /* xEof - check for end of scan */ + completionColumn, /* xColumn - read data */ + completionRowid, /* xRowid - read data */ + 0, /* xUpdate */ + 0, /* xBegin */ + 0, /* xSync */ + 0, /* xCommit */ + 0, /* xRollback */ + 0, /* xFindMethod */ + 0, /* xRename */ + 0, /* xSavepoint */ + 0, /* xRelease */ + 0, /* xRollbackTo */ + 0 /* xShadowName */ +}; + +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +int sqlite3CompletionVtabInit(sqlite3 *db){ + int rc = SQLITE_OK; +#ifndef SQLITE_OMIT_VIRTUALTABLE + rc = sqlite3_create_module(db, "completion", &completionModule, 0); +#endif + return rc; +} + +#ifdef _WIN32 + +#endif +int sqlite3_completion_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi +){ + int rc = SQLITE_OK; + SQLITE_EXTENSION_INIT2(pApi); + (void)(pzErrMsg); /* Unused parameter */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + rc = sqlite3CompletionVtabInit(db); +#endif + return rc; +} + +/************************* End ../ext/misc/completion.c ********************/ +/************************* Begin ../ext/misc/appendvfs.c ******************/ +/* +** 2017-10-20 +** +** 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 a VFS shim that allows an SQLite database to be +** appended onto the end of some other file, such as an executable. +** +** A special record must appear at the end of the file that identifies the +** file as an appended database and provides an offset to page 1. For +** best performance page 1 should be located at a disk page boundary, though +** that is not required. +** +** When opening a database using this VFS, the connection might treat +** the file as an ordinary SQLite database, or it might treat is as a +** database appended onto some other file. Here are the rules: +** +** (1) When opening a new empty file, that file is treated as an ordinary +** database. +** +** (2) When opening a file that begins with the standard SQLite prefix +** string "SQLite format 3", that file is treated as an ordinary +** database. +** +** (3) When opening a file that ends with the appendvfs trailer string +** "Start-Of-SQLite3-NNNNNNNN" that file is treated as an appended +** database. +** +** (4) If none of the above apply and the SQLITE_OPEN_CREATE flag is +** set, then a new database is appended to the already existing file. +** +** (5) Otherwise, SQLITE_CANTOPEN is returned. +** +** To avoid unnecessary complications with the PENDING_BYTE, the size of +** the file containing the database is limited to 1GB. This VFS will refuse +** to read or write past the 1GB mark. This restriction might be lifted in +** future versions. For now, if you need a large database, then keep the +** database in a separate file. +** +** If the file being opened is not an appended database, then this shim is +** a pass-through into the default underlying VFS. +**/ +/* #include "sqlite3ext.h" */ +SQLITE_EXTENSION_INIT1 +#include +#include + +/* The append mark at the end of the database is: +** +** Start-Of-SQLite3-NNNNNNNN +** 123456789 123456789 12345 +** +** The NNNNNNNN represents a 64-bit big-endian unsigned integer which is +** the offset to page 1. +*/ +#define APND_MARK_PREFIX "Start-Of-SQLite3-" +#define APND_MARK_PREFIX_SZ 17 +#define APND_MARK_SIZE 25 + +/* +** Maximum size of the combined prefix + database + append-mark. This +** must be less than 0x40000000 to avoid locking issues on Windows. +*/ +#define APND_MAX_SIZE (65536*15259) + +/* +** Forward declaration of objects used by this utility +*/ +typedef struct sqlite3_vfs ApndVfs; +typedef struct ApndFile ApndFile; + +/* Access to a lower-level VFS that (might) implement dynamic loading, +** access to randomness, etc. +*/ +#define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData)) +#define ORIGFILE(p) ((sqlite3_file*)(((ApndFile*)(p))+1)) + +/* An open file */ +struct ApndFile { + sqlite3_file base; /* IO methods */ + sqlite3_int64 iPgOne; /* File offset to page 1 */ + sqlite3_int64 iMark; /* Start of the append-mark */ +}; + +/* +** Methods for ApndFile +*/ +static int apndClose(sqlite3_file*); +static int apndRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); +static int apndWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst); +static int apndTruncate(sqlite3_file*, sqlite3_int64 size); +static int apndSync(sqlite3_file*, int flags); +static int apndFileSize(sqlite3_file*, sqlite3_int64 *pSize); +static int apndLock(sqlite3_file*, int); +static int apndUnlock(sqlite3_file*, int); +static int apndCheckReservedLock(sqlite3_file*, int *pResOut); +static int apndFileControl(sqlite3_file*, int op, void *pArg); +static int apndSectorSize(sqlite3_file*); +static int apndDeviceCharacteristics(sqlite3_file*); +static int apndShmMap(sqlite3_file*, int iPg, int pgsz, int, void volatile**); +static int apndShmLock(sqlite3_file*, int offset, int n, int flags); +static void apndShmBarrier(sqlite3_file*); +static int apndShmUnmap(sqlite3_file*, int deleteFlag); +static int apndFetch(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp); +static int apndUnfetch(sqlite3_file*, sqlite3_int64 iOfst, void *p); + +/* +** Methods for ApndVfs +*/ +static int apndOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *); +static int apndDelete(sqlite3_vfs*, const char *zName, int syncDir); +static int apndAccess(sqlite3_vfs*, const char *zName, int flags, int *); +static int apndFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut); +static void *apndDlOpen(sqlite3_vfs*, const char *zFilename); +static void apndDlError(sqlite3_vfs*, int nByte, char *zErrMsg); +static void (*apndDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void); +static void apndDlClose(sqlite3_vfs*, void*); +static int apndRandomness(sqlite3_vfs*, int nByte, char *zOut); +static int apndSleep(sqlite3_vfs*, int microseconds); +static int apndCurrentTime(sqlite3_vfs*, double*); +static int apndGetLastError(sqlite3_vfs*, int, char *); +static int apndCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*); +static int apndSetSystemCall(sqlite3_vfs*, const char*,sqlite3_syscall_ptr); +static sqlite3_syscall_ptr apndGetSystemCall(sqlite3_vfs*, const char *z); +static const char *apndNextSystemCall(sqlite3_vfs*, const char *zName); + +static sqlite3_vfs apnd_vfs = { + 3, /* iVersion (set when registered) */ + 0, /* szOsFile (set when registered) */ + 1024, /* mxPathname */ + 0, /* pNext */ + "apndvfs", /* zName */ + 0, /* pAppData (set when registered) */ + apndOpen, /* xOpen */ + apndDelete, /* xDelete */ + apndAccess, /* xAccess */ + apndFullPathname, /* xFullPathname */ + apndDlOpen, /* xDlOpen */ + apndDlError, /* xDlError */ + apndDlSym, /* xDlSym */ + apndDlClose, /* xDlClose */ + apndRandomness, /* xRandomness */ + apndSleep, /* xSleep */ + apndCurrentTime, /* xCurrentTime */ + apndGetLastError, /* xGetLastError */ + apndCurrentTimeInt64, /* xCurrentTimeInt64 */ + apndSetSystemCall, /* xSetSystemCall */ + apndGetSystemCall, /* xGetSystemCall */ + apndNextSystemCall /* xNextSystemCall */ +}; + +static const sqlite3_io_methods apnd_io_methods = { + 3, /* iVersion */ + apndClose, /* xClose */ + apndRead, /* xRead */ + apndWrite, /* xWrite */ + apndTruncate, /* xTruncate */ + apndSync, /* xSync */ + apndFileSize, /* xFileSize */ + apndLock, /* xLock */ + apndUnlock, /* xUnlock */ + apndCheckReservedLock, /* xCheckReservedLock */ + apndFileControl, /* xFileControl */ + apndSectorSize, /* xSectorSize */ + apndDeviceCharacteristics, /* xDeviceCharacteristics */ + apndShmMap, /* xShmMap */ + apndShmLock, /* xShmLock */ + apndShmBarrier, /* xShmBarrier */ + apndShmUnmap, /* xShmUnmap */ + apndFetch, /* xFetch */ + apndUnfetch /* xUnfetch */ +}; + + + +/* +** Close an apnd-file. +*/ +static int apndClose(sqlite3_file *pFile){ + pFile = ORIGFILE(pFile); + return pFile->pMethods->xClose(pFile); +} + +/* +** Read data from an apnd-file. +*/ +static int apndRead( + sqlite3_file *pFile, + void *zBuf, + int iAmt, + sqlite_int64 iOfst +){ + ApndFile *p = (ApndFile *)pFile; + pFile = ORIGFILE(pFile); + return pFile->pMethods->xRead(pFile, zBuf, iAmt, iOfst+p->iPgOne); +} + +/* +** Add the append-mark onto the end of the file. +*/ +static int apndWriteMark(ApndFile *p, sqlite3_file *pFile){ + int i; + unsigned char a[APND_MARK_SIZE]; + memcpy(a, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ); + for(i=0; i<8; i++){ + a[APND_MARK_PREFIX_SZ+i] = (p->iPgOne >> (56 - i*8)) & 0xff; + } + return pFile->pMethods->xWrite(pFile, a, APND_MARK_SIZE, p->iMark); +} + +/* +** Write data to an apnd-file. +*/ +static int apndWrite( + sqlite3_file *pFile, + const void *zBuf, + int iAmt, + sqlite_int64 iOfst +){ + int rc; + ApndFile *p = (ApndFile *)pFile; + pFile = ORIGFILE(pFile); + if( iOfst+iAmt>=APND_MAX_SIZE ) return SQLITE_FULL; + rc = pFile->pMethods->xWrite(pFile, zBuf, iAmt, iOfst+p->iPgOne); + if( rc==SQLITE_OK && iOfst + iAmt + p->iPgOne > p->iMark ){ + sqlite3_int64 sz = 0; + rc = pFile->pMethods->xFileSize(pFile, &sz); + if( rc==SQLITE_OK ){ + p->iMark = sz - APND_MARK_SIZE; + if( iOfst + iAmt + p->iPgOne > p->iMark ){ + p->iMark = p->iPgOne + iOfst + iAmt; + rc = apndWriteMark(p, pFile); + } + } + } + return rc; +} + +/* +** Truncate an apnd-file. +*/ +static int apndTruncate(sqlite3_file *pFile, sqlite_int64 size){ + int rc; + ApndFile *p = (ApndFile *)pFile; + pFile = ORIGFILE(pFile); + rc = pFile->pMethods->xTruncate(pFile, size+p->iPgOne+APND_MARK_SIZE); + if( rc==SQLITE_OK ){ + p->iMark = p->iPgOne+size; + rc = apndWriteMark(p, pFile); + } + return rc; +} + +/* +** Sync an apnd-file. +*/ +static int apndSync(sqlite3_file *pFile, int flags){ + pFile = ORIGFILE(pFile); + return pFile->pMethods->xSync(pFile, flags); +} + +/* +** Return the current file-size of an apnd-file. +*/ +static int apndFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ + ApndFile *p = (ApndFile *)pFile; + int rc; + pFile = ORIGFILE(p); + rc = pFile->pMethods->xFileSize(pFile, pSize); + if( rc==SQLITE_OK && p->iPgOne ){ + *pSize -= p->iPgOne + APND_MARK_SIZE; + } + return rc; +} + +/* +** Lock an apnd-file. +*/ +static int apndLock(sqlite3_file *pFile, int eLock){ + pFile = ORIGFILE(pFile); + return pFile->pMethods->xLock(pFile, eLock); +} + +/* +** Unlock an apnd-file. +*/ +static int apndUnlock(sqlite3_file *pFile, int eLock){ + pFile = ORIGFILE(pFile); + return pFile->pMethods->xUnlock(pFile, eLock); +} + +/* +** Check if another file-handle holds a RESERVED lock on an apnd-file. +*/ +static int apndCheckReservedLock(sqlite3_file *pFile, int *pResOut){ + pFile = ORIGFILE(pFile); + return pFile->pMethods->xCheckReservedLock(pFile, pResOut); +} + +/* +** File control method. For custom operations on an apnd-file. +*/ +static int apndFileControl(sqlite3_file *pFile, int op, void *pArg){ + ApndFile *p = (ApndFile *)pFile; + int rc; + pFile = ORIGFILE(pFile); + rc = pFile->pMethods->xFileControl(pFile, op, pArg); + if( rc==SQLITE_OK && op==SQLITE_FCNTL_VFSNAME ){ + *(char**)pArg = sqlite3_mprintf("apnd(%lld)/%z", p->iPgOne, *(char**)pArg); + } + return rc; +} + +/* +** Return the sector-size in bytes for an apnd-file. +*/ +static int apndSectorSize(sqlite3_file *pFile){ + pFile = ORIGFILE(pFile); + return pFile->pMethods->xSectorSize(pFile); +} + +/* +** Return the device characteristic flags supported by an apnd-file. +*/ +static int apndDeviceCharacteristics(sqlite3_file *pFile){ + pFile = ORIGFILE(pFile); + return pFile->pMethods->xDeviceCharacteristics(pFile); +} + +/* Create a shared memory file mapping */ +static int apndShmMap( + sqlite3_file *pFile, + int iPg, + int pgsz, + int bExtend, + void volatile **pp +){ + pFile = ORIGFILE(pFile); + return pFile->pMethods->xShmMap(pFile,iPg,pgsz,bExtend,pp); +} + +/* Perform locking on a shared-memory segment */ +static int apndShmLock(sqlite3_file *pFile, int offset, int n, int flags){ + pFile = ORIGFILE(pFile); + return pFile->pMethods->xShmLock(pFile,offset,n,flags); +} + +/* Memory barrier operation on shared memory */ +static void apndShmBarrier(sqlite3_file *pFile){ + pFile = ORIGFILE(pFile); + pFile->pMethods->xShmBarrier(pFile); +} + +/* Unmap a shared memory segment */ +static int apndShmUnmap(sqlite3_file *pFile, int deleteFlag){ + pFile = ORIGFILE(pFile); + return pFile->pMethods->xShmUnmap(pFile,deleteFlag); +} + +/* Fetch a page of a memory-mapped file */ +static int apndFetch( + sqlite3_file *pFile, + sqlite3_int64 iOfst, + int iAmt, + void **pp +){ + ApndFile *p = (ApndFile *)pFile; + pFile = ORIGFILE(pFile); + return pFile->pMethods->xFetch(pFile, iOfst+p->iPgOne, iAmt, pp); +} + +/* Release a memory-mapped page */ +static int apndUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){ + ApndFile *p = (ApndFile *)pFile; + pFile = ORIGFILE(pFile); + return pFile->pMethods->xUnfetch(pFile, iOfst+p->iPgOne, pPage); +} + +/* +** Check to see if the file is an ordinary SQLite database file. +*/ +static int apndIsOrdinaryDatabaseFile(sqlite3_int64 sz, sqlite3_file *pFile){ + int rc; + char zHdr[16]; + static const char aSqliteHdr[] = "SQLite format 3"; + if( sz<512 ) return 0; + rc = pFile->pMethods->xRead(pFile, zHdr, sizeof(zHdr), 0); + if( rc ) return 0; + return memcmp(zHdr, aSqliteHdr, sizeof(zHdr))==0; +} + +/* +** Try to read the append-mark off the end of a file. Return the +** start of the appended database if the append-mark is present. If +** there is no append-mark, return -1; +*/ +static sqlite3_int64 apndReadMark(sqlite3_int64 sz, sqlite3_file *pFile){ + int rc, i; + sqlite3_int64 iMark; + unsigned char a[APND_MARK_SIZE]; + + if( sz<=APND_MARK_SIZE ) return -1; + rc = pFile->pMethods->xRead(pFile, a, APND_MARK_SIZE, sz-APND_MARK_SIZE); + if( rc ) return -1; + if( memcmp(a, APND_MARK_PREFIX, APND_MARK_PREFIX_SZ)!=0 ) return -1; + iMark = ((sqlite3_int64)(a[APND_MARK_PREFIX_SZ]&0x7f))<<56; + for(i=1; i<8; i++){ + iMark += (sqlite3_int64)a[APND_MARK_PREFIX_SZ+i]<<(56-8*i); + } + return iMark; +} + +/* +** Open an apnd file handle. +*/ +static int apndOpen( + sqlite3_vfs *pVfs, + const char *zName, + sqlite3_file *pFile, + int flags, + int *pOutFlags +){ + ApndFile *p; + sqlite3_file *pSubFile; + sqlite3_vfs *pSubVfs; + int rc; + sqlite3_int64 sz; + pSubVfs = ORIGVFS(pVfs); + if( (flags & SQLITE_OPEN_MAIN_DB)==0 ){ + return pSubVfs->xOpen(pSubVfs, zName, pFile, flags, pOutFlags); + } + p = (ApndFile*)pFile; + memset(p, 0, sizeof(*p)); + pSubFile = ORIGFILE(pFile); + pFile->pMethods = &apnd_io_methods; + rc = pSubVfs->xOpen(pSubVfs, zName, pSubFile, flags, pOutFlags); + if( rc ) goto apnd_open_done; + rc = pSubFile->pMethods->xFileSize(pSubFile, &sz); + if( rc ){ + pSubFile->pMethods->xClose(pSubFile); + goto apnd_open_done; + } + if( apndIsOrdinaryDatabaseFile(sz, pSubFile) ){ + memmove(pFile, pSubFile, pSubVfs->szOsFile); + return SQLITE_OK; + } + p->iMark = 0; + p->iPgOne = apndReadMark(sz, pFile); + if( p->iPgOne>0 ){ + return SQLITE_OK; + } + if( (flags & SQLITE_OPEN_CREATE)==0 ){ + pSubFile->pMethods->xClose(pSubFile); + rc = SQLITE_CANTOPEN; + } + p->iPgOne = (sz+0xfff) & ~(sqlite3_int64)0xfff; +apnd_open_done: + if( rc ) pFile->pMethods = 0; + return rc; +} + +/* +** All other VFS methods are pass-thrus. +*/ +static int apndDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ + return ORIGVFS(pVfs)->xDelete(ORIGVFS(pVfs), zPath, dirSync); +} +static int apndAccess( + sqlite3_vfs *pVfs, + const char *zPath, + int flags, + int *pResOut +){ + return ORIGVFS(pVfs)->xAccess(ORIGVFS(pVfs), zPath, flags, pResOut); +} +static int apndFullPathname( + sqlite3_vfs *pVfs, + const char *zPath, + int nOut, + char *zOut +){ + return ORIGVFS(pVfs)->xFullPathname(ORIGVFS(pVfs),zPath,nOut,zOut); +} +static void *apndDlOpen(sqlite3_vfs *pVfs, const char *zPath){ + return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath); +} +static void apndDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){ + ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg); +} +static void (*apndDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){ + return ORIGVFS(pVfs)->xDlSym(ORIGVFS(pVfs), p, zSym); +} +static void apndDlClose(sqlite3_vfs *pVfs, void *pHandle){ + ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle); +} +static int apndRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ + return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut); +} +static int apndSleep(sqlite3_vfs *pVfs, int nMicro){ + return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro); +} +static int apndCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ + return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut); +} +static int apndGetLastError(sqlite3_vfs *pVfs, int a, char *b){ + return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b); +} +static int apndCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){ + return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p); +} +static int apndSetSystemCall( + sqlite3_vfs *pVfs, + const char *zName, + sqlite3_syscall_ptr pCall +){ + return ORIGVFS(pVfs)->xSetSystemCall(ORIGVFS(pVfs),zName,pCall); +} +static sqlite3_syscall_ptr apndGetSystemCall( + sqlite3_vfs *pVfs, + const char *zName +){ + return ORIGVFS(pVfs)->xGetSystemCall(ORIGVFS(pVfs),zName); +} +static const char *apndNextSystemCall(sqlite3_vfs *pVfs, const char *zName){ + return ORIGVFS(pVfs)->xNextSystemCall(ORIGVFS(pVfs), zName); +} + + +#ifdef _WIN32 + +#endif +/* +** This routine is called when the extension is loaded. +** Register the new VFS. +*/ +int sqlite3_appendvfs_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi +){ + int rc = SQLITE_OK; + sqlite3_vfs *pOrig; + SQLITE_EXTENSION_INIT2(pApi); + (void)pzErrMsg; + (void)db; + pOrig = sqlite3_vfs_find(0); + apnd_vfs.iVersion = pOrig->iVersion; + apnd_vfs.pAppData = pOrig; + apnd_vfs.szOsFile = pOrig->szOsFile + sizeof(ApndFile); + rc = sqlite3_vfs_register(&apnd_vfs, 0); +#ifdef APPENDVFS_TEST + if( rc==SQLITE_OK ){ + rc = sqlite3_auto_extension((void(*)(void))apndvfsRegister); + } +#endif + if( rc==SQLITE_OK ) rc = SQLITE_OK_LOAD_PERMANENTLY; + return rc; +} + +/************************* End ../ext/misc/appendvfs.c ********************/ +/************************* Begin ../ext/misc/memtrace.c ******************/ +/* +** 2019-01-21 +** +** 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 an extension that uses the SQLITE_CONFIG_MALLOC +** mechanism to add a tracing layer on top of SQLite. If this extension +** is registered prior to sqlite3_initialize(), it will cause all memory +** allocation activities to be logged on standard output, or to some other +** FILE specified by the initializer. +** +** This file needs to be compiled into the application that uses it. +** +** This extension is used to implement the --memtrace option of the +** command-line shell. +*/ +#include +#include +#include + +/* The original memory allocation routines */ +static sqlite3_mem_methods memtraceBase; +static FILE *memtraceOut; + +/* Methods that trace memory allocations */ +static void *memtraceMalloc(int n){ + if( memtraceOut ){ + fprintf(memtraceOut, "MEMTRACE: allocate %d bytes\n", + memtraceBase.xRoundup(n)); + } + return memtraceBase.xMalloc(n); +} +static void memtraceFree(void *p){ + if( p==0 ) return; + if( memtraceOut ){ + fprintf(memtraceOut, "MEMTRACE: free %d bytes\n", memtraceBase.xSize(p)); + } + memtraceBase.xFree(p); +} +static void *memtraceRealloc(void *p, int n){ + if( p==0 ) return memtraceMalloc(n); + if( n==0 ){ + memtraceFree(p); + return 0; + } + if( memtraceOut ){ + fprintf(memtraceOut, "MEMTRACE: resize %d -> %d bytes\n", + memtraceBase.xSize(p), memtraceBase.xRoundup(n)); + } + return memtraceBase.xRealloc(p, n); +} +static int memtraceSize(void *p){ + return memtraceBase.xSize(p); +} +static int memtraceRoundup(int n){ + return memtraceBase.xRoundup(n); +} +static int memtraceInit(void *p){ + return memtraceBase.xInit(p); +} +static void memtraceShutdown(void *p){ + memtraceBase.xShutdown(p); +} + +/* The substitute memory allocator */ +static sqlite3_mem_methods ersaztMethods = { + memtraceMalloc, + memtraceFree, + memtraceRealloc, + memtraceSize, + memtraceRoundup, + memtraceInit, + memtraceShutdown, + 0 +}; + +/* Begin tracing memory allocations to out. */ +int sqlite3MemTraceActivate(FILE *out){ + int rc = SQLITE_OK; + if( memtraceBase.xMalloc==0 ){ + rc = sqlite3_config(SQLITE_CONFIG_GETMALLOC, &memtraceBase); + if( rc==SQLITE_OK ){ + rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &ersaztMethods); + } + } + memtraceOut = out; + return rc; +} + +/* Deactivate memory tracing */ +int sqlite3MemTraceDeactivate(void){ + int rc = SQLITE_OK; + if( memtraceBase.xMalloc!=0 ){ + rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &memtraceBase); + if( rc==SQLITE_OK ){ + memset(&memtraceBase, 0, sizeof(memtraceBase)); + } + } + memtraceOut = 0; + return rc; +} + +/************************* End ../ext/misc/memtrace.c ********************/ +/************************* Begin ../ext/misc/uint.c ******************/ +/* +** 2020-04-14 +** +** 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 SQLite extension implements the UINT collating sequence. +** +** UINT works like BINARY for text, except that embedded strings +** of digits compare in numeric order. +** +** * Leading zeros are handled properly, in the sense that +** they do not mess of the maginitude comparison of embedded +** strings of digits. "x00123y" is equal to "x123y". +** +** * Only unsigned integers are recognized. Plus and minus +** signs are ignored. Decimal points and exponential notation +** are ignored. +** +** * Embedded integers can be of arbitrary length. Comparison +** is *not* limited integers that can be expressed as a +** 64-bit machine integer. +*/ +/* #include "sqlite3ext.h" */ +SQLITE_EXTENSION_INIT1 +#include +#include +#include + +/* +** Compare text in lexicographic order, except strings of digits +** compare in numeric order. +*/ +static int uintCollFunc( + void *notUsed, + int nKey1, const void *pKey1, + int nKey2, const void *pKey2 +){ + const unsigned char *zA = (const unsigned char*)pKey1; + const unsigned char *zB = (const unsigned char*)pKey2; + int i=0, j=0, x; + (void)notUsed; + while( i +#include +#include +#include + +/* Mark a function parameter as unused, to suppress nuisance compiler +** warnings. */ +#ifndef UNUSED_PARAMETER +# define UNUSED_PARAMETER(X) (void)(X) +#endif + + +/* A decimal object */ +typedef struct Decimal Decimal; +struct Decimal { + char sign; /* 0 for positive, 1 for negative */ + char oom; /* True if an OOM is encountered */ + char isNull; /* True if holds a NULL rather than a number */ + char isInit; /* True upon initialization */ + int nDigit; /* Total number of digits */ + int nFrac; /* Number of digits to the right of the decimal point */ + signed char *a; /* Array of digits. Most significant first. */ +}; + +/* +** Release memory held by a Decimal, but do not free the object itself. +*/ +static void decimal_clear(Decimal *p){ + sqlite3_free(p->a); +} + +/* +** Destroy a Decimal object +*/ +static void decimal_free(Decimal *p){ + if( p ){ + decimal_clear(p); + sqlite3_free(p); + } +} + +/* +** Allocate a new Decimal object. Initialize it to the number given +** by the input string. +*/ +static Decimal *decimal_new( + sqlite3_context *pCtx, + sqlite3_value *pIn, + int nAlt, + const unsigned char *zAlt +){ + Decimal *p; + int n, i; + const unsigned char *zIn; + int iExp = 0; + p = sqlite3_malloc( sizeof(*p) ); + if( p==0 ) goto new_no_mem; + p->sign = 0; + p->oom = 0; + p->isInit = 1; + p->isNull = 0; + p->nDigit = 0; + p->nFrac = 0; + if( zAlt ){ + n = nAlt, + zIn = zAlt; + }else{ + if( sqlite3_value_type(pIn)==SQLITE_NULL ){ + p->a = 0; + p->isNull = 1; + return p; + } + n = sqlite3_value_bytes(pIn); + zIn = sqlite3_value_text(pIn); + } + p->a = sqlite3_malloc64( n+1 ); + if( p->a==0 ) goto new_no_mem; + for(i=0; isspace(zIn[i]); i++){} + if( zIn[i]=='-' ){ + p->sign = 1; + i++; + }else if( zIn[i]=='+' ){ + i++; + } + while( i='0' && c<='9' ){ + p->a[p->nDigit++] = c - '0'; + }else if( c=='.' ){ + p->nFrac = p->nDigit + 1; + }else if( c=='e' || c=='E' ){ + int j = i+1; + int neg = 0; + if( j>=n ) break; + if( zIn[j]=='-' ){ + neg = 1; + j++; + }else if( zIn[j]=='+' ){ + j++; + } + while( j='0' && zIn[j]<='9' ){ + iExp = iExp*10 + zIn[j] - '0'; + } + j++; + } + if( neg ) iExp = -iExp; + break; + } + i++; + } + if( p->nFrac ){ + p->nFrac = p->nDigit - (p->nFrac - 1); + } + if( iExp>0 ){ + if( p->nFrac>0 ){ + if( iExp<=p->nFrac ){ + p->nFrac -= iExp; + iExp = 0; + }else{ + iExp -= p->nFrac; + p->nFrac = 0; + } + } + if( iExp>0 ){ + p->a = sqlite3_realloc64(p->a, p->nDigit + iExp + 1 ); + if( p->a==0 ) goto new_no_mem; + memset(p->a+p->nDigit, 0, iExp); + p->nDigit += iExp; + } + }else if( iExp<0 ){ + int nExtra; + iExp = -iExp; + nExtra = p->nDigit - p->nFrac - 1; + if( nExtra ){ + if( nExtra>=iExp ){ + p->nFrac += iExp; + iExp = 0; + }else{ + iExp -= nExtra; + p->nFrac = p->nDigit - 1; + } + } + if( iExp>0 ){ + p->a = sqlite3_realloc64(p->a, p->nDigit + iExp + 1 ); + if( p->a==0 ) goto new_no_mem; + memmove(p->a+iExp, p->a, p->nDigit); + memset(p->a, 0, iExp); + p->nDigit += iExp; + p->nFrac += iExp; + } + } + return p; + +new_no_mem: + if( pCtx ) sqlite3_result_error_nomem(pCtx); + sqlite3_free(p); + return 0; +} + +/* +** Make the given Decimal the result. +*/ +static void decimal_result(sqlite3_context *pCtx, Decimal *p){ + char *z; + int i, j; + int n; + if( p==0 || p->oom ){ + sqlite3_result_error_nomem(pCtx); + return; + } + if( p->isNull ){ + sqlite3_result_null(pCtx); + return; + } + z = sqlite3_malloc( p->nDigit+4 ); + if( z==0 ){ + sqlite3_result_error_nomem(pCtx); + return; + } + i = 0; + if( p->nDigit==0 || (p->nDigit==1 && p->a[0]==0) ){ + p->sign = 0; + } + if( p->sign ){ + z[0] = '-'; + i = 1; + } + n = p->nDigit - p->nFrac; + if( n<=0 ){ + z[i++] = '0'; + } + j = 0; + while( n>1 && p->a[j]==0 ){ + j++; + n--; + } + while( n>0 ){ + z[i++] = p->a[j] + '0'; + j++; + n--; + } + if( p->nFrac ){ + z[i++] = '.'; + do{ + z[i++] = p->a[j] + '0'; + j++; + }while( jnDigit ); + } + z[i] = 0; + sqlite3_result_text(pCtx, z, i, sqlite3_free); +} + +/* +** SQL Function: decimal(X) +** +** Convert input X into decimal and then back into text +*/ +static void decimalFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + Decimal *p = decimal_new(context, argv[0], 0, 0); + UNUSED_PARAMETER(argc); + decimal_result(context, p); + decimal_free(p); +} + +/* +** Compare to Decimal objects. Return negative, 0, or positive if the +** first object is less than, equal to, or greater than the second. +** +** Preconditions for this routine: +** +** pA!=0 +** pA->isNull==0 +** pB!=0 +** pB->isNull==0 +*/ +static int decimal_cmp(const Decimal *pA, const Decimal *pB){ + int nASig, nBSig, rc, n; + if( pA->sign!=pB->sign ){ + return pA->sign ? -1 : +1; + } + if( pA->sign ){ + const Decimal *pTemp = pA; + pA = pB; + pB = pTemp; + } + nASig = pA->nDigit - pA->nFrac; + nBSig = pB->nDigit - pB->nFrac; + if( nASig!=nBSig ){ + return nASig - nBSig; + } + n = pA->nDigit; + if( n>pB->nDigit ) n = pB->nDigit; + rc = memcmp(pA->a, pB->a, n); + if( rc==0 ){ + rc = pA->nDigit - pB->nDigit; + } + return rc; +} + +/* +** SQL Function: decimal_cmp(X, Y) +** +** Return negative, zero, or positive if X is less then, equal to, or +** greater than Y. +*/ +static void decimalCmpFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + Decimal *pA = 0, *pB = 0; + int rc; + + UNUSED_PARAMETER(argc); + pA = decimal_new(context, argv[0], 0, 0); + if( pA==0 || pA->isNull ) goto cmp_done; + pB = decimal_new(context, argv[1], 0, 0); + if( pB==0 || pB->isNull ) goto cmp_done; + rc = decimal_cmp(pA, pB); + if( rc<0 ) rc = -1; + else if( rc>0 ) rc = +1; + sqlite3_result_int(context, rc); +cmp_done: + decimal_free(pA); + decimal_free(pB); +} + +/* +** Expand the Decimal so that it has a least nDigit digits and nFrac +** digits to the right of the decimal point. +*/ +static void decimal_expand(Decimal *p, int nDigit, int nFrac){ + int nAddSig; + int nAddFrac; + if( p==0 ) return; + nAddFrac = nFrac - p->nFrac; + nAddSig = (nDigit - p->nDigit) - nAddFrac; + if( nAddFrac==0 && nAddSig==0 ) return; + p->a = sqlite3_realloc64(p->a, nDigit+1); + if( p->a==0 ){ + p->oom = 1; + return; + } + if( nAddSig ){ + memmove(p->a+nAddSig, p->a, p->nDigit); + memset(p->a, 0, nAddSig); + p->nDigit += nAddSig; + } + if( nAddFrac ){ + memset(p->a+p->nDigit, 0, nAddFrac); + p->nDigit += nAddFrac; + p->nFrac += nAddFrac; + } +} + +/* +** Add the value pB into pA. +** +** Both pA and pB might become denormalized by this routine. +*/ +static void decimal_add(Decimal *pA, Decimal *pB){ + int nSig, nFrac, nDigit; + int i, rc; + if( pA==0 ){ + return; + } + if( pA->oom || pB==0 || pB->oom ){ + pA->oom = 1; + return; + } + if( pA->isNull || pB->isNull ){ + pA->isNull = 1; + return; + } + nSig = pA->nDigit - pA->nFrac; + if( nSig && pA->a[0]==0 ) nSig--; + if( nSignDigit-pB->nFrac ){ + nSig = pB->nDigit - pB->nFrac; + } + nFrac = pA->nFrac; + if( nFracnFrac ) nFrac = pB->nFrac; + nDigit = nSig + nFrac + 1; + decimal_expand(pA, nDigit, nFrac); + decimal_expand(pB, nDigit, nFrac); + if( pA->oom || pB->oom ){ + pA->oom = 1; + }else{ + if( pA->sign==pB->sign ){ + int carry = 0; + for(i=nDigit-1; i>=0; i--){ + int x = pA->a[i] + pB->a[i] + carry; + if( x>=10 ){ + carry = 1; + pA->a[i] = x - 10; + }else{ + carry = 0; + pA->a[i] = x; + } + } + }else{ + signed char *aA, *aB; + int borrow = 0; + rc = memcmp(pA->a, pB->a, nDigit); + if( rc<0 ){ + aA = pB->a; + aB = pA->a; + pA->sign = !pA->sign; + }else{ + aA = pA->a; + aB = pB->a; + } + for(i=nDigit-1; i>=0; i--){ + int x = aA[i] - aB[i] - borrow; + if( x<0 ){ + pA->a[i] = x+10; + borrow = 1; + }else{ + pA->a[i] = x; + borrow = 0; + } + } + } + } +} + +/* +** Compare text in decimal order. +*/ +static int decimalCollFunc( + void *notUsed, + int nKey1, const void *pKey1, + int nKey2, const void *pKey2 +){ + const unsigned char *zA = (const unsigned char*)pKey1; + const unsigned char *zB = (const unsigned char*)pKey2; + Decimal *pA = decimal_new(0, 0, nKey1, zA); + Decimal *pB = decimal_new(0, 0, nKey2, zB); + int rc; + UNUSED_PARAMETER(notUsed); + if( pA==0 || pB==0 ){ + rc = 0; + }else{ + rc = decimal_cmp(pA, pB); + } + decimal_free(pA); + decimal_free(pB); + return rc; +} + + +/* +** SQL Function: decimal_add(X, Y) +** decimal_sub(X, Y) +** +** Return the sum or difference of X and Y. +*/ +static void decimalAddFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + Decimal *pA = decimal_new(context, argv[0], 0, 0); + Decimal *pB = decimal_new(context, argv[1], 0, 0); + UNUSED_PARAMETER(argc); + decimal_add(pA, pB); + decimal_result(context, pA); + decimal_free(pA); + decimal_free(pB); +} +static void decimalSubFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + Decimal *pA = decimal_new(context, argv[0], 0, 0); + Decimal *pB = decimal_new(context, argv[1], 0, 0); + UNUSED_PARAMETER(argc); + if( pB==0 ) return; + pB->sign = !pB->sign; + decimal_add(pA, pB); + decimal_result(context, pA); + decimal_free(pA); + decimal_free(pB); +} + +/* Aggregate funcion: decimal_sum(X) +** +** Works like sum() except that it uses decimal arithmetic for unlimited +** precision. +*/ +static void decimalSumStep( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + Decimal *p; + Decimal *pArg; + UNUSED_PARAMETER(argc); + p = sqlite3_aggregate_context(context, sizeof(*p)); + if( p==0 ) return; + if( !p->isInit ){ + p->isInit = 1; + p->a = sqlite3_malloc(2); + if( p->a==0 ){ + p->oom = 1; + }else{ + p->a[0] = 0; + } + p->nDigit = 1; + p->nFrac = 0; + } + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + pArg = decimal_new(context, argv[0], 0, 0); + decimal_add(p, pArg); + decimal_free(pArg); +} +static void decimalSumInverse( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + Decimal *p; + Decimal *pArg; + UNUSED_PARAMETER(argc); + p = sqlite3_aggregate_context(context, sizeof(*p)); + if( p==0 ) return; + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + pArg = decimal_new(context, argv[0], 0, 0); + if( pArg ) pArg->sign = !pArg->sign; + decimal_add(p, pArg); + decimal_free(pArg); +} +static void decimalSumValue(sqlite3_context *context){ + Decimal *p = sqlite3_aggregate_context(context, 0); + if( p==0 ) return; + decimal_result(context, p); +} +static void decimalSumFinalize(sqlite3_context *context){ + Decimal *p = sqlite3_aggregate_context(context, 0); + if( p==0 ) return; + decimal_result(context, p); + decimal_clear(p); +} + +/* +** SQL Function: decimal_mul(X, Y) +** +** Return the product of X and Y. +** +** All significant digits after the decimal point are retained. +** Trailing zeros after the decimal point are omitted as long as +** the number of digits after the decimal point is no less than +** either the number of digits in either input. +*/ +static void decimalMulFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + Decimal *pA = decimal_new(context, argv[0], 0, 0); + Decimal *pB = decimal_new(context, argv[1], 0, 0); + signed char *acc = 0; + int i, j, k; + int minFrac; + UNUSED_PARAMETER(argc); + if( pA==0 || pA->oom || pA->isNull + || pB==0 || pB->oom || pB->isNull + ){ + goto mul_end; + } + acc = sqlite3_malloc64( pA->nDigit + pB->nDigit + 2 ); + if( acc==0 ){ + sqlite3_result_error_nomem(context); + goto mul_end; + } + memset(acc, 0, pA->nDigit + pB->nDigit + 2); + minFrac = pA->nFrac; + if( pB->nFracnFrac; + for(i=pA->nDigit-1; i>=0; i--){ + signed char f = pA->a[i]; + int carry = 0, x; + for(j=pB->nDigit-1, k=i+j+3; j>=0; j--, k--){ + x = acc[k] + f*pB->a[j] + carry; + acc[k] = x%10; + carry = x/10; + } + x = acc[k] + carry; + acc[k] = x%10; + acc[k-1] += x/10; + } + sqlite3_free(pA->a); + pA->a = acc; + acc = 0; + pA->nDigit += pB->nDigit + 2; + pA->nFrac += pB->nFrac; + pA->sign ^= pB->sign; + while( pA->nFrac>minFrac && pA->a[pA->nDigit-1]==0 ){ + pA->nFrac--; + pA->nDigit--; + } + decimal_result(context, pA); + +mul_end: + sqlite3_free(acc); + decimal_free(pA); + decimal_free(pB); +} + +#ifdef _WIN32 + +#endif +int sqlite3_decimal_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi +){ + int rc = SQLITE_OK; + static const struct { + const char *zFuncName; + int nArg; + void (*xFunc)(sqlite3_context*,int,sqlite3_value**); + } aFunc[] = { + { "decimal", 1, decimalFunc }, + { "decimal_cmp", 2, decimalCmpFunc }, + { "decimal_add", 2, decimalAddFunc }, + { "decimal_sub", 2, decimalSubFunc }, + { "decimal_mul", 2, decimalMulFunc }, + }; + unsigned int i; + (void)pzErrMsg; /* Unused parameter */ + + SQLITE_EXTENSION_INIT2(pApi); + + for(i=0; i 'ieee754(2,0)' +** ieee754(45.25) -> 'ieee754(181,-2)' +** ieee754(2, 0) -> 2.0 +** ieee754(181, -2) -> 45.25 +** +** Two additional functions break apart the one-argument ieee754() +** result into separate integer values: +** +** ieee754_mantissa(45.25) -> 181 +** ieee754_exponent(45.25) -> -2 +** +** These functions convert binary64 numbers into blobs and back again. +** +** ieee754_from_blob(x'3ff0000000000000') -> 1.0 +** ieee754_to_blob(1.0) -> x'3ff0000000000000' +** +** In all single-argument functions, if the argument is an 8-byte blob +** then that blob is interpreted as a big-endian binary64 value. +** +** +** EXACT DECIMAL REPRESENTATION OF BINARY64 VALUES +** ----------------------------------------------- +** +** This extension in combination with the separate 'decimal' extension +** can be used to compute the exact decimal representation of binary64 +** values. To begin, first compute a table of exponent values: +** +** CREATE TABLE pow2(x INTEGER PRIMARY KEY, v TEXT); +** WITH RECURSIVE c(x,v) AS ( +** VALUES(0,'1') +** UNION ALL +** SELECT x+1, decimal_mul(v,'2') FROM c WHERE x+1<=971 +** ) INSERT INTO pow2(x,v) SELECT x, v FROM c; +** WITH RECURSIVE c(x,v) AS ( +** VALUES(-1,'0.5') +** UNION ALL +** SELECT x-1, decimal_mul(v,'0.5') FROM c WHERE x-1>=-1075 +** ) INSERT INTO pow2(x,v) SELECT x, v FROM c; +** +** Then, to compute the exact decimal representation of a floating +** point value (the value 47.49 is used in the example) do: +** +** WITH c(n) AS (VALUES(47.49)) +** ---------------^^^^^---- Replace with whatever you want +** SELECT decimal_mul(ieee754_mantissa(c.n),pow2.v) +** FROM pow2, c WHERE pow2.x=ieee754_exponent(c.n); +** +** Here is a query to show various boundry values for the binary64 +** number format: +** +** WITH c(name,bin) AS (VALUES +** ('minimum positive value', x'0000000000000001'), +** ('maximum subnormal value', x'000fffffffffffff'), +** ('mininum positive nornal value', x'0010000000000000'), +** ('maximum value', x'7fefffffffffffff')) +** SELECT c.name, decimal_mul(ieee754_mantissa(c.bin),pow2.v) +** FROM pow2, c WHERE pow2.x=ieee754_exponent(c.bin); +** +*/ +/* #include "sqlite3ext.h" */ +SQLITE_EXTENSION_INIT1 +#include +#include + +/* Mark a function parameter as unused, to suppress nuisance compiler +** warnings. */ +#ifndef UNUSED_PARAMETER +# define UNUSED_PARAMETER(X) (void)(X) +#endif + +/* +** Implementation of the ieee754() function +*/ +static void ieee754func( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + if( argc==1 ){ + sqlite3_int64 m, a; + double r; + int e; + int isNeg; + char zResult[100]; + assert( sizeof(m)==sizeof(r) ); + if( sqlite3_value_type(argv[0])==SQLITE_BLOB + && sqlite3_value_bytes(argv[0])==sizeof(r) + ){ + const unsigned char *x = sqlite3_value_blob(argv[0]); + unsigned int i; + sqlite3_uint64 v = 0; + for(i=0; i>52; + m = a & ((((sqlite3_int64)1)<<52)-1); + if( e==0 ){ + m <<= 1; + }else{ + m |= ((sqlite3_int64)1)<<52; + } + while( e<1075 && m>0 && (m&1)==0 ){ + m >>= 1; + e++; + } + if( isNeg ) m = -m; + } + switch( *(int*)sqlite3_user_data(context) ){ + case 0: + sqlite3_snprintf(sizeof(zResult), zResult, "ieee754(%lld,%d)", + m, e-1075); + sqlite3_result_text(context, zResult, -1, SQLITE_TRANSIENT); + break; + case 1: + sqlite3_result_int64(context, m); + break; + case 2: + sqlite3_result_int(context, e-1075); + break; + } + }else{ + sqlite3_int64 m, e, a; + double r; + int isNeg = 0; + m = sqlite3_value_int64(argv[0]); + e = sqlite3_value_int64(argv[1]); + if( m<0 ){ + isNeg = 1; + m = -m; + if( m<0 ) return; + }else if( m==0 && e>-1000 && e<1000 ){ + sqlite3_result_double(context, 0.0); + return; + } + while( (m>>32)&0xffe00000 ){ + m >>= 1; + e++; + } + while( m!=0 && ((m>>32)&0xfff00000)==0 ){ + m <<= 1; + e--; + } + e += 1075; + if( e<=0 ){ + /* Subnormal */ + m >>= 1-e; + e = 0; + }else if( e>0x7ff ){ + e = 0x7ff; + } + a = m & ((((sqlite3_int64)1)<<52)-1); + a |= e<<52; + if( isNeg ) a |= ((sqlite3_uint64)1)<<63; + memcpy(&r, &a, sizeof(r)); + sqlite3_result_double(context, r); + } +} + +/* +** Functions to convert between blobs and floats. +*/ +static void ieee754func_from_blob( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + UNUSED_PARAMETER(argc); + if( sqlite3_value_type(argv[0])==SQLITE_BLOB + && sqlite3_value_bytes(argv[0])==sizeof(double) + ){ + double r; + const unsigned char *x = sqlite3_value_blob(argv[0]); + unsigned int i; + sqlite3_uint64 v = 0; + for(i=0; i>= 8; + } + sqlite3_result_blob(context, a, sizeof(r), SQLITE_TRANSIENT); + } +} + + +#ifdef _WIN32 + +#endif +int sqlite3_ieee_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi +){ + static const struct { + char *zFName; + int nArg; + int iAux; + void (*xFunc)(sqlite3_context*,int,sqlite3_value**); + } aFunc[] = { + { "ieee754", 1, 0, ieee754func }, + { "ieee754", 2, 0, ieee754func }, + { "ieee754_mantissa", 1, 1, ieee754func }, + { "ieee754_exponent", 1, 2, ieee754func }, + { "ieee754_to_blob", 1, 0, ieee754func_to_blob }, + { "ieee754_from_blob", 1, 0, ieee754func_from_blob }, + + }; + unsigned int i; + int rc = SQLITE_OK; + SQLITE_EXTENSION_INIT2(pApi); + (void)pzErrMsg; /* Unused parameter */ + for(i=0; i

      +**
    • A database filename pointer created by the SQLite core and +** passed into the xOpen() method of a VFS implemention, or +**
    • A filename obtained from [sqlite3_db_filename()], or +**
    • A new filename constructed using [sqlite3_create_filename()]. +**
    +** If the F parameter is not one of the above, then the behavior is +** undefined and probably undesirable. Older versions of SQLite were +** more tolerant of invalid F parameters than newer versions. +** +** If F is a suitable filename (as described in the previous paragraph) +** and if P is the name of the query parameter, then +** sqlite3_uri_parameter(F,P) returns the value of the P +** parameter if it exists or a NULL pointer if P does not appear as a +** query parameter on F. If P is a query parameter of F and it +** has no explicit value, then sqlite3_uri_parameter(F,P) returns +** a pointer to an empty string. +** +** The sqlite3_uri_boolean(F,P,B) routine assumes that P is a boolean +** parameter and returns true (1) or false (0) according to the value +** of P. The sqlite3_uri_boolean(F,P,B) routine returns true (1) if the +** value of query parameter P is one of "yes", "true", or "on" in any +** case or if the value begins with a non-zero number. The +** sqlite3_uri_boolean(F,P,B) routines returns false (0) if the value of +** query parameter P is one of "no", "false", or "off" in any case or +** if the value begins with a numeric zero. If P is not a query +** parameter on F or if the value of P does not match any of the +** above, then sqlite3_uri_boolean(F,P,B) returns (B!=0). +** +** The sqlite3_uri_int64(F,P,D) routine converts the value of P into a +** 64-bit signed integer and returns that integer, or D if P does not +** exist. If the value of P is something other than an integer, then +** zero is returned. +** +** The sqlite3_uri_key(F,N) returns a pointer to the name (not +** the value) of the N-th query parameter for filename F, or a NULL +** pointer if N is less than zero or greater than the number of query +** parameters minus 1. The N value is zero-based so N should be 0 to obtain +** the name of the first query parameter, 1 for the second parameter, and +** so forth. +** +** If F is a NULL pointer, then sqlite3_uri_parameter(F,P) returns NULL and +** sqlite3_uri_boolean(F,P,B) returns B. If F is not a NULL pointer and +** is not a database file pathname pointer that the SQLite core passed +** into the xOpen VFS method, then the behavior of this routine is undefined +** and probably undesirable. +** +** Beginning with SQLite [version 3.31.0] ([dateof:3.31.0]) the input F +** parameter can also be the name of a rollback journal file or WAL file +** in addition to the main database file. Prior to version 3.31.0, these +** routines would only work if F was the name of the main database file. +** When the F parameter is the name of the rollback journal or WAL file, +** it has access to all the same query parameters as were found on the +** main database file. +** +** See the [URI filename] documentation for additional information. +*/ +SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam); +SQLITE_API int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault); +SQLITE_API sqlite3_int64 sqlite3_uri_int64(const char*, const char*, sqlite3_int64); +SQLITE_API const char *sqlite3_uri_key(const char *zFilename, int N); + +/* +** CAPI3REF: Translate filenames +** +** These routines are available to [VFS|custom VFS implementations] for +** translating filenames between the main database file, the journal file, +** and the WAL file. +** +** If F is the name of an sqlite database file, journal file, or WAL file +** passed by the SQLite core into the VFS, then sqlite3_filename_database(F) +** returns the name of the corresponding database file. +** +** If F is the name of an sqlite database file, journal file, or WAL file +** passed by the SQLite core into the VFS, or if F is a database filename +** obtained from [sqlite3_db_filename()], then sqlite3_filename_journal(F) +** returns the name of the corresponding rollback journal file. +** +** If F is the name of an sqlite database file, journal file, or WAL file +** that was passed by the SQLite core into the VFS, or if F is a database +** filename obtained from [sqlite3_db_filename()], then +** sqlite3_filename_wal(F) returns the name of the corresponding +** WAL file. +** +** In all of the above, if F is not the name of a database, journal or WAL +** filename passed into the VFS from the SQLite core and F is not the +** return value from [sqlite3_db_filename()], then the result is +** undefined and is likely a memory access violation. +*/ +SQLITE_API const char *sqlite3_filename_database(const char*); +SQLITE_API const char *sqlite3_filename_journal(const char*); +SQLITE_API const char *sqlite3_filename_wal(const char*); + +/* +** CAPI3REF: Database File Corresponding To A Journal +** +** ^If X is the name of a rollback or WAL-mode journal file that is +** passed into the xOpen method of [sqlite3_vfs], then +** sqlite3_database_file_object(X) returns a pointer to the [sqlite3_file] +** object that represents the main database file. +** +** This routine is intended for use in custom [VFS] implementations +** only. It is not a general-purpose interface. +** The argument sqlite3_file_object(X) must be a filename pointer that +** has been passed into [sqlite3_vfs].xOpen method where the +** flags parameter to xOpen contains one of the bits +** [SQLITE_OPEN_MAIN_JOURNAL] or [SQLITE_OPEN_WAL]. Any other use +** of this routine results in undefined and probably undesirable +** behavior. +*/ +SQLITE_API sqlite3_file *sqlite3_database_file_object(const char*); + +/* +** CAPI3REF: Create and Destroy VFS Filenames +** +** These interfces are provided for use by [VFS shim] implementations and +** are not useful outside of that context. +** +** The sqlite3_create_filename(D,J,W,N,P) allocates memory to hold a version of +** database filename D with corresponding journal file J and WAL file W and +** with N URI parameters key/values pairs in the array P. The result from +** sqlite3_create_filename(D,J,W,N,P) is a pointer to a database filename that +** is safe to pass to routines like: +**
      +**
    • [sqlite3_uri_parameter()], +**
    • [sqlite3_uri_boolean()], +**
    • [sqlite3_uri_int64()], +**
    • [sqlite3_uri_key()], +**
    • [sqlite3_filename_database()], +**
    • [sqlite3_filename_journal()], or +**
    • [sqlite3_filename_wal()]. +**
    +** If a memory allocation error occurs, sqlite3_create_filename() might +** return a NULL pointer. The memory obtained from sqlite3_create_filename(X) +** must be released by a corresponding call to sqlite3_free_filename(Y). +** +** The P parameter in sqlite3_create_filename(D,J,W,N,P) should be an array +** of 2*N pointers to strings. Each pair of pointers in this array corresponds +** to a key and value for a query parameter. The P parameter may be a NULL +** pointer if N is zero. None of the 2*N pointers in the P array may be +** NULL pointers and key pointers should not be empty strings. +** None of the D, J, or W parameters to sqlite3_create_filename(D,J,W,N,P) may +** be NULL pointers, though they can be empty strings. +** +** The sqlite3_free_filename(Y) routine releases a memory allocation +** previously obtained from sqlite3_create_filename(). Invoking +** sqlite3_free_filename(Y) where Y is a NULL pointer is a harmless no-op. +** +** If the Y parameter to sqlite3_free_filename(Y) is anything other +** than a NULL pointer or a pointer previously acquired from +** sqlite3_create_filename(), then bad things such as heap +** corruption or segfaults may occur. The value Y should not be +** used again after sqlite3_free_filename(Y) has been called. This means +** that if the [sqlite3_vfs.xOpen()] method of a VFS has been called using Y, +** then the corresponding [sqlite3_module.xClose() method should also be +** invoked prior to calling sqlite3_free_filename(Y). +*/ +SQLITE_API char *sqlite3_create_filename( + const char *zDatabase, + const char *zJournal, + const char *zWal, + int nParam, + const char **azParam +); +SQLITE_API void sqlite3_free_filename(char*); + +/* +** CAPI3REF: Error Codes And Messages +** METHOD: sqlite3 +** +** ^If the most recent sqlite3_* API call associated with +** [database connection] D failed, then the sqlite3_errcode(D) interface +** returns the numeric [result code] or [extended result code] for that +** API call. +** ^The sqlite3_extended_errcode() +** interface is the same except that it always returns the +** [extended result code] even when extended result codes are +** disabled. +** +** The values returned by sqlite3_errcode() and/or +** sqlite3_extended_errcode() might change with each API call. +** Except, there are some interfaces that are guaranteed to never +** change the value of the error code. The error-code preserving +** interfaces are: +** +**
      +**
    • sqlite3_errcode() +**
    • sqlite3_extended_errcode() +**
    • sqlite3_errmsg() +**
    • sqlite3_errmsg16() +**
    +** +** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language +** text that describes the error, as either UTF-8 or UTF-16 respectively. +** ^(Memory to hold the error message string is managed internally. +** The application does not need to worry about freeing the result. +** However, the error string might be overwritten or deallocated by +** subsequent calls to other SQLite interface functions.)^ +** +** ^The sqlite3_errstr() interface returns the English-language text +** that describes the [result code], as UTF-8. +** ^(Memory to hold the error message string is managed internally +** and must not be freed by the application)^. +** +** When the serialized [threading mode] is in use, it might be the +** case that a second error occurs on a separate thread in between +** the time of the first error and the call to these interfaces. +** When that happens, the second error will be reported since these +** interfaces always report the most recent result. To avoid +** this, each thread can obtain exclusive use of the [database connection] D +** by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning +** to use D and invoking [sqlite3_mutex_leave]([sqlite3_db_mutex](D)) after +** all calls to the interfaces listed here are completed. +** +** If an interface fails with SQLITE_MISUSE, that means the interface +** was invoked incorrectly by the application. In that case, the +** error code and message may or may not be set. +*/ +SQLITE_API int sqlite3_errcode(sqlite3 *db); +SQLITE_API int sqlite3_extended_errcode(sqlite3 *db); +SQLITE_API const char *sqlite3_errmsg(sqlite3*); +SQLITE_API const void *sqlite3_errmsg16(sqlite3*); +SQLITE_API const char *sqlite3_errstr(int); + +/* +** CAPI3REF: Prepared Statement Object +** KEYWORDS: {prepared statement} {prepared statements} +** +** An instance of this object represents a single SQL statement that +** has been compiled into binary form and is ready to be evaluated. +** +** Think of each SQL statement as a separate computer program. The +** original SQL text is source code. A prepared statement object +** is the compiled object code. All SQL must be converted into a +** prepared statement before it can be run. +** +** The life-cycle of a prepared statement object usually goes like this: +** +**
      +**
    1. Create the prepared statement object using [sqlite3_prepare_v2()]. +**
    2. Bind values to [parameters] using the sqlite3_bind_*() +** interfaces. +**
    3. Run the SQL by calling [sqlite3_step()] one or more times. +**
    4. Reset the prepared statement using [sqlite3_reset()] then go back +** to step 2. Do this zero or more times. +**
    5. Destroy the object using [sqlite3_finalize()]. +**
    +*/ +typedef struct sqlite3_stmt sqlite3_stmt; + +/* +** CAPI3REF: Run-time Limits +** METHOD: sqlite3 +** +** ^(This interface allows the size of various constructs to be limited +** on a connection by connection basis. The first parameter is the +** [database connection] whose limit is to be set or queried. The +** second parameter is one of the [limit categories] that define a +** class of constructs to be size limited. The third parameter is the +** new limit for that construct.)^ +** +** ^If the new limit is a negative number, the limit is unchanged. +** ^(For each limit category SQLITE_LIMIT_NAME there is a +** [limits | hard upper bound] +** set at compile-time by a C preprocessor macro called +** [limits | SQLITE_MAX_NAME]. +** (The "_LIMIT_" in the name is changed to "_MAX_".))^ +** ^Attempts to increase a limit above its hard upper bound are +** silently truncated to the hard upper bound. +** +** ^Regardless of whether or not the limit was changed, the +** [sqlite3_limit()] interface returns the prior value of the limit. +** ^Hence, to find the current value of a limit without changing it, +** simply invoke this interface with the third parameter set to -1. +** +** Run-time limits are intended for use in applications that manage +** both their own internal database and also databases that are controlled +** by untrusted external sources. An example application might be a +** web browser that has its own databases for storing history and +** separate databases controlled by JavaScript applications downloaded +** off the Internet. The internal databases can be given the +** large, default limits. Databases managed by external sources can +** be given much smaller limits designed to prevent a denial of service +** attack. Developers might also want to use the [sqlite3_set_authorizer()] +** interface to further control untrusted SQL. The size of the database +** created by an untrusted script can be contained using the +** [max_page_count] [PRAGMA]. +** +** New run-time limit categories may be added in future releases. +*/ +SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal); + +/* +** CAPI3REF: Run-Time Limit Categories +** KEYWORDS: {limit category} {*limit categories} +** +** These constants define various performance limits +** that can be lowered at run-time using [sqlite3_limit()]. +** The synopsis of the meanings of the various limits is shown below. +** Additional information is available at [limits | Limits in SQLite]. +** +**
    +** [[SQLITE_LIMIT_LENGTH]] ^(
    SQLITE_LIMIT_LENGTH
    +**
    The maximum size of any string or BLOB or table row, in bytes.
    )^ +** +** [[SQLITE_LIMIT_SQL_LENGTH]] ^(
    SQLITE_LIMIT_SQL_LENGTH
    +**
    The maximum length of an SQL statement, in bytes.
    )^ +** +** [[SQLITE_LIMIT_COLUMN]] ^(
    SQLITE_LIMIT_COLUMN
    +**
    The maximum number of columns in a table definition or in the +** result set of a [SELECT] or the maximum number of columns in an index +** or in an ORDER BY or GROUP BY clause.
    )^ +** +** [[SQLITE_LIMIT_EXPR_DEPTH]] ^(
    SQLITE_LIMIT_EXPR_DEPTH
    +**
    The maximum depth of the parse tree on any expression.
    )^ +** +** [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(
    SQLITE_LIMIT_COMPOUND_SELECT
    +**
    The maximum number of terms in a compound SELECT statement.
    )^ +** +** [[SQLITE_LIMIT_VDBE_OP]] ^(
    SQLITE_LIMIT_VDBE_OP
    +**
    The maximum number of instructions in a virtual machine program +** used to implement an SQL statement. If [sqlite3_prepare_v2()] or +** the equivalent tries to allocate space for more than this many opcodes +** in a single prepared statement, an SQLITE_NOMEM error is returned.
    )^ +** +** [[SQLITE_LIMIT_FUNCTION_ARG]] ^(
    SQLITE_LIMIT_FUNCTION_ARG
    +**
    The maximum number of arguments on a function.
    )^ +** +** [[SQLITE_LIMIT_ATTACHED]] ^(
    SQLITE_LIMIT_ATTACHED
    +**
    The maximum number of [ATTACH | attached databases].)^
    +** +** [[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]] +** ^(
    SQLITE_LIMIT_LIKE_PATTERN_LENGTH
    +**
    The maximum length of the pattern argument to the [LIKE] or +** [GLOB] operators.
    )^ +** +** [[SQLITE_LIMIT_VARIABLE_NUMBER]] +** ^(
    SQLITE_LIMIT_VARIABLE_NUMBER
    +**
    The maximum index number of any [parameter] in an SQL statement.)^ +** +** [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(
    SQLITE_LIMIT_TRIGGER_DEPTH
    +**
    The maximum depth of recursion for triggers.
    )^ +** +** [[SQLITE_LIMIT_WORKER_THREADS]] ^(
    SQLITE_LIMIT_WORKER_THREADS
    +**
    The maximum number of auxiliary worker threads that a single +** [prepared statement] may start.
    )^ +**
    +*/ +#define SQLITE_LIMIT_LENGTH 0 +#define SQLITE_LIMIT_SQL_LENGTH 1 +#define SQLITE_LIMIT_COLUMN 2 +#define SQLITE_LIMIT_EXPR_DEPTH 3 +#define SQLITE_LIMIT_COMPOUND_SELECT 4 +#define SQLITE_LIMIT_VDBE_OP 5 +#define SQLITE_LIMIT_FUNCTION_ARG 6 +#define SQLITE_LIMIT_ATTACHED 7 +#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8 +#define SQLITE_LIMIT_VARIABLE_NUMBER 9 +#define SQLITE_LIMIT_TRIGGER_DEPTH 10 +#define SQLITE_LIMIT_WORKER_THREADS 11 + +/* +** CAPI3REF: Prepare Flags +** +** These constants define various flags that can be passed into +** "prepFlags" parameter of the [sqlite3_prepare_v3()] and +** [sqlite3_prepare16_v3()] interfaces. +** +** New flags may be added in future releases of SQLite. +** +**
    +** [[SQLITE_PREPARE_PERSISTENT]] ^(
    SQLITE_PREPARE_PERSISTENT
    +**
    The SQLITE_PREPARE_PERSISTENT flag is a hint to the query planner +** that the prepared statement will be retained for a long time and +** probably reused many times.)^ ^Without this flag, [sqlite3_prepare_v3()] +** and [sqlite3_prepare16_v3()] assume that the prepared statement will +** be used just once or at most a few times and then destroyed using +** [sqlite3_finalize()] relatively soon. The current implementation acts +** on this hint by avoiding the use of [lookaside memory] so as not to +** deplete the limited store of lookaside memory. Future versions of +** SQLite may act on this hint differently. +** +** [[SQLITE_PREPARE_NORMALIZE]]
    SQLITE_PREPARE_NORMALIZE
    +**
    The SQLITE_PREPARE_NORMALIZE flag is a no-op. This flag used +** to be required for any prepared statement that wanted to use the +** [sqlite3_normalized_sql()] interface. However, the +** [sqlite3_normalized_sql()] interface is now available to all +** prepared statements, regardless of whether or not they use this +** flag. +** +** [[SQLITE_PREPARE_NO_VTAB]]
    SQLITE_PREPARE_NO_VTAB
    +**
    The SQLITE_PREPARE_NO_VTAB flag causes the SQL compiler +** to return an error (error code SQLITE_ERROR) if the statement uses +** any virtual tables. +**
    +*/ +#define SQLITE_PREPARE_PERSISTENT 0x01 +#define SQLITE_PREPARE_NORMALIZE 0x02 +#define SQLITE_PREPARE_NO_VTAB 0x04 + +/* +** CAPI3REF: Compiling An SQL Statement +** KEYWORDS: {SQL statement compiler} +** METHOD: sqlite3 +** CONSTRUCTOR: sqlite3_stmt +** +** To execute an SQL statement, it must first be compiled into a byte-code +** program using one of these routines. Or, in other words, these routines +** are constructors for the [prepared statement] object. +** +** The preferred routine to use is [sqlite3_prepare_v2()]. The +** [sqlite3_prepare()] interface is legacy and should be avoided. +** [sqlite3_prepare_v3()] has an extra "prepFlags" option that is used +** for special purposes. +** +** The use of the UTF-8 interfaces is preferred, as SQLite currently +** does all parsing using UTF-8. The UTF-16 interfaces are provided +** as a convenience. The UTF-16 interfaces work by converting the +** input text into UTF-8, then invoking the corresponding UTF-8 interface. +** +** The first argument, "db", is a [database connection] obtained from a +** prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or +** [sqlite3_open16()]. The database connection must not have been closed. +** +** The second argument, "zSql", is the statement to be compiled, encoded +** as either UTF-8 or UTF-16. The sqlite3_prepare(), sqlite3_prepare_v2(), +** and sqlite3_prepare_v3() +** interfaces use UTF-8, and sqlite3_prepare16(), sqlite3_prepare16_v2(), +** and sqlite3_prepare16_v3() use UTF-16. +** +** ^If the nByte argument is negative, then zSql is read up to the +** first zero terminator. ^If nByte is positive, then it is the +** number of bytes read from zSql. ^If nByte is zero, then no prepared +** statement is generated. +** If the caller knows that the supplied string is nul-terminated, then +** there is a small performance advantage to passing an nByte parameter that +** is the number of bytes in the input string including +** the nul-terminator. +** +** ^If pzTail is not NULL then *pzTail is made to point to the first byte +** past the end of the first SQL statement in zSql. These routines only +** compile the first statement in zSql, so *pzTail is left pointing to +** what remains uncompiled. +** +** ^*ppStmt is left pointing to a compiled [prepared statement] that can be +** executed using [sqlite3_step()]. ^If there is an error, *ppStmt is set +** to NULL. ^If the input text contains no SQL (if the input is an empty +** string or a comment) then *ppStmt is set to NULL. +** The calling procedure is responsible for deleting the compiled +** SQL statement using [sqlite3_finalize()] after it has finished with it. +** ppStmt may not be NULL. +** +** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK]; +** otherwise an [error code] is returned. +** +** The sqlite3_prepare_v2(), sqlite3_prepare_v3(), sqlite3_prepare16_v2(), +** and sqlite3_prepare16_v3() interfaces are recommended for all new programs. +** The older interfaces (sqlite3_prepare() and sqlite3_prepare16()) +** are retained for backwards compatibility, but their use is discouraged. +** ^In the "vX" interfaces, the prepared statement +** that is returned (the [sqlite3_stmt] object) contains a copy of the +** original SQL text. This causes the [sqlite3_step()] interface to +** behave differently in three ways: +** +**
      +**
    1. +** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it +** always used to do, [sqlite3_step()] will automatically recompile the SQL +** statement and try to run it again. As many as [SQLITE_MAX_SCHEMA_RETRY] +** retries will occur before sqlite3_step() gives up and returns an error. +**
      2. +** +**
    2. +** ^When an error occurs, [sqlite3_step()] will return one of the detailed +** [error codes] or [extended error codes]. ^The legacy behavior was that +** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code +** and the application would have to make a second call to [sqlite3_reset()] +** in order to find the underlying cause of the problem. With the "v2" prepare +** interfaces, the underlying reason for the error is returned immediately. +**
      3. +** +**
    3. +** ^If the specific value bound to a [parameter | host parameter] in the +** WHERE clause might influence the choice of query plan for a statement, +** then the statement will be automatically recompiled, as if there had been +** a schema change, on the first [sqlite3_step()] call following any change +** to the [sqlite3_bind_text | bindings] of that [parameter]. +** ^The specific value of a WHERE-clause [parameter] might influence the +** choice of query plan if the parameter is the left-hand side of a [LIKE] +** or [GLOB] operator or if the parameter is compared to an indexed column +** and the [SQLITE_ENABLE_STAT4] compile-time option is enabled. +**
      4. +**
    +** +**

    ^sqlite3_prepare_v3() differs from sqlite3_prepare_v2() only in having +** the extra prepFlags parameter, which is a bit array consisting of zero or +** more of the [SQLITE_PREPARE_PERSISTENT|SQLITE_PREPARE_*] flags. ^The +** sqlite3_prepare_v2() interface works exactly the same as +** sqlite3_prepare_v3() with a zero prepFlags parameter. +*/ +SQLITE_API int sqlite3_prepare( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare_v2( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare_v3( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_ flags */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare16( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare16_v2( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare16_v3( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_ flags */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); + +/* +** CAPI3REF: Retrieving Statement SQL +** METHOD: sqlite3_stmt +** +** ^The sqlite3_sql(P) interface returns a pointer to a copy of the UTF-8 +** SQL text used to create [prepared statement] P if P was +** created by [sqlite3_prepare_v2()], [sqlite3_prepare_v3()], +** [sqlite3_prepare16_v2()], or [sqlite3_prepare16_v3()]. +** ^The sqlite3_expanded_sql(P) interface returns a pointer to a UTF-8 +** string containing the SQL text of prepared statement P with +** [bound parameters] expanded. +** ^The sqlite3_normalized_sql(P) interface returns a pointer to a UTF-8 +** string containing the normalized SQL text of prepared statement P. The +** semantics used to normalize a SQL statement are unspecified and subject +** to change. At a minimum, literal values will be replaced with suitable +** placeholders. +** +** ^(For example, if a prepared statement is created using the SQL +** text "SELECT $abc,:xyz" and if parameter $abc is bound to integer 2345 +** and parameter :xyz is unbound, then sqlite3_sql() will return +** the original string, "SELECT $abc,:xyz" but sqlite3_expanded_sql() +** will return "SELECT 2345,NULL".)^ +** +** ^The sqlite3_expanded_sql() interface returns NULL if insufficient memory +** is available to hold the result, or if the result would exceed the +** the maximum string length determined by the [SQLITE_LIMIT_LENGTH]. +** +** ^The [SQLITE_TRACE_SIZE_LIMIT] compile-time option limits the size of +** bound parameter expansions. ^The [SQLITE_OMIT_TRACE] compile-time +** option causes sqlite3_expanded_sql() to always return NULL. +** +** ^The strings returned by sqlite3_sql(P) and sqlite3_normalized_sql(P) +** are managed by SQLite and are automatically freed when the prepared +** statement is finalized. +** ^The string returned by sqlite3_expanded_sql(P), on the other hand, +** is obtained from [sqlite3_malloc()] and must be free by the application +** by passing it to [sqlite3_free()]. +*/ +SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt); +SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt); +SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Determine If An SQL Statement Writes The Database +** METHOD: sqlite3_stmt +** +** ^The sqlite3_stmt_readonly(X) interface returns true (non-zero) if +** and only if the [prepared statement] X makes no direct changes to +** the content of the database file. +** +** Note that [application-defined SQL functions] or +** [virtual tables] might change the database indirectly as a side effect. +** ^(For example, if an application defines a function "eval()" that +** calls [sqlite3_exec()], then the following SQL statement would +** change the database file through side-effects: +** +** 

    +**    SELECT eval('DELETE FROM t1') FROM t2;
+**
    +** +** But because the [SELECT] statement does not change the database file +** directly, sqlite3_stmt_readonly() would still return true.)^ +** +** ^Transaction control statements such as [BEGIN], [COMMIT], [ROLLBACK], +** [SAVEPOINT], and [RELEASE] cause sqlite3_stmt_readonly() to return true, +** since the statements themselves do not actually modify the database but +** rather they control the timing of when other statements modify the +** database. ^The [ATTACH] and [DETACH] statements also cause +** sqlite3_stmt_readonly() to return true since, while those statements +** change the configuration of a database connection, they do not make +** changes to the content of the database files on disk. +** ^The sqlite3_stmt_readonly() interface returns true for [BEGIN] since +** [BEGIN] merely sets internal flags, but the [BEGIN|BEGIN IMMEDIATE] and +** [BEGIN|BEGIN EXCLUSIVE] commands do touch the database and so +** sqlite3_stmt_readonly() returns false for those commands. +*/ +SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Query The EXPLAIN Setting For A Prepared Statement +** METHOD: sqlite3_stmt +** +** ^The sqlite3_stmt_isexplain(S) interface returns 1 if the +** prepared statement S is an EXPLAIN statement, or 2 if the +** statement S is an EXPLAIN QUERY PLAN. +** ^The sqlite3_stmt_isexplain(S) interface returns 0 if S is +** an ordinary statement or a NULL pointer. +*/ +SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Determine If A Prepared Statement Has Been Reset +** METHOD: sqlite3_stmt +** +** ^The sqlite3_stmt_busy(S) interface returns true (non-zero) if the +** [prepared statement] S has been stepped at least once using +** [sqlite3_step(S)] but has neither run to completion (returned +** [SQLITE_DONE] from [sqlite3_step(S)]) nor +** been reset using [sqlite3_reset(S)]. ^The sqlite3_stmt_busy(S) +** interface returns false if S is a NULL pointer. If S is not a +** NULL pointer and is not a pointer to a valid [prepared statement] +** object, then the behavior is undefined and probably undesirable. +** +** This interface can be used in combination [sqlite3_next_stmt()] +** to locate all prepared statements associated with a database +** connection that are in need of being reset. This can be used, +** for example, in diagnostic routines to search for prepared +** statements that are holding a transaction open. +*/ +SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt*); + +/* +** CAPI3REF: Dynamically Typed Value Object +** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value} +** +** SQLite uses the sqlite3_value object to represent all values +** that can be stored in a database table. SQLite uses dynamic typing +** for the values it stores. ^Values stored in sqlite3_value objects +** can be integers, floating point values, strings, BLOBs, or NULL. +** +** An sqlite3_value object may be either "protected" or "unprotected". +** Some interfaces require a protected sqlite3_value. Other interfaces +** will accept either a protected or an unprotected sqlite3_value. +** Every interface that accepts sqlite3_value arguments specifies +** whether or not it requires a protected sqlite3_value. The +** [sqlite3_value_dup()] interface can be used to construct a new +** protected sqlite3_value from an unprotected sqlite3_value. +** +** The terms "protected" and "unprotected" refer to whether or not +** a mutex is held. An internal mutex is held for a protected +** sqlite3_value object but no mutex is held for an unprotected +** sqlite3_value object. If SQLite is compiled to be single-threaded +** (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0) +** or if SQLite is run in one of reduced mutex modes +** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD] +** then there is no distinction between protected and unprotected +** sqlite3_value objects and they can be used interchangeably. However, +** for maximum code portability it is recommended that applications +** still make the distinction between protected and unprotected +** sqlite3_value objects even when not strictly required. +** +** ^The sqlite3_value objects that are passed as parameters into the +** implementation of [application-defined SQL functions] are protected. +** ^The sqlite3_value object returned by +** [sqlite3_column_value()] is unprotected. +** Unprotected sqlite3_value objects may only be used as arguments +** to [sqlite3_result_value()], [sqlite3_bind_value()], and +** [sqlite3_value_dup()]. +** The [sqlite3_value_blob | sqlite3_value_type()] family of +** interfaces require protected sqlite3_value objects. +*/ +typedef struct sqlite3_value sqlite3_value; + +/* +** CAPI3REF: SQL Function Context Object +** +** The context in which an SQL function executes is stored in an +** sqlite3_context object. ^A pointer to an sqlite3_context object +** is always first parameter to [application-defined SQL functions]. +** The application-defined SQL function implementation will pass this +** pointer through into calls to [sqlite3_result_int | sqlite3_result()], +** [sqlite3_aggregate_context()], [sqlite3_user_data()], +** [sqlite3_context_db_handle()], [sqlite3_get_auxdata()], +** and/or [sqlite3_set_auxdata()]. +*/ +typedef struct sqlite3_context sqlite3_context; + +/* +** CAPI3REF: Binding Values To Prepared Statements +** KEYWORDS: {host parameter} {host parameters} {host parameter name} +** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding} +** METHOD: sqlite3_stmt +** +** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants, +** literals may be replaced by a [parameter] that matches one of following +** templates: +** +**
      +**
    • ? +**
    • ?NNN +**
    • :VVV +**
    • @VVV +**
    • $VVV +**
    +** +** In the templates above, NNN represents an integer literal, +** and VVV represents an alphanumeric identifier.)^ ^The values of these +** parameters (also called "host parameter names" or "SQL parameters") +** can be set using the sqlite3_bind_*() routines defined here. +** +** ^The first argument to the sqlite3_bind_*() routines is always +** a pointer to the [sqlite3_stmt] object returned from +** [sqlite3_prepare_v2()] or its variants. +** +** ^The second argument is the index of the SQL parameter to be set. +** ^The leftmost SQL parameter has an index of 1. ^When the same named +** SQL parameter is used more than once, second and subsequent +** occurrences have the same index as the first occurrence. +** ^The index for named parameters can be looked up using the +** [sqlite3_bind_parameter_index()] API if desired. ^The index +** for "?NNN" parameters is the value of NNN. +** ^The NNN value must be between 1 and the [sqlite3_limit()] +** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 32766). +** +** ^The third argument is the value to bind to the parameter. +** ^If the third parameter to sqlite3_bind_text() or sqlite3_bind_text16() +** or sqlite3_bind_blob() is a NULL pointer then the fourth parameter +** is ignored and the end result is the same as sqlite3_bind_null(). +** ^If the third parameter to sqlite3_bind_text() is not NULL, then +** it should be a pointer to well-formed UTF8 text. +** ^If the third parameter to sqlite3_bind_text16() is not NULL, then +** it should be a pointer to well-formed UTF16 text. +** ^If the third parameter to sqlite3_bind_text64() is not NULL, then +** it should be a pointer to a well-formed unicode string that is +** either UTF8 if the sixth parameter is SQLITE_UTF8, or UTF16 +** otherwise. +** +** [[byte-order determination rules]] ^The byte-order of +** UTF16 input text is determined by the byte-order mark (BOM, U+FEFF) +** found in first character, which is removed, or in the absence of a BOM +** the byte order is the native byte order of the host +** machine for sqlite3_bind_text16() or the byte order specified in +** the 6th parameter for sqlite3_bind_text64().)^ +** ^If UTF16 input text contains invalid unicode +** characters, then SQLite might change those invalid characters +** into the unicode replacement character: U+FFFD. +** +** ^(In those routines that have a fourth argument, its value is the +** number of bytes in the parameter. To be clear: the value is the +** number of bytes in the value, not the number of characters.)^ +** ^If the fourth parameter to sqlite3_bind_text() or sqlite3_bind_text16() +** is negative, then the length of the string is +** the number of bytes up to the first zero terminator. +** If the fourth parameter to sqlite3_bind_blob() is negative, then +** the behavior is undefined. +** If a non-negative fourth parameter is provided to sqlite3_bind_text() +** or sqlite3_bind_text16() or sqlite3_bind_text64() then +** that parameter must be the byte offset +** where the NUL terminator would occur assuming the string were NUL +** terminated. If any NUL characters occurs at byte offsets less than +** the value of the fourth parameter then the resulting string value will +** contain embedded NULs. The result of expressions involving strings +** with embedded NULs is undefined. +** +** ^The fifth argument to the BLOB and string binding interfaces +** is a destructor used to dispose of the BLOB or +** string after SQLite has finished with it. ^The destructor is called +** to dispose of the BLOB or string even if the call to the bind API fails, +** except the destructor is not called if the third parameter is a NULL +** pointer or the fourth parameter is negative. +** ^If the fifth argument is +** the special value [SQLITE_STATIC], then SQLite assumes that the +** information is in static, unmanaged space and does not need to be freed. +** ^If the fifth argument has the value [SQLITE_TRANSIENT], then +** SQLite makes its own private copy of the data immediately, before +** the sqlite3_bind_*() routine returns. +** +** ^The sixth argument to sqlite3_bind_text64() must be one of +** [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE] +** to specify the encoding of the text in the third parameter. If +** the sixth argument to sqlite3_bind_text64() is not one of the +** allowed values shown above, or if the text encoding is different +** from the encoding specified by the sixth parameter, then the behavior +** is undefined. +** +** ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that +** is filled with zeroes. ^A zeroblob uses a fixed amount of memory +** (just an integer to hold its size) while it is being processed. +** Zeroblobs are intended to serve as placeholders for BLOBs whose +** content is later written using +** [sqlite3_blob_open | incremental BLOB I/O] routines. +** ^A negative value for the zeroblob results in a zero-length BLOB. +** +** ^The sqlite3_bind_pointer(S,I,P,T,D) routine causes the I-th parameter in +** [prepared statement] S to have an SQL value of NULL, but to also be +** associated with the pointer P of type T. ^D is either a NULL pointer or +** a pointer to a destructor function for P. ^SQLite will invoke the +** destructor D with a single argument of P when it is finished using +** P. The T parameter should be a static string, preferably a string +** literal. The sqlite3_bind_pointer() routine is part of the +** [pointer passing interface] added for SQLite 3.20.0. +** +** ^If any of the sqlite3_bind_*() routines are called with a NULL pointer +** for the [prepared statement] or with a prepared statement for which +** [sqlite3_step()] has been called more recently than [sqlite3_reset()], +** then the call will return [SQLITE_MISUSE]. If any sqlite3_bind_() +** routine is passed a [prepared statement] that has been finalized, the +** result is undefined and probably harmful. +** +** ^Bindings are not cleared by the [sqlite3_reset()] routine. +** ^Unbound parameters are interpreted as NULL. +** +** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an +** [error code] if anything goes wrong. +** ^[SQLITE_TOOBIG] might be returned if the size of a string or BLOB +** exceeds limits imposed by [sqlite3_limit]([SQLITE_LIMIT_LENGTH]) or +** [SQLITE_MAX_LENGTH]. +** ^[SQLITE_RANGE] is returned if the parameter +** index is out of range. ^[SQLITE_NOMEM] is returned if malloc() fails. +** +** See also: [sqlite3_bind_parameter_count()], +** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); +SQLITE_API int sqlite3_bind_blob64(sqlite3_stmt*, int, const void*, sqlite3_uint64, + void(*)(void*)); +SQLITE_API int sqlite3_bind_double(sqlite3_stmt*, int, double); +SQLITE_API int sqlite3_bind_int(sqlite3_stmt*, int, int); +SQLITE_API int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64); +SQLITE_API int sqlite3_bind_null(sqlite3_stmt*, int); +SQLITE_API int sqlite3_bind_text(sqlite3_stmt*,int,const char*,int,void(*)(void*)); +SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); +SQLITE_API int sqlite3_bind_text64(sqlite3_stmt*, int, const char*, sqlite3_uint64, + void(*)(void*), unsigned char encoding); +SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); +SQLITE_API int sqlite3_bind_pointer(sqlite3_stmt*, int, void*, const char*,void(*)(void*)); +SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); +SQLITE_API int sqlite3_bind_zeroblob64(sqlite3_stmt*, int, sqlite3_uint64); + +/* +** CAPI3REF: Number Of SQL Parameters +** METHOD: sqlite3_stmt +** +** ^This routine can be used to find the number of [SQL parameters] +** in a [prepared statement]. SQL parameters are tokens of the +** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as +** placeholders for values that are [sqlite3_bind_blob | bound] +** to the parameters at a later time. +** +** ^(This routine actually returns the index of the largest (rightmost) +** parameter. For all forms except ?NNN, this will correspond to the +** number of unique parameters. If parameters of the ?NNN form are used, +** there may be gaps in the list.)^ +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_name()], and +** [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*); + +/* +** CAPI3REF: Name Of A Host Parameter +** METHOD: sqlite3_stmt +** +** ^The sqlite3_bind_parameter_name(P,N) interface returns +** the name of the N-th [SQL parameter] in the [prepared statement] P. +** ^(SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA" +** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA" +** respectively. +** In other words, the initial ":" or "$" or "@" or "?" +** is included as part of the name.)^ +** ^Parameters of the form "?" without a following integer have no name +** and are referred to as "nameless" or "anonymous parameters". +** +** ^The first host parameter has an index of 1, not 0. +** +** ^If the value N is out of range or if the N-th parameter is +** nameless, then NULL is returned. ^The returned string is +** always in UTF-8 encoding even if the named parameter was +** originally specified as UTF-16 in [sqlite3_prepare16()], +** [sqlite3_prepare16_v2()], or [sqlite3_prepare16_v3()]. +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_count()], and +** [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); + +/* +** CAPI3REF: Index Of A Parameter With A Given Name +** METHOD: sqlite3_stmt +** +** ^Return the index of an SQL parameter given its name. ^The +** index value returned is suitable for use as the second +** parameter to [sqlite3_bind_blob|sqlite3_bind()]. ^A zero +** is returned if no matching parameter is found. ^The parameter +** name must be given in UTF-8 even if the original statement +** was prepared from UTF-16 text using [sqlite3_prepare16_v2()] or +** [sqlite3_prepare16_v3()]. +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_count()], and +** [sqlite3_bind_parameter_name()]. +*/ +SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); + +/* +** CAPI3REF: Reset All Bindings On A Prepared Statement +** METHOD: sqlite3_stmt +** +** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset +** the [sqlite3_bind_blob | bindings] on a [prepared statement]. +** ^Use this routine to reset all host parameters to NULL. +*/ +SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*); + +/* +** CAPI3REF: Number Of Columns In A Result Set +** METHOD: sqlite3_stmt +** +** ^Return the number of columns in the result set returned by the +** [prepared statement]. ^If this routine returns 0, that means the +** [prepared statement] returns no data (for example an [UPDATE]). +** ^However, just because this routine returns a positive number does not +** mean that one or more rows of data will be returned. ^A SELECT statement +** will always have a positive sqlite3_column_count() but depending on the +** WHERE clause constraints and the table content, it might return no rows. +** +** See also: [sqlite3_data_count()] +*/ +SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Column Names In A Result Set +** METHOD: sqlite3_stmt +** +** ^These routines return the name assigned to a particular column +** in the result set of a [SELECT] statement. ^The sqlite3_column_name() +** interface returns a pointer to a zero-terminated UTF-8 string +** and sqlite3_column_name16() returns a pointer to a zero-terminated +** UTF-16 string. ^The first parameter is the [prepared statement] +** that implements the [SELECT] statement. ^The second parameter is the +** column number. ^The leftmost column is number 0. +** +** ^The returned string pointer is valid until either the [prepared statement] +** is destroyed by [sqlite3_finalize()] or until the statement is automatically +** reprepared by the first call to [sqlite3_step()] for a particular run +** or until the next call to +** sqlite3_column_name() or sqlite3_column_name16() on the same column. +** +** ^If sqlite3_malloc() fails during the processing of either routine +** (for example during a conversion from UTF-8 to UTF-16) then a +** NULL pointer is returned. +** +** ^The name of a result column is the value of the "AS" clause for +** that column, if there is an AS clause. If there is no AS clause +** then the name of the column is unspecified and may change from +** one release of SQLite to the next. +*/ +SQLITE_API const char *sqlite3_column_name(sqlite3_stmt*, int N); +SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N); + +/* +** CAPI3REF: Source Of Data In A Query Result +** METHOD: sqlite3_stmt +** +** ^These routines provide a means to determine the database, table, and +** table column that is the origin of a particular result column in +** [SELECT] statement. +** ^The name of the database or table or column can be returned as +** either a UTF-8 or UTF-16 string. ^The _database_ routines return +** the database name, the _table_ routines return the table name, and +** the origin_ routines return the column name. +** ^The returned string is valid until the [prepared statement] is destroyed +** using [sqlite3_finalize()] or until the statement is automatically +** reprepared by the first call to [sqlite3_step()] for a particular run +** or until the same information is requested +** again in a different encoding. +** +** ^The names returned are the original un-aliased names of the +** database, table, and column. +** +** ^The first argument to these interfaces is a [prepared statement]. +** ^These functions return information about the Nth result column returned by +** the statement, where N is the second function argument. +** ^The left-most column is column 0 for these routines. +** +** ^If the Nth column returned by the statement is an expression or +** subquery and is not a column value, then all of these functions return +** NULL. ^These routines might also return NULL if a memory allocation error +** occurs. ^Otherwise, they return the name of the attached database, table, +** or column that query result column was extracted from. +** +** ^As with all other SQLite APIs, those whose names end with "16" return +** UTF-16 encoded strings and the other functions return UTF-8. +** +** ^These APIs are only available if the library was compiled with the +** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol. +** +** If two or more threads call one or more +** [sqlite3_column_database_name | column metadata interfaces] +** for the same [prepared statement] and result column +** at the same time then the results are undefined. +*/ +SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int); +SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int); +SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Declared Datatype Of A Query Result +** METHOD: sqlite3_stmt +** +** ^(The first parameter is a [prepared statement]. +** If this statement is a [SELECT] statement and the Nth column of the +** returned result set of that [SELECT] is a table column (not an +** expression or subquery) then the declared type of the table +** column is returned.)^ ^If the Nth column of the result set is an +** expression or subquery, then a NULL pointer is returned. +** ^The returned string is always UTF-8 encoded. +** +** ^(For example, given the database schema: +** +** CREATE TABLE t1(c1 VARIANT); +** +** and the following statement to be compiled: +** +** SELECT c1 + 1, c1 FROM t1; +** +** this routine would return the string "VARIANT" for the second result +** column (i==1), and a NULL pointer for the first result column (i==0).)^ +** +** ^SQLite uses dynamic run-time typing. ^So just because a column +** is declared to contain a particular type does not mean that the +** data stored in that column is of the declared type. SQLite is +** strongly typed, but the typing is dynamic not static. ^Type +** is associated with individual values, not with the containers +** used to hold those values. +*/ +SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Evaluate An SQL Statement +** METHOD: sqlite3_stmt +** +** After a [prepared statement] has been prepared using any of +** [sqlite3_prepare_v2()], [sqlite3_prepare_v3()], [sqlite3_prepare16_v2()], +** or [sqlite3_prepare16_v3()] or one of the legacy +** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function +** must be called one or more times to evaluate the statement. +** +** The details of the behavior of the sqlite3_step() interface depend +** on whether the statement was prepared using the newer "vX" interfaces +** [sqlite3_prepare_v3()], [sqlite3_prepare_v2()], [sqlite3_prepare16_v3()], +** [sqlite3_prepare16_v2()] or the older legacy +** interfaces [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the +** new "vX" interface is recommended for new applications but the legacy +** interface will continue to be supported. +** +** ^In the legacy interface, the return value will be either [SQLITE_BUSY], +** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE]. +** ^With the "v2" interface, any of the other [result codes] or +** [extended result codes] might be returned as well. +** +** ^[SQLITE_BUSY] means that the database engine was unable to acquire the +** database locks it needs to do its job. ^If the statement is a [COMMIT] +** or occurs outside of an explicit transaction, then you can retry the +** statement. If the statement is not a [COMMIT] and occurs within an +** explicit transaction then you should rollback the transaction before +** continuing. +** +** ^[SQLITE_DONE] means that the statement has finished executing +** successfully. sqlite3_step() should not be called again on this virtual +** machine without first calling [sqlite3_reset()] to reset the virtual +** machine back to its initial state. +** +** ^If the SQL statement being executed returns any data, then [SQLITE_ROW] +** is returned each time a new row of data is ready for processing by the +** caller. The values may be accessed using the [column access functions]. +** sqlite3_step() is called again to retrieve the next row of data. +** +** ^[SQLITE_ERROR] means that a run-time error (such as a constraint +** violation) has occurred. sqlite3_step() should not be called again on +** the VM. More information may be found by calling [sqlite3_errmsg()]. +** ^With the legacy interface, a more specific error code (for example, +** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth) +** can be obtained by calling [sqlite3_reset()] on the +** [prepared statement]. ^In the "v2" interface, +** the more specific error code is returned directly by sqlite3_step(). +** +** [SQLITE_MISUSE] means that the this routine was called inappropriately. +** Perhaps it was called on a [prepared statement] that has +** already been [sqlite3_finalize | finalized] or on one that had +** previously returned [SQLITE_ERROR] or [SQLITE_DONE]. Or it could +** be the case that the same database connection is being used by two or +** more threads at the same moment in time. +** +** For all versions of SQLite up to and including 3.6.23.1, a call to +** [sqlite3_reset()] was required after sqlite3_step() returned anything +** other than [SQLITE_ROW] before any subsequent invocation of +** sqlite3_step(). Failure to reset the prepared statement using +** [sqlite3_reset()] would result in an [SQLITE_MISUSE] return from +** sqlite3_step(). But after [version 3.6.23.1] ([dateof:3.6.23.1], +** sqlite3_step() began +** calling [sqlite3_reset()] automatically in this circumstance rather +** than returning [SQLITE_MISUSE]. This is not considered a compatibility +** break because any application that ever receives an SQLITE_MISUSE error +** is broken by definition. The [SQLITE_OMIT_AUTORESET] compile-time option +** can be used to restore the legacy behavior. +** +** Goofy Interface Alert: In the legacy interface, the sqlite3_step() +** API always returns a generic error code, [SQLITE_ERROR], following any +** error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call +** [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the +** specific [error codes] that better describes the error. +** We admit that this is a goofy design. The problem has been fixed +** with the "v2" interface. If you prepare all of your SQL statements +** using [sqlite3_prepare_v3()] or [sqlite3_prepare_v2()] +** or [sqlite3_prepare16_v2()] or [sqlite3_prepare16_v3()] instead +** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces, +** then the more specific [error codes] are returned directly +** by sqlite3_step(). The use of the "vX" interfaces is recommended. +*/ +SQLITE_API int sqlite3_step(sqlite3_stmt*); + +/* +** CAPI3REF: Number of columns in a result set +** METHOD: sqlite3_stmt +** +** ^The sqlite3_data_count(P) interface returns the number of columns in the +** current row of the result set of [prepared statement] P. +** ^If prepared statement P does not have results ready to return +** (via calls to the [sqlite3_column_int | sqlite3_column()] family of +** interfaces) then sqlite3_data_count(P) returns 0. +** ^The sqlite3_data_count(P) routine also returns 0 if P is a NULL pointer. +** ^The sqlite3_data_count(P) routine returns 0 if the previous call to +** [sqlite3_step](P) returned [SQLITE_DONE]. ^The sqlite3_data_count(P) +** will return non-zero if previous call to [sqlite3_step](P) returned +** [SQLITE_ROW], except in the case of the [PRAGMA incremental_vacuum] +** where it always returns zero since each step of that multi-step +** pragma returns 0 columns of data. +** +** See also: [sqlite3_column_count()] +*/ +SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Fundamental Datatypes +** KEYWORDS: SQLITE_TEXT +** +** ^(Every value in SQLite has one of five fundamental datatypes: +** +**
      +**
    • 64-bit signed integer +**
    • 64-bit IEEE floating point number +**
    • string +**
    • BLOB +**
    • NULL +**
    )^ +** +** These constants are codes for each of those types. +** +** Note that the SQLITE_TEXT constant was also used in SQLite version 2 +** for a completely different meaning. Software that links against both +** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not +** SQLITE_TEXT. +*/ +#define SQLITE_INTEGER 1 +#define SQLITE_FLOAT 2 +#define SQLITE_BLOB 4 +#define SQLITE_NULL 5 +#ifdef SQLITE_TEXT +# undef SQLITE_TEXT +#else +# define SQLITE_TEXT 3 +#endif +#define SQLITE3_TEXT 3 + +/* +** CAPI3REF: Result Values From A Query +** KEYWORDS: {column access functions} +** METHOD: sqlite3_stmt +** +** Summary: +**
    +**
    sqlite3_column_blob→BLOB result +**
    sqlite3_column_double→REAL result +**
    sqlite3_column_int→32-bit INTEGER result +**
    sqlite3_column_int64→64-bit INTEGER result +**
    sqlite3_column_text→UTF-8 TEXT result +**
    sqlite3_column_text16→UTF-16 TEXT result +**
    sqlite3_column_value→The result as an +** [sqlite3_value|unprotected sqlite3_value] object. +**
        +**
    sqlite3_column_bytes→Size of a BLOB +** or a UTF-8 TEXT result in bytes +**
    sqlite3_column_bytes16   +** →  Size of UTF-16 +** TEXT in bytes +**
    sqlite3_column_type→Default +** datatype of the result +**
    +** +** Details: +** +** ^These routines return information about a single column of the current +** result row of a query. ^In every case the first argument is a pointer +** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*] +** that was returned from [sqlite3_prepare_v2()] or one of its variants) +** and the second argument is the index of the column for which information +** should be returned. ^The leftmost column of the result set has the index 0. +** ^The number of columns in the result can be determined using +** [sqlite3_column_count()]. +** +** If the SQL statement does not currently point to a valid row, or if the +** column index is out of range, the result is undefined. +** These routines may only be called when the most recent call to +** [sqlite3_step()] has returned [SQLITE_ROW] and neither +** [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently. +** If any of these routines are called after [sqlite3_reset()] or +** [sqlite3_finalize()] or after [sqlite3_step()] has returned +** something other than [SQLITE_ROW], the results are undefined. +** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] +** are called from a different thread while any of these routines +** are pending, then the results are undefined. +** +** The first six interfaces (_blob, _double, _int, _int64, _text, and _text16) +** each return the value of a result column in a specific data format. If +** the result column is not initially in the requested format (for example, +** if the query returns an integer but the sqlite3_column_text() interface +** is used to extract the value) then an automatic type conversion is performed. +** +** ^The sqlite3_column_type() routine returns the +** [SQLITE_INTEGER | datatype code] for the initial data type +** of the result column. ^The returned value is one of [SQLITE_INTEGER], +** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. +** The return value of sqlite3_column_type() can be used to decide which +** of the first six interface should be used to extract the column value. +** The value returned by sqlite3_column_type() is only meaningful if no +** automatic type conversions have occurred for the value in question. +** After a type conversion, the result of calling sqlite3_column_type() +** is undefined, though harmless. Future +** versions of SQLite may change the behavior of sqlite3_column_type() +** following a type conversion. +** +** If the result is a BLOB or a TEXT string, then the sqlite3_column_bytes() +** or sqlite3_column_bytes16() interfaces can be used to determine the size +** of that BLOB or string. +** +** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() +** routine returns the number of bytes in that BLOB or string. +** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts +** the string to UTF-8 and then returns the number of bytes. +** ^If the result is a numeric value then sqlite3_column_bytes() uses +** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns +** the number of bytes in that string. +** ^If the result is NULL, then sqlite3_column_bytes() returns zero. +** +** ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16() +** routine returns the number of bytes in that BLOB or string. +** ^If the result is a UTF-8 string, then sqlite3_column_bytes16() converts +** the string to UTF-16 and then returns the number of bytes. +** ^If the result is a numeric value then sqlite3_column_bytes16() uses +** [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns +** the number of bytes in that string. +** ^If the result is NULL, then sqlite3_column_bytes16() returns zero. +** +** ^The values returned by [sqlite3_column_bytes()] and +** [sqlite3_column_bytes16()] do not include the zero terminators at the end +** of the string. ^For clarity: the values returned by +** [sqlite3_column_bytes()] and [sqlite3_column_bytes16()] are the number of +** bytes in the string, not the number of characters. +** +** ^Strings returned by sqlite3_column_text() and sqlite3_column_text16(), +** even empty strings, are always zero-terminated. ^The return +** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer. +** +** Warning: ^The object returned by [sqlite3_column_value()] is an +** [unprotected sqlite3_value] object. In a multithreaded environment, +** an unprotected sqlite3_value object may only be used safely with +** [sqlite3_bind_value()] and [sqlite3_result_value()]. +** If the [unprotected sqlite3_value] object returned by +** [sqlite3_column_value()] is used in any other way, including calls +** to routines like [sqlite3_value_int()], [sqlite3_value_text()], +** or [sqlite3_value_bytes()], the behavior is not threadsafe. +** Hence, the sqlite3_column_value() interface +** is normally only useful within the implementation of +** [application-defined SQL functions] or [virtual tables], not within +** top-level application code. +** +** The these routines may attempt to convert the datatype of the result. +** ^For example, if the internal representation is FLOAT and a text result +** is requested, [sqlite3_snprintf()] is used internally to perform the +** conversion automatically. ^(The following table details the conversions +** that are applied: +** +**
    +** +**
    Internal
    Type     		Requested
    Type     		Conversion +** +**
    NULL INTEGER Result is 0 +**
    NULL FLOAT Result is 0.0 +**
    NULL TEXT Result is a NULL pointer +**
    NULL BLOB Result is a NULL pointer +**
    INTEGER FLOAT Convert from integer to float +**
    INTEGER TEXT ASCII rendering of the integer +**
    INTEGER BLOB Same as INTEGER->TEXT +**
    FLOAT INTEGER [CAST] to INTEGER +**
    FLOAT TEXT ASCII rendering of the float +**
    FLOAT BLOB [CAST] to BLOB +**
    TEXT INTEGER [CAST] to INTEGER +**
    TEXT FLOAT [CAST] to REAL +**
    TEXT BLOB No change +**
    BLOB INTEGER [CAST] to INTEGER +**
    BLOB FLOAT [CAST] to REAL +**
    BLOB TEXT Add a zero terminator if needed +**
    +**
    )^ +** +** Note that when type conversions occur, pointers returned by prior +** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or +** sqlite3_column_text16() may be invalidated. +** Type conversions and pointer invalidations might occur +** in the following cases: +** +**
      +**
    • The initial content is a BLOB and sqlite3_column_text() or +** sqlite3_column_text16() is called. A zero-terminator might +** need to be added to the string.
      • +**
    • The initial content is UTF-8 text and sqlite3_column_bytes16() or +** sqlite3_column_text16() is called. The content must be converted +** to UTF-16.
      • +**
    • The initial content is UTF-16 text and sqlite3_column_bytes() or +** sqlite3_column_text() is called. The content must be converted +** to UTF-8.
      • +**
    +** +** ^Conversions between UTF-16be and UTF-16le are always done in place and do +** not invalidate a prior pointer, though of course the content of the buffer +** that the prior pointer references will have been modified. Other kinds +** of conversion are done in place when it is possible, but sometimes they +** are not possible and in those cases prior pointers are invalidated. +** +** The safest policy is to invoke these routines +** in one of the following ways: +** +**
      +**
    • sqlite3_column_text() followed by sqlite3_column_bytes()
      • +**
    • sqlite3_column_blob() followed by sqlite3_column_bytes()
      • +**
    • sqlite3_column_text16() followed by sqlite3_column_bytes16()
      • +**
    +** +** In other words, you should call sqlite3_column_text(), +** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result +** into the desired format, then invoke sqlite3_column_bytes() or +** sqlite3_column_bytes16() to find the size of the result. Do not mix calls +** to sqlite3_column_text() or sqlite3_column_blob() with calls to +** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16() +** with calls to sqlite3_column_bytes(). +** +** ^The pointers returned are valid until a type conversion occurs as +** described above, or until [sqlite3_step()] or [sqlite3_reset()] or +** [sqlite3_finalize()] is called. ^The memory space used to hold strings +** and BLOBs is freed automatically. Do not pass the pointers returned +** from [sqlite3_column_blob()], [sqlite3_column_text()], etc. into +** [sqlite3_free()]. +** +** As long as the input parameters are correct, these routines will only +** fail if an out-of-memory error occurs during a format conversion. +** Only the following subset of interfaces are subject to out-of-memory +** errors: +** +**
      +**
    • sqlite3_column_blob() +**
    • sqlite3_column_text() +**
    • sqlite3_column_text16() +**
    • sqlite3_column_bytes() +**
    • sqlite3_column_bytes16() +**
    +** +** If an out-of-memory error occurs, then the return value from these +** routines is the same as if the column had contained an SQL NULL value. +** Valid SQL NULL returns can be distinguished from out-of-memory errors +** by invoking the [sqlite3_errcode()] immediately after the suspect +** return value is obtained and before any +** other SQLite interface is called on the same [database connection]. +*/ +SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); +SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol); +SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); +SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); +SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); +SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol); + +/* +** CAPI3REF: Destroy A Prepared Statement Object +** DESTRUCTOR: sqlite3_stmt +** +** ^The sqlite3_finalize() function is called to delete a [prepared statement]. +** ^If the most recent evaluation of the statement encountered no errors +** or if the statement is never been evaluated, then sqlite3_finalize() returns +** SQLITE_OK. ^If the most recent evaluation of statement S failed, then +** sqlite3_finalize(S) returns the appropriate [error code] or +** [extended error code]. +** +** ^The sqlite3_finalize(S) routine can be called at any point during +** the life cycle of [prepared statement] S: +** before statement S is ever evaluated, after +** one or more calls to [sqlite3_reset()], or after any call +** to [sqlite3_step()] regardless of whether or not the statement has +** completed execution. +** +** ^Invoking sqlite3_finalize() on a NULL pointer is a harmless no-op. +** +** The application must finalize every [prepared statement] in order to avoid +** resource leaks. It is a grievous error for the application to try to use +** a prepared statement after it has been finalized. Any use of a prepared +** statement after it has been finalized can result in undefined and +** undesirable behavior such as segfaults and heap corruption. +*/ +SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Reset A Prepared Statement Object +** METHOD: sqlite3_stmt +** +** The sqlite3_reset() function is called to reset a [prepared statement] +** object back to its initial state, ready to be re-executed. +** ^Any SQL statement variables that had values bound to them using +** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values. +** Use [sqlite3_clear_bindings()] to reset the bindings. +** +** ^The [sqlite3_reset(S)] interface resets the [prepared statement] S +** back to the beginning of its program. +** +** ^If the most recent call to [sqlite3_step(S)] for the +** [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE], +** or if [sqlite3_step(S)] has never before been called on S, +** then [sqlite3_reset(S)] returns [SQLITE_OK]. +** +** ^If the most recent call to [sqlite3_step(S)] for the +** [prepared statement] S indicated an error, then +** [sqlite3_reset(S)] returns an appropriate [error code]. +** +** ^The [sqlite3_reset(S)] interface does not change the values +** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S. +*/ +SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Create Or Redefine SQL Functions +** KEYWORDS: {function creation routines} +** METHOD: sqlite3 +** +** ^These functions (collectively known as "function creation routines") +** are used to add SQL functions or aggregates or to redefine the behavior +** of existing SQL functions or aggregates. The only differences between +** the three "sqlite3_create_function*" routines are the text encoding +** expected for the second parameter (the name of the function being +** created) and the presence or absence of a destructor callback for +** the application data pointer. Function sqlite3_create_window_function() +** is similar, but allows the user to supply the extra callback functions +** needed by [aggregate window functions]. +** +** ^The first parameter is the [database connection] to which the SQL +** function is to be added. ^If an application uses more than one database +** connection then application-defined SQL functions must be added +** to each database connection separately. +** +** ^The second parameter is the name of the SQL function to be created or +** redefined. ^The length of the name is limited to 255 bytes in a UTF-8 +** representation, exclusive of the zero-terminator. ^Note that the name +** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes. +** ^Any attempt to create a function with a longer name +** will result in [SQLITE_MISUSE] being returned. +** +** ^The third parameter (nArg) +** is the number of arguments that the SQL function or +** aggregate takes. ^If this parameter is -1, then the SQL function or +** aggregate may take any number of arguments between 0 and the limit +** set by [sqlite3_limit]([SQLITE_LIMIT_FUNCTION_ARG]). If the third +** parameter is less than -1 or greater than 127 then the behavior is +** undefined. +** +** ^The fourth parameter, eTextRep, specifies what +** [SQLITE_UTF8 | text encoding] this SQL function prefers for +** its parameters. The application should set this parameter to +** [SQLITE_UTF16LE] if the function implementation invokes +** [sqlite3_value_text16le()] on an input, or [SQLITE_UTF16BE] if the +** implementation invokes [sqlite3_value_text16be()] on an input, or +** [SQLITE_UTF16] if [sqlite3_value_text16()] is used, or [SQLITE_UTF8] +** otherwise. ^The same SQL function may be registered multiple times using +** different preferred text encodings, with different implementations for +** each encoding. +** ^When multiple implementations of the same function are available, SQLite +** will pick the one that involves the least amount of data conversion. +** +** ^The fourth parameter may optionally be ORed with [SQLITE_DETERMINISTIC] +** to signal that the function will always return the same result given +** the same inputs within a single SQL statement. Most SQL functions are +** deterministic. The built-in [random()] SQL function is an example of a +** function that is not deterministic. The SQLite query planner is able to +** perform additional optimizations on deterministic functions, so use +** of the [SQLITE_DETERMINISTIC] flag is recommended where possible. +** +** ^The fourth parameter may also optionally include the [SQLITE_DIRECTONLY] +** flag, which if present prevents the function from being invoked from +** within VIEWs, TRIGGERs, CHECK constraints, generated column expressions, +** index expressions, or the WHERE clause of partial indexes. +** +** +** For best security, the [SQLITE_DIRECTONLY] flag is recommended for +** all application-defined SQL functions that do not need to be +** used inside of triggers, view, CHECK constraints, or other elements of +** the database schema. This flags is especially recommended for SQL +** functions that have side effects or reveal internal application state. +** Without this flag, an attacker might be able to modify the schema of +** a database file to include invocations of the function with parameters +** chosen by the attacker, which the application will then execute when +** the database file is opened and read. +** +** +** ^(The fifth parameter is an arbitrary pointer. The implementation of the +** function can gain access to this pointer using [sqlite3_user_data()].)^ +** +** ^The sixth, seventh and eighth parameters passed to the three +** "sqlite3_create_function*" functions, xFunc, xStep and xFinal, are +** pointers to C-language functions that implement the SQL function or +** aggregate. ^A scalar SQL function requires an implementation of the xFunc +** callback only; NULL pointers must be passed as the xStep and xFinal +** parameters. ^An aggregate SQL function requires an implementation of xStep +** and xFinal and NULL pointer must be passed for xFunc. ^To delete an existing +** SQL function or aggregate, pass NULL pointers for all three function +** callbacks. +** +** ^The sixth, seventh, eighth and ninth parameters (xStep, xFinal, xValue +** and xInverse) passed to sqlite3_create_window_function are pointers to +** C-language callbacks that implement the new function. xStep and xFinal +** must both be non-NULL. xValue and xInverse may either both be NULL, in +** which case a regular aggregate function is created, or must both be +** non-NULL, in which case the new function may be used as either an aggregate +** or aggregate window function. More details regarding the implementation +** of aggregate window functions are +** [user-defined window functions|available here]. +** +** ^(If the final parameter to sqlite3_create_function_v2() or +** sqlite3_create_window_function() is not NULL, then it is destructor for +** the application data pointer. The destructor is invoked when the function +** is deleted, either by being overloaded or when the database connection +** closes.)^ ^The destructor is also invoked if the call to +** sqlite3_create_function_v2() fails. ^When the destructor callback is +** invoked, it is passed a single argument which is a copy of the application +** data pointer which was the fifth parameter to sqlite3_create_function_v2(). +** +** ^It is permitted to register multiple implementations of the same +** functions with the same name but with either differing numbers of +** arguments or differing preferred text encodings. ^SQLite will use +** the implementation that most closely matches the way in which the +** SQL function is used. ^A function implementation with a non-negative +** nArg parameter is a better match than a function implementation with +** a negative nArg. ^A function where the preferred text encoding +** matches the database encoding is a better +** match than a function where the encoding is different. +** ^A function where the encoding difference is between UTF16le and UTF16be +** is a closer match than a function where the encoding difference is +** between UTF8 and UTF16. +** +** ^Built-in functions may be overloaded by new application-defined functions. +** +** ^An application-defined function is permitted to call other +** SQLite interfaces. However, such calls must not +** close the database connection nor finalize or reset the prepared +** statement in which the function is running. +*/ +SQLITE_API int sqlite3_create_function( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +SQLITE_API int sqlite3_create_function16( + sqlite3 *db, + const void *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +SQLITE_API int sqlite3_create_function_v2( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void(*xDestroy)(void*) +); +SQLITE_API int sqlite3_create_window_function( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void (*xValue)(sqlite3_context*), + void (*xInverse)(sqlite3_context*,int,sqlite3_value**), + void(*xDestroy)(void*) +); + +/* +** CAPI3REF: Text Encodings +** +** These constant define integer codes that represent the various +** text encodings supported by SQLite. +*/ +#define SQLITE_UTF8 1 /* IMP: R-37514-35566 */ +#define SQLITE_UTF16LE 2 /* IMP: R-03371-37637 */ +#define SQLITE_UTF16BE 3 /* IMP: R-51971-34154 */ +#define SQLITE_UTF16 4 /* Use native byte order */ +#define SQLITE_ANY 5 /* Deprecated */ +#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ + +/* +** CAPI3REF: Function Flags +** +** These constants may be ORed together with the +** [SQLITE_UTF8 | preferred text encoding] as the fourth argument +** to [sqlite3_create_function()], [sqlite3_create_function16()], or +** [sqlite3_create_function_v2()]. +** +**
    +** [[SQLITE_DETERMINISTIC]]
    SQLITE_DETERMINISTIC
    +** The SQLITE_DETERMINISTIC flag means that the new function always gives +** the same output when the input parameters are the same. +** The [abs|abs() function] is deterministic, for example, but +** [randomblob|randomblob()] is not. Functions must +** be deterministic in order to be used in certain contexts such as +** with the WHERE clause of [partial indexes] or in [generated columns]. +** SQLite might also optimize deterministic functions by factoring them +** out of inner loops. +**
    +** +** [[SQLITE_DIRECTONLY]]
    SQLITE_DIRECTONLY
    +** The SQLITE_DIRECTONLY flag means that the function may only be invoked +** from top-level SQL, and cannot be used in VIEWs or TRIGGERs nor in +** schema structures such as [CHECK constraints], [DEFAULT clauses], +** [expression indexes], [partial indexes], or [generated columns]. +** The SQLITE_DIRECTONLY flags is a security feature which is recommended +** for all [application-defined SQL functions], and especially for functions +** that have side-effects or that could potentially leak sensitive +** information. +**
    +** +** [[SQLITE_INNOCUOUS]]
    SQLITE_INNOCUOUS
    +** The SQLITE_INNOCUOUS flag means that the function is unlikely +** to cause problems even if misused. An innocuous function should have +** no side effects and should not depend on any values other than its +** input parameters. The [abs|abs() function] is an example of an +** innocuous function. +** The [load_extension() SQL function] is not innocuous because of its +** side effects. +**

    SQLITE_INNOCUOUS is similar to SQLITE_DETERMINISTIC, but is not +** exactly the same. The [random|random() function] is an example of a +** function that is innocuous but not deterministic. +**

    Some heightened security settings +** ([SQLITE_DBCONFIG_TRUSTED_SCHEMA] and [PRAGMA trusted_schema=OFF]) +** disable the use of SQL functions inside views and triggers and in +** schema structures such as [CHECK constraints], [DEFAULT clauses], +** [expression indexes], [partial indexes], and [generated columns] unless +** the function is tagged with SQLITE_INNOCUOUS. Most built-in functions +** are innocuous. Developers are advised to avoid using the +** SQLITE_INNOCUOUS flag for application-defined functions unless the +** function has been carefully audited and found to be free of potentially +** security-adverse side-effects and information-leaks. +**

    +** +** [[SQLITE_SUBTYPE]]
    SQLITE_SUBTYPE
    +** The SQLITE_SUBTYPE flag indicates to SQLite that a function may call +** [sqlite3_value_subtype()] to inspect the sub-types of its arguments. +** Specifying this flag makes no difference for scalar or aggregate user +** functions. However, if it is not specified for a user-defined window +** function, then any sub-types belonging to arguments passed to the window +** function may be discarded before the window function is called (i.e. +** sqlite3_value_subtype() will always return 0). +**
    +**
    +*/ +#define SQLITE_DETERMINISTIC 0x000000800 +#define SQLITE_DIRECTONLY 0x000080000 +#define SQLITE_SUBTYPE 0x000100000 +#define SQLITE_INNOCUOUS 0x000200000 + +/* +** CAPI3REF: Deprecated Functions +** DEPRECATED +** +** These functions are [deprecated]. In order to maintain +** backwards compatibility with older code, these functions continue +** to be supported. However, new applications should avoid +** the use of these functions. To encourage programmers to avoid +** these functions, we will not explain what they do. +*/ +#ifndef SQLITE_OMIT_DEPRECATED +SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*); +SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*); +SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*); +SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void); +SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void); +SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int), + void*,sqlite3_int64); +#endif + +/* +** CAPI3REF: Obtaining SQL Values +** METHOD: sqlite3_value +** +** Summary: +**
    +**
    sqlite3_value_blob→BLOB value +**
    sqlite3_value_double→REAL value +**
    sqlite3_value_int→32-bit INTEGER value +**
    sqlite3_value_int64→64-bit INTEGER value +**
    sqlite3_value_pointer→Pointer value +**
    sqlite3_value_text→UTF-8 TEXT value +**
    sqlite3_value_text16→UTF-16 TEXT value in +** the native byteorder +**
    sqlite3_value_text16be→UTF-16be TEXT value +**
    sqlite3_value_text16le→UTF-16le TEXT value +**
        +**
    sqlite3_value_bytes→Size of a BLOB +** or a UTF-8 TEXT in bytes +**
    sqlite3_value_bytes16   +** →  Size of UTF-16 +** TEXT in bytes +**
    sqlite3_value_type→Default +** datatype of the value +**
    sqlite3_value_numeric_type   +** →  Best numeric datatype of the value +**
    sqlite3_value_nochange   +** →  True if the column is unchanged in an UPDATE +** against a virtual table. +**
    sqlite3_value_frombind   +** →  True if value originated from a [bound parameter] +**
    +** +** Details: +** +** These routines extract type, size, and content information from +** [protected sqlite3_value] objects. Protected sqlite3_value objects +** are used to pass parameter information into the functions that +** implement [application-defined SQL functions] and [virtual tables]. +** +** These routines work only with [protected sqlite3_value] objects. +** Any attempt to use these routines on an [unprotected sqlite3_value] +** is not threadsafe. +** +** ^These routines work just like the corresponding [column access functions] +** except that these routines take a single [protected sqlite3_value] object +** pointer instead of a [sqlite3_stmt*] pointer and an integer column number. +** +** ^The sqlite3_value_text16() interface extracts a UTF-16 string +** in the native byte-order of the host machine. ^The +** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces +** extract UTF-16 strings as big-endian and little-endian respectively. +** +** ^If [sqlite3_value] object V was initialized +** using [sqlite3_bind_pointer(S,I,P,X,D)] or [sqlite3_result_pointer(C,P,X,D)] +** and if X and Y are strings that compare equal according to strcmp(X,Y), +** then sqlite3_value_pointer(V,Y) will return the pointer P. ^Otherwise, +** sqlite3_value_pointer(V,Y) returns a NULL. The sqlite3_bind_pointer() +** routine is part of the [pointer passing interface] added for SQLite 3.20.0. +** +** ^(The sqlite3_value_type(V) interface returns the +** [SQLITE_INTEGER | datatype code] for the initial datatype of the +** [sqlite3_value] object V. The returned value is one of [SQLITE_INTEGER], +** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL].)^ +** Other interfaces might change the datatype for an sqlite3_value object. +** For example, if the datatype is initially SQLITE_INTEGER and +** sqlite3_value_text(V) is called to extract a text value for that +** integer, then subsequent calls to sqlite3_value_type(V) might return +** SQLITE_TEXT. Whether or not a persistent internal datatype conversion +** occurs is undefined and may change from one release of SQLite to the next. +** +** ^(The sqlite3_value_numeric_type() interface attempts to apply +** numeric affinity to the value. This means that an attempt is +** made to convert the value to an integer or floating point. If +** such a conversion is possible without loss of information (in other +** words, if the value is a string that looks like a number) +** then the conversion is performed. Otherwise no conversion occurs. +** The [SQLITE_INTEGER | datatype] after conversion is returned.)^ +** +** ^Within the [xUpdate] method of a [virtual table], the +** sqlite3_value_nochange(X) interface returns true if and only if +** the column corresponding to X is unchanged by the UPDATE operation +** that the xUpdate method call was invoked to implement and if +** and the prior [xColumn] method call that was invoked to extracted +** the value for that column returned without setting a result (probably +** because it queried [sqlite3_vtab_nochange()] and found that the column +** was unchanging). ^Within an [xUpdate] method, any value for which +** sqlite3_value_nochange(X) is true will in all other respects appear +** to be a NULL value. If sqlite3_value_nochange(X) is invoked anywhere other +** than within an [xUpdate] method call for an UPDATE statement, then +** the return value is arbitrary and meaningless. +** +** ^The sqlite3_value_frombind(X) interface returns non-zero if the +** value X originated from one of the [sqlite3_bind_int|sqlite3_bind()] +** interfaces. ^If X comes from an SQL literal value, or a table column, +** or an expression, then sqlite3_value_frombind(X) returns zero. +** +** Please pay particular attention to the fact that the pointer returned +** from [sqlite3_value_blob()], [sqlite3_value_text()], or +** [sqlite3_value_text16()] can be invalidated by a subsequent call to +** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()], +** or [sqlite3_value_text16()]. +** +** These routines must be called from the same thread as +** the SQL function that supplied the [sqlite3_value*] parameters. +** +** As long as the input parameter is correct, these routines can only +** fail if an out-of-memory error occurs during a format conversion. +** Only the following subset of interfaces are subject to out-of-memory +** errors: +** +**
      +**
    • sqlite3_value_blob() +**
    • sqlite3_value_text() +**
    • sqlite3_value_text16() +**
    • sqlite3_value_text16le() +**
    • sqlite3_value_text16be() +**
    • sqlite3_value_bytes() +**
    • sqlite3_value_bytes16() +**
    +** +** If an out-of-memory error occurs, then the return value from these +** routines is the same as if the column had contained an SQL NULL value. +** Valid SQL NULL returns can be distinguished from out-of-memory errors +** by invoking the [sqlite3_errcode()] immediately after the suspect +** return value is obtained and before any +** other SQLite interface is called on the same [database connection]. +*/ +SQLITE_API const void *sqlite3_value_blob(sqlite3_value*); +SQLITE_API double sqlite3_value_double(sqlite3_value*); +SQLITE_API int sqlite3_value_int(sqlite3_value*); +SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value*); +SQLITE_API void *sqlite3_value_pointer(sqlite3_value*, const char*); +SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value*); +SQLITE_API const void *sqlite3_value_text16(sqlite3_value*); +SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*); +SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*); +SQLITE_API int sqlite3_value_bytes(sqlite3_value*); +SQLITE_API int sqlite3_value_bytes16(sqlite3_value*); +SQLITE_API int sqlite3_value_type(sqlite3_value*); +SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*); +SQLITE_API int sqlite3_value_nochange(sqlite3_value*); +SQLITE_API int sqlite3_value_frombind(sqlite3_value*); + +/* +** CAPI3REF: Finding The Subtype Of SQL Values +** METHOD: sqlite3_value +** +** The sqlite3_value_subtype(V) function returns the subtype for +** an [application-defined SQL function] argument V. The subtype +** information can be used to pass a limited amount of context from +** one SQL function to another. Use the [sqlite3_result_subtype()] +** routine to set the subtype for the return value of an SQL function. +*/ +SQLITE_API unsigned int sqlite3_value_subtype(sqlite3_value*); + +/* +** CAPI3REF: Copy And Free SQL Values +** METHOD: sqlite3_value +** +** ^The sqlite3_value_dup(V) interface makes a copy of the [sqlite3_value] +** object D and returns a pointer to that copy. ^The [sqlite3_value] returned +** is a [protected sqlite3_value] object even if the input is not. +** ^The sqlite3_value_dup(V) interface returns NULL if V is NULL or if a +** memory allocation fails. +** +** ^The sqlite3_value_free(V) interface frees an [sqlite3_value] object +** previously obtained from [sqlite3_value_dup()]. ^If V is a NULL pointer +** then sqlite3_value_free(V) is a harmless no-op. +*/ +SQLITE_API sqlite3_value *sqlite3_value_dup(const sqlite3_value*); +SQLITE_API void sqlite3_value_free(sqlite3_value*); + +/* +** CAPI3REF: Obtain Aggregate Function Context +** METHOD: sqlite3_context +** +** Implementations of aggregate SQL functions use this +** routine to allocate memory for storing their state. +** +** ^The first time the sqlite3_aggregate_context(C,N) routine is called +** for a particular aggregate function, SQLite allocates +** N bytes of memory, zeroes out that memory, and returns a pointer +** to the new memory. ^On second and subsequent calls to +** sqlite3_aggregate_context() for the same aggregate function instance, +** the same buffer is returned. Sqlite3_aggregate_context() is normally +** called once for each invocation of the xStep callback and then one +** last time when the xFinal callback is invoked. ^(When no rows match +** an aggregate query, the xStep() callback of the aggregate function +** implementation is never called and xFinal() is called exactly once. +** In those cases, sqlite3_aggregate_context() might be called for the +** first time from within xFinal().)^ +** +** ^The sqlite3_aggregate_context(C,N) routine returns a NULL pointer +** when first called if N is less than or equal to zero or if a memory +** allocate error occurs. +** +** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is +** determined by the N parameter on first successful call. Changing the +** value of N in any subsequent call to sqlite3_aggregate_context() within +** the same aggregate function instance will not resize the memory +** allocation.)^ Within the xFinal callback, it is customary to set +** N=0 in calls to sqlite3_aggregate_context(C,N) so that no +** pointless memory allocations occur. +** +** ^SQLite automatically frees the memory allocated by +** sqlite3_aggregate_context() when the aggregate query concludes. +** +** The first parameter must be a copy of the +** [sqlite3_context | SQL function context] that is the first parameter +** to the xStep or xFinal callback routine that implements the aggregate +** function. +** +** This routine must be called from the same thread in which +** the aggregate SQL function is running. +*/ +SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); + +/* +** CAPI3REF: User Data For Functions +** METHOD: sqlite3_context +** +** ^The sqlite3_user_data() interface returns a copy of +** the pointer that was the pUserData parameter (the 5th parameter) +** of the [sqlite3_create_function()] +** and [sqlite3_create_function16()] routines that originally +** registered the application defined function. +** +** This routine must be called from the same thread in which +** the application-defined function is running. +*/ +SQLITE_API void *sqlite3_user_data(sqlite3_context*); + +/* +** CAPI3REF: Database Connection For Functions +** METHOD: sqlite3_context +** +** ^The sqlite3_context_db_handle() interface returns a copy of +** the pointer to the [database connection] (the 1st parameter) +** of the [sqlite3_create_function()] +** and [sqlite3_create_function16()] routines that originally +** registered the application defined function. +*/ +SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*); + +/* +** CAPI3REF: Function Auxiliary Data +** METHOD: sqlite3_context +** +** These functions may be used by (non-aggregate) SQL functions to +** associate metadata with argument values. If the same value is passed to +** multiple invocations of the same SQL function during query execution, under +** some circumstances the associated metadata may be preserved. An example +** of where this might be useful is in a regular-expression matching +** function. The compiled version of the regular expression can be stored as +** metadata associated with the pattern string. +** Then as long as the pattern string remains the same, +** the compiled regular expression can be reused on multiple +** invocations of the same function. +** +** ^The sqlite3_get_auxdata(C,N) interface returns a pointer to the metadata +** associated by the sqlite3_set_auxdata(C,N,P,X) function with the Nth argument +** value to the application-defined function. ^N is zero for the left-most +** function argument. ^If there is no metadata +** associated with the function argument, the sqlite3_get_auxdata(C,N) interface +** returns a NULL pointer. +** +** ^The sqlite3_set_auxdata(C,N,P,X) interface saves P as metadata for the N-th +** argument of the application-defined function. ^Subsequent +** calls to sqlite3_get_auxdata(C,N) return P from the most recent +** sqlite3_set_auxdata(C,N,P,X) call if the metadata is still valid or +** NULL if the metadata has been discarded. +** ^After each call to sqlite3_set_auxdata(C,N,P,X) where X is not NULL, +** SQLite will invoke the destructor function X with parameter P exactly +** once, when the metadata is discarded. +** SQLite is free to discard the metadata at any time, including:
      +**
    • ^(when the corresponding function parameter changes)^, or +**
    • ^(when [sqlite3_reset()] or [sqlite3_finalize()] is called for the +** SQL statement)^, or +**
    • ^(when sqlite3_set_auxdata() is invoked again on the same +** parameter)^, or +**
    • ^(during the original sqlite3_set_auxdata() call when a memory +** allocation error occurs.)^
    +** +** Note the last bullet in particular. The destructor X in +** sqlite3_set_auxdata(C,N,P,X) might be called immediately, before the +** sqlite3_set_auxdata() interface even returns. Hence sqlite3_set_auxdata() +** should be called near the end of the function implementation and the +** function implementation should not make any use of P after +** sqlite3_set_auxdata() has been called. +** +** ^(In practice, metadata is preserved between function calls for +** function parameters that are compile-time constants, including literal +** values and [parameters] and expressions composed from the same.)^ +** +** The value of the N parameter to these interfaces should be non-negative. +** Future enhancements may make use of negative N values to define new +** kinds of function caching behavior. +** +** These routines must be called from the same thread in which +** the SQL function is running. +*/ +SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N); +SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*)); + + +/* +** CAPI3REF: Constants Defining Special Destructor Behavior +** +** These are special values for the destructor that is passed in as the +** final argument to routines like [sqlite3_result_blob()]. ^If the destructor +** argument is SQLITE_STATIC, it means that the content pointer is constant +** and will never change. It does not need to be destroyed. ^The +** SQLITE_TRANSIENT value means that the content will likely change in +** the near future and that SQLite should make its own private copy of +** the content before returning. +** +** The typedef is necessary to work around problems in certain +** C++ compilers. +*/ +typedef void (*sqlite3_destructor_type)(void*); +#define SQLITE_STATIC ((sqlite3_destructor_type)0) +#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1) + +/* +** CAPI3REF: Setting The Result Of An SQL Function +** METHOD: sqlite3_context +** +** These routines are used by the xFunc or xFinal callbacks that +** implement SQL functions and aggregates. See +** [sqlite3_create_function()] and [sqlite3_create_function16()] +** for additional information. +** +** These functions work very much like the [parameter binding] family of +** functions used to bind values to host parameters in prepared statements. +** Refer to the [SQL parameter] documentation for additional information. +** +** ^The sqlite3_result_blob() interface sets the result from +** an application-defined function to be the BLOB whose content is pointed +** to by the second parameter and which is N bytes long where N is the +** third parameter. +** +** ^The sqlite3_result_zeroblob(C,N) and sqlite3_result_zeroblob64(C,N) +** interfaces set the result of the application-defined function to be +** a BLOB containing all zero bytes and N bytes in size. +** +** ^The sqlite3_result_double() interface sets the result from +** an application-defined function to be a floating point value specified +** by its 2nd argument. +** +** ^The sqlite3_result_error() and sqlite3_result_error16() functions +** cause the implemented SQL function to throw an exception. +** ^SQLite uses the string pointed to by the +** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16() +** as the text of an error message. ^SQLite interprets the error +** message string from sqlite3_result_error() as UTF-8. ^SQLite +** interprets the string from sqlite3_result_error16() as UTF-16 using +** the same [byte-order determination rules] as [sqlite3_bind_text16()]. +** ^If the third parameter to sqlite3_result_error() +** or sqlite3_result_error16() is negative then SQLite takes as the error +** message all text up through the first zero character. +** ^If the third parameter to sqlite3_result_error() or +** sqlite3_result_error16() is non-negative then SQLite takes that many +** bytes (not characters) from the 2nd parameter as the error message. +** ^The sqlite3_result_error() and sqlite3_result_error16() +** routines make a private copy of the error message text before +** they return. Hence, the calling function can deallocate or +** modify the text after they return without harm. +** ^The sqlite3_result_error_code() function changes the error code +** returned by SQLite as a result of an error in a function. ^By default, +** the error code is SQLITE_ERROR. ^A subsequent call to sqlite3_result_error() +** or sqlite3_result_error16() resets the error code to SQLITE_ERROR. +** +** ^The sqlite3_result_error_toobig() interface causes SQLite to throw an +** error indicating that a string or BLOB is too long to represent. +** +** ^The sqlite3_result_error_nomem() interface causes SQLite to throw an +** error indicating that a memory allocation failed. +** +** ^The sqlite3_result_int() interface sets the return value +** of the application-defined function to be the 32-bit signed integer +** value given in the 2nd argument. +** ^The sqlite3_result_int64() interface sets the return value +** of the application-defined function to be the 64-bit signed integer +** value given in the 2nd argument. +** +** ^The sqlite3_result_null() interface sets the return value +** of the application-defined function to be NULL. +** +** ^The sqlite3_result_text(), sqlite3_result_text16(), +** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces +** set the return value of the application-defined function to be +** a text string which is represented as UTF-8, UTF-16 native byte order, +** UTF-16 little endian, or UTF-16 big endian, respectively. +** ^The sqlite3_result_text64() interface sets the return value of an +** application-defined function to be a text string in an encoding +** specified by the fifth (and last) parameter, which must be one +** of [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE]. +** ^SQLite takes the text result from the application from +** the 2nd parameter of the sqlite3_result_text* interfaces. +** ^If the 3rd parameter to the sqlite3_result_text* interfaces +** is negative, then SQLite takes result text from the 2nd parameter +** through the first zero character. +** ^If the 3rd parameter to the sqlite3_result_text* interfaces +** is non-negative, then as many bytes (not characters) of the text +** pointed to by the 2nd parameter are taken as the application-defined +** function result. If the 3rd parameter is non-negative, then it +** must be the byte offset into the string where the NUL terminator would +** appear if the string where NUL terminated. If any NUL characters occur +** in the string at a byte offset that is less than the value of the 3rd +** parameter, then the resulting string will contain embedded NULs and the +** result of expressions operating on strings with embedded NULs is undefined. +** ^If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that +** function as the destructor on the text or BLOB result when it has +** finished using that result. +** ^If the 4th parameter to the sqlite3_result_text* interfaces or to +** sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite +** assumes that the text or BLOB result is in constant space and does not +** copy the content of the parameter nor call a destructor on the content +** when it has finished using that result. +** ^If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT +** then SQLite makes a copy of the result into space obtained +** from [sqlite3_malloc()] before it returns. +** +** ^For the sqlite3_result_text16(), sqlite3_result_text16le(), and +** sqlite3_result_text16be() routines, and for sqlite3_result_text64() +** when the encoding is not UTF8, if the input UTF16 begins with a +** byte-order mark (BOM, U+FEFF) then the BOM is removed from the +** string and the rest of the string is interpreted according to the +** byte-order specified by the BOM. ^The byte-order specified by +** the BOM at the beginning of the text overrides the byte-order +** specified by the interface procedure. ^So, for example, if +** sqlite3_result_text16le() is invoked with text that begins +** with bytes 0xfe, 0xff (a big-endian byte-order mark) then the +** first two bytes of input are skipped and the remaining input +** is interpreted as UTF16BE text. +** +** ^For UTF16 input text to the sqlite3_result_text16(), +** sqlite3_result_text16be(), sqlite3_result_text16le(), and +** sqlite3_result_text64() routines, if the text contains invalid +** UTF16 characters, the invalid characters might be converted +** into the unicode replacement character, U+FFFD. +** +** ^The sqlite3_result_value() interface sets the result of +** the application-defined function to be a copy of the +** [unprotected sqlite3_value] object specified by the 2nd parameter. ^The +** sqlite3_result_value() interface makes a copy of the [sqlite3_value] +** so that the [sqlite3_value] specified in the parameter may change or +** be deallocated after sqlite3_result_value() returns without harm. +** ^A [protected sqlite3_value] object may always be used where an +** [unprotected sqlite3_value] object is required, so either +** kind of [sqlite3_value] object can be used with this interface. +** +** ^The sqlite3_result_pointer(C,P,T,D) interface sets the result to an +** SQL NULL value, just like [sqlite3_result_null(C)], except that it +** also associates the host-language pointer P or type T with that +** NULL value such that the pointer can be retrieved within an +** [application-defined SQL function] using [sqlite3_value_pointer()]. +** ^If the D parameter is not NULL, then it is a pointer to a destructor +** for the P parameter. ^SQLite invokes D with P as its only argument +** when SQLite is finished with P. The T parameter should be a static +** string and preferably a string literal. The sqlite3_result_pointer() +** routine is part of the [pointer passing interface] added for SQLite 3.20.0. +** +** If these routines are called from within the different thread +** than the one containing the application-defined function that received +** the [sqlite3_context] pointer, the results are undefined. +*/ +SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*)); +SQLITE_API void sqlite3_result_blob64(sqlite3_context*,const void*, + sqlite3_uint64,void(*)(void*)); +SQLITE_API void sqlite3_result_double(sqlite3_context*, double); +SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int); +SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int); +SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*); +SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*); +SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int); +SQLITE_API void sqlite3_result_int(sqlite3_context*, int); +SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64); +SQLITE_API void sqlite3_result_null(sqlite3_context*); +SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*)); +SQLITE_API void sqlite3_result_text64(sqlite3_context*, const char*,sqlite3_uint64, + void(*)(void*), unsigned char encoding); +SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); +SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); +SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); +SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*); +SQLITE_API void sqlite3_result_pointer(sqlite3_context*, void*,const char*,void(*)(void*)); +SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n); +SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context*, sqlite3_uint64 n); + + +/* +** CAPI3REF: Setting The Subtype Of An SQL Function +** METHOD: sqlite3_context +** +** The sqlite3_result_subtype(C,T) function causes the subtype of +** the result from the [application-defined SQL function] with +** [sqlite3_context] C to be the value T. Only the lower 8 bits +** of the subtype T are preserved in current versions of SQLite; +** higher order bits are discarded. +** The number of subtype bytes preserved by SQLite might increase +** in future releases of SQLite. +*/ +SQLITE_API void sqlite3_result_subtype(sqlite3_context*,unsigned int); + +/* +** CAPI3REF: Define New Collating Sequences +** METHOD: sqlite3 +** +** ^These functions add, remove, or modify a [collation] associated +** with the [database connection] specified as the first argument. +** +** ^The name of the collation is a UTF-8 string +** for sqlite3_create_collation() and sqlite3_create_collation_v2() +** and a UTF-16 string in native byte order for sqlite3_create_collation16(). +** ^Collation names that compare equal according to [sqlite3_strnicmp()] are +** considered to be the same name. +** +** ^(The third argument (eTextRep) must be one of the constants: +**
      +**
    • [SQLITE_UTF8], +**
    • [SQLITE_UTF16LE], +**
    • [SQLITE_UTF16BE], +**
    • [SQLITE_UTF16], or +**
    • [SQLITE_UTF16_ALIGNED]. +**
    )^ +** ^The eTextRep argument determines the encoding of strings passed +** to the collating function callback, xCompare. +** ^The [SQLITE_UTF16] and [SQLITE_UTF16_ALIGNED] values for eTextRep +** force strings to be UTF16 with native byte order. +** ^The [SQLITE_UTF16_ALIGNED] value for eTextRep forces strings to begin +** on an even byte address. +** +** ^The fourth argument, pArg, is an application data pointer that is passed +** through as the first argument to the collating function callback. +** +** ^The fifth argument, xCompare, is a pointer to the collating function. +** ^Multiple collating functions can be registered using the same name but +** with different eTextRep parameters and SQLite will use whichever +** function requires the least amount of data transformation. +** ^If the xCompare argument is NULL then the collating function is +** deleted. ^When all collating functions having the same name are deleted, +** that collation is no longer usable. +** +** ^The collating function callback is invoked with a copy of the pArg +** application data pointer and with two strings in the encoding specified +** by the eTextRep argument. The two integer parameters to the collating +** function callback are the length of the two strings, in bytes. The collating +** function must return an integer that is negative, zero, or positive +** if the first string is less than, equal to, or greater than the second, +** respectively. A collating function must always return the same answer +** given the same inputs. If two or more collating functions are registered +** to the same collation name (using different eTextRep values) then all +** must give an equivalent answer when invoked with equivalent strings. +** The collating function must obey the following properties for all +** strings A, B, and C: +** +**
      +**
    1. If A==B then B==A. +**
    2. If A==B and B==C then A==C. +**
    3. If A<B THEN B>A. +**
    4. If A<B and B<C then A<C. +**
    +** +** If a collating function fails any of the above constraints and that +** collating function is registered and used, then the behavior of SQLite +** is undefined. +** +** ^The sqlite3_create_collation_v2() works like sqlite3_create_collation() +** with the addition that the xDestroy callback is invoked on pArg when +** the collating function is deleted. +** ^Collating functions are deleted when they are overridden by later +** calls to the collation creation functions or when the +** [database connection] is closed using [sqlite3_close()]. +** +** ^The xDestroy callback is not called if the +** sqlite3_create_collation_v2() function fails. Applications that invoke +** sqlite3_create_collation_v2() with a non-NULL xDestroy argument should +** check the return code and dispose of the application data pointer +** themselves rather than expecting SQLite to deal with it for them. +** This is different from every other SQLite interface. The inconsistency +** is unfortunate but cannot be changed without breaking backwards +** compatibility. +** +** See also: [sqlite3_collation_needed()] and [sqlite3_collation_needed16()]. +*/ +SQLITE_API int sqlite3_create_collation( + sqlite3*, + const char *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*) +); +SQLITE_API int sqlite3_create_collation_v2( + sqlite3*, + const char *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDestroy)(void*) +); +SQLITE_API int sqlite3_create_collation16( + sqlite3*, + const void *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*) +); + +/* +** CAPI3REF: Collation Needed Callbacks +** METHOD: sqlite3 +** +** ^To avoid having to register all collation sequences before a database +** can be used, a single callback function may be registered with the +** [database connection] to be invoked whenever an undefined collation +** sequence is required. +** +** ^If the function is registered using the sqlite3_collation_needed() API, +** then it is passed the names of undefined collation sequences as strings +** encoded in UTF-8. ^If sqlite3_collation_needed16() is used, +** the names are passed as UTF-16 in machine native byte order. +** ^A call to either function replaces the existing collation-needed callback. +** +** ^(When the callback is invoked, the first argument passed is a copy +** of the second argument to sqlite3_collation_needed() or +** sqlite3_collation_needed16(). The second argument is the database +** connection. The third argument is one of [SQLITE_UTF8], [SQLITE_UTF16BE], +** or [SQLITE_UTF16LE], indicating the most desirable form of the collation +** sequence function required. The fourth parameter is the name of the +** required collation sequence.)^ +** +** The callback function should register the desired collation using +** [sqlite3_create_collation()], [sqlite3_create_collation16()], or +** [sqlite3_create_collation_v2()]. +*/ +SQLITE_API int sqlite3_collation_needed( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const char*) +); +SQLITE_API int sqlite3_collation_needed16( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const void*) +); + +#ifdef SQLITE_ENABLE_CEROD +/* +** Specify the activation key for a CEROD database. Unless +** activated, none of the CEROD routines will work. +*/ +SQLITE_API void sqlite3_activate_cerod( + const char *zPassPhrase /* Activation phrase */ +); +#endif + +/* +** CAPI3REF: Suspend Execution For A Short Time +** +** The sqlite3_sleep() function causes the current thread to suspend execution +** for at least a number of milliseconds specified in its parameter. +** +** If the operating system does not support sleep requests with +** millisecond time resolution, then the time will be rounded up to +** the nearest second. The number of milliseconds of sleep actually +** requested from the operating system is returned. +** +** ^SQLite implements this interface by calling the xSleep() +** method of the default [sqlite3_vfs] object. If the xSleep() method +** of the default VFS is not implemented correctly, or not implemented at +** all, then the behavior of sqlite3_sleep() may deviate from the description +** in the previous paragraphs. +*/ +SQLITE_API int sqlite3_sleep(int); + +/* +** CAPI3REF: Name Of The Folder Holding Temporary Files +** +** ^(If this global variable is made to point to a string which is +** the name of a folder (a.k.a. directory), then all temporary files +** created by SQLite when using a built-in [sqlite3_vfs | VFS] +** will be placed in that directory.)^ ^If this variable +** is a NULL pointer, then SQLite performs a search for an appropriate +** temporary file directory. +** +** Applications are strongly discouraged from using this global variable. +** It is required to set a temporary folder on Windows Runtime (WinRT). +** But for all other platforms, it is highly recommended that applications +** neither read nor write this variable. This global variable is a relic +** that exists for backwards compatibility of legacy applications and should +** be avoided in new projects. +** +** It is not safe to read or modify this variable in more than one +** thread at a time. It is not safe to read or modify this variable +** if a [database connection] is being used at the same time in a separate +** thread. +** It is intended that this variable be set once +** as part of process initialization and before any SQLite interface +** routines have been called and that this variable remain unchanged +** thereafter. +** +** ^The [temp_store_directory pragma] may modify this variable and cause +** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore, +** the [temp_store_directory pragma] always assumes that any string +** that this variable points to is held in memory obtained from +** [sqlite3_malloc] and the pragma may attempt to free that memory +** using [sqlite3_free]. +** Hence, if this variable is modified directly, either it should be +** made NULL or made to point to memory obtained from [sqlite3_malloc] +** or else the use of the [temp_store_directory pragma] should be avoided. +** Except when requested by the [temp_store_directory pragma], SQLite +** does not free the memory that sqlite3_temp_directory points to. If +** the application wants that memory to be freed, it must do +** so itself, taking care to only do so after all [database connection] +** objects have been destroyed. +** +** Note to Windows Runtime users: The temporary directory must be set +** prior to calling [sqlite3_open] or [sqlite3_open_v2]. Otherwise, various +** features that require the use of temporary files may fail. Here is an +** example of how to do this using C++ with the Windows Runtime: +** +** 
    +** LPCWSTR zPath = Windows::Storage::ApplicationData::Current->
+**       TemporaryFolder->Path->Data();
+** char zPathBuf[MAX_PATH + 1];
+** memset(zPathBuf, 0, sizeof(zPathBuf));
+** WideCharToMultiByte(CP_UTF8, 0, zPath, -1, zPathBuf, sizeof(zPathBuf),
+**       NULL, NULL);
+** sqlite3_temp_directory = sqlite3_mprintf("%s", zPathBuf);
+**
    +*/ +SQLITE_API char *sqlite3_temp_directory; + +/* +** CAPI3REF: Name Of The Folder Holding Database Files +** +** ^(If this global variable is made to point to a string which is +** the name of a folder (a.k.a. directory), then all database files +** specified with a relative pathname and created or accessed by +** SQLite when using a built-in windows [sqlite3_vfs | VFS] will be assumed +** to be relative to that directory.)^ ^If this variable is a NULL +** pointer, then SQLite assumes that all database files specified +** with a relative pathname are relative to the current directory +** for the process. Only the windows VFS makes use of this global +** variable; it is ignored by the unix VFS. +** +** Changing the value of this variable while a database connection is +** open can result in a corrupt database. +** +** It is not safe to read or modify this variable in more than one +** thread at a time. It is not safe to read or modify this variable +** if a [database connection] is being used at the same time in a separate +** thread. +** It is intended that this variable be set once +** as part of process initialization and before any SQLite interface +** routines have been called and that this variable remain unchanged +** thereafter. +** +** ^The [data_store_directory pragma] may modify this variable and cause +** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore, +** the [data_store_directory pragma] always assumes that any string +** that this variable points to is held in memory obtained from +** [sqlite3_malloc] and the pragma may attempt to free that memory +** using [sqlite3_free]. +** Hence, if this variable is modified directly, either it should be +** made NULL or made to point to memory obtained from [sqlite3_malloc] +** or else the use of the [data_store_directory pragma] should be avoided. +*/ +SQLITE_API char *sqlite3_data_directory; + +/* +** CAPI3REF: Win32 Specific Interface +** +** These interfaces are available only on Windows. The +** [sqlite3_win32_set_directory] interface is used to set the value associated +** with the [sqlite3_temp_directory] or [sqlite3_data_directory] variable, to +** zValue, depending on the value of the type parameter. The zValue parameter +** should be NULL to cause the previous value to be freed via [sqlite3_free]; +** a non-NULL value will be copied into memory obtained from [sqlite3_malloc] +** prior to being used. The [sqlite3_win32_set_directory] interface returns +** [SQLITE_OK] to indicate success, [SQLITE_ERROR] if the type is unsupported, +** or [SQLITE_NOMEM] if memory could not be allocated. The value of the +** [sqlite3_data_directory] variable is intended to act as a replacement for +** the current directory on the sub-platforms of Win32 where that concept is +** not present, e.g. WinRT and UWP. The [sqlite3_win32_set_directory8] and +** [sqlite3_win32_set_directory16] interfaces behave exactly the same as the +** sqlite3_win32_set_directory interface except the string parameter must be +** UTF-8 or UTF-16, respectively. +*/ +SQLITE_API int sqlite3_win32_set_directory( + unsigned long type, /* Identifier for directory being set or reset */ + void *zValue /* New value for directory being set or reset */ +); +SQLITE_API int sqlite3_win32_set_directory8(unsigned long type, const char *zValue); +SQLITE_API int sqlite3_win32_set_directory16(unsigned long type, const void *zValue); + +/* +** CAPI3REF: Win32 Directory Types +** +** These macros are only available on Windows. They define the allowed values +** for the type argument to the [sqlite3_win32_set_directory] interface. +*/ +#define SQLITE_WIN32_DATA_DIRECTORY_TYPE 1 +#define SQLITE_WIN32_TEMP_DIRECTORY_TYPE 2 + +/* +** CAPI3REF: Test For Auto-Commit Mode +** KEYWORDS: {autocommit mode} +** METHOD: sqlite3 +** +** ^The sqlite3_get_autocommit() interface returns non-zero or +** zero if the given database connection is or is not in autocommit mode, +** respectively. ^Autocommit mode is on by default. +** ^Autocommit mode is disabled by a [BEGIN] statement. +** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK]. +** +** If certain kinds of errors occur on a statement within a multi-statement +** transaction (errors including [SQLITE_FULL], [SQLITE_IOERR], +** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the +** transaction might be rolled back automatically. The only way to +** find out whether SQLite automatically rolled back the transaction after +** an error is to use this function. +** +** If another thread changes the autocommit status of the database +** connection while this routine is running, then the return value +** is undefined. +*/ +SQLITE_API int sqlite3_get_autocommit(sqlite3*); + +/* +** CAPI3REF: Find The Database Handle Of A Prepared Statement +** METHOD: sqlite3_stmt +** +** ^The sqlite3_db_handle interface returns the [database connection] handle +** to which a [prepared statement] belongs. ^The [database connection] +** returned by sqlite3_db_handle is the same [database connection] +** that was the first argument +** to the [sqlite3_prepare_v2()] call (or its variants) that was used to +** create the statement in the first place. +*/ +SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*); + +/* +** CAPI3REF: Return The Filename For A Database Connection +** METHOD: sqlite3 +** +** ^The sqlite3_db_filename(D,N) interface returns a pointer to the filename +** associated with database N of connection D. +** ^If there is no attached database N on the database +** connection D, or if database N is a temporary or in-memory database, then +** this function will return either a NULL pointer or an empty string. +** +** ^The string value returned by this routine is owned and managed by +** the database connection. ^The value will be valid until the database N +** is [DETACH]-ed or until the database connection closes. +** +** ^The filename returned by this function is the output of the +** xFullPathname method of the [VFS]. ^In other words, the filename +** will be an absolute pathname, even if the filename used +** to open the database originally was a URI or relative pathname. +** +** If the filename pointer returned by this routine is not NULL, then it +** can be used as the filename input parameter to these routines: +**
      +**
    • [sqlite3_uri_parameter()] +**
    • [sqlite3_uri_boolean()] +**
    • [sqlite3_uri_int64()] +**
    • [sqlite3_filename_database()] +**
    • [sqlite3_filename_journal()] +**
    • [sqlite3_filename_wal()] +**
    +*/ +SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName); + +/* +** CAPI3REF: Determine if a database is read-only +** METHOD: sqlite3 +** +** ^The sqlite3_db_readonly(D,N) interface returns 1 if the database N +** of connection D is read-only, 0 if it is read/write, or -1 if N is not +** the name of a database on connection D. +*/ +SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName); + +/* +** CAPI3REF: Determine the transaction state of a database +** METHOD: sqlite3 +** +** ^The sqlite3_txn_state(D,S) interface returns the current +** [transaction state] of schema S in database connection D. ^If S is NULL, +** then the highest transaction state of any schema on database connection D +** is returned. Transaction states are (in order of lowest to highest): +**
      +**
    1. SQLITE_TXN_NONE +**
    2. SQLITE_TXN_READ +**
    3. SQLITE_TXN_WRITE +**
    +** ^If the S argument to sqlite3_txn_state(D,S) is not the name of +** a valid schema, then -1 is returned. +*/ +SQLITE_API int sqlite3_txn_state(sqlite3*,const char *zSchema); + +/* +** CAPI3REF: Allowed return values from [sqlite3_txn_state()] +** KEYWORDS: {transaction state} +** +** These constants define the current transaction state of a database file. +** ^The [sqlite3_txn_state(D,S)] interface returns one of these +** constants in order to describe the transaction state of schema S +** in [database connection] D. +** +**
    +** [[SQLITE_TXN_NONE]]
    SQLITE_TXN_NONE
    +**
    The SQLITE_TXN_NONE state means that no transaction is currently +** pending.
    +** +** [[SQLITE_TXN_READ]]
    SQLITE_TXN_READ
    +**
    The SQLITE_TXN_READ state means that the database is currently +** in a read transaction. Content has been read from the database file +** but nothing in the database file has changed. The transaction state +** will advanced to SQLITE_TXN_WRITE if any changes occur and there are +** no other conflicting concurrent write transactions. The transaction +** state will revert to SQLITE_TXN_NONE following a [ROLLBACK] or +** [COMMIT].
    +** +** [[SQLITE_TXN_WRITE]]
    SQLITE_TXN_WRITE
    +**
    The SQLITE_TXN_WRITE state means that the database is currently +** in a write transaction. Content has been written to the database file +** but has not yet committed. The transaction state will change to +** to SQLITE_TXN_NONE at the next [ROLLBACK] or [COMMIT].
    +*/ +#define SQLITE_TXN_NONE 0 +#define SQLITE_TXN_READ 1 +#define SQLITE_TXN_WRITE 2 + +/* +** CAPI3REF: Find the next prepared statement +** METHOD: sqlite3 +** +** ^This interface returns a pointer to the next [prepared statement] after +** pStmt associated with the [database connection] pDb. ^If pStmt is NULL +** then this interface returns a pointer to the first prepared statement +** associated with the database connection pDb. ^If no prepared statement +** satisfies the conditions of this routine, it returns NULL. +** +** The [database connection] pointer D in a call to +** [sqlite3_next_stmt(D,S)] must refer to an open database +** connection and in particular must not be a NULL pointer. +*/ +SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Commit And Rollback Notification Callbacks +** METHOD: sqlite3 +** +** ^The sqlite3_commit_hook() interface registers a callback +** function to be invoked whenever a transaction is [COMMIT | committed]. +** ^Any callback set by a previous call to sqlite3_commit_hook() +** for the same database connection is overridden. +** ^The sqlite3_rollback_hook() interface registers a callback +** function to be invoked whenever a transaction is [ROLLBACK | rolled back]. +** ^Any callback set by a previous call to sqlite3_rollback_hook() +** for the same database connection is overridden. +** ^The pArg argument is passed through to the callback. +** ^If the callback on a commit hook function returns non-zero, +** then the commit is converted into a rollback. +** +** ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions +** return the P argument from the previous call of the same function +** on the same [database connection] D, or NULL for +** the first call for each function on D. +** +** The commit and rollback hook callbacks are not reentrant. +** The callback implementation must not do anything that will modify +** the database connection that invoked the callback. Any actions +** to modify the database connection must be deferred until after the +** completion of the [sqlite3_step()] call that triggered the commit +** or rollback hook in the first place. +** Note that running any other SQL statements, including SELECT statements, +** or merely calling [sqlite3_prepare_v2()] and [sqlite3_step()] will modify +** the database connections for the meaning of "modify" in this paragraph. +** +** ^Registering a NULL function disables the callback. +** +** ^When the commit hook callback routine returns zero, the [COMMIT] +** operation is allowed to continue normally. ^If the commit hook +** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK]. +** ^The rollback hook is invoked on a rollback that results from a commit +** hook returning non-zero, just as it would be with any other rollback. +** +** ^For the purposes of this API, a transaction is said to have been +** rolled back if an explicit "ROLLBACK" statement is executed, or +** an error or constraint causes an implicit rollback to occur. +** ^The rollback callback is not invoked if a transaction is +** automatically rolled back because the database connection is closed. +** +** See also the [sqlite3_update_hook()] interface. +*/ +SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); +SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); + +/* +** CAPI3REF: Data Change Notification Callbacks +** METHOD: sqlite3 +** +** ^The sqlite3_update_hook() interface registers a callback function +** with the [database connection] identified by the first argument +** to be invoked whenever a row is updated, inserted or deleted in +** a [rowid table]. +** ^Any callback set by a previous call to this function +** for the same database connection is overridden. +** +** ^The second argument is a pointer to the function to invoke when a +** row is updated, inserted or deleted in a rowid table. +** ^The first argument to the callback is a copy of the third argument +** to sqlite3_update_hook(). +** ^The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE], +** or [SQLITE_UPDATE], depending on the operation that caused the callback +** to be invoked. +** ^The third and fourth arguments to the callback contain pointers to the +** database and table name containing the affected row. +** ^The final callback parameter is the [rowid] of the row. +** ^In the case of an update, this is the [rowid] after the update takes place. +** +** ^(The update hook is not invoked when internal system tables are +** modified (i.e. sqlite_sequence).)^ +** ^The update hook is not invoked when [WITHOUT ROWID] tables are modified. +** +** ^In the current implementation, the update hook +** is not invoked when conflicting rows are deleted because of an +** [ON CONFLICT | ON CONFLICT REPLACE] clause. ^Nor is the update hook +** invoked when rows are deleted using the [truncate optimization]. +** The exceptions defined in this paragraph might change in a future +** release of SQLite. +** +** The update hook implementation must not do anything that will modify +** the database connection that invoked the update hook. Any actions +** to modify the database connection must be deferred until after the +** completion of the [sqlite3_step()] call that triggered the update hook. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +** ^The sqlite3_update_hook(D,C,P) function +** returns the P argument from the previous call +** on the same [database connection] D, or NULL for +** the first call on D. +** +** See also the [sqlite3_commit_hook()], [sqlite3_rollback_hook()], +** and [sqlite3_preupdate_hook()] interfaces. +*/ +SQLITE_API void *sqlite3_update_hook( + sqlite3*, + void(*)(void *,int ,char const *,char const *,sqlite3_int64), + void* +); + +/* +** CAPI3REF: Enable Or Disable Shared Pager Cache +** +** ^(This routine enables or disables the sharing of the database cache +** and schema data structures between [database connection | connections] +** to the same database. Sharing is enabled if the argument is true +** and disabled if the argument is false.)^ +** +** ^Cache sharing is enabled and disabled for an entire process. +** This is a change as of SQLite [version 3.5.0] ([dateof:3.5.0]). +** In prior versions of SQLite, +** sharing was enabled or disabled for each thread separately. +** +** ^(The cache sharing mode set by this interface effects all subsequent +** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()]. +** Existing database connections continue to use the sharing mode +** that was in effect at the time they were opened.)^ +** +** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled +** successfully. An [error code] is returned otherwise.)^ +** +** ^Shared cache is disabled by default. It is recommended that it stay +** that way. In other words, do not use this routine. This interface +** continues to be provided for historical compatibility, but its use is +** discouraged. Any use of shared cache is discouraged. If shared cache +** must be used, it is recommended that shared cache only be enabled for +** individual database connections using the [sqlite3_open_v2()] interface +** with the [SQLITE_OPEN_SHAREDCACHE] flag. +** +** Note: This method is disabled on MacOS X 10.7 and iOS version 5.0 +** and will always return SQLITE_MISUSE. On those systems, +** shared cache mode should be enabled per-database connection via +** [sqlite3_open_v2()] with [SQLITE_OPEN_SHAREDCACHE]. +** +** This interface is threadsafe on processors where writing a +** 32-bit integer is atomic. +** +** See Also: [SQLite Shared-Cache Mode] +*/ +SQLITE_API int sqlite3_enable_shared_cache(int); + +/* +** CAPI3REF: Attempt To Free Heap Memory +** +** ^The sqlite3_release_memory() interface attempts to free N bytes +** of heap memory by deallocating non-essential memory allocations +** held by the database library. Memory used to cache database +** pages to improve performance is an example of non-essential memory. +** ^sqlite3_release_memory() returns the number of bytes actually freed, +** which might be more or less than the amount requested. +** ^The sqlite3_release_memory() routine is a no-op returning zero +** if SQLite is not compiled with [SQLITE_ENABLE_MEMORY_MANAGEMENT]. +** +** See also: [sqlite3_db_release_memory()] +*/ +SQLITE_API int sqlite3_release_memory(int); + +/* +** CAPI3REF: Free Memory Used By A Database Connection +** METHOD: sqlite3 +** +** ^The sqlite3_db_release_memory(D) interface attempts to free as much heap +** memory as possible from database connection D. Unlike the +** [sqlite3_release_memory()] interface, this interface is in effect even +** when the [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is +** omitted. +** +** See also: [sqlite3_release_memory()] +*/ +SQLITE_API int sqlite3_db_release_memory(sqlite3*); + +/* +** CAPI3REF: Impose A Limit On Heap Size +** +** These interfaces impose limits on the amount of heap memory that will be +** by all database connections within a single process. +** +** ^The sqlite3_soft_heap_limit64() interface sets and/or queries the +** soft limit on the amount of heap memory that may be allocated by SQLite. +** ^SQLite strives to keep heap memory utilization below the soft heap +** limit by reducing the number of pages held in the page cache +** as heap memory usages approaches the limit. +** ^The soft heap limit is "soft" because even though SQLite strives to stay +** below the limit, it will exceed the limit rather than generate +** an [SQLITE_NOMEM] error. In other words, the soft heap limit +** is advisory only. +** +** ^The sqlite3_hard_heap_limit64(N) interface sets a hard upper bound of +** N bytes on the amount of memory that will be allocated. ^The +** sqlite3_hard_heap_limit64(N) interface is similar to +** sqlite3_soft_heap_limit64(N) except that memory allocations will fail +** when the hard heap limit is reached. +** +** ^The return value from both sqlite3_soft_heap_limit64() and +** sqlite3_hard_heap_limit64() is the size of +** the heap limit prior to the call, or negative in the case of an +** error. ^If the argument N is negative +** then no change is made to the heap limit. Hence, the current +** size of heap limits can be determined by invoking +** sqlite3_soft_heap_limit64(-1) or sqlite3_hard_heap_limit(-1). +** +** ^Setting the heap limits to zero disables the heap limiter mechanism. +** +** ^The soft heap limit may not be greater than the hard heap limit. +** ^If the hard heap limit is enabled and if sqlite3_soft_heap_limit(N) +** is invoked with a value of N that is greater than the hard heap limit, +** the the soft heap limit is set to the value of the hard heap limit. +** ^The soft heap limit is automatically enabled whenever the hard heap +** limit is enabled. ^When sqlite3_hard_heap_limit64(N) is invoked and +** the soft heap limit is outside the range of 1..N, then the soft heap +** limit is set to N. ^Invoking sqlite3_soft_heap_limit64(0) when the +** hard heap limit is enabled makes the soft heap limit equal to the +** hard heap limit. +** +** The memory allocation limits can also be adjusted using +** [PRAGMA soft_heap_limit] and [PRAGMA hard_heap_limit]. +** +** ^(The heap limits are not enforced in the current implementation +** if one or more of following conditions are true: +** +**
      +**
    • The limit value is set to zero. +**
    • Memory accounting is disabled using a combination of the +** [sqlite3_config]([SQLITE_CONFIG_MEMSTATUS],...) start-time option and +** the [SQLITE_DEFAULT_MEMSTATUS] compile-time option. +**
    • An alternative page cache implementation is specified using +** [sqlite3_config]([SQLITE_CONFIG_PCACHE2],...). +**
    • The page cache allocates from its own memory pool supplied +** by [sqlite3_config]([SQLITE_CONFIG_PAGECACHE],...) rather than +** from the heap. +**
    )^ +** +** The circumstances under which SQLite will enforce the heap limits may +** changes in future releases of SQLite. +*/ +SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N); +SQLITE_API sqlite3_int64 sqlite3_hard_heap_limit64(sqlite3_int64 N); + +/* +** CAPI3REF: Deprecated Soft Heap Limit Interface +** DEPRECATED +** +** This is a deprecated version of the [sqlite3_soft_heap_limit64()] +** interface. This routine is provided for historical compatibility +** only. All new applications should use the +** [sqlite3_soft_heap_limit64()] interface rather than this one. +*/ +SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N); + + +/* +** CAPI3REF: Extract Metadata About A Column Of A Table +** METHOD: sqlite3 +** +** ^(The sqlite3_table_column_metadata(X,D,T,C,....) routine returns +** information about column C of table T in database D +** on [database connection] X.)^ ^The sqlite3_table_column_metadata() +** interface returns SQLITE_OK and fills in the non-NULL pointers in +** the final five arguments with appropriate values if the specified +** column exists. ^The sqlite3_table_column_metadata() interface returns +** SQLITE_ERROR if the specified column does not exist. +** ^If the column-name parameter to sqlite3_table_column_metadata() is a +** NULL pointer, then this routine simply checks for the existence of the +** table and returns SQLITE_OK if the table exists and SQLITE_ERROR if it +** does not. If the table name parameter T in a call to +** sqlite3_table_column_metadata(X,D,T,C,...) is NULL then the result is +** undefined behavior. +** +** ^The column is identified by the second, third and fourth parameters to +** this function. ^(The second parameter is either the name of the database +** (i.e. "main", "temp", or an attached database) containing the specified +** table or NULL.)^ ^If it is NULL, then all attached databases are searched +** for the table using the same algorithm used by the database engine to +** resolve unqualified table references. +** +** ^The third and fourth parameters to this function are the table and column +** name of the desired column, respectively. +** +** ^Metadata is returned by writing to the memory locations passed as the 5th +** and subsequent parameters to this function. ^Any of these arguments may be +** NULL, in which case the corresponding element of metadata is omitted. +** +** ^(
    +** +**
    Parameter Output
    Type     		Description +** +**
    5th const char* Data type +**
    6th const char* Name of default collation sequence +**
    7th int True if column has a NOT NULL constraint +**
    8th int True if column is part of the PRIMARY KEY +**
    9th int True if column is [AUTOINCREMENT] +**
    +**
    )^ +** +** ^The memory pointed to by the character pointers returned for the +** declaration type and collation sequence is valid until the next +** call to any SQLite API function. +** +** ^If the specified table is actually a view, an [error code] is returned. +** +** ^If the specified column is "rowid", "oid" or "_rowid_" and the table +** is not a [WITHOUT ROWID] table and an +** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output +** parameters are set for the explicitly declared column. ^(If there is no +** [INTEGER PRIMARY KEY] column, then the outputs +** for the [rowid] are set as follows: +** +** 
    +**     data type: "INTEGER"
+**     collation sequence: "BINARY"
+**     not null: 0
+**     primary key: 1
+**     auto increment: 0
+**
    )^ +** +** ^This function causes all database schemas to be read from disk and +** parsed, if that has not already been done, and returns an error if +** any errors are encountered while loading the schema. +*/ +SQLITE_API int sqlite3_table_column_metadata( + sqlite3 *db, /* Connection handle */ + const char *zDbName, /* Database name or NULL */ + const char *zTableName, /* Table name */ + const char *zColumnName, /* Column name */ + char const **pzDataType, /* OUTPUT: Declared data type */ + char const **pzCollSeq, /* OUTPUT: Collation sequence name */ + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ + int *pPrimaryKey, /* OUTPUT: True if column part of PK */ + int *pAutoinc /* OUTPUT: True if column is auto-increment */ +); + +/* +** CAPI3REF: Load An Extension +** METHOD: sqlite3 +** +** ^This interface loads an SQLite extension library from the named file. +** +** ^The sqlite3_load_extension() interface attempts to load an +** [SQLite extension] library contained in the file zFile. If +** the file cannot be loaded directly, attempts are made to load +** with various operating-system specific extensions added. +** So for example, if "samplelib" cannot be loaded, then names like +** "samplelib.so" or "samplelib.dylib" or "samplelib.dll" might +** be tried also. +** +** ^The entry point is zProc. +** ^(zProc may be 0, in which case SQLite will try to come up with an +** entry point name on its own. It first tries "sqlite3_extension_init". +** If that does not work, it constructs a name "sqlite3_X_init" where the +** X is consists of the lower-case equivalent of all ASCII alphabetic +** characters in the filename from the last "/" to the first following +** "." and omitting any initial "lib".)^ +** ^The sqlite3_load_extension() interface returns +** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong. +** ^If an error occurs and pzErrMsg is not 0, then the +** [sqlite3_load_extension()] interface shall attempt to +** fill *pzErrMsg with error message text stored in memory +** obtained from [sqlite3_malloc()]. The calling function +** should free this memory by calling [sqlite3_free()]. +** +** ^Extension loading must be enabled using +** [sqlite3_enable_load_extension()] or +** [sqlite3_db_config](db,[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION],1,NULL) +** prior to calling this API, +** otherwise an error will be returned. +** +** Security warning: It is recommended that the +** [SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION] method be used to enable only this +** interface. The use of the [sqlite3_enable_load_extension()] interface +** should be avoided. This will keep the SQL function [load_extension()] +** disabled and prevent SQL injections from giving attackers +** access to extension loading capabilities. +** +** See also the [load_extension() SQL function]. +*/ +SQLITE_API int sqlite3_load_extension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Derived from zFile if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +); + +/* +** CAPI3REF: Enable Or Disable Extension Loading +** METHOD: sqlite3 +** +** ^So as not to open security holes in older applications that are +** unprepared to deal with [extension loading], and as a means of disabling +** [extension loading] while evaluating user-entered SQL, the following API +** is provided to turn the [sqlite3_load_extension()] mechanism on and off. +** +** ^Extension loading is off by default. +** ^Call the sqlite3_enable_load_extension() routine with onoff==1 +** to turn extension loading on and call it with onoff==0 to turn +** it back off again. +** +** ^This interface enables or disables both the C-API +** [sqlite3_load_extension()] and the SQL function [load_extension()]. +** ^(Use [sqlite3_db_config](db,[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION],..) +** to enable or disable only the C-API.)^ +** +** Security warning: It is recommended that extension loading +** be enabled using the [SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION] method +** rather than this interface, so the [load_extension()] SQL function +** remains disabled. This will prevent SQL injections from giving attackers +** access to extension loading capabilities. +*/ +SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff); + +/* +** CAPI3REF: Automatically Load Statically Linked Extensions +** +** ^This interface causes the xEntryPoint() function to be invoked for +** each new [database connection] that is created. The idea here is that +** xEntryPoint() is the entry point for a statically linked [SQLite extension] +** that is to be automatically loaded into all new database connections. +** +** ^(Even though the function prototype shows that xEntryPoint() takes +** no arguments and returns void, SQLite invokes xEntryPoint() with three +** arguments and expects an integer result as if the signature of the +** entry point where as follows: +** +** 
    +**    int xEntryPoint(
+**      sqlite3 *db,
+**      const char **pzErrMsg,
+**      const struct sqlite3_api_routines *pThunk
+**    );
+**
    )^ +** +** If the xEntryPoint routine encounters an error, it should make *pzErrMsg +** point to an appropriate error message (obtained from [sqlite3_mprintf()]) +** and return an appropriate [error code]. ^SQLite ensures that *pzErrMsg +** is NULL before calling the xEntryPoint(). ^SQLite will invoke +** [sqlite3_free()] on *pzErrMsg after xEntryPoint() returns. ^If any +** xEntryPoint() returns an error, the [sqlite3_open()], [sqlite3_open16()], +** or [sqlite3_open_v2()] call that provoked the xEntryPoint() will fail. +** +** ^Calling sqlite3_auto_extension(X) with an entry point X that is already +** on the list of automatic extensions is a harmless no-op. ^No entry point +** will be called more than once for each database connection that is opened. +** +** See also: [sqlite3_reset_auto_extension()] +** and [sqlite3_cancel_auto_extension()] +*/ +SQLITE_API int sqlite3_auto_extension(void(*xEntryPoint)(void)); + +/* +** CAPI3REF: Cancel Automatic Extension Loading +** +** ^The [sqlite3_cancel_auto_extension(X)] interface unregisters the +** initialization routine X that was registered using a prior call to +** [sqlite3_auto_extension(X)]. ^The [sqlite3_cancel_auto_extension(X)] +** routine returns 1 if initialization routine X was successfully +** unregistered and it returns 0 if X was not on the list of initialization +** routines. +*/ +SQLITE_API int sqlite3_cancel_auto_extension(void(*xEntryPoint)(void)); + +/* +** CAPI3REF: Reset Automatic Extension Loading +** +** ^This interface disables all automatic extensions previously +** registered using [sqlite3_auto_extension()]. +*/ +SQLITE_API 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 +*/ +typedef struct sqlite3_vtab sqlite3_vtab; +typedef struct sqlite3_index_info sqlite3_index_info; +typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor; +typedef struct sqlite3_module sqlite3_module; + +/* +** CAPI3REF: Virtual Table Object +** KEYWORDS: sqlite3_module {virtual table module} +** +** This structure, sometimes called a "virtual table module", +** defines the implementation of a [virtual table]. +** This structure consists mostly of methods for the module. +** +** ^A virtual table module is created by filling in a persistent +** instance of this structure and passing a pointer to that instance +** to [sqlite3_create_module()] or [sqlite3_create_module_v2()]. +** ^The registration remains valid until it is replaced by a different +** module or until the [database connection] closes. The content +** of this structure must not change while it is registered with +** any database connection. +*/ +struct sqlite3_module { + int iVersion; + int (*xCreate)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xConnect)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*); + int (*xDisconnect)(sqlite3_vtab *pVTab); + int (*xDestroy)(sqlite3_vtab *pVTab); + int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor); + int (*xClose)(sqlite3_vtab_cursor*); + int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr, + int argc, sqlite3_value **argv); + int (*xNext)(sqlite3_vtab_cursor*); + int (*xEof)(sqlite3_vtab_cursor*); + int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int); + int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid); + int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *); + int (*xBegin)(sqlite3_vtab *pVTab); + int (*xSync)(sqlite3_vtab *pVTab); + int (*xCommit)(sqlite3_vtab *pVTab); + int (*xRollback)(sqlite3_vtab *pVTab); + int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName, + void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), + void **ppArg); + int (*xRename)(sqlite3_vtab *pVtab, const char *zNew); + /* The methods above are in version 1 of the sqlite_module object. Those + ** below are for version 2 and greater. */ + int (*xSavepoint)(sqlite3_vtab *pVTab, int); + int (*xRelease)(sqlite3_vtab *pVTab, int); + int (*xRollbackTo)(sqlite3_vtab *pVTab, int); + /* The methods above are in versions 1 and 2 of the sqlite_module object. + ** Those below are for version 3 and greater. */ + int (*xShadowName)(const char*); +}; + +/* +** CAPI3REF: Virtual Table Indexing Information +** KEYWORDS: sqlite3_index_info +** +** The sqlite3_index_info structure and its substructures is used as part +** of the [virtual table] interface to +** pass information into and receive the reply from the [xBestIndex] +** method of a [virtual table module]. The fields under **Inputs** are the +** inputs to xBestIndex and are read-only. xBestIndex inserts its +** results into the **Outputs** fields. +** +** ^(The aConstraint[] array records WHERE clause constraints of the form: +** +**
    column OP expr
    +** +** where OP is =, <, <=, >, or >=.)^ ^(The particular operator is +** stored in aConstraint[].op using one of the +** [SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_ values].)^ +** ^(The index of the column is stored in +** aConstraint[].iColumn.)^ ^(aConstraint[].usable is TRUE if the +** expr on the right-hand side can be evaluated (and thus the constraint +** is usable) and false if it cannot.)^ +** +** ^The optimizer automatically inverts terms of the form "expr OP column" +** and makes other simplifications to the WHERE clause in an attempt to +** get as many WHERE clause terms into the form shown above as possible. +** ^The aConstraint[] array only reports WHERE clause terms that are +** relevant to the particular virtual table being queried. +** +** ^Information about the ORDER BY clause is stored in aOrderBy[]. +** ^Each term of aOrderBy records a column of the ORDER BY clause. +** +** The colUsed field indicates which columns of the virtual table may be +** required by the current scan. Virtual table columns are numbered from +** zero in the order in which they appear within the CREATE TABLE statement +** passed to sqlite3_declare_vtab(). For the first 63 columns (columns 0-62), +** the corresponding bit is set within the colUsed mask if the column may be +** required by SQLite. If the table has at least 64 columns and any column +** to the right of the first 63 is required, then bit 63 of colUsed is also +** set. In other words, column iCol may be required if the expression +** (colUsed & ((sqlite3_uint64)1 << (iCol>=63 ? 63 : iCol))) evaluates to +** non-zero. +** +** The [xBestIndex] method must fill aConstraintUsage[] with information +** about what parameters to pass to xFilter. ^If argvIndex>0 then +** the right-hand side of the corresponding aConstraint[] is evaluated +** and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit +** is true, then the constraint is assumed to be fully handled by the +** virtual table and might not be checked again by the byte code.)^ ^(The +** aConstraintUsage[].omit flag is an optimization hint. When the omit flag +** is left in its default setting of false, the constraint will always be +** checked separately in byte code. If the omit flag is change to true, then +** the constraint may or may not be checked in byte code. In other words, +** when the omit flag is true there is no guarantee that the constraint will +** not be checked again using byte code.)^ +** +** ^The idxNum and idxPtr values are recorded and passed into the +** [xFilter] method. +** ^[sqlite3_free()] is used to free idxPtr if and only if +** needToFreeIdxPtr is true. +** +** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in +** the correct order to satisfy the ORDER BY clause so that no separate +** sorting step is required. +** +** ^The estimatedCost value is an estimate of the cost of a particular +** strategy. A cost of N indicates that the cost of the strategy is similar +** to a linear scan of an SQLite table with N rows. A cost of log(N) +** indicates that the expense of the operation is similar to that of a +** binary search on a unique indexed field of an SQLite table with N rows. +** +** ^The estimatedRows value is an estimate of the number of rows that +** will be returned by the strategy. +** +** The xBestIndex method may optionally populate the idxFlags field with a +** mask of SQLITE_INDEX_SCAN_* flags. Currently there is only one such flag - +** SQLITE_INDEX_SCAN_UNIQUE. If the xBestIndex method sets this flag, SQLite +** assumes that the strategy may visit at most one row. +** +** Additionally, if xBestIndex sets the SQLITE_INDEX_SCAN_UNIQUE flag, then +** SQLite also assumes that if a call to the xUpdate() method is made as +** part of the same statement to delete or update a virtual table row and the +** implementation returns SQLITE_CONSTRAINT, then there is no need to rollback +** any database changes. In other words, if the xUpdate() returns +** SQLITE_CONSTRAINT, the database contents must be exactly as they were +** before xUpdate was called. By contrast, if SQLITE_INDEX_SCAN_UNIQUE is not +** set and xUpdate returns SQLITE_CONSTRAINT, any database changes made by +** the xUpdate method are automatically rolled back by SQLite. +** +** IMPORTANT: The estimatedRows field was added to the sqlite3_index_info +** structure for SQLite [version 3.8.2] ([dateof:3.8.2]). +** If a virtual table extension is +** used with an SQLite version earlier than 3.8.2, the results of attempting +** to read or write the estimatedRows field are undefined (but are likely +** to include crashing the application). The estimatedRows field should +** therefore only be used if [sqlite3_libversion_number()] returns a +** value greater than or equal to 3008002. Similarly, the idxFlags field +** was added for [version 3.9.0] ([dateof:3.9.0]). +** It may therefore only be used if +** sqlite3_libversion_number() returns a value greater than or equal to +** 3009000. +*/ +struct sqlite3_index_info { + /* Inputs */ + int nConstraint; /* Number of entries in aConstraint */ + struct sqlite3_index_constraint { + int iColumn; /* Column constrained. -1 for ROWID */ + unsigned char op; /* Constraint operator */ + unsigned char usable; /* True if this constraint is usable */ + int iTermOffset; /* Used internally - xBestIndex should ignore */ + } *aConstraint; /* Table of WHERE clause constraints */ + int nOrderBy; /* Number of terms in the ORDER BY clause */ + struct sqlite3_index_orderby { + int iColumn; /* Column number */ + unsigned char desc; /* True for DESC. False for ASC. */ + } *aOrderBy; /* The ORDER BY clause */ + /* Outputs */ + struct sqlite3_index_constraint_usage { + int argvIndex; /* if >0, constraint is part of argv to xFilter */ + unsigned char omit; /* Do not code a test for this constraint */ + } *aConstraintUsage; + int idxNum; /* Number used to identify the index */ + char *idxStr; /* String, possibly obtained from sqlite3_malloc */ + int needToFreeIdxStr; /* Free idxStr using sqlite3_free() if true */ + int orderByConsumed; /* True if output is already ordered */ + double estimatedCost; /* Estimated cost of using this index */ + /* Fields below are only available in SQLite 3.8.2 and later */ + sqlite3_int64 estimatedRows; /* Estimated number of rows returned */ + /* Fields below are only available in SQLite 3.9.0 and later */ + int idxFlags; /* Mask of SQLITE_INDEX_SCAN_* flags */ + /* Fields below are only available in SQLite 3.10.0 and later */ + sqlite3_uint64 colUsed; /* Input: Mask of columns used by statement */ +}; + +/* +** CAPI3REF: Virtual Table Scan Flags +** +** Virtual table implementations are allowed to set the +** [sqlite3_index_info].idxFlags field to some combination of +** these bits. +*/ +#define SQLITE_INDEX_SCAN_UNIQUE 1 /* Scan visits at most 1 row */ + +/* +** CAPI3REF: Virtual Table Constraint Operator Codes +** +** These macros define the allowed values for the +** [sqlite3_index_info].aConstraint[].op field. Each value represents +** an operator that is part of a constraint term in the wHERE clause of +** a query that uses a [virtual table]. +*/ +#define SQLITE_INDEX_CONSTRAINT_EQ 2 +#define SQLITE_INDEX_CONSTRAINT_GT 4 +#define SQLITE_INDEX_CONSTRAINT_LE 8 +#define SQLITE_INDEX_CONSTRAINT_LT 16 +#define SQLITE_INDEX_CONSTRAINT_GE 32 +#define SQLITE_INDEX_CONSTRAINT_MATCH 64 +#define SQLITE_INDEX_CONSTRAINT_LIKE 65 +#define SQLITE_INDEX_CONSTRAINT_GLOB 66 +#define SQLITE_INDEX_CONSTRAINT_REGEXP 67 +#define SQLITE_INDEX_CONSTRAINT_NE 68 +#define SQLITE_INDEX_CONSTRAINT_ISNOT 69 +#define SQLITE_INDEX_CONSTRAINT_ISNOTNULL 70 +#define SQLITE_INDEX_CONSTRAINT_ISNULL 71 +#define SQLITE_INDEX_CONSTRAINT_IS 72 +#define SQLITE_INDEX_CONSTRAINT_FUNCTION 150 + +/* +** CAPI3REF: Register A Virtual Table Implementation +** METHOD: sqlite3 +** +** ^These routines are used to register a new [virtual table module] name. +** ^Module names must be registered before +** creating a new [virtual table] using the module and before using a +** preexisting [virtual table] for the module. +** +** ^The module name is registered on the [database connection] specified +** by the first parameter. ^The name of the module is given by the +** second parameter. ^The third parameter is a pointer to +** the implementation of the [virtual table module]. ^The fourth +** parameter is an arbitrary client data pointer that is passed through +** into the [xCreate] and [xConnect] methods of the virtual table module +** when a new virtual table is be being created or reinitialized. +** +** ^The sqlite3_create_module_v2() interface has a fifth parameter which +** is a pointer to a destructor for the pClientData. ^SQLite will +** invoke the destructor function (if it is not NULL) when SQLite +** no longer needs the pClientData pointer. ^The destructor will also +** be invoked if the call to sqlite3_create_module_v2() fails. +** ^The sqlite3_create_module() +** interface is equivalent to sqlite3_create_module_v2() with a NULL +** destructor. +** +** ^If the third parameter (the pointer to the sqlite3_module object) is +** NULL then no new module is create and any existing modules with the +** same name are dropped. +** +** See also: [sqlite3_drop_modules()] +*/ +SQLITE_API int sqlite3_create_module( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *p, /* Methods for the module */ + void *pClientData /* Client data for xCreate/xConnect */ +); +SQLITE_API int sqlite3_create_module_v2( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *p, /* Methods for the module */ + void *pClientData, /* Client data for xCreate/xConnect */ + void(*xDestroy)(void*) /* Module destructor function */ +); + +/* +** CAPI3REF: Remove Unnecessary Virtual Table Implementations +** METHOD: sqlite3 +** +** ^The sqlite3_drop_modules(D,L) interface removes all virtual +** table modules from database connection D except those named on list L. +** The L parameter must be either NULL or a pointer to an array of pointers +** to strings where the array is terminated by a single NULL pointer. +** ^If the L parameter is NULL, then all virtual table modules are removed. +** +** See also: [sqlite3_create_module()] +*/ +SQLITE_API int sqlite3_drop_modules( + sqlite3 *db, /* Remove modules from this connection */ + const char **azKeep /* Except, do not remove the ones named here */ +); + +/* +** CAPI3REF: Virtual Table Instance Object +** KEYWORDS: sqlite3_vtab +** +** Every [virtual table module] implementation uses a subclass +** of this object to describe a particular instance +** of the [virtual table]. Each subclass will +** be tailored to the specific needs of the module implementation. +** The purpose of this superclass is to define certain fields that are +** common to all module implementations. +** +** ^Virtual tables methods can set an error message by assigning a +** string obtained from [sqlite3_mprintf()] to zErrMsg. The method should +** take care that any prior string is freed by a call to [sqlite3_free()] +** prior to assigning a new string to zErrMsg. ^After the error message +** is delivered up to the client application, the string will be automatically +** freed by sqlite3_free() and the zErrMsg field will be zeroed. +*/ +struct sqlite3_vtab { + const sqlite3_module *pModule; /* The module for this virtual table */ + int nRef; /* Number of open cursors */ + char *zErrMsg; /* Error message from sqlite3_mprintf() */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* +** CAPI3REF: Virtual Table Cursor Object +** KEYWORDS: sqlite3_vtab_cursor {virtual table cursor} +** +** Every [virtual table module] implementation uses a subclass of the +** following structure to describe cursors that point into the +** [virtual table] and are used +** to loop through the virtual table. Cursors are created using the +** [sqlite3_module.xOpen | xOpen] method of the module and are destroyed +** by the [sqlite3_module.xClose | xClose] method. Cursors are used +** by the [xFilter], [xNext], [xEof], [xColumn], and [xRowid] methods +** of the module. Each module implementation will define +** the content of a cursor structure to suit its own needs. +** +** This superclass exists in order to define fields of the cursor that +** are common to all implementations. +*/ +struct sqlite3_vtab_cursor { + sqlite3_vtab *pVtab; /* Virtual table of this cursor */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* +** CAPI3REF: Declare The Schema Of A Virtual Table +** +** ^The [xCreate] and [xConnect] methods of a +** [virtual table module] call this interface +** to declare the format (the names and datatypes of the columns) of +** the virtual tables they implement. +*/ +SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL); + +/* +** CAPI3REF: Overload A Function For A Virtual Table +** METHOD: sqlite3 +** +** ^(Virtual tables can provide alternative implementations of functions +** using the [xFindFunction] method of the [virtual table module]. +** But global versions of those functions +** must exist in order to be overloaded.)^ +** +** ^(This API makes sure a global version of a function with a particular +** name and number of parameters exists. If no such function exists +** before this API is called, a new function is created.)^ ^The implementation +** of the new function always causes an exception to be thrown. So +** the new function is not good for anything by itself. Its only +** purpose is to be a placeholder function that can be overloaded +** by a [virtual table]. +*/ +SQLITE_API 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} +** +** An instance of this object represents an open BLOB on which +** [sqlite3_blob_open | incremental BLOB I/O] can be performed. +** ^Objects of this type are created by [sqlite3_blob_open()] +** and destroyed by [sqlite3_blob_close()]. +** ^The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces +** can be used to read or write small subsections of the BLOB. +** ^The [sqlite3_blob_bytes()] interface returns the size of the BLOB in bytes. +*/ +typedef struct sqlite3_blob sqlite3_blob; + +/* +** CAPI3REF: Open A BLOB For Incremental I/O +** METHOD: sqlite3 +** CONSTRUCTOR: sqlite3_blob +** +** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located +** in row iRow, column zColumn, table zTable in database zDb; +** in other words, the same BLOB that would be selected by: +** +** 
    +**     SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
+**
    )^ +** +** ^(Parameter zDb is not the filename that contains the database, but +** rather the symbolic name of the database. For attached databases, this is +** the name that appears after the AS keyword in the [ATTACH] statement. +** For the main database file, the database name is "main". For TEMP +** tables, the database name is "temp".)^ +** +** ^If the flags parameter is non-zero, then the BLOB is opened for read +** and write access. ^If the flags parameter is zero, the BLOB is opened for +** read-only access. +** +** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is stored +** in *ppBlob. Otherwise an [error code] is returned and, unless the error +** code is SQLITE_MISUSE, *ppBlob is set to NULL.)^ ^This means that, provided +** the API is not misused, it is always safe to call [sqlite3_blob_close()] +** on *ppBlob after this function it returns. +** +** This function fails with SQLITE_ERROR if any of the following are true: +**
      +**
    • ^(Database zDb does not exist)^, +**
    • ^(Table zTable does not exist within database zDb)^, +**
    • ^(Table zTable is a WITHOUT ROWID table)^, +**
    • ^(Column zColumn does not exist)^, +**
    • ^(Row iRow is not present in the table)^, +**
    • ^(The specified column of row iRow contains a value that is not +** a TEXT or BLOB value)^, +**
    • ^(Column zColumn is part of an index, PRIMARY KEY or UNIQUE +** constraint and the blob is being opened for read/write access)^, +**
    • ^([foreign key constraints | Foreign key constraints] are enabled, +** column zColumn is part of a [child key] definition and the blob is +** being opened for read/write access)^. +**
    +** +** ^Unless it returns SQLITE_MISUSE, this function sets the +** [database connection] error code and message accessible via +** [sqlite3_errcode()] and [sqlite3_errmsg()] and related functions. +** +** A BLOB referenced by sqlite3_blob_open() may be read using the +** [sqlite3_blob_read()] interface and modified by using +** [sqlite3_blob_write()]. The [BLOB handle] can be moved to a +** different row of the same table using the [sqlite3_blob_reopen()] +** interface. However, the column, table, or database of a [BLOB handle] +** cannot be changed after the [BLOB handle] is opened. +** +** ^(If the row that a BLOB handle points to is modified by an +** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects +** then the BLOB handle is marked as "expired". +** This is true if any column of the row is changed, even a column +** other than the one the BLOB handle is open on.)^ +** ^Calls to [sqlite3_blob_read()] and [sqlite3_blob_write()] for +** an expired BLOB handle fail with a return code of [SQLITE_ABORT]. +** ^(Changes written into a BLOB prior to the BLOB expiring are not +** rolled back by the expiration of the BLOB. Such changes will eventually +** commit if the transaction continues to completion.)^ +** +** ^Use the [sqlite3_blob_bytes()] interface to determine the size of +** the opened blob. ^The size of a blob may not be changed by this +** interface. Use the [UPDATE] SQL command to change the size of a +** blob. +** +** ^The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces +** and the built-in [zeroblob] SQL function may be used to create a +** zero-filled blob to read or write using the incremental-blob interface. +** +** To avoid a resource leak, every open [BLOB handle] should eventually +** be released by a call to [sqlite3_blob_close()]. +** +** See also: [sqlite3_blob_close()], +** [sqlite3_blob_reopen()], [sqlite3_blob_read()], +** [sqlite3_blob_bytes()], [sqlite3_blob_write()]. +*/ +SQLITE_API int sqlite3_blob_open( + sqlite3*, + const char *zDb, + const char *zTable, + const char *zColumn, + sqlite3_int64 iRow, + int flags, + sqlite3_blob **ppBlob +); + +/* +** CAPI3REF: Move a BLOB Handle to a New Row +** METHOD: sqlite3_blob +** +** ^This function is used to move an existing [BLOB handle] so that it points +** to a different row of the same database table. ^The new row is identified +** by the rowid value passed as the second argument. Only the row can be +** changed. ^The database, table and column on which the blob handle is open +** remain the same. Moving an existing [BLOB handle] to a new row is +** faster than closing the existing handle and opening a new one. +** +** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] - +** it must exist and there must be either a blob or text value stored in +** the nominated column.)^ ^If the new row is not present in the table, or if +** it does not contain a blob or text value, or if another error occurs, an +** SQLite error code is returned and the blob handle is considered aborted. +** ^All subsequent calls to [sqlite3_blob_read()], [sqlite3_blob_write()] or +** [sqlite3_blob_reopen()] on an aborted blob handle immediately return +** SQLITE_ABORT. ^Calling [sqlite3_blob_bytes()] on an aborted blob handle +** always returns zero. +** +** ^This function sets the database handle error code and message. +*/ +SQLITE_API int sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64); + +/* +** CAPI3REF: Close A BLOB Handle +** DESTRUCTOR: sqlite3_blob +** +** ^This function closes an open [BLOB handle]. ^(The BLOB handle is closed +** unconditionally. Even if this routine returns an error code, the +** handle is still closed.)^ +** +** ^If the blob handle being closed was opened for read-write access, and if +** the database is in auto-commit mode and there are no other open read-write +** blob handles or active write statements, the current transaction is +** committed. ^If an error occurs while committing the transaction, an error +** code is returned and the transaction rolled back. +** +** Calling this function with an argument that is not a NULL pointer or an +** open blob handle results in undefined behaviour. ^Calling this routine +** with a null pointer (such as would be returned by a failed call to +** [sqlite3_blob_open()]) is a harmless no-op. ^Otherwise, if this function +** is passed a valid open blob handle, the values returned by the +** sqlite3_errcode() and sqlite3_errmsg() functions are set before returning. +*/ +SQLITE_API int sqlite3_blob_close(sqlite3_blob *); + +/* +** CAPI3REF: Return The Size Of An Open BLOB +** METHOD: sqlite3_blob +** +** ^Returns the size in bytes of the BLOB accessible via the +** successfully opened [BLOB handle] in its only argument. ^The +** incremental blob I/O routines can only read or overwriting existing +** blob content; they cannot change the size of a blob. +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +*/ +SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *); + +/* +** CAPI3REF: Read Data From A BLOB Incrementally +** METHOD: sqlite3_blob +** +** ^(This function is used to read data from an open [BLOB handle] into a +** caller-supplied buffer. N bytes of data are copied into buffer Z +** from the open BLOB, starting at offset iOffset.)^ +** +** ^If offset iOffset is less than N bytes from the end of the BLOB, +** [SQLITE_ERROR] is returned and no data is read. ^If N or iOffset is +** less than zero, [SQLITE_ERROR] is returned and no data is read. +** ^The size of the blob (and hence the maximum value of N+iOffset) +** can be determined using the [sqlite3_blob_bytes()] interface. +** +** ^An attempt to read from an expired [BLOB handle] fails with an +** error code of [SQLITE_ABORT]. +** +** ^(On success, sqlite3_blob_read() returns SQLITE_OK. +** Otherwise, an [error code] or an [extended error code] is returned.)^ +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +** +** See also: [sqlite3_blob_write()]. +*/ +SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset); + +/* +** CAPI3REF: Write Data Into A BLOB Incrementally +** METHOD: sqlite3_blob +** +** ^(This function is used to write data into an open [BLOB handle] from a +** caller-supplied buffer. N bytes of data are copied from the buffer Z +** into the open BLOB, starting at offset iOffset.)^ +** +** ^(On success, sqlite3_blob_write() returns SQLITE_OK. +** Otherwise, an [error code] or an [extended error code] is returned.)^ +** ^Unless SQLITE_MISUSE is returned, this function sets the +** [database connection] error code and message accessible via +** [sqlite3_errcode()] and [sqlite3_errmsg()] and related functions. +** +** ^If the [BLOB handle] passed as the first argument was not opened for +** writing (the flags parameter to [sqlite3_blob_open()] was zero), +** this function returns [SQLITE_READONLY]. +** +** This function may only modify the contents of the BLOB; it is +** not possible to increase the size of a BLOB using this API. +** ^If offset iOffset is less than N bytes from the end of the BLOB, +** [SQLITE_ERROR] is returned and no data is written. The size of the +** BLOB (and hence the maximum value of N+iOffset) can be determined +** using the [sqlite3_blob_bytes()] interface. ^If N or iOffset are less +** than zero [SQLITE_ERROR] is returned and no data is written. +** +** ^An attempt to write to an expired [BLOB handle] fails with an +** error code of [SQLITE_ABORT]. ^Writes to the BLOB that occurred +** before the [BLOB handle] expired are not rolled back by the +** expiration of the handle, though of course those changes might +** have been overwritten by the statement that expired the BLOB handle +** or by other independent statements. +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +** +** See also: [sqlite3_blob_read()]. +*/ +SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset); + +/* +** CAPI3REF: Virtual File System Objects +** +** A virtual filesystem (VFS) is an [sqlite3_vfs] object +** that SQLite uses to interact +** with the underlying operating system. Most SQLite builds come with a +** single default VFS that is appropriate for the host computer. +** New VFSes can be registered and existing VFSes can be unregistered. +** The following interfaces are provided. +** +** ^The sqlite3_vfs_find() interface returns a pointer to a VFS given its name. +** ^Names are case sensitive. +** ^Names are zero-terminated UTF-8 strings. +** ^If there is no match, a NULL pointer is returned. +** ^If zVfsName is NULL then the default VFS is returned. +** +** ^New VFSes are registered with sqlite3_vfs_register(). +** ^Each new VFS becomes the default VFS if the makeDflt flag is set. +** ^The same VFS can be registered multiple times without injury. +** ^To make an existing VFS into the default VFS, register it again +** with the makeDflt flag set. If two different VFSes with the +** same name are registered, the behavior is undefined. If a +** VFS is registered with a name that is NULL or an empty string, +** then the behavior is undefined. +** +** ^Unregister a VFS with the sqlite3_vfs_unregister() interface. +** ^(If the default VFS is unregistered, another VFS is chosen as +** the default. The choice for the new VFS is arbitrary.)^ +*/ +SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName); +SQLITE_API int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt); +SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*); + +/* +** CAPI3REF: Mutexes +** +** The SQLite core uses these routines for thread +** synchronization. Though they are intended for internal +** use by SQLite, code that links against SQLite is +** permitted to use any of these routines. +** +** The SQLite source code contains multiple implementations +** of these mutex routines. An appropriate implementation +** is selected automatically at compile-time. The following +** implementations are available in the SQLite core: +** +**
      +**
    • SQLITE_MUTEX_PTHREADS +**
    • SQLITE_MUTEX_W32 +**
    • SQLITE_MUTEX_NOOP +**
    +** +** The SQLITE_MUTEX_NOOP implementation is a set of routines +** that does no real locking and is appropriate for use in +** a single-threaded application. The SQLITE_MUTEX_PTHREADS and +** SQLITE_MUTEX_W32 implementations are appropriate for use on Unix +** and Windows. +** +** If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor +** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex +** implementation is included with the library. In this case the +** application must supply a custom mutex implementation using the +** [SQLITE_CONFIG_MUTEX] option of the sqlite3_config() function +** before calling sqlite3_initialize() or any other public sqlite3_ +** function that calls sqlite3_initialize(). +** +** ^The sqlite3_mutex_alloc() routine allocates a new +** mutex and returns a pointer to it. ^The sqlite3_mutex_alloc() +** routine returns NULL if it is unable to allocate the requested +** mutex. The argument to sqlite3_mutex_alloc() must one of these +** integer constants: +** +**
      +**
    • SQLITE_MUTEX_FAST +**
    • SQLITE_MUTEX_RECURSIVE +**
    • SQLITE_MUTEX_STATIC_MAIN +**
    • SQLITE_MUTEX_STATIC_MEM +**
    • SQLITE_MUTEX_STATIC_OPEN +**
    • SQLITE_MUTEX_STATIC_PRNG +**
    • SQLITE_MUTEX_STATIC_LRU +**
    • SQLITE_MUTEX_STATIC_PMEM +**
    • SQLITE_MUTEX_STATIC_APP1 +**
    • SQLITE_MUTEX_STATIC_APP2 +**
    • SQLITE_MUTEX_STATIC_APP3 +**
    • SQLITE_MUTEX_STATIC_VFS1 +**
    • SQLITE_MUTEX_STATIC_VFS2 +**
    • SQLITE_MUTEX_STATIC_VFS3 +**
    +** +** ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) +** cause sqlite3_mutex_alloc() to create +** a new mutex. ^The new mutex is recursive when SQLITE_MUTEX_RECURSIVE +** is used but not necessarily so when SQLITE_MUTEX_FAST is used. +** The mutex implementation does not need to make a distinction +** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does +** not want to. SQLite will only request a recursive mutex in +** cases where it really needs one. If a faster non-recursive mutex +** implementation is available on the host platform, the mutex subsystem +** might return such a mutex in response to SQLITE_MUTEX_FAST. +** +** ^The other allowed parameters to sqlite3_mutex_alloc() (anything other +** than SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) each return +** a pointer to a static preexisting mutex. ^Nine static mutexes are +** used by the current version of SQLite. Future versions of SQLite +** may add additional static mutexes. Static mutexes are for internal +** use by SQLite only. Applications that use SQLite mutexes should +** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or +** SQLITE_MUTEX_RECURSIVE. +** +** ^Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST +** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() +** returns a different mutex on every call. ^For the static +** mutex types, the same mutex is returned on every call that has +** the same type number. +** +** ^The sqlite3_mutex_free() routine deallocates a previously +** allocated dynamic mutex. Attempting to deallocate a static +** mutex results in undefined behavior. +** +** ^The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. ^If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. ^The sqlite3_mutex_try() interface returns [SQLITE_OK] +** upon successful entry. ^(Mutexes created using +** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread. +** In such cases, the +** mutex must be exited an equal number of times before another thread +** can enter.)^ If the same thread tries to enter any mutex other +** than an SQLITE_MUTEX_RECURSIVE more than once, the behavior is undefined. +** +** ^(Some systems (for example, Windows 95) do not support the operation +** implemented by sqlite3_mutex_try(). On those systems, sqlite3_mutex_try() +** will always return SQLITE_BUSY. The SQLite core only ever uses +** sqlite3_mutex_try() as an optimization so this is acceptable +** behavior.)^ +** +** ^The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. The behavior +** is undefined if the mutex is not currently entered by the +** calling thread or is not currently allocated. +** +** ^If the argument to sqlite3_mutex_enter(), sqlite3_mutex_try(), or +** sqlite3_mutex_leave() is a NULL pointer, then all three routines +** behave as no-ops. +** +** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()]. +*/ +SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int); +SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*); +SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*); +SQLITE_API int sqlite3_mutex_try(sqlite3_mutex*); +SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*); + +/* +** CAPI3REF: Mutex Methods Object +** +** An instance of this structure defines the low-level routines +** used to allocate and use mutexes. +** +** Usually, the default mutex implementations provided by SQLite are +** sufficient, however the application has the option of substituting a custom +** implementation for specialized deployments or systems for which SQLite +** does not provide a suitable implementation. In this case, the application +** creates and populates an instance of this structure to pass +** to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option. +** Additionally, an instance of this structure can be used as an +** output variable when querying the system for the current mutex +** implementation, using the [SQLITE_CONFIG_GETMUTEX] option. +** +** ^The xMutexInit method defined by this structure is invoked as +** part of system initialization by the sqlite3_initialize() function. +** ^The xMutexInit routine is called by SQLite exactly once for each +** effective call to [sqlite3_initialize()]. +** +** ^The xMutexEnd method defined by this structure is invoked as +** part of system shutdown by the sqlite3_shutdown() function. The +** implementation of this method is expected to release all outstanding +** resources obtained by the mutex methods implementation, especially +** those obtained by the xMutexInit method. ^The xMutexEnd() +** interface is invoked exactly once for each call to [sqlite3_shutdown()]. +** +** ^(The remaining seven methods defined by this structure (xMutexAlloc, +** xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and +** xMutexNotheld) implement the following interfaces (respectively): +** +**
      +**
    • [sqlite3_mutex_alloc()]
      • +**
    • [sqlite3_mutex_free()]
      • +**
    • [sqlite3_mutex_enter()]
      • +**
    • [sqlite3_mutex_try()]
      • +**
    • [sqlite3_mutex_leave()]
      • +**
    • [sqlite3_mutex_held()]
      • +**
    • [sqlite3_mutex_notheld()]
      • +**
    )^ +** +** The only difference is that the public sqlite3_XXX functions enumerated +** above silently ignore any invocations that pass a NULL pointer instead +** of a valid mutex handle. The implementations of the methods defined +** by this structure are not required to handle this case. The results +** of passing a NULL pointer instead of a valid mutex handle are undefined +** (i.e. it is acceptable to provide an implementation that segfaults if +** it is passed a NULL pointer). +** +** The xMutexInit() method must be threadsafe. It must be harmless to +** invoke xMutexInit() multiple times within the same process and without +** intervening calls to xMutexEnd(). Second and subsequent calls to +** xMutexInit() must be no-ops. +** +** xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()] +** and its associates). Similarly, xMutexAlloc() must not use SQLite memory +** allocation for a static mutex. ^However xMutexAlloc() may use SQLite +** memory allocation for a fast or recursive mutex. +** +** ^SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is +** called, but only if the prior call to xMutexInit returned SQLITE_OK. +** If xMutexInit fails in any way, it is expected to clean up after itself +** prior to returning. +*/ +typedef struct sqlite3_mutex_methods sqlite3_mutex_methods; +struct sqlite3_mutex_methods { + int (*xMutexInit)(void); + int (*xMutexEnd)(void); + sqlite3_mutex *(*xMutexAlloc)(int); + void (*xMutexFree)(sqlite3_mutex *); + void (*xMutexEnter)(sqlite3_mutex *); + int (*xMutexTry)(sqlite3_mutex *); + void (*xMutexLeave)(sqlite3_mutex *); + int (*xMutexHeld)(sqlite3_mutex *); + int (*xMutexNotheld)(sqlite3_mutex *); +}; + +/* +** CAPI3REF: Mutex Verification Routines +** +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines +** are intended for use inside assert() statements. The SQLite core +** never uses these routines except inside an assert() and applications +** are advised to follow the lead of the core. The SQLite core only +** provides implementations for these routines when it is compiled +** with the SQLITE_DEBUG flag. External mutex implementations +** are only required to provide these routines if SQLITE_DEBUG is +** defined and if NDEBUG is not defined. +** +** These routines should return true if the mutex in their argument +** is held or not held, respectively, by the calling thread. +** +** The implementation is not required to provide versions of these +** routines that actually work. If the implementation does not provide working +** versions of these routines, it should at least provide stubs that always +** return true so that one does not get spurious assertion failures. +** +** If the argument to sqlite3_mutex_held() is a NULL pointer then +** the routine should return 1. This seems counter-intuitive since +** clearly the mutex cannot be held if it does not exist. But +** the reason the mutex does not exist is because the build is not +** using mutexes. And we do not want the assert() containing the +** call to sqlite3_mutex_held() to fail, so a non-zero return is +** the appropriate thing to do. The sqlite3_mutex_notheld() +** interface should also return 1 when given a NULL pointer. +*/ +#ifndef NDEBUG +SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*); +SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*); +#endif + +/* +** CAPI3REF: Mutex Types +** +** The [sqlite3_mutex_alloc()] interface takes a single argument +** which is one of these integer constants. +** +** The set of static mutexes may change from one SQLite release to the +** next. Applications that override the built-in mutex logic must be +** prepared to accommodate additional static mutexes. +*/ +#define SQLITE_MUTEX_FAST 0 +#define SQLITE_MUTEX_RECURSIVE 1 +#define SQLITE_MUTEX_STATIC_MAIN 2 +#define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */ +#define SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */ +#define SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */ +#define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_randomness() */ +#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */ +#define SQLITE_MUTEX_STATIC_LRU2 7 /* NOT USED */ +#define SQLITE_MUTEX_STATIC_PMEM 7 /* sqlite3PageMalloc() */ +#define SQLITE_MUTEX_STATIC_APP1 8 /* For use by application */ +#define SQLITE_MUTEX_STATIC_APP2 9 /* For use by application */ +#define SQLITE_MUTEX_STATIC_APP3 10 /* For use by application */ +#define SQLITE_MUTEX_STATIC_VFS1 11 /* For use by built-in VFS */ +#define SQLITE_MUTEX_STATIC_VFS2 12 /* For use by extension VFS */ +#define SQLITE_MUTEX_STATIC_VFS3 13 /* For use by application VFS */ + +/* Legacy compatibility: */ +#define SQLITE_MUTEX_STATIC_MASTER 2 + + +/* +** CAPI3REF: Retrieve the mutex for a database connection +** METHOD: sqlite3 +** +** ^This interface returns a pointer the [sqlite3_mutex] object that +** serializes access to the [database connection] given in the argument +** when the [threading mode] is Serialized. +** ^If the [threading mode] is Single-thread or Multi-thread then this +** routine returns a NULL pointer. +*/ +SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*); + +/* +** CAPI3REF: Low-Level Control Of Database Files +** METHOD: sqlite3 +** KEYWORDS: {file control} +** +** ^The [sqlite3_file_control()] interface makes a direct call to the +** xFileControl method for the [sqlite3_io_methods] object associated +** with a particular database identified by the second argument. ^The +** name of the database is "main" for the main database or "temp" for the +** TEMP database, or the name that appears after the AS keyword for +** databases that are added using the [ATTACH] SQL command. +** ^A NULL pointer can be used in place of "main" to refer to the +** main database file. +** ^The third and fourth parameters to this routine +** are passed directly through to the second and third parameters of +** the xFileControl method. ^The return value of the xFileControl +** method becomes the return value of this routine. +** +** A few opcodes for [sqlite3_file_control()] are handled directly +** by the SQLite core and never invoke the +** sqlite3_io_methods.xFileControl method. +** ^The [SQLITE_FCNTL_FILE_POINTER] value for the op parameter causes +** a pointer to the underlying [sqlite3_file] object to be written into +** the space pointed to by the 4th parameter. The +** [SQLITE_FCNTL_JOURNAL_POINTER] works similarly except that it returns +** the [sqlite3_file] object associated with the journal file instead of +** the main database. The [SQLITE_FCNTL_VFS_POINTER] opcode returns +** a pointer to the underlying [sqlite3_vfs] object for the file. +** The [SQLITE_FCNTL_DATA_VERSION] returns the data version counter +** from the pager. +** +** ^If the second parameter (zDbName) does not match the name of any +** open database file, then SQLITE_ERROR is returned. ^This error +** code is not remembered and will not be recalled by [sqlite3_errcode()] +** or [sqlite3_errmsg()]. The underlying xFileControl method might +** also return SQLITE_ERROR. There is no way to distinguish between +** an incorrect zDbName and an SQLITE_ERROR return from the underlying +** xFileControl method. +** +** See also: [file control opcodes] +*/ +SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*); + +/* +** CAPI3REF: Testing Interface +** +** ^The sqlite3_test_control() interface is used to read out internal +** state of SQLite and to inject faults into SQLite for testing +** purposes. ^The first parameter is an operation code that determines +** the number, meaning, and operation of all subsequent parameters. +** +** This interface is not for use by applications. It exists solely +** for verifying the correct operation of the SQLite library. Depending +** on how the SQLite library is compiled, this interface might not exist. +** +** The details of the operation codes, their meanings, the parameters +** they take, and what they do are all subject to change without notice. +** Unlike most of the SQLite API, this function is not guaranteed to +** operate consistently from one release to the next. +*/ +SQLITE_API int sqlite3_test_control(int op, ...); + +/* +** CAPI3REF: Testing Interface Operation Codes +** +** These constants are the valid operation code parameters used +** as the first argument to [sqlite3_test_control()]. +** +** These parameters and their meanings are subject to change +** without notice. These values are for testing purposes only. +** Applications should not use any of these parameters or the +** [sqlite3_test_control()] interface. +*/ +#define SQLITE_TESTCTRL_FIRST 5 +#define SQLITE_TESTCTRL_PRNG_SAVE 5 +#define SQLITE_TESTCTRL_PRNG_RESTORE 6 +#define SQLITE_TESTCTRL_PRNG_RESET 7 /* NOT USED */ +#define SQLITE_TESTCTRL_BITVEC_TEST 8 +#define SQLITE_TESTCTRL_FAULT_INSTALL 9 +#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10 +#define SQLITE_TESTCTRL_PENDING_BYTE 11 +#define SQLITE_TESTCTRL_ASSERT 12 +#define SQLITE_TESTCTRL_ALWAYS 13 +#define SQLITE_TESTCTRL_RESERVE 14 /* NOT USED */ +#define SQLITE_TESTCTRL_OPTIMIZATIONS 15 +#define SQLITE_TESTCTRL_ISKEYWORD 16 /* NOT USED */ +#define SQLITE_TESTCTRL_SCRATCHMALLOC 17 /* NOT USED */ +#define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS 17 +#define SQLITE_TESTCTRL_LOCALTIME_FAULT 18 +#define SQLITE_TESTCTRL_EXPLAIN_STMT 19 /* NOT USED */ +#define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD 19 +#define SQLITE_TESTCTRL_NEVER_CORRUPT 20 +#define SQLITE_TESTCTRL_VDBE_COVERAGE 21 +#define SQLITE_TESTCTRL_BYTEORDER 22 +#define SQLITE_TESTCTRL_ISINIT 23 +#define SQLITE_TESTCTRL_SORTER_MMAP 24 +#define SQLITE_TESTCTRL_IMPOSTER 25 +#define SQLITE_TESTCTRL_PARSER_COVERAGE 26 +#define SQLITE_TESTCTRL_RESULT_INTREAL 27 +#define SQLITE_TESTCTRL_PRNG_SEED 28 +#define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS 29 +#define SQLITE_TESTCTRL_SEEK_COUNT 30 +#define SQLITE_TESTCTRL_LAST 30 /* Largest TESTCTRL */ + +/* +** CAPI3REF: SQL Keyword Checking +** +** These routines provide access to the set of SQL language keywords +** recognized by SQLite. Applications can uses these routines to determine +** whether or not a specific identifier needs to be escaped (for example, +** by enclosing in double-quotes) so as not to confuse the parser. +** +** The sqlite3_keyword_count() interface returns the number of distinct +** keywords understood by SQLite. +** +** The sqlite3_keyword_name(N,Z,L) interface finds the N-th keyword and +** makes *Z point to that keyword expressed as UTF8 and writes the number +** of bytes in the keyword into *L. The string that *Z points to is not +** zero-terminated. The sqlite3_keyword_name(N,Z,L) routine returns +** SQLITE_OK if N is within bounds and SQLITE_ERROR if not. If either Z +** or L are NULL or invalid pointers then calls to +** sqlite3_keyword_name(N,Z,L) result in undefined behavior. +** +** The sqlite3_keyword_check(Z,L) interface checks to see whether or not +** the L-byte UTF8 identifier that Z points to is a keyword, returning non-zero +** if it is and zero if not. +** +** The parser used by SQLite is forgiving. It is often possible to use +** a keyword as an identifier as long as such use does not result in a +** parsing ambiguity. For example, the statement +** "CREATE TABLE BEGIN(REPLACE,PRAGMA,END);" is accepted by SQLite, and +** creates a new table named "BEGIN" with three columns named +** "REPLACE", "PRAGMA", and "END". Nevertheless, best practice is to avoid +** using keywords as identifiers. Common techniques used to avoid keyword +** name collisions include: +**
      +**
    • Put all identifier names inside double-quotes. This is the official +** SQL way to escape identifier names. +**
    • Put identifier names inside [...]. This is not standard SQL, +** but it is what SQL Server does and so lots of programmers use this +** technique. +**
    • Begin every identifier with the letter "Z" as no SQL keywords start +** with "Z". +**
    • Include a digit somewhere in every identifier name. +**
    +** +** Note that the number of keywords understood by SQLite can depend on +** compile-time options. For example, "VACUUM" is not a keyword if +** SQLite is compiled with the [-DSQLITE_OMIT_VACUUM] option. Also, +** new keywords may be added to future releases of SQLite. +*/ +SQLITE_API int sqlite3_keyword_count(void); +SQLITE_API int sqlite3_keyword_name(int,const char**,int*); +SQLITE_API int sqlite3_keyword_check(const char*,int); + +/* +** CAPI3REF: Dynamic String Object +** KEYWORDS: {dynamic string} +** +** An instance of the sqlite3_str object contains a dynamically-sized +** string under construction. +** +** The lifecycle of an sqlite3_str object is as follows: +**
      +**
    1. ^The sqlite3_str object is created using [sqlite3_str_new()]. +**
    2. ^Text is appended to the sqlite3_str object using various +** methods, such as [sqlite3_str_appendf()]. +**
    3. ^The sqlite3_str object is destroyed and the string it created +** is returned using the [sqlite3_str_finish()] interface. +**
    +*/ +typedef struct sqlite3_str sqlite3_str; + +/* +** CAPI3REF: Create A New Dynamic String Object +** CONSTRUCTOR: sqlite3_str +** +** ^The [sqlite3_str_new(D)] interface allocates and initializes +** a new [sqlite3_str] object. To avoid memory leaks, the object returned by +** [sqlite3_str_new()] must be freed by a subsequent call to +** [sqlite3_str_finish(X)]. +** +** ^The [sqlite3_str_new(D)] interface always returns a pointer to a +** valid [sqlite3_str] object, though in the event of an out-of-memory +** error the returned object might be a special singleton that will +** silently reject new text, always return SQLITE_NOMEM from +** [sqlite3_str_errcode()], always return 0 for +** [sqlite3_str_length()], and always return NULL from +** [sqlite3_str_finish(X)]. It is always safe to use the value +** returned by [sqlite3_str_new(D)] as the sqlite3_str parameter +** to any of the other [sqlite3_str] methods. +** +** The D parameter to [sqlite3_str_new(D)] may be NULL. If the +** D parameter in [sqlite3_str_new(D)] is not NULL, then the maximum +** length of the string contained in the [sqlite3_str] object will be +** the value set for [sqlite3_limit](D,[SQLITE_LIMIT_LENGTH]) instead +** of [SQLITE_MAX_LENGTH]. +*/ +SQLITE_API sqlite3_str *sqlite3_str_new(sqlite3*); + +/* +** CAPI3REF: Finalize A Dynamic String +** DESTRUCTOR: sqlite3_str +** +** ^The [sqlite3_str_finish(X)] interface destroys the sqlite3_str object X +** and returns a pointer to a memory buffer obtained from [sqlite3_malloc64()] +** that contains the constructed string. The calling application should +** pass the returned value to [sqlite3_free()] to avoid a memory leak. +** ^The [sqlite3_str_finish(X)] interface may return a NULL pointer if any +** errors were encountered during construction of the string. ^The +** [sqlite3_str_finish(X)] interface will also return a NULL pointer if the +** string in [sqlite3_str] object X is zero bytes long. +*/ +SQLITE_API char *sqlite3_str_finish(sqlite3_str*); + +/* +** CAPI3REF: Add Content To A Dynamic String +** METHOD: sqlite3_str +** +** These interfaces add content to an sqlite3_str object previously obtained +** from [sqlite3_str_new()]. +** +** ^The [sqlite3_str_appendf(X,F,...)] and +** [sqlite3_str_vappendf(X,F,V)] interfaces uses the [built-in printf] +** functionality of SQLite to append formatted text onto the end of +** [sqlite3_str] object X. +** +** ^The [sqlite3_str_append(X,S,N)] method appends exactly N bytes from string S +** onto the end of the [sqlite3_str] object X. N must be non-negative. +** S must contain at least N non-zero bytes of content. To append a +** zero-terminated string in its entirety, use the [sqlite3_str_appendall()] +** method instead. +** +** ^The [sqlite3_str_appendall(X,S)] method appends the complete content of +** zero-terminated string S onto the end of [sqlite3_str] object X. +** +** ^The [sqlite3_str_appendchar(X,N,C)] method appends N copies of the +** single-byte character C onto the end of [sqlite3_str] object X. +** ^This method can be used, for example, to add whitespace indentation. +** +** ^The [sqlite3_str_reset(X)] method resets the string under construction +** inside [sqlite3_str] object X back to zero bytes in length. +** +** These methods do not return a result code. ^If an error occurs, that fact +** is recorded in the [sqlite3_str] object and can be recovered by a +** subsequent call to [sqlite3_str_errcode(X)]. +*/ +SQLITE_API void sqlite3_str_appendf(sqlite3_str*, const char *zFormat, ...); +SQLITE_API void sqlite3_str_vappendf(sqlite3_str*, const char *zFormat, va_list); +SQLITE_API void sqlite3_str_append(sqlite3_str*, const char *zIn, int N); +SQLITE_API void sqlite3_str_appendall(sqlite3_str*, const char *zIn); +SQLITE_API void sqlite3_str_appendchar(sqlite3_str*, int N, char C); +SQLITE_API void sqlite3_str_reset(sqlite3_str*); + +/* +** CAPI3REF: Status Of A Dynamic String +** METHOD: sqlite3_str +** +** These interfaces return the current status of an [sqlite3_str] object. +** +** ^If any prior errors have occurred while constructing the dynamic string +** in sqlite3_str X, then the [sqlite3_str_errcode(X)] method will return +** an appropriate error code. ^The [sqlite3_str_errcode(X)] method returns +** [SQLITE_NOMEM] following any out-of-memory error, or +** [SQLITE_TOOBIG] if the size of the dynamic string exceeds +** [SQLITE_MAX_LENGTH], or [SQLITE_OK] if there have been no errors. +** +** ^The [sqlite3_str_length(X)] method returns the current length, in bytes, +** of the dynamic string under construction in [sqlite3_str] object X. +** ^The length returned by [sqlite3_str_length(X)] does not include the +** zero-termination byte. +** +** ^The [sqlite3_str_value(X)] method returns a pointer to the current +** content of the dynamic string under construction in X. The value +** returned by [sqlite3_str_value(X)] is managed by the sqlite3_str object X +** and might be freed or altered by any subsequent method on the same +** [sqlite3_str] object. Applications must not used the pointer returned +** [sqlite3_str_value(X)] after any subsequent method call on the same +** object. ^Applications may change the content of the string returned +** by [sqlite3_str_value(X)] as long as they do not write into any bytes +** outside the range of 0 to [sqlite3_str_length(X)] and do not read or +** write any byte after any subsequent sqlite3_str method call. +*/ +SQLITE_API int sqlite3_str_errcode(sqlite3_str*); +SQLITE_API int sqlite3_str_length(sqlite3_str*); +SQLITE_API char *sqlite3_str_value(sqlite3_str*); + +/* +** CAPI3REF: SQLite Runtime Status +** +** ^These interfaces are used to retrieve runtime status information +** about the performance of SQLite, and optionally to reset various +** highwater marks. ^The first argument is an integer code for +** the specific parameter to measure. ^(Recognized integer codes +** are of the form [status parameters | SQLITE_STATUS_...].)^ +** ^The current value of the parameter is returned into *pCurrent. +** ^The highest recorded value is returned in *pHighwater. ^If the +** resetFlag is true, then the highest record value is reset after +** *pHighwater is written. ^(Some parameters do not record the highest +** value. For those parameters +** nothing is written into *pHighwater and the resetFlag is ignored.)^ +** ^(Other parameters record only the highwater mark and not the current +** value. For these latter parameters nothing is written into *pCurrent.)^ +** +** ^The sqlite3_status() and sqlite3_status64() routines return +** SQLITE_OK on success and a non-zero [error code] on failure. +** +** If either the current value or the highwater mark is too large to +** be represented by a 32-bit integer, then the values returned by +** sqlite3_status() are undefined. +** +** See also: [sqlite3_db_status()] +*/ +SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag); +SQLITE_API int sqlite3_status64( + int op, + sqlite3_int64 *pCurrent, + sqlite3_int64 *pHighwater, + int resetFlag +); + + +/* +** CAPI3REF: Status Parameters +** KEYWORDS: {status parameters} +** +** These integer constants designate various run-time status parameters +** that can be returned by [sqlite3_status()]. +** +**
    +** [[SQLITE_STATUS_MEMORY_USED]] ^(
    SQLITE_STATUS_MEMORY_USED
    +**
    This parameter is the current amount of memory checked out +** using [sqlite3_malloc()], either directly or indirectly. The +** figure includes calls made to [sqlite3_malloc()] by the application +** and internal memory usage by the SQLite library. Auxiliary page-cache +** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in +** this parameter. The amount returned is the sum of the allocation +** sizes as reported by the xSize method in [sqlite3_mem_methods].
    )^ +** +** [[SQLITE_STATUS_MALLOC_SIZE]] ^(
    SQLITE_STATUS_MALLOC_SIZE
    +**
    This parameter records the largest memory allocation request +** handed to [sqlite3_malloc()] or [sqlite3_realloc()] (or their +** internal equivalents). Only the value returned in the +** *pHighwater parameter to [sqlite3_status()] is of interest. +** The value written into the *pCurrent parameter is undefined.
    )^ +** +** [[SQLITE_STATUS_MALLOC_COUNT]] ^(
    SQLITE_STATUS_MALLOC_COUNT
    +**
    This parameter records the number of separate memory allocations +** currently checked out.
    )^ +** +** [[SQLITE_STATUS_PAGECACHE_USED]] ^(
    SQLITE_STATUS_PAGECACHE_USED
    +**
    This parameter returns the number of pages used out of the +** [pagecache memory allocator] that was configured using +** [SQLITE_CONFIG_PAGECACHE]. The +** value returned is in pages, not in bytes.
    )^ +** +** [[SQLITE_STATUS_PAGECACHE_OVERFLOW]] +** ^(
    SQLITE_STATUS_PAGECACHE_OVERFLOW
    +**
    This parameter returns the number of bytes of page cache +** allocation which could not be satisfied by the [SQLITE_CONFIG_PAGECACHE] +** buffer and where forced to overflow to [sqlite3_malloc()]. The +** returned value includes allocations that overflowed because they +** where too large (they were larger than the "sz" parameter to +** [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because +** no space was left in the page cache.
    )^ +** +** [[SQLITE_STATUS_PAGECACHE_SIZE]] ^(
    SQLITE_STATUS_PAGECACHE_SIZE
    +**
    This parameter records the largest memory allocation request +** handed to the [pagecache memory allocator]. Only the value returned in the +** *pHighwater parameter to [sqlite3_status()] is of interest. +** The value written into the *pCurrent parameter is undefined.
    )^ +** +** [[SQLITE_STATUS_SCRATCH_USED]]
    SQLITE_STATUS_SCRATCH_USED
    +**
    No longer used.
    +** +** [[SQLITE_STATUS_SCRATCH_OVERFLOW]] ^(
    SQLITE_STATUS_SCRATCH_OVERFLOW
    +**
    No longer used.
    +** +** [[SQLITE_STATUS_SCRATCH_SIZE]]
    SQLITE_STATUS_SCRATCH_SIZE
    +**
    No longer used.
    +** +** [[SQLITE_STATUS_PARSER_STACK]] ^(
    SQLITE_STATUS_PARSER_STACK
    +**
    The *pHighwater parameter records the deepest parser stack. +** The *pCurrent value is undefined. The *pHighwater value is only +** meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].
    )^ +**
    +** +** New status parameters may be added from time to time. +*/ +#define SQLITE_STATUS_MEMORY_USED 0 +#define SQLITE_STATUS_PAGECACHE_USED 1 +#define SQLITE_STATUS_PAGECACHE_OVERFLOW 2 +#define SQLITE_STATUS_SCRATCH_USED 3 /* NOT USED */ +#define SQLITE_STATUS_SCRATCH_OVERFLOW 4 /* NOT USED */ +#define SQLITE_STATUS_MALLOC_SIZE 5 +#define SQLITE_STATUS_PARSER_STACK 6 +#define SQLITE_STATUS_PAGECACHE_SIZE 7 +#define SQLITE_STATUS_SCRATCH_SIZE 8 /* NOT USED */ +#define SQLITE_STATUS_MALLOC_COUNT 9 + +/* +** CAPI3REF: Database Connection Status +** METHOD: sqlite3 +** +** ^This interface is used to retrieve runtime status information +** about a single [database connection]. ^The first argument is the +** database connection object to be interrogated. ^The second argument +** is an integer constant, taken from the set of +** [SQLITE_DBSTATUS options], that +** determines the parameter to interrogate. The set of +** [SQLITE_DBSTATUS options] is likely +** to grow in future releases of SQLite. +** +** ^The current value of the requested parameter is written into *pCur +** and the highest instantaneous value is written into *pHiwtr. ^If +** the resetFlg is true, then the highest instantaneous value is +** reset back down to the current value. +** +** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a +** non-zero [error code] on failure. +** +** See also: [sqlite3_status()] and [sqlite3_stmt_status()]. +*/ +SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg); + +/* +** CAPI3REF: Status Parameters for database connections +** KEYWORDS: {SQLITE_DBSTATUS options} +** +** These constants are the available integer "verbs" that can be passed as +** the second argument to the [sqlite3_db_status()] interface. +** +** New verbs may be added in future releases of SQLite. Existing verbs +** might be discontinued. Applications should check the return code from +** [sqlite3_db_status()] to make sure that the call worked. +** The [sqlite3_db_status()] interface will return a non-zero error code +** if a discontinued or unsupported verb is invoked. +** +**
    +** [[SQLITE_DBSTATUS_LOOKASIDE_USED]] ^(
    SQLITE_DBSTATUS_LOOKASIDE_USED
    +**
    This parameter returns the number of lookaside memory slots currently +** checked out.
    )^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_HIT]] ^(
    SQLITE_DBSTATUS_LOOKASIDE_HIT
    +**
    This parameter returns the number of malloc attempts that were +** satisfied using lookaside memory. Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE]] +** ^(
    SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE
    +**
    This parameter returns the number malloc attempts that might have +** been satisfied using lookaside memory but failed due to the amount of +** memory requested being larger than the lookaside slot size. +** Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL]] +** ^(
    SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL
    +**
    This parameter returns the number malloc attempts that might have +** been satisfied using lookaside memory but failed due to all lookaside +** memory already being in use. +** Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_CACHE_USED]] ^(
    SQLITE_DBSTATUS_CACHE_USED
    +**
    This parameter returns the approximate number of bytes of heap +** memory used by all pager caches associated with the database connection.)^ +** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0. +** +** [[SQLITE_DBSTATUS_CACHE_USED_SHARED]] +** ^(
    SQLITE_DBSTATUS_CACHE_USED_SHARED
    +**
    This parameter is similar to DBSTATUS_CACHE_USED, except that if a +** pager cache is shared between two or more connections the bytes of heap +** memory used by that pager cache is divided evenly between the attached +** connections.)^ In other words, if none of the pager caches associated +** with the database connection are shared, this request returns the same +** value as DBSTATUS_CACHE_USED. Or, if one or more or the pager caches are +** shared, the value returned by this call will be smaller than that returned +** by DBSTATUS_CACHE_USED. ^The highwater mark associated with +** SQLITE_DBSTATUS_CACHE_USED_SHARED is always 0. +** +** [[SQLITE_DBSTATUS_SCHEMA_USED]] ^(
    SQLITE_DBSTATUS_SCHEMA_USED
    +**
    This parameter returns the approximate number of bytes of heap +** memory used to store the schema for all databases associated +** with the connection - main, temp, and any [ATTACH]-ed databases.)^ +** ^The full amount of memory used by the schemas is reported, even if the +** schema memory is shared with other database connections due to +** [shared cache mode] being enabled. +** ^The highwater mark associated with SQLITE_DBSTATUS_SCHEMA_USED is always 0. +** +** [[SQLITE_DBSTATUS_STMT_USED]] ^(
    SQLITE_DBSTATUS_STMT_USED
    +**
    This parameter returns the approximate number of bytes of heap +** and lookaside memory used by all prepared statements associated with +** the database connection.)^ +** ^The highwater mark associated with SQLITE_DBSTATUS_STMT_USED is always 0. +**
    +** +** [[SQLITE_DBSTATUS_CACHE_HIT]] ^(
    SQLITE_DBSTATUS_CACHE_HIT
    +**
    This parameter returns the number of pager cache hits that have +** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_HIT +** is always 0. +**
    +** +** [[SQLITE_DBSTATUS_CACHE_MISS]] ^(
    SQLITE_DBSTATUS_CACHE_MISS
    +**
    This parameter returns the number of pager cache misses that have +** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_MISS +** is always 0. +**
    +** +** [[SQLITE_DBSTATUS_CACHE_WRITE]] ^(
    SQLITE_DBSTATUS_CACHE_WRITE
    +**
    This parameter returns the number of dirty cache entries that have +** been written to disk. Specifically, the number of pages written to the +** wal file in wal mode databases, or the number of pages written to the +** database file in rollback mode databases. Any pages written as part of +** transaction rollback or database recovery operations are not included. +** If an IO or other error occurs while writing a page to disk, the effect +** on subsequent SQLITE_DBSTATUS_CACHE_WRITE requests is undefined.)^ ^The +** highwater mark associated with SQLITE_DBSTATUS_CACHE_WRITE is always 0. +**
    +** +** [[SQLITE_DBSTATUS_CACHE_SPILL]] ^(
    SQLITE_DBSTATUS_CACHE_SPILL
    +**
    This parameter returns the number of dirty cache entries that have +** been written to disk in the middle of a transaction due to the page +** cache overflowing. Transactions are more efficient if they are written +** to disk all at once. When pages spill mid-transaction, that introduces +** additional overhead. This parameter can be used help identify +** inefficiencies that can be resolved by increasing the cache size. +**
    +** +** [[SQLITE_DBSTATUS_DEFERRED_FKS]] ^(
    SQLITE_DBSTATUS_DEFERRED_FKS
    +**
    This parameter returns zero for the current value if and only if +** all foreign key constraints (deferred or immediate) have been +** resolved.)^ ^The highwater mark is always 0. +**
    +**
    +*/ +#define SQLITE_DBSTATUS_LOOKASIDE_USED 0 +#define SQLITE_DBSTATUS_CACHE_USED 1 +#define SQLITE_DBSTATUS_SCHEMA_USED 2 +#define SQLITE_DBSTATUS_STMT_USED 3 +#define SQLITE_DBSTATUS_LOOKASIDE_HIT 4 +#define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5 +#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6 +#define SQLITE_DBSTATUS_CACHE_HIT 7 +#define SQLITE_DBSTATUS_CACHE_MISS 8 +#define SQLITE_DBSTATUS_CACHE_WRITE 9 +#define SQLITE_DBSTATUS_DEFERRED_FKS 10 +#define SQLITE_DBSTATUS_CACHE_USED_SHARED 11 +#define SQLITE_DBSTATUS_CACHE_SPILL 12 +#define SQLITE_DBSTATUS_MAX 12 /* Largest defined DBSTATUS */ + + +/* +** CAPI3REF: Prepared Statement Status +** METHOD: sqlite3_stmt +** +** ^(Each prepared statement maintains various +** [SQLITE_STMTSTATUS counters] that measure the number +** of times it has performed specific operations.)^ These counters can +** be used to monitor the performance characteristics of the prepared +** statements. For example, if the number of table steps greatly exceeds +** the number of table searches or result rows, that would tend to indicate +** that the prepared statement is using a full table scan rather than +** an index. +** +** ^(This interface is used to retrieve and reset counter values from +** a [prepared statement]. The first argument is the prepared statement +** object to be interrogated. The second argument +** is an integer code for a specific [SQLITE_STMTSTATUS counter] +** to be interrogated.)^ +** ^The current value of the requested counter is returned. +** ^If the resetFlg is true, then the counter is reset to zero after this +** interface call returns. +** +** See also: [sqlite3_status()] and [sqlite3_db_status()]. +*/ +SQLITE_API int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg); + +/* +** CAPI3REF: Status Parameters for prepared statements +** KEYWORDS: {SQLITE_STMTSTATUS counter} {SQLITE_STMTSTATUS counters} +** +** These preprocessor macros define integer codes that name counter +** values associated with the [sqlite3_stmt_status()] interface. +** The meanings of the various counters are as follows: +** +**
    +** [[SQLITE_STMTSTATUS_FULLSCAN_STEP]]
    SQLITE_STMTSTATUS_FULLSCAN_STEP
    +**
    ^This is the number of times that SQLite has stepped forward in +** a table as part of a full table scan. Large numbers for this counter +** may indicate opportunities for performance improvement through +** careful use of indices.
    +** +** [[SQLITE_STMTSTATUS_SORT]]
    SQLITE_STMTSTATUS_SORT
    +**
    ^This is the number of sort operations that have occurred. +** A non-zero value in this counter may indicate an opportunity to +** improvement performance through careful use of indices.
    +** +** [[SQLITE_STMTSTATUS_AUTOINDEX]]
    SQLITE_STMTSTATUS_AUTOINDEX
    +**
    ^This is the number of rows inserted into transient indices that +** were created automatically in order to help joins run faster. +** A non-zero value in this counter may indicate an opportunity to +** improvement performance by adding permanent indices that do not +** need to be reinitialized each time the statement is run.
    +** +** [[SQLITE_STMTSTATUS_VM_STEP]]
    SQLITE_STMTSTATUS_VM_STEP
    +**
    ^This is the number of virtual machine operations executed +** by the prepared statement if that number is less than or equal +** to 2147483647. The number of virtual machine operations can be +** used as a proxy for the total work done by the prepared statement. +** If the number of virtual machine operations exceeds 2147483647 +** then the value returned by this statement status code is undefined. +** +** [[SQLITE_STMTSTATUS_REPREPARE]]
    SQLITE_STMTSTATUS_REPREPARE
    +**
    ^This is the number of times that the prepare statement has been +** automatically regenerated due to schema changes or changes to +** [bound parameters] that might affect the query plan. +** +** [[SQLITE_STMTSTATUS_RUN]]
    SQLITE_STMTSTATUS_RUN
    +**
    ^This is the number of times that the prepared statement has +** been run. A single "run" for the purposes of this counter is one +** or more calls to [sqlite3_step()] followed by a call to [sqlite3_reset()]. +** The counter is incremented on the first [sqlite3_step()] call of each +** cycle. +** +** [[SQLITE_STMTSTATUS_MEMUSED]]
    SQLITE_STMTSTATUS_MEMUSED
    +**
    ^This is the approximate number of bytes of heap memory +** used to store the prepared statement. ^This value is not actually +** a counter, and so the resetFlg parameter to sqlite3_stmt_status() +** is ignored when the opcode is SQLITE_STMTSTATUS_MEMUSED. +**
    +**
    +*/ +#define SQLITE_STMTSTATUS_FULLSCAN_STEP 1 +#define SQLITE_STMTSTATUS_SORT 2 +#define SQLITE_STMTSTATUS_AUTOINDEX 3 +#define SQLITE_STMTSTATUS_VM_STEP 4 +#define SQLITE_STMTSTATUS_REPREPARE 5 +#define SQLITE_STMTSTATUS_RUN 6 +#define SQLITE_STMTSTATUS_MEMUSED 99 + +/* +** CAPI3REF: Custom Page Cache Object +** +** The sqlite3_pcache type is opaque. It is implemented by +** the pluggable module. The SQLite core has no knowledge of +** its size or internal structure and never deals with the +** sqlite3_pcache object except by holding and passing pointers +** to the object. +** +** See [sqlite3_pcache_methods2] for additional information. +*/ +typedef struct sqlite3_pcache sqlite3_pcache; + +/* +** CAPI3REF: Custom Page Cache Object +** +** The sqlite3_pcache_page object represents a single page in the +** page cache. The page cache will allocate instances of this +** object. Various methods of the page cache use pointers to instances +** of this object as parameters or as their return value. +** +** See [sqlite3_pcache_methods2] for additional information. +*/ +typedef struct sqlite3_pcache_page sqlite3_pcache_page; +struct sqlite3_pcache_page { + void *pBuf; /* The content of the page */ + void *pExtra; /* Extra information associated with the page */ +}; + +/* +** CAPI3REF: Application Defined Page Cache. +** KEYWORDS: {page cache} +** +** ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE2], ...) interface can +** register an alternative page cache implementation by passing in an +** instance of the sqlite3_pcache_methods2 structure.)^ +** In many applications, most of the heap memory allocated by +** SQLite is used for the page cache. +** By implementing a +** custom page cache using this API, an application can better control +** the amount of memory consumed by SQLite, the way in which +** that memory is allocated and released, and the policies used to +** determine exactly which parts of a database file are cached and for +** how long. +** +** The alternative page cache mechanism is an +** extreme measure that is only needed by the most demanding applications. +** The built-in page cache is recommended for most uses. +** +** ^(The contents of the sqlite3_pcache_methods2 structure are copied to an +** internal buffer by SQLite within the call to [sqlite3_config]. Hence +** the application may discard the parameter after the call to +** [sqlite3_config()] returns.)^ +** +** [[the xInit() page cache method]] +** ^(The xInit() method is called once for each effective +** call to [sqlite3_initialize()])^ +** (usually only once during the lifetime of the process). ^(The xInit() +** method is passed a copy of the sqlite3_pcache_methods2.pArg value.)^ +** The intent of the xInit() method is to set up global data structures +** required by the custom page cache implementation. +** ^(If the xInit() method is NULL, then the +** built-in default page cache is used instead of the application defined +** page cache.)^ +** +** [[the xShutdown() page cache method]] +** ^The xShutdown() method is called by [sqlite3_shutdown()]. +** It can be used to clean up +** any outstanding resources before process shutdown, if required. +** ^The xShutdown() method may be NULL. +** +** ^SQLite automatically serializes calls to the xInit method, +** so the xInit method need not be threadsafe. ^The +** xShutdown method is only called from [sqlite3_shutdown()] so it does +** not need to be threadsafe either. All other methods must be threadsafe +** in multithreaded applications. +** +** ^SQLite will never invoke xInit() more than once without an intervening +** call to xShutdown(). +** +** [[the xCreate() page cache methods]] +** ^SQLite invokes the xCreate() method to construct a new cache instance. +** SQLite will typically create one cache instance for each open database file, +** though this is not guaranteed. ^The +** first parameter, szPage, is the size in bytes of the pages that must +** be allocated by the cache. ^szPage will always a power of two. ^The +** second parameter szExtra is a number of bytes of extra storage +** associated with each page cache entry. ^The szExtra parameter will +** a number less than 250. SQLite will use the +** extra szExtra bytes on each page to store metadata about the underlying +** database page on disk. The value passed into szExtra depends +** on the SQLite version, the target platform, and how SQLite was compiled. +** ^The third argument to xCreate(), bPurgeable, is true if the cache being +** created will be used to cache database pages of a file stored on disk, or +** false if it is used for an in-memory database. The cache implementation +** does not have to do anything special based with the value of bPurgeable; +** it is purely advisory. ^On a cache where bPurgeable is false, SQLite will +** never invoke xUnpin() except to deliberately delete a page. +** ^In other words, calls to xUnpin() on a cache with bPurgeable set to +** false will always have the "discard" flag set to true. +** ^Hence, a cache created with bPurgeable false will +** never contain any unpinned pages. +** +** [[the xCachesize() page cache method]] +** ^(The xCachesize() method may be called at any time by SQLite to set the +** suggested maximum cache-size (number of pages stored by) the cache +** instance passed as the first argument. This is the value configured using +** the SQLite "[PRAGMA cache_size]" command.)^ As with the bPurgeable +** parameter, the implementation is not required to do anything with this +** value; it is advisory only. +** +** [[the xPagecount() page cache methods]] +** The xPagecount() method must return the number of pages currently +** stored in the cache, both pinned and unpinned. +** +** [[the xFetch() page cache methods]] +** The xFetch() method locates a page in the cache and returns a pointer to +** an sqlite3_pcache_page object associated with that page, or a NULL pointer. +** The pBuf element of the returned sqlite3_pcache_page object will be a +** pointer to a buffer of szPage bytes used to store the content of a +** single database page. The pExtra element of sqlite3_pcache_page will be +** a pointer to the szExtra bytes of extra storage that SQLite has requested +** for each entry in the page cache. +** +** The page to be fetched is determined by the key. ^The minimum key value +** is 1. After it has been retrieved using xFetch, the page is considered +** to be "pinned". +** +** If the requested page is already in the page cache, then the page cache +** implementation must return a pointer to the page buffer with its content +** intact. If the requested page is not already in the cache, then the +** cache implementation should use the value of the createFlag +** parameter to help it determined what action to take: +** +** +**
    createFlag Behavior when page is not already in cache +**
    0 Do not allocate a new page. Return NULL. +**
    1 Allocate a new page if it easy and convenient to do so. +** Otherwise return NULL. +**
    2 Make every effort to allocate a new page. Only return +** NULL if allocating a new page is effectively impossible. +**
    +** +** ^(SQLite will normally invoke xFetch() with a createFlag of 0 or 1. SQLite +** will only use a createFlag of 2 after a prior call with a createFlag of 1 +** failed.)^ In between the xFetch() calls, SQLite may +** attempt to unpin one or more cache pages by spilling the content of +** pinned pages to disk and synching the operating system disk cache. +** +** [[the xUnpin() page cache method]] +** ^xUnpin() is called by SQLite with a pointer to a currently pinned page +** as its second argument. If the third parameter, discard, is non-zero, +** then the page must be evicted from the cache. +** ^If the discard parameter is +** zero, then the page may be discarded or retained at the discretion of +** page cache implementation. ^The page cache implementation +** may choose to evict unpinned pages at any time. +** +** The cache must not perform any reference counting. A single +** call to xUnpin() unpins the page regardless of the number of prior calls +** to xFetch(). +** +** [[the xRekey() page cache methods]] +** The xRekey() method is used to change the key value associated with the +** page passed as the second argument. If the cache +** previously contains an entry associated with newKey, it must be +** discarded. ^Any prior cache entry associated with newKey is guaranteed not +** to be pinned. +** +** When SQLite calls the xTruncate() method, the cache must discard all +** existing cache entries with page numbers (keys) greater than or equal +** to the value of the iLimit parameter passed to xTruncate(). If any +** of these pages are pinned, they are implicitly unpinned, meaning that +** they can be safely discarded. +** +** [[the xDestroy() page cache method]] +** ^The xDestroy() method is used to delete a cache allocated by xCreate(). +** All resources associated with the specified cache should be freed. ^After +** calling the xDestroy() method, SQLite considers the [sqlite3_pcache*] +** handle invalid, and will not use it with any other sqlite3_pcache_methods2 +** functions. +** +** [[the xShrink() page cache method]] +** ^SQLite invokes the xShrink() method when it wants the page cache to +** free up as much of heap memory as possible. The page cache implementation +** is not obligated to free any memory, but well-behaved implementations should +** do their best. +*/ +typedef struct sqlite3_pcache_methods2 sqlite3_pcache_methods2; +struct sqlite3_pcache_methods2 { + int iVersion; + void *pArg; + int (*xInit)(void*); + void (*xShutdown)(void*); + sqlite3_pcache *(*xCreate)(int szPage, int szExtra, int bPurgeable); + void (*xCachesize)(sqlite3_pcache*, int nCachesize); + int (*xPagecount)(sqlite3_pcache*); + sqlite3_pcache_page *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); + void (*xUnpin)(sqlite3_pcache*, sqlite3_pcache_page*, int discard); + void (*xRekey)(sqlite3_pcache*, sqlite3_pcache_page*, + unsigned oldKey, unsigned newKey); + void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); + void (*xDestroy)(sqlite3_pcache*); + void (*xShrink)(sqlite3_pcache*); +}; + +/* +** This is the obsolete pcache_methods object that has now been replaced +** by sqlite3_pcache_methods2. This object is not used by SQLite. It is +** retained in the header file for backwards compatibility only. +*/ +typedef struct sqlite3_pcache_methods sqlite3_pcache_methods; +struct sqlite3_pcache_methods { + void *pArg; + int (*xInit)(void*); + void (*xShutdown)(void*); + sqlite3_pcache *(*xCreate)(int szPage, int bPurgeable); + void (*xCachesize)(sqlite3_pcache*, int nCachesize); + int (*xPagecount)(sqlite3_pcache*); + void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); + void (*xUnpin)(sqlite3_pcache*, void*, int discard); + void (*xRekey)(sqlite3_pcache*, void*, unsigned oldKey, unsigned newKey); + void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); + void (*xDestroy)(sqlite3_pcache*); +}; + + +/* +** CAPI3REF: Online Backup Object +** +** The sqlite3_backup object records state information about an ongoing +** online backup operation. ^The sqlite3_backup object is created by +** a call to [sqlite3_backup_init()] and is destroyed by a call to +** [sqlite3_backup_finish()]. +** +** See Also: [Using the SQLite Online Backup API] +*/ +typedef struct sqlite3_backup sqlite3_backup; + +/* +** CAPI3REF: Online Backup API. +** +** The backup API copies the content of one database into another. +** It is useful either for creating backups of databases or +** for copying in-memory databases to or from persistent files. +** +** See Also: [Using the SQLite Online Backup API] +** +** ^SQLite holds a write transaction open on the destination database file +** for the duration of the backup operation. +** ^The source database is read-locked only while it is being read; +** it is not locked continuously for the entire backup operation. +** ^Thus, the backup may be performed on a live source database without +** preventing other database connections from +** reading or writing to the source database while the backup is underway. +** +** ^(To perform a backup operation: +**
      +**
    1. sqlite3_backup_init() is called once to initialize the +** backup, +**
    2. sqlite3_backup_step() is called one or more times to transfer +** the data between the two databases, and finally +**
    3. sqlite3_backup_finish() is called to release all resources +** associated with the backup operation. +**
    )^ +** There should be exactly one call to sqlite3_backup_finish() for each +** successful call to sqlite3_backup_init(). +** +** [[sqlite3_backup_init()]] sqlite3_backup_init() +** +** ^The D and N arguments to sqlite3_backup_init(D,N,S,M) are the +** [database connection] associated with the destination database +** and the database name, respectively. +** ^The database name is "main" for the main database, "temp" for the +** temporary database, or the name specified after the AS keyword in +** an [ATTACH] statement for an attached database. +** ^The S and M arguments passed to +** sqlite3_backup_init(D,N,S,M) identify the [database connection] +** and database name of the source database, respectively. +** ^The source and destination [database connections] (parameters S and D) +** must be different or else sqlite3_backup_init(D,N,S,M) will fail with +** an error. +** +** ^A call to sqlite3_backup_init() will fail, returning NULL, if +** there is already a read or read-write transaction open on the +** destination database. +** +** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is +** returned and an error code and error message are stored in the +** destination [database connection] D. +** ^The error code and message for the failed call to sqlite3_backup_init() +** can be retrieved using the [sqlite3_errcode()], [sqlite3_errmsg()], and/or +** [sqlite3_errmsg16()] functions. +** ^A successful call to sqlite3_backup_init() returns a pointer to an +** [sqlite3_backup] object. +** ^The [sqlite3_backup] object may be used with the sqlite3_backup_step() and +** sqlite3_backup_finish() functions to perform the specified backup +** operation. +** +** [[sqlite3_backup_step()]] sqlite3_backup_step() +** +** ^Function sqlite3_backup_step(B,N) will copy up to N pages between +** the source and destination databases specified by [sqlite3_backup] object B. +** ^If N is negative, all remaining source pages are copied. +** ^If sqlite3_backup_step(B,N) successfully copies N pages and there +** are still more pages to be copied, then the function returns [SQLITE_OK]. +** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages +** from source to destination, then it returns [SQLITE_DONE]. +** ^If an error occurs while running sqlite3_backup_step(B,N), +** then an [error code] is returned. ^As well as [SQLITE_OK] and +** [SQLITE_DONE], a call to sqlite3_backup_step() may return [SQLITE_READONLY], +** [SQLITE_NOMEM], [SQLITE_BUSY], [SQLITE_LOCKED], or an +** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX] extended error code. +** +** ^(The sqlite3_backup_step() might return [SQLITE_READONLY] if +**
      +**
    1. the destination database was opened read-only, or +**
    2. the destination database is using write-ahead-log journaling +** and the destination and source page sizes differ, or +**
    3. the destination database is an in-memory database and the +** destination and source page sizes differ. +**
    )^ +** +** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then +** the [sqlite3_busy_handler | busy-handler function] +** is invoked (if one is specified). ^If the +** busy-handler returns non-zero before the lock is available, then +** [SQLITE_BUSY] is returned to the caller. ^In this case the call to +** sqlite3_backup_step() can be retried later. ^If the source +** [database connection] +** is being used to write to the source database when sqlite3_backup_step() +** is called, then [SQLITE_LOCKED] is returned immediately. ^Again, in this +** case the call to sqlite3_backup_step() can be retried later on. ^(If +** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX], [SQLITE_NOMEM], or +** [SQLITE_READONLY] is returned, then +** there is no point in retrying the call to sqlite3_backup_step(). These +** errors are considered fatal.)^ The application must accept +** that the backup operation has failed and pass the backup operation handle +** to the sqlite3_backup_finish() to release associated resources. +** +** ^The first call to sqlite3_backup_step() obtains an exclusive lock +** on the destination file. ^The exclusive lock is not released until either +** sqlite3_backup_finish() is called or the backup operation is complete +** and sqlite3_backup_step() returns [SQLITE_DONE]. ^Every call to +** sqlite3_backup_step() obtains a [shared lock] on the source database that +** lasts for the duration of the sqlite3_backup_step() call. +** ^Because the source database is not locked between calls to +** sqlite3_backup_step(), the source database may be modified mid-way +** through the backup process. ^If the source database is modified by an +** external process or via a database connection other than the one being +** used by the backup operation, then the backup will be automatically +** restarted by the next call to sqlite3_backup_step(). ^If the source +** database is modified by the using the same database connection as is used +** by the backup operation, then the backup database is automatically +** updated at the same time. +** +** [[sqlite3_backup_finish()]] sqlite3_backup_finish() +** +** When sqlite3_backup_step() has returned [SQLITE_DONE], or when the +** application wishes to abandon the backup operation, the application +** should destroy the [sqlite3_backup] by passing it to sqlite3_backup_finish(). +** ^The sqlite3_backup_finish() interfaces releases all +** resources associated with the [sqlite3_backup] object. +** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any +** active write-transaction on the destination database is rolled back. +** The [sqlite3_backup] object is invalid +** and may not be used following a call to sqlite3_backup_finish(). +** +** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no +** sqlite3_backup_step() errors occurred, regardless or whether or not +** sqlite3_backup_step() completed. +** ^If an out-of-memory condition or IO error occurred during any prior +** sqlite3_backup_step() call on the same [sqlite3_backup] object, then +** sqlite3_backup_finish() returns the corresponding [error code]. +** +** ^A return of [SQLITE_BUSY] or [SQLITE_LOCKED] from sqlite3_backup_step() +** is not a permanent error and does not affect the return value of +** sqlite3_backup_finish(). +** +** [[sqlite3_backup_remaining()]] [[sqlite3_backup_pagecount()]] +** sqlite3_backup_remaining() and sqlite3_backup_pagecount() +** +** ^The sqlite3_backup_remaining() routine returns the number of pages still +** to be backed up at the conclusion of the most recent sqlite3_backup_step(). +** ^The sqlite3_backup_pagecount() routine returns the total number of pages +** in the source database at the conclusion of the most recent +** sqlite3_backup_step(). +** ^(The values returned by these functions are only updated by +** sqlite3_backup_step(). If the source database is modified in a way that +** changes the size of the source database or the number of pages remaining, +** those changes are not reflected in the output of sqlite3_backup_pagecount() +** and sqlite3_backup_remaining() until after the next +** sqlite3_backup_step().)^ +** +** Concurrent Usage of Database Handles +** +** ^The source [database connection] may be used by the application for other +** purposes while a backup operation is underway or being initialized. +** ^If SQLite is compiled and configured to support threadsafe database +** connections, then the source database connection may be used concurrently +** from within other threads. +** +** However, the application must guarantee that the destination +** [database connection] is not passed to any other API (by any thread) after +** sqlite3_backup_init() is called and before the corresponding call to +** sqlite3_backup_finish(). SQLite does not currently check to see +** if the application incorrectly accesses the destination [database connection] +** and so no error code is reported, but the operations may malfunction +** nevertheless. Use of the destination database connection while a +** backup is in progress might also also cause a mutex deadlock. +** +** If running in [shared cache mode], the application must +** guarantee that the shared cache used by the destination database +** is not accessed while the backup is running. In practice this means +** that the application must guarantee that the disk file being +** backed up to is not accessed by any connection within the process, +** not just the specific connection that was passed to sqlite3_backup_init(). +** +** The [sqlite3_backup] object itself is partially threadsafe. Multiple +** threads may safely make multiple concurrent calls to sqlite3_backup_step(). +** However, the sqlite3_backup_remaining() and sqlite3_backup_pagecount() +** APIs are not strictly speaking threadsafe. If they are invoked at the +** same time as another thread is invoking sqlite3_backup_step() it is +** possible that they return invalid values. +*/ +SQLITE_API sqlite3_backup *sqlite3_backup_init( + sqlite3 *pDest, /* Destination database handle */ + const char *zDestName, /* Destination database name */ + sqlite3 *pSource, /* Source database handle */ + const char *zSourceName /* Source database name */ +); +SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage); +SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p); +SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p); +SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p); + +/* +** CAPI3REF: Unlock Notification +** METHOD: sqlite3 +** +** ^When running in shared-cache mode, a database operation may fail with +** an [SQLITE_LOCKED] error if the required locks on the shared-cache or +** individual tables within the shared-cache cannot be obtained. See +** [SQLite Shared-Cache Mode] for a description of shared-cache locking. +** ^This API may be used to register a callback that SQLite will invoke +** when the connection currently holding the required lock relinquishes it. +** ^This API is only available if the library was compiled with the +** [SQLITE_ENABLE_UNLOCK_NOTIFY] C-preprocessor symbol defined. +** +** See Also: [Using the SQLite Unlock Notification Feature]. +** +** ^Shared-cache locks are released when a database connection concludes +** its current transaction, either by committing it or rolling it back. +** +** ^When a connection (known as the blocked connection) fails to obtain a +** shared-cache lock and SQLITE_LOCKED is returned to the caller, the +** identity of the database connection (the blocking connection) that +** has locked the required resource is stored internally. ^After an +** application receives an SQLITE_LOCKED error, it may call the +** sqlite3_unlock_notify() method with the blocked connection handle as +** the first argument to register for a callback that will be invoked +** when the blocking connections current transaction is concluded. ^The +** callback is invoked from within the [sqlite3_step] or [sqlite3_close] +** call that concludes the blocking connection's transaction. +** +** ^(If sqlite3_unlock_notify() is called in a multi-threaded application, +** there is a chance that the blocking connection will have already +** concluded its transaction by the time sqlite3_unlock_notify() is invoked. +** If this happens, then the specified callback is invoked immediately, +** from within the call to sqlite3_unlock_notify().)^ +** +** ^If the blocked connection is attempting to obtain a write-lock on a +** shared-cache table, and more than one other connection currently holds +** a read-lock on the same table, then SQLite arbitrarily selects one of +** the other connections to use as the blocking connection. +** +** ^(There may be at most one unlock-notify callback registered by a +** blocked connection. If sqlite3_unlock_notify() is called when the +** blocked connection already has a registered unlock-notify callback, +** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is +** called with a NULL pointer as its second argument, then any existing +** unlock-notify callback is canceled. ^The blocked connections +** unlock-notify callback may also be canceled by closing the blocked +** connection using [sqlite3_close()]. +** +** The unlock-notify callback is not reentrant. If an application invokes +** any sqlite3_xxx API functions from within an unlock-notify callback, a +** crash or deadlock may be the result. +** +** ^Unless deadlock is detected (see below), sqlite3_unlock_notify() always +** returns SQLITE_OK. +** +** Callback Invocation Details +** +** When an unlock-notify callback is registered, the application provides a +** single void* pointer that is passed to the callback when it is invoked. +** However, the signature of the callback function allows SQLite to pass +** it an array of void* context pointers. The first argument passed to +** an unlock-notify callback is a pointer to an array of void* pointers, +** and the second is the number of entries in the array. +** +** When a blocking connection's transaction is concluded, there may be +** more than one blocked connection that has registered for an unlock-notify +** callback. ^If two or more such blocked connections have specified the +** same callback function, then instead of invoking the callback function +** multiple times, it is invoked once with the set of void* context pointers +** specified by the blocked connections bundled together into an array. +** This gives the application an opportunity to prioritize any actions +** related to the set of unblocked database connections. +** +** Deadlock Detection +** +** Assuming that after registering for an unlock-notify callback a +** database waits for the callback to be issued before taking any further +** action (a reasonable assumption), then using this API may cause the +** application to deadlock. For example, if connection X is waiting for +** connection Y's transaction to be concluded, and similarly connection +** Y is waiting on connection X's transaction, then neither connection +** will proceed and the system may remain deadlocked indefinitely. +** +** To avoid this scenario, the sqlite3_unlock_notify() performs deadlock +** detection. ^If a given call to sqlite3_unlock_notify() would put the +** system in a deadlocked state, then SQLITE_LOCKED is returned and no +** unlock-notify callback is registered. The system is said to be in +** a deadlocked state if connection A has registered for an unlock-notify +** callback on the conclusion of connection B's transaction, and connection +** B has itself registered for an unlock-notify callback when connection +** A's transaction is concluded. ^Indirect deadlock is also detected, so +** the system is also considered to be deadlocked if connection B has +** registered for an unlock-notify callback on the conclusion of connection +** C's transaction, where connection C is waiting on connection A. ^Any +** number of levels of indirection are allowed. +** +** The "DROP TABLE" Exception +** +** When a call to [sqlite3_step()] returns SQLITE_LOCKED, it is almost +** always appropriate to call sqlite3_unlock_notify(). There is however, +** one exception. When executing a "DROP TABLE" or "DROP INDEX" statement, +** SQLite checks if there are any currently executing SELECT statements +** that belong to the same connection. If there are, SQLITE_LOCKED is +** returned. In this case there is no "blocking connection", so invoking +** sqlite3_unlock_notify() results in the unlock-notify callback being +** invoked immediately. If the application then re-attempts the "DROP TABLE" +** or "DROP INDEX" query, an infinite loop might be the result. +** +** One way around this problem is to check the extended error code returned +** by an sqlite3_step() call. ^(If there is a blocking connection, then the +** extended error code is set to SQLITE_LOCKED_SHAREDCACHE. Otherwise, in +** the special "DROP TABLE/INDEX" case, the extended error code is just +** SQLITE_LOCKED.)^ +*/ +SQLITE_API int sqlite3_unlock_notify( + sqlite3 *pBlocked, /* Waiting connection */ + void (*xNotify)(void **apArg, int nArg), /* Callback function to invoke */ + void *pNotifyArg /* Argument to pass to xNotify */ +); + + +/* +** CAPI3REF: String Comparison +** +** ^The [sqlite3_stricmp()] and [sqlite3_strnicmp()] APIs allow applications +** and extensions to compare the contents of two buffers containing UTF-8 +** strings in a case-independent fashion, using the same definition of "case +** independence" that SQLite uses internally when comparing identifiers. +*/ +SQLITE_API int sqlite3_stricmp(const char *, const char *); +SQLITE_API int sqlite3_strnicmp(const char *, const char *, int); + +/* +** CAPI3REF: String Globbing +* +** ^The [sqlite3_strglob(P,X)] interface returns zero if and only if +** string X matches the [GLOB] pattern P. +** ^The definition of [GLOB] pattern matching used in +** [sqlite3_strglob(P,X)] is the same as for the "X GLOB P" operator in the +** SQL dialect understood by SQLite. ^The [sqlite3_strglob(P,X)] function +** is case sensitive. +** +** Note that this routine returns zero on a match and non-zero if the strings +** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()]. +** +** See also: [sqlite3_strlike()]. +*/ +SQLITE_API int sqlite3_strglob(const char *zGlob, const char *zStr); + +/* +** CAPI3REF: String LIKE Matching +* +** ^The [sqlite3_strlike(P,X,E)] interface returns zero if and only if +** string X matches the [LIKE] pattern P with escape character E. +** ^The definition of [LIKE] pattern matching used in +** [sqlite3_strlike(P,X,E)] is the same as for the "X LIKE P ESCAPE E" +** operator in the SQL dialect understood by SQLite. ^For "X LIKE P" without +** the ESCAPE clause, set the E parameter of [sqlite3_strlike(P,X,E)] to 0. +** ^As with the LIKE operator, the [sqlite3_strlike(P,X,E)] function is case +** insensitive - equivalent upper and lower case ASCII characters match +** one another. +** +** ^The [sqlite3_strlike(P,X,E)] function matches Unicode characters, though +** only ASCII characters are case folded. +** +** Note that this routine returns zero on a match and non-zero if the strings +** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()]. +** +** See also: [sqlite3_strglob()]. +*/ +SQLITE_API int sqlite3_strlike(const char *zGlob, const char *zStr, unsigned int cEsc); + +/* +** CAPI3REF: Error Logging Interface +** +** ^The [sqlite3_log()] interface writes a message into the [error log] +** established by the [SQLITE_CONFIG_LOG] option to [sqlite3_config()]. +** ^If logging is enabled, the zFormat string and subsequent arguments are +** used with [sqlite3_snprintf()] to generate the final output string. +** +** The sqlite3_log() interface is intended for use by extensions such as +** virtual tables, collating functions, and SQL functions. While there is +** nothing to prevent an application from calling sqlite3_log(), doing so +** is considered bad form. +** +** The zFormat string must not be NULL. +** +** To avoid deadlocks and other threading problems, the sqlite3_log() routine +** will not use dynamically allocated memory. The log message is stored in +** a fixed-length buffer on the stack. If the log message is longer than +** a few hundred characters, it will be truncated to the length of the +** buffer. +*/ +SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...); + +/* +** CAPI3REF: Write-Ahead Log Commit Hook +** METHOD: sqlite3 +** +** ^The [sqlite3_wal_hook()] function is used to register a callback that +** is invoked each time data is committed to a database in wal mode. +** +** ^(The callback is invoked by SQLite after the commit has taken place and +** the associated write-lock on the database released)^, so the implementation +** may read, write or [checkpoint] the database as required. +** +** ^The first parameter passed to the callback function when it is invoked +** is a copy of the third parameter passed to sqlite3_wal_hook() when +** registering the callback. ^The second is a copy of the database handle. +** ^The third parameter is the name of the database that was written to - +** either "main" or the name of an [ATTACH]-ed database. ^The fourth parameter +** is the number of pages currently in the write-ahead log file, +** including those that were just committed. +** +** The callback function should normally return [SQLITE_OK]. ^If an error +** code is returned, that error will propagate back up through the +** SQLite code base to cause the statement that provoked the callback +** to report an error, though the commit will have still occurred. If the +** callback returns [SQLITE_ROW] or [SQLITE_DONE], or if it returns a value +** that does not correspond to any valid SQLite error code, the results +** are undefined. +** +** A single database handle may have at most a single write-ahead log callback +** registered at one time. ^Calling [sqlite3_wal_hook()] replaces any +** previously registered write-ahead log callback. ^Note that the +** [sqlite3_wal_autocheckpoint()] interface and the +** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will +** overwrite any prior [sqlite3_wal_hook()] settings. +*/ +SQLITE_API void *sqlite3_wal_hook( + sqlite3*, + int(*)(void *,sqlite3*,const char*,int), + void* +); + +/* +** CAPI3REF: Configure an auto-checkpoint +** METHOD: sqlite3 +** +** ^The [sqlite3_wal_autocheckpoint(D,N)] is a wrapper around +** [sqlite3_wal_hook()] that causes any database on [database connection] D +** to automatically [checkpoint] +** after committing a transaction if there are N or +** more frames in the [write-ahead log] file. ^Passing zero or +** a negative value as the nFrame parameter disables automatic +** checkpoints entirely. +** +** ^The callback registered by this function replaces any existing callback +** registered using [sqlite3_wal_hook()]. ^Likewise, registering a callback +** using [sqlite3_wal_hook()] disables the automatic checkpoint mechanism +** configured by this function. +** +** ^The [wal_autocheckpoint pragma] can be used to invoke this interface +** from SQL. +** +** ^Checkpoints initiated by this mechanism are +** [sqlite3_wal_checkpoint_v2|PASSIVE]. +** +** ^Every new [database connection] defaults to having the auto-checkpoint +** enabled with a threshold of 1000 or [SQLITE_DEFAULT_WAL_AUTOCHECKPOINT] +** pages. The use of this interface +** is only necessary if the default setting is found to be suboptimal +** for a particular application. +*/ +SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int N); + +/* +** CAPI3REF: Checkpoint a database +** METHOD: sqlite3 +** +** ^(The sqlite3_wal_checkpoint(D,X) is equivalent to +** [sqlite3_wal_checkpoint_v2](D,X,[SQLITE_CHECKPOINT_PASSIVE],0,0).)^ +** +** In brief, sqlite3_wal_checkpoint(D,X) causes the content in the +** [write-ahead log] for database X on [database connection] D to be +** transferred into the database file and for the write-ahead log to +** be reset. See the [checkpointing] documentation for addition +** information. +** +** This interface used to be the only way to cause a checkpoint to +** occur. But then the newer and more powerful [sqlite3_wal_checkpoint_v2()] +** interface was added. This interface is retained for backwards +** compatibility and as a convenience for applications that need to manually +** start a callback but which do not need the full power (and corresponding +** complication) of [sqlite3_wal_checkpoint_v2()]. +*/ +SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb); + +/* +** CAPI3REF: Checkpoint a database +** METHOD: sqlite3 +** +** ^(The sqlite3_wal_checkpoint_v2(D,X,M,L,C) interface runs a checkpoint +** operation on database X of [database connection] D in mode M. Status +** information is written back into integers pointed to by L and C.)^ +** ^(The M parameter must be a valid [checkpoint mode]:)^ +** +**
    +**
    SQLITE_CHECKPOINT_PASSIVE
    +** ^Checkpoint as many frames as possible without waiting for any database +** readers or writers to finish, then sync the database file if all frames +** in the log were checkpointed. ^The [busy-handler callback] +** is never invoked in the SQLITE_CHECKPOINT_PASSIVE mode. +** ^On the other hand, passive mode might leave the checkpoint unfinished +** if there are concurrent readers or writers. +** +**
    SQLITE_CHECKPOINT_FULL
    +** ^This mode blocks (it invokes the +** [sqlite3_busy_handler|busy-handler callback]) until there is no +** database writer and all readers are reading from the most recent database +** snapshot. ^It then checkpoints all frames in the log file and syncs the +** database file. ^This mode blocks new database writers while it is pending, +** but new database readers are allowed to continue unimpeded. +** +**
    SQLITE_CHECKPOINT_RESTART
    +** ^This mode works the same way as SQLITE_CHECKPOINT_FULL with the addition +** that after checkpointing the log file it blocks (calls the +** [busy-handler callback]) +** until all readers are reading from the database file only. ^This ensures +** that the next writer will restart the log file from the beginning. +** ^Like SQLITE_CHECKPOINT_FULL, this mode blocks new +** database writer attempts while it is pending, but does not impede readers. +** +**
    SQLITE_CHECKPOINT_TRUNCATE
    +** ^This mode works the same way as SQLITE_CHECKPOINT_RESTART with the +** addition that it also truncates the log file to zero bytes just prior +** to a successful return. +**
    +** +** ^If pnLog is not NULL, then *pnLog is set to the total number of frames in +** the log file or to -1 if the checkpoint could not run because +** of an error or because the database is not in [WAL mode]. ^If pnCkpt is not +** NULL,then *pnCkpt is set to the total number of checkpointed frames in the +** log file (including any that were already checkpointed before the function +** was called) or to -1 if the checkpoint could not run due to an error or +** because the database is not in WAL mode. ^Note that upon successful +** completion of an SQLITE_CHECKPOINT_TRUNCATE, the log file will have been +** truncated to zero bytes and so both *pnLog and *pnCkpt will be set to zero. +** +** ^All calls obtain an exclusive "checkpoint" lock on the database file. ^If +** any other process is running a checkpoint operation at the same time, the +** lock cannot be obtained and SQLITE_BUSY is returned. ^Even if there is a +** busy-handler configured, it will not be invoked in this case. +** +** ^The SQLITE_CHECKPOINT_FULL, RESTART and TRUNCATE modes also obtain the +** exclusive "writer" lock on the database file. ^If the writer lock cannot be +** obtained immediately, and a busy-handler is configured, it is invoked and +** the writer lock retried until either the busy-handler returns 0 or the lock +** is successfully obtained. ^The busy-handler is also invoked while waiting for +** database readers as described above. ^If the busy-handler returns 0 before +** the writer lock is obtained or while waiting for database readers, the +** checkpoint operation proceeds from that point in the same way as +** SQLITE_CHECKPOINT_PASSIVE - checkpointing as many frames as possible +** without blocking any further. ^SQLITE_BUSY is returned in this case. +** +** ^If parameter zDb is NULL or points to a zero length string, then the +** specified operation is attempted on all WAL databases [attached] to +** [database connection] db. In this case the +** values written to output parameters *pnLog and *pnCkpt are undefined. ^If +** an SQLITE_BUSY error is encountered when processing one or more of the +** attached WAL databases, the operation is still attempted on any remaining +** attached databases and SQLITE_BUSY is returned at the end. ^If any other +** error occurs while processing an attached database, processing is abandoned +** and the error code is returned to the caller immediately. ^If no error +** (SQLITE_BUSY or otherwise) is encountered while processing the attached +** databases, SQLITE_OK is returned. +** +** ^If database zDb is the name of an attached database that is not in WAL +** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. ^If +** zDb is not NULL (or a zero length string) and is not the name of any +** attached database, SQLITE_ERROR is returned to the caller. +** +** ^Unless it returns SQLITE_MISUSE, +** the sqlite3_wal_checkpoint_v2() interface +** sets the error information that is queried by +** [sqlite3_errcode()] and [sqlite3_errmsg()]. +** +** ^The [PRAGMA wal_checkpoint] command can be used to invoke this interface +** from SQL. +*/ +SQLITE_API int sqlite3_wal_checkpoint_v2( + sqlite3 *db, /* Database handle */ + const char *zDb, /* Name of attached database (or NULL) */ + int eMode, /* SQLITE_CHECKPOINT_* value */ + int *pnLog, /* OUT: Size of WAL log in frames */ + int *pnCkpt /* OUT: Total number of frames checkpointed */ +); + +/* +** CAPI3REF: Checkpoint Mode Values +** KEYWORDS: {checkpoint mode} +** +** These constants define all valid values for the "checkpoint mode" passed +** as the third parameter to the [sqlite3_wal_checkpoint_v2()] interface. +** See the [sqlite3_wal_checkpoint_v2()] documentation for details on the +** meaning of each of these checkpoint modes. +*/ +#define SQLITE_CHECKPOINT_PASSIVE 0 /* Do as much as possible w/o blocking */ +#define SQLITE_CHECKPOINT_FULL 1 /* Wait for writers, then checkpoint */ +#define SQLITE_CHECKPOINT_RESTART 2 /* Like FULL but wait for for readers */ +#define SQLITE_CHECKPOINT_TRUNCATE 3 /* Like RESTART but also truncate WAL */ + +/* +** CAPI3REF: Virtual Table Interface Configuration +** +** This function may be called by either the [xConnect] or [xCreate] method +** of a [virtual table] implementation to configure +** various facets of the virtual table interface. +** +** If this interface is invoked outside the context of an xConnect or +** xCreate virtual table method then the behavior is undefined. +** +** In the call sqlite3_vtab_config(D,C,...) the D parameter is the +** [database connection] in which the virtual table is being created and +** which is passed in as the first argument to the [xConnect] or [xCreate] +** method that is invoking sqlite3_vtab_config(). The C parameter is one +** of the [virtual table configuration options]. The presence and meaning +** of parameters after C depend on which [virtual table configuration option] +** is used. +*/ +SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...); + +/* +** CAPI3REF: Virtual Table Configuration Options +** KEYWORDS: {virtual table configuration options} +** KEYWORDS: {virtual table configuration option} +** +** These macros define the various options to the +** [sqlite3_vtab_config()] interface that [virtual table] implementations +** can use to customize and optimize their behavior. +** +**
    +** [[SQLITE_VTAB_CONSTRAINT_SUPPORT]] +**
    SQLITE_VTAB_CONSTRAINT_SUPPORT
    +**
    Calls of the form +** [sqlite3_vtab_config](db,SQLITE_VTAB_CONSTRAINT_SUPPORT,X) are supported, +** where X is an integer. If X is zero, then the [virtual table] whose +** [xCreate] or [xConnect] method invoked [sqlite3_vtab_config()] does not +** support constraints. In this configuration (which is the default) if +** a call to the [xUpdate] method returns [SQLITE_CONSTRAINT], then the entire +** statement is rolled back as if [ON CONFLICT | OR ABORT] had been +** specified as part of the users SQL statement, regardless of the actual +** ON CONFLICT mode specified. +** +** If X is non-zero, then the virtual table implementation guarantees +** that if [xUpdate] returns [SQLITE_CONSTRAINT], it will do so before +** any modifications to internal or persistent data structures have been made. +** If the [ON CONFLICT] mode is ABORT, FAIL, IGNORE or ROLLBACK, SQLite +** is able to roll back a statement or database transaction, and abandon +** or continue processing the current SQL statement as appropriate. +** If the ON CONFLICT mode is REPLACE and the [xUpdate] method returns +** [SQLITE_CONSTRAINT], SQLite handles this as if the ON CONFLICT mode +** had been ABORT. +** +** Virtual table implementations that are required to handle OR REPLACE +** must do so within the [xUpdate] method. If a call to the +** [sqlite3_vtab_on_conflict()] function indicates that the current ON +** CONFLICT policy is REPLACE, the virtual table implementation should +** silently replace the appropriate rows within the xUpdate callback and +** return SQLITE_OK. Or, if this is not possible, it may return +** SQLITE_CONSTRAINT, in which case SQLite falls back to OR ABORT +** constraint handling. +**
    +** +** [[SQLITE_VTAB_DIRECTONLY]]
    SQLITE_VTAB_DIRECTONLY
    +**
    Calls of the form +** [sqlite3_vtab_config](db,SQLITE_VTAB_DIRECTONLY) from within the +** the [xConnect] or [xCreate] methods of a [virtual table] implmentation +** prohibits that virtual table from being used from within triggers and +** views. +**
    +** +** [[SQLITE_VTAB_INNOCUOUS]]
    SQLITE_VTAB_INNOCUOUS
    +**
    Calls of the form +** [sqlite3_vtab_config](db,SQLITE_VTAB_INNOCUOUS) from within the +** the [xConnect] or [xCreate] methods of a [virtual table] implmentation +** identify that virtual table as being safe to use from within triggers +** and views. Conceptually, the SQLITE_VTAB_INNOCUOUS tag means that the +** virtual table can do no serious harm even if it is controlled by a +** malicious hacker. Developers should avoid setting the SQLITE_VTAB_INNOCUOUS +** flag unless absolutely necessary. +**
    +**
    +*/ +#define SQLITE_VTAB_CONSTRAINT_SUPPORT 1 +#define SQLITE_VTAB_INNOCUOUS 2 +#define SQLITE_VTAB_DIRECTONLY 3 + +/* +** CAPI3REF: Determine The Virtual Table Conflict Policy +** +** This function may only be called from within a call to the [xUpdate] method +** of a [virtual table] implementation for an INSERT or UPDATE operation. ^The +** value returned is one of [SQLITE_ROLLBACK], [SQLITE_IGNORE], [SQLITE_FAIL], +** [SQLITE_ABORT], or [SQLITE_REPLACE], according to the [ON CONFLICT] mode +** of the SQL statement that triggered the call to the [xUpdate] method of the +** [virtual table]. +*/ +SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *); + +/* +** CAPI3REF: Determine If Virtual Table Column Access Is For UPDATE +** +** If the sqlite3_vtab_nochange(X) routine is called within the [xColumn] +** method of a [virtual table], then it might return true if the +** column is being fetched as part of an UPDATE operation during which the +** column value will not change. The virtual table implementation can use +** this hint as permission to substitute a return value that is less +** expensive to compute and that the corresponding +** [xUpdate] method understands as a "no-change" value. +** +** If the [xColumn] method calls sqlite3_vtab_nochange() and finds that +** the column is not changed by the UPDATE statement, then the xColumn +** method can optionally return without setting a result, without calling +** any of the [sqlite3_result_int|sqlite3_result_xxxxx() interfaces]. +** In that case, [sqlite3_value_nochange(X)] will return true for the +** same column in the [xUpdate] method. +** +** The sqlite3_vtab_nochange() routine is an optimization. Virtual table +** implementations should continue to give a correct answer even if the +** sqlite3_vtab_nochange() interface were to always return false. In the +** current implementation, the sqlite3_vtab_nochange() interface does always +** returns false for the enhanced [UPDATE FROM] statement. +*/ +SQLITE_API int sqlite3_vtab_nochange(sqlite3_context*); + +/* +** CAPI3REF: Determine The Collation For a Virtual Table Constraint +** +** This function may only be called from within a call to the [xBestIndex] +** method of a [virtual table]. +** +** The first argument must be the sqlite3_index_info object that is the +** first parameter to the xBestIndex() method. The second argument must be +** an index into the aConstraint[] array belonging to the sqlite3_index_info +** structure passed to xBestIndex. This function returns a pointer to a buffer +** containing the name of the collation sequence for the corresponding +** constraint. +*/ +SQLITE_API SQLITE_EXPERIMENTAL const char *sqlite3_vtab_collation(sqlite3_index_info*,int); + +/* +** CAPI3REF: Conflict resolution modes +** KEYWORDS: {conflict resolution mode} +** +** These constants are returned by [sqlite3_vtab_on_conflict()] to +** inform a [virtual table] implementation what the [ON CONFLICT] mode +** is for the SQL statement being evaluated. +** +** Note that the [SQLITE_IGNORE] constant is also used as a potential +** return value from the [sqlite3_set_authorizer()] callback and that +** [SQLITE_ABORT] is also a [result code]. +*/ +#define SQLITE_ROLLBACK 1 +/* #define SQLITE_IGNORE 2 // Also used by sqlite3_authorizer() callback */ +#define SQLITE_FAIL 3 +/* #define SQLITE_ABORT 4 // Also an error code */ +#define SQLITE_REPLACE 5 + +/* +** CAPI3REF: Prepared Statement Scan Status Opcodes +** KEYWORDS: {scanstatus options} +** +** The following constants can be used for the T parameter to the +** [sqlite3_stmt_scanstatus(S,X,T,V)] interface. Each constant designates a +** different metric for sqlite3_stmt_scanstatus() to return. +** +** When the value returned to V is a string, space to hold that string is +** managed by the prepared statement S and will be automatically freed when +** S is finalized. +** +**
    +** [[SQLITE_SCANSTAT_NLOOP]]
    SQLITE_SCANSTAT_NLOOP
    +**
    ^The [sqlite3_int64] variable pointed to by the V parameter will be +** set to the total number of times that the X-th loop has run.
    +** +** [[SQLITE_SCANSTAT_NVISIT]]
    SQLITE_SCANSTAT_NVISIT
    +**
    ^The [sqlite3_int64] variable pointed to by the V parameter will be set +** to the total number of rows examined by all iterations of the X-th loop.
    +** +** [[SQLITE_SCANSTAT_EST]]
    SQLITE_SCANSTAT_EST
    +**
    ^The "double" variable pointed to by the V parameter will be set to the +** query planner's estimate for the average number of rows output from each +** iteration of the X-th loop. If the query planner's estimates was accurate, +** then this value will approximate the quotient NVISIT/NLOOP and the +** product of this value for all prior loops with the same SELECTID will +** be the NLOOP value for the current loop. +** +** [[SQLITE_SCANSTAT_NAME]]
    SQLITE_SCANSTAT_NAME
    +**
    ^The "const char *" variable pointed to by the V parameter will be set +** to a zero-terminated UTF-8 string containing the name of the index or table +** used for the X-th loop. +** +** [[SQLITE_SCANSTAT_EXPLAIN]]
    SQLITE_SCANSTAT_EXPLAIN
    +**
    ^The "const char *" variable pointed to by the V parameter will be set +** to a zero-terminated UTF-8 string containing the [EXPLAIN QUERY PLAN] +** description for the X-th loop. +** +** [[SQLITE_SCANSTAT_SELECTID]]
    SQLITE_SCANSTAT_SELECT
    +**
    ^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. +**
    +*/ +#define SQLITE_SCANSTAT_NLOOP 0 +#define SQLITE_SCANSTAT_NVISIT 1 +#define SQLITE_SCANSTAT_EST 2 +#define SQLITE_SCANSTAT_NAME 3 +#define SQLITE_SCANSTAT_EXPLAIN 4 +#define SQLITE_SCANSTAT_SELECTID 5 + +/* +** CAPI3REF: Prepared Statement Scan Status +** METHOD: sqlite3_stmt +** +** This interface returns 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. +** +** Since this interface is expected to be rarely used, it is only +** available if SQLite is compiled using the [SQLITE_ENABLE_STMT_SCANSTATUS] +** compile-time option. +** +** 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. +** +** ^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. +** +** See also: [sqlite3_stmt_scanstatus_reset()] +*/ +SQLITE_API int sqlite3_stmt_scanstatus( + sqlite3_stmt *pStmt, /* Prepared statement for which info desired */ + int idx, /* Index of loop to report on */ + int iScanStatusOp, /* Information desired. SQLITE_SCANSTAT_* */ + void *pOut /* Result written here */ +); + +/* +** CAPI3REF: Zero Scan-Status Counters +** METHOD: sqlite3_stmt +** +** ^Zero all [sqlite3_stmt_scanstatus()] related event counters. +** +** This API is only available if the library is built with pre-processor +** symbol [SQLITE_ENABLE_STMT_SCANSTATUS] defined. +*/ +SQLITE_API void sqlite3_stmt_scanstatus_reset(sqlite3_stmt*); + +/* +** CAPI3REF: Flush caches to disk mid-transaction +** METHOD: sqlite3 +** +** ^If a write-transaction is open on [database connection] D when the +** [sqlite3_db_cacheflush(D)] interface invoked, any dirty +** pages in the pager-cache that are not currently in use are written out +** to disk. A dirty page may be in use if a database cursor created by an +** active SQL statement is reading from it, or if it is page 1 of a database +** file (page 1 is always "in use"). ^The [sqlite3_db_cacheflush(D)] +** interface flushes caches for all schemas - "main", "temp", and +** any [attached] databases. +** +** ^If this function needs to obtain extra database locks before dirty pages +** can be flushed to disk, it does so. ^If those locks cannot be obtained +** immediately and there is a busy-handler callback configured, it is invoked +** in the usual manner. ^If the required lock still cannot be obtained, then +** the database is skipped and an attempt made to flush any dirty pages +** belonging to the next (if any) database. ^If any databases are skipped +** because locks cannot be obtained, but no other error occurs, this +** function returns SQLITE_BUSY. +** +** ^If any other error occurs while flushing dirty pages to disk (for +** example an IO error or out-of-memory condition), then processing is +** abandoned and an SQLite [error code] is returned to the caller immediately. +** +** ^Otherwise, if no error occurs, [sqlite3_db_cacheflush()] returns SQLITE_OK. +** +** ^This function does not set the database handle error code or message +** returned by the [sqlite3_errcode()] and [sqlite3_errmsg()] functions. +*/ +SQLITE_API int sqlite3_db_cacheflush(sqlite3*); + +/* +** CAPI3REF: The pre-update hook. +** METHOD: sqlite3 +** +** ^These interfaces are only available if SQLite is compiled using the +** [SQLITE_ENABLE_PREUPDATE_HOOK] compile-time option. +** +** ^The [sqlite3_preupdate_hook()] interface registers a callback function +** that is invoked prior to each [INSERT], [UPDATE], and [DELETE] operation +** on a database table. +** ^At most one preupdate hook may be registered at a time on a single +** [database connection]; each call to [sqlite3_preupdate_hook()] overrides +** the previous setting. +** ^The preupdate hook is disabled by invoking [sqlite3_preupdate_hook()] +** with a NULL pointer as the second parameter. +** ^The third parameter to [sqlite3_preupdate_hook()] is passed through as +** the first parameter to callbacks. +** +** ^The preupdate hook only fires for changes to real database tables; the +** preupdate hook is not invoked for changes to [virtual tables] or to +** system tables like sqlite_sequence or sqlite_stat1. +** +** ^The second parameter to the preupdate callback is a pointer to +** the [database connection] that registered the preupdate hook. +** ^The third parameter to the preupdate callback is one of the constants +** [SQLITE_INSERT], [SQLITE_DELETE], or [SQLITE_UPDATE] to identify the +** kind of update operation that is about to occur. +** ^(The fourth parameter to the preupdate callback is the name of the +** database within the database connection that is being modified. This +** will be "main" for the main database or "temp" for TEMP tables or +** the name given after the AS keyword in the [ATTACH] statement for attached +** databases.)^ +** ^The fifth parameter to the preupdate callback is the name of the +** table that is being modified. +** +** For an UPDATE or DELETE operation on a [rowid table], the sixth +** parameter passed to the preupdate callback is the initial [rowid] of the +** row being modified or deleted. For an INSERT operation on a rowid table, +** or any operation on a WITHOUT ROWID table, the value of the sixth +** parameter is undefined. For an INSERT or UPDATE on a rowid table the +** seventh parameter is the final rowid value of the row being inserted +** or updated. The value of the seventh parameter passed to the callback +** function is not defined for operations on WITHOUT ROWID tables, or for +** DELETE operations on rowid tables. +** +** The [sqlite3_preupdate_old()], [sqlite3_preupdate_new()], +** [sqlite3_preupdate_count()], and [sqlite3_preupdate_depth()] interfaces +** provide additional information about a preupdate event. These routines +** may only be called from within a preupdate callback. Invoking any of +** these routines from outside of a preupdate callback or with a +** [database connection] pointer that is different from the one supplied +** to the preupdate callback results in undefined and probably undesirable +** behavior. +** +** ^The [sqlite3_preupdate_count(D)] interface returns the number of columns +** in the row that is being inserted, updated, or deleted. +** +** ^The [sqlite3_preupdate_old(D,N,P)] interface writes into P a pointer to +** a [protected sqlite3_value] that contains the value of the Nth column of +** the table row before it is updated. The N parameter must be between 0 +** and one less than the number of columns or the behavior will be +** undefined. This must only be used within SQLITE_UPDATE and SQLITE_DELETE +** preupdate callbacks; if it is used by an SQLITE_INSERT callback then the +** behavior is undefined. The [sqlite3_value] that P points to +** will be destroyed when the preupdate callback returns. +** +** ^The [sqlite3_preupdate_new(D,N,P)] interface writes into P a pointer to +** a [protected sqlite3_value] that contains the value of the Nth column of +** the table row after it is updated. The N parameter must be between 0 +** and one less than the number of columns or the behavior will be +** undefined. This must only be used within SQLITE_INSERT and SQLITE_UPDATE +** preupdate callbacks; if it is used by an SQLITE_DELETE callback then the +** behavior is undefined. The [sqlite3_value] that P points to +** will be destroyed when the preupdate callback returns. +** +** ^The [sqlite3_preupdate_depth(D)] interface returns 0 if the preupdate +** callback was invoked as a result of a direct insert, update, or delete +** operation; or 1 for inserts, updates, or deletes invoked by top-level +** triggers; or 2 for changes resulting from triggers called by top-level +** triggers; and so forth. +** +** See also: [sqlite3_update_hook()] +*/ +#if defined(SQLITE_ENABLE_PREUPDATE_HOOK) +SQLITE_API void *sqlite3_preupdate_hook( + sqlite3 *db, + void(*xPreUpdate)( + void *pCtx, /* Copy of third arg to preupdate_hook() */ + sqlite3 *db, /* Database handle */ + int op, /* SQLITE_UPDATE, DELETE or INSERT */ + char const *zDb, /* Database name */ + char const *zName, /* Table name */ + sqlite3_int64 iKey1, /* Rowid of row about to be deleted/updated */ + sqlite3_int64 iKey2 /* New rowid value (for a rowid UPDATE) */ + ), + void* +); +SQLITE_API int sqlite3_preupdate_old(sqlite3 *, int, sqlite3_value **); +SQLITE_API int sqlite3_preupdate_count(sqlite3 *); +SQLITE_API int sqlite3_preupdate_depth(sqlite3 *); +SQLITE_API int sqlite3_preupdate_new(sqlite3 *, int, sqlite3_value **); +#endif + +/* +** CAPI3REF: Low-level system error code +** METHOD: sqlite3 +** +** ^Attempt to return the underlying operating system error code or error +** number that caused the most recent I/O error or failure to open a file. +** The return value is OS-dependent. For example, on unix systems, after +** [sqlite3_open_v2()] returns [SQLITE_CANTOPEN], this interface could be +** called to get back the underlying "errno" that caused the problem, such +** as ENOSPC, EAUTH, EISDIR, and so forth. +*/ +SQLITE_API int sqlite3_system_errno(sqlite3*); + +/* +** CAPI3REF: Database Snapshot +** KEYWORDS: {snapshot} {sqlite3_snapshot} +** +** An instance of the snapshot object records the state of a [WAL mode] +** database for some specific point in history. +** +** In [WAL mode], multiple [database connections] that are open on the +** same database file can each be reading a different historical version +** of the database file. When a [database connection] begins a read +** transaction, that connection sees an unchanging copy of the database +** as it existed for the point in time when the transaction first started. +** Subsequent changes to the database from other connections are not seen +** by the reader until a new read transaction is started. +** +** The sqlite3_snapshot object records state information about an historical +** version of the database file so that it is possible to later open a new read +** transaction that sees that historical version of the database rather than +** the most recent version. +*/ +typedef struct sqlite3_snapshot { + unsigned char hidden[48]; +} sqlite3_snapshot; + +/* +** CAPI3REF: Record A Database Snapshot +** CONSTRUCTOR: sqlite3_snapshot +** +** ^The [sqlite3_snapshot_get(D,S,P)] interface attempts to make a +** new [sqlite3_snapshot] object that records the current state of +** schema S in database connection D. ^On success, the +** [sqlite3_snapshot_get(D,S,P)] interface writes a pointer to the newly +** created [sqlite3_snapshot] object into *P and returns SQLITE_OK. +** If there is not already a read-transaction open on schema S when +** this function is called, one is opened automatically. +** +** The following must be true for this function to succeed. If any of +** the following statements are false when sqlite3_snapshot_get() is +** called, SQLITE_ERROR is returned. The final value of *P is undefined +** in this case. +** +**
      +**
    • The database handle must not be in [autocommit mode]. +** +**
    • Schema S of [database connection] D must be a [WAL mode] database. +** +**
    • There must not be a write transaction open on schema S of database +** connection D. +** +**
    • One or more transactions must have been written to the current wal +** file since it was created on disk (by any connection). This means +** that a snapshot cannot be taken on a wal mode database with no wal +** file immediately after it is first opened. At least one transaction +** must be written to it first. +**
    +** +** This function may also return SQLITE_NOMEM. If it is called with the +** database handle in autocommit mode but fails for some other reason, +** whether or not a read transaction is opened on schema S is undefined. +** +** The [sqlite3_snapshot] object returned from a successful call to +** [sqlite3_snapshot_get()] must be freed using [sqlite3_snapshot_free()] +** to avoid a memory leak. +** +** The [sqlite3_snapshot_get()] interface is only available when the +** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. +*/ +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_get( + sqlite3 *db, + const char *zSchema, + sqlite3_snapshot **ppSnapshot +); + +/* +** CAPI3REF: Start a read transaction on an historical snapshot +** METHOD: sqlite3_snapshot +** +** ^The [sqlite3_snapshot_open(D,S,P)] interface either starts a new read +** transaction or upgrades an existing one for schema S of +** [database connection] D such that the read transaction refers to +** historical [snapshot] P, rather than the most recent change to the +** database. ^The [sqlite3_snapshot_open()] interface returns SQLITE_OK +** on success or an appropriate [error code] if it fails. +** +** ^In order to succeed, the database connection must not be in +** [autocommit mode] when [sqlite3_snapshot_open(D,S,P)] is called. If there +** is already a read transaction open on schema S, then the database handle +** must have no active statements (SELECT statements that have been passed +** to sqlite3_step() but not sqlite3_reset() or sqlite3_finalize()). +** SQLITE_ERROR is returned if either of these conditions is violated, or +** if schema S does not exist, or if the snapshot object is invalid. +** +** ^A call to sqlite3_snapshot_open() will fail to open if the specified +** snapshot has been overwritten by a [checkpoint]. In this case +** SQLITE_ERROR_SNAPSHOT is returned. +** +** If there is already a read transaction open when this function is +** invoked, then the same read transaction remains open (on the same +** database snapshot) if SQLITE_ERROR, SQLITE_BUSY or SQLITE_ERROR_SNAPSHOT +** is returned. If another error code - for example SQLITE_PROTOCOL or an +** SQLITE_IOERR error code - is returned, then the final state of the +** read transaction is undefined. If SQLITE_OK is returned, then the +** read transaction is now open on database snapshot P. +** +** ^(A call to [sqlite3_snapshot_open(D,S,P)] will fail if the +** database connection D does not know that the database file for +** schema S is in [WAL mode]. A database connection might not know +** that the database file is in [WAL mode] if there has been no prior +** I/O on that database connection, or if the database entered [WAL mode] +** after the most recent I/O on the database connection.)^ +** (Hint: Run "[PRAGMA application_id]" against a newly opened +** database connection in order to make it ready to use snapshots.) +** +** The [sqlite3_snapshot_open()] interface is only available when the +** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. +*/ +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_open( + sqlite3 *db, + const char *zSchema, + sqlite3_snapshot *pSnapshot +); + +/* +** CAPI3REF: Destroy a snapshot +** DESTRUCTOR: sqlite3_snapshot +** +** ^The [sqlite3_snapshot_free(P)] interface destroys [sqlite3_snapshot] P. +** The application must eventually free every [sqlite3_snapshot] object +** using this routine to avoid a memory leak. +** +** The [sqlite3_snapshot_free()] interface is only available when the +** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. +*/ +SQLITE_API SQLITE_EXPERIMENTAL void sqlite3_snapshot_free(sqlite3_snapshot*); + +/* +** CAPI3REF: Compare the ages of two snapshot handles. +** METHOD: sqlite3_snapshot +** +** The sqlite3_snapshot_cmp(P1, P2) interface is used to compare the ages +** of two valid snapshot handles. +** +** If the two snapshot handles are not associated with the same database +** file, the result of the comparison is undefined. +** +** Additionally, the result of the comparison is only valid if both of the +** snapshot handles were obtained by calling sqlite3_snapshot_get() since the +** last time the wal file was deleted. The wal file is deleted when the +** database is changed back to rollback mode or when the number of database +** clients drops to zero. If either snapshot handle was obtained before the +** wal file was last deleted, the value returned by this function +** is undefined. +** +** Otherwise, this API returns a negative value if P1 refers to an older +** snapshot than P2, zero if the two handles refer to the same database +** snapshot, and a positive value if P1 is a newer snapshot than P2. +** +** This interface is only available if SQLite is compiled with the +** [SQLITE_ENABLE_SNAPSHOT] option. +*/ +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_cmp( + sqlite3_snapshot *p1, + sqlite3_snapshot *p2 +); + +/* +** CAPI3REF: Recover snapshots from a wal file +** METHOD: sqlite3_snapshot +** +** If a [WAL file] remains on disk after all database connections close +** (either through the use of the [SQLITE_FCNTL_PERSIST_WAL] [file control] +** or because the last process to have the database opened exited without +** calling [sqlite3_close()]) and a new connection is subsequently opened +** on that database and [WAL file], the [sqlite3_snapshot_open()] interface +** will only be able to open the last transaction added to the WAL file +** even though the WAL file contains other valid transactions. +** +** This function attempts to scan the WAL file associated with database zDb +** of database handle db and make all valid snapshots available to +** sqlite3_snapshot_open(). It is an error if there is already a read +** transaction open on the database, or if the database is not a WAL mode +** database. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +** +** This interface is only available if SQLite is compiled with the +** [SQLITE_ENABLE_SNAPSHOT] option. +*/ +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb); + +/* +** CAPI3REF: Serialize a database +** +** The sqlite3_serialize(D,S,P,F) interface returns a pointer to memory +** that is a serialization of the S database on [database connection] D. +** If P is not a NULL pointer, then the size of the database in bytes +** is written into *P. +** +** For an ordinary on-disk database file, the serialization is just a +** copy of the disk file. For an in-memory database or a "TEMP" database, +** the serialization is the same sequence of bytes which would be written +** to disk if that database where backed up to disk. +** +** The usual case is that sqlite3_serialize() copies the serialization of +** the database into memory obtained from [sqlite3_malloc64()] and returns +** a pointer to that memory. The caller is responsible for freeing the +** returned value to avoid a memory leak. However, if the F argument +** contains the SQLITE_SERIALIZE_NOCOPY bit, then no memory allocations +** are made, and the sqlite3_serialize() function will return a pointer +** to the contiguous memory representation of the database that SQLite +** is currently using for that database, or NULL if the no such contiguous +** memory representation of the database exists. A contiguous memory +** representation of the database will usually only exist if there has +** been a prior call to [sqlite3_deserialize(D,S,...)] with the same +** values of D and S. +** The size of the database is written into *P even if the +** SQLITE_SERIALIZE_NOCOPY bit is set but no contiguous copy +** of the database exists. +** +** A call to sqlite3_serialize(D,S,P,F) might return NULL even if the +** SQLITE_SERIALIZE_NOCOPY bit is omitted from argument F if a memory +** allocation error occurs. +** +** This interface is only available if SQLite is compiled with the +** [SQLITE_ENABLE_DESERIALIZE] option. +*/ +SQLITE_API unsigned char *sqlite3_serialize( + sqlite3 *db, /* The database connection */ + const char *zSchema, /* Which DB to serialize. ex: "main", "temp", ... */ + sqlite3_int64 *piSize, /* Write size of the DB here, if not NULL */ + unsigned int mFlags /* Zero or more SQLITE_SERIALIZE_* flags */ +); + +/* +** CAPI3REF: Flags for sqlite3_serialize +** +** Zero or more of the following constants can be OR-ed together for +** the F argument to [sqlite3_serialize(D,S,P,F)]. +** +** SQLITE_SERIALIZE_NOCOPY means that [sqlite3_serialize()] will return +** a pointer to contiguous in-memory database that it is currently using, +** without making a copy of the database. If SQLite is not currently using +** a contiguous in-memory database, then this option causes +** [sqlite3_serialize()] to return a NULL pointer. SQLite will only be +** using a contiguous in-memory database if it has been initialized by a +** prior call to [sqlite3_deserialize()]. +*/ +#define SQLITE_SERIALIZE_NOCOPY 0x001 /* Do no memory allocations */ + +/* +** CAPI3REF: Deserialize a database +** +** The sqlite3_deserialize(D,S,P,N,M,F) interface causes the +** [database connection] D to disconnect from database S and then +** reopen S as an in-memory database based on the serialization contained +** in P. The serialized database P is N bytes in size. M is the size of +** the buffer P, which might be larger than N. If M is larger than N, and +** the SQLITE_DESERIALIZE_READONLY bit is not set in F, then SQLite is +** permitted to add content to the in-memory database as long as the total +** size does not exceed M bytes. +** +** If the SQLITE_DESERIALIZE_FREEONCLOSE bit is set in F, then SQLite will +** invoke sqlite3_free() on the serialization buffer when the database +** connection closes. If the SQLITE_DESERIALIZE_RESIZEABLE bit is set, then +** SQLite will try to increase the buffer size using sqlite3_realloc64() +** if writes on the database cause it to grow larger than M bytes. +** +** The sqlite3_deserialize() interface will fail with SQLITE_BUSY if the +** database is currently in a read transaction or is involved in a backup +** operation. +** +** If sqlite3_deserialize(D,S,P,N,M,F) fails for any reason and if the +** SQLITE_DESERIALIZE_FREEONCLOSE bit is set in argument F, then +** [sqlite3_free()] is invoked on argument P prior to returning. +** +** This interface is only available if SQLite is compiled with the +** [SQLITE_ENABLE_DESERIALIZE] option. +*/ +SQLITE_API int sqlite3_deserialize( + sqlite3 *db, /* The database connection */ + const char *zSchema, /* Which DB to reopen with the deserialization */ + unsigned char *pData, /* The serialized database content */ + sqlite3_int64 szDb, /* Number bytes in the deserialization */ + sqlite3_int64 szBuf, /* Total size of buffer pData[] */ + unsigned mFlags /* Zero or more SQLITE_DESERIALIZE_* flags */ +); + +/* +** CAPI3REF: Flags for sqlite3_deserialize() +** +** The following are allowed values for 6th argument (the F argument) to +** the [sqlite3_deserialize(D,S,P,N,M,F)] interface. +** +** The SQLITE_DESERIALIZE_FREEONCLOSE means that the database serialization +** in the P argument is held in memory obtained from [sqlite3_malloc64()] +** and that SQLite should take ownership of this memory and automatically +** free it when it has finished using it. Without this flag, the caller +** is responsible for freeing any dynamically allocated memory. +** +** The SQLITE_DESERIALIZE_RESIZEABLE flag means that SQLite is allowed to +** grow the size of the database using calls to [sqlite3_realloc64()]. This +** flag should only be used if SQLITE_DESERIALIZE_FREEONCLOSE is also used. +** Without this flag, the deserialized database cannot increase in size beyond +** the number of bytes specified by the M parameter. +** +** The SQLITE_DESERIALIZE_READONLY flag means that the deserialized database +** should be treated as read-only. +*/ +#define SQLITE_DESERIALIZE_FREEONCLOSE 1 /* Call sqlite3_free() on close */ +#define SQLITE_DESERIALIZE_RESIZEABLE 2 /* Resize using sqlite3_realloc64() */ +#define SQLITE_DESERIALIZE_READONLY 4 /* Database is read-only */ + +/* +** Undo the hack that converts floating point types to integer for +** builds on processors without floating point support. +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# undef double +#endif + +#if 0 +} /* End of the 'extern "C"' block */ +#endif +#endif /* SQLITE3_H */ + +/******** Begin file sqlite3rtree.h *********/ +/* +** 2010 August 30 +** +** 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. +** +************************************************************************* +*/ + +#ifndef _SQLITE3RTREE_H_ +#define _SQLITE3RTREE_H_ + + +#if 0 +extern "C" { +#endif + +typedef struct sqlite3_rtree_geometry sqlite3_rtree_geometry; +typedef struct sqlite3_rtree_query_info sqlite3_rtree_query_info; + +/* The double-precision datatype used by RTree depends on the +** SQLITE_RTREE_INT_ONLY compile-time option. +*/ +#ifdef SQLITE_RTREE_INT_ONLY + typedef sqlite3_int64 sqlite3_rtree_dbl; +#else + typedef double sqlite3_rtree_dbl; +#endif + +/* +** Register a geometry callback named zGeom that can be used as part of an +** R-Tree geometry query as follows: +** +** SELECT ... FROM WHERE MATCH $zGeom(... params ...) +*/ +SQLITE_API int sqlite3_rtree_geometry_callback( + sqlite3 *db, + const char *zGeom, + int (*xGeom)(sqlite3_rtree_geometry*, int, sqlite3_rtree_dbl*,int*), + void *pContext +); + + +/* +** A pointer to a structure of the following type is passed as the first +** argument to callbacks registered using rtree_geometry_callback(). +*/ +struct sqlite3_rtree_geometry { + void *pContext; /* Copy of pContext passed to s_r_g_c() */ + int nParam; /* Size of array aParam[] */ + sqlite3_rtree_dbl *aParam; /* Parameters passed to SQL geom function */ + void *pUser; /* Callback implementation user data */ + void (*xDelUser)(void *); /* Called by SQLite to clean up pUser */ +}; + +/* +** Register a 2nd-generation geometry callback named zScore that can be +** used as part of an R-Tree geometry query as follows: +** +** SELECT ... FROM WHERE MATCH $zQueryFunc(... params ...) +*/ +SQLITE_API int sqlite3_rtree_query_callback( + sqlite3 *db, + const char *zQueryFunc, + int (*xQueryFunc)(sqlite3_rtree_query_info*), + void *pContext, + void (*xDestructor)(void*) +); + + +/* +** A pointer to a structure of the following type is passed as the +** argument to scored geometry callback registered using +** sqlite3_rtree_query_callback(). +** +** Note that the first 5 fields of this structure are identical to +** sqlite3_rtree_geometry. This structure is a subclass of +** sqlite3_rtree_geometry. +*/ +struct sqlite3_rtree_query_info { + void *pContext; /* pContext from when function registered */ + int nParam; /* Number of function parameters */ + sqlite3_rtree_dbl *aParam; /* value of function parameters */ + void *pUser; /* callback can use this, if desired */ + void (*xDelUser)(void*); /* function to free pUser */ + sqlite3_rtree_dbl *aCoord; /* Coordinates of node or entry to check */ + unsigned int *anQueue; /* Number of pending entries in the queue */ + int nCoord; /* Number of coordinates */ + int iLevel; /* Level of current node or entry */ + int mxLevel; /* The largest iLevel value in the tree */ + sqlite3_int64 iRowid; /* Rowid for current entry */ + sqlite3_rtree_dbl rParentScore; /* Score of parent node */ + int eParentWithin; /* Visibility of parent node */ + int eWithin; /* OUT: Visibility */ + sqlite3_rtree_dbl rScore; /* OUT: Write the score here */ + /* The following fields are only available in 3.8.11 and later */ + sqlite3_value **apSqlParam; /* Original SQL values of parameters */ +}; + +/* +** Allowed values for sqlite3_rtree_query.eWithin and .eParentWithin. +*/ +#define NOT_WITHIN 0 /* Object completely outside of query region */ +#define PARTLY_WITHIN 1 /* Object partially overlaps query region */ +#define FULLY_WITHIN 2 /* Object fully contained within query region */ + + +#if 0 +} /* end of the 'extern "C"' block */ +#endif + +#endif /* ifndef _SQLITE3RTREE_H_ */ + +/******** End of sqlite3rtree.h *********/ +/******** Begin file sqlite3session.h *********/ + +#if !defined(__SQLITESESSION_H_) && defined(SQLITE_ENABLE_SESSION) +#define __SQLITESESSION_H_ 1 + +/* +** Make sure we can call this stuff from C++. +*/ +#if 0 +extern "C" { +#endif + + +/* +** CAPI3REF: Session Object Handle +** +** An instance of this object is a [session] that can be used to +** record changes to a database. +*/ +typedef struct sqlite3_session sqlite3_session; + +/* +** CAPI3REF: Changeset Iterator Handle +** +** An instance of this object acts as a cursor for iterating +** over the elements of a [changeset] or [patchset]. +*/ +typedef struct sqlite3_changeset_iter sqlite3_changeset_iter; + +/* +** CAPI3REF: Create A New Session Object +** CONSTRUCTOR: sqlite3_session +** +** Create a new session object attached to database handle db. If successful, +** a pointer to the new object is written to *ppSession and SQLITE_OK is +** returned. If an error occurs, *ppSession is set to NULL and an SQLite +** error code (e.g. SQLITE_NOMEM) is returned. +** +** It is possible to create multiple session objects attached to a single +** database handle. +** +** Session objects created using this function should be deleted using the +** [sqlite3session_delete()] function before the database handle that they +** are attached to is itself closed. If the database handle is closed before +** the session object is deleted, then the results of calling any session +** module function, including [sqlite3session_delete()] on the session object +** are undefined. +** +** Because the session module uses the [sqlite3_preupdate_hook()] API, it +** is not possible for an application to register a pre-update hook on a +** database handle that has one or more session objects attached. Nor is +** it possible to create a session object attached to a database handle for +** which a pre-update hook is already defined. The results of attempting +** either of these things are undefined. +** +** The session object will be used to create changesets for tables in +** database zDb, where zDb is either "main", or "temp", or the name of an +** attached database. It is not an error if database zDb is not attached +** to the database when the session object is created. +*/ +SQLITE_API int sqlite3session_create( + sqlite3 *db, /* Database handle */ + const char *zDb, /* Name of db (e.g. "main") */ + sqlite3_session **ppSession /* OUT: New session object */ +); + +/* +** CAPI3REF: Delete A Session Object +** DESTRUCTOR: sqlite3_session +** +** Delete a session object previously allocated using +** [sqlite3session_create()]. Once a session object has been deleted, the +** results of attempting to use pSession with any other session module +** function are undefined. +** +** Session objects must be deleted before the database handle to which they +** are attached is closed. Refer to the documentation for +** [sqlite3session_create()] for details. +*/ +SQLITE_API void sqlite3session_delete(sqlite3_session *pSession); + + +/* +** CAPI3REF: Enable Or Disable A Session Object +** METHOD: sqlite3_session +** +** Enable or disable the recording of changes by a session object. When +** enabled, a session object records changes made to the database. When +** disabled - it does not. A newly created session object is enabled. +** Refer to the documentation for [sqlite3session_changeset()] for further +** details regarding how enabling and disabling a session object affects +** the eventual changesets. +** +** Passing zero to this function disables the session. Passing a value +** greater than zero enables it. Passing a value less than zero is a +** no-op, and may be used to query the current state of the session. +** +** The return value indicates the final state of the session object: 0 if +** the session is disabled, or 1 if it is enabled. +*/ +SQLITE_API int sqlite3session_enable(sqlite3_session *pSession, int bEnable); + +/* +** CAPI3REF: Set Or Clear the Indirect Change Flag +** METHOD: sqlite3_session +** +** Each change recorded by a session object is marked as either direct or +** indirect. A change is marked as indirect if either: +** +**
      +**
    • The session object "indirect" flag is set when the change is +** made, or +**
    • The change is made by an SQL trigger or foreign key action +** instead of directly as a result of a users SQL statement. +**
    +** +** If a single row is affected by more than one operation within a session, +** then the change is considered indirect if all operations meet the criteria +** for an indirect change above, or direct otherwise. +** +** This function is used to set, clear or query the session object indirect +** flag. If the second argument passed to this function is zero, then the +** indirect flag is cleared. If it is greater than zero, the indirect flag +** is set. Passing a value less than zero does not modify the current value +** of the indirect flag, and may be used to query the current state of the +** indirect flag for the specified session object. +** +** The return value indicates the final state of the indirect flag: 0 if +** it is clear, or 1 if it is set. +*/ +SQLITE_API int sqlite3session_indirect(sqlite3_session *pSession, int bIndirect); + +/* +** CAPI3REF: Attach A Table To A Session Object +** METHOD: sqlite3_session +** +** If argument zTab is not NULL, then it is the name of a table to attach +** to the session object passed as the first argument. All subsequent changes +** made to the table while the session object is enabled will be recorded. See +** documentation for [sqlite3session_changeset()] for further details. +** +** Or, if argument zTab is NULL, then changes are recorded for all tables +** in the database. If additional tables are added to the database (by +** executing "CREATE TABLE" statements) after this call is made, changes for +** the new tables are also recorded. +** +** Changes can only be recorded for tables that have a PRIMARY KEY explicitly +** defined as part of their CREATE TABLE statement. It does not matter if the +** PRIMARY KEY is an "INTEGER PRIMARY KEY" (rowid alias) or not. The PRIMARY +** KEY may consist of a single column, or may be a composite key. +** +** It is not an error if the named table does not exist in the database. Nor +** is it an error if the named table does not have a PRIMARY KEY. However, +** no changes will be recorded in either of these scenarios. +** +** Changes are not recorded for individual rows that have NULL values stored +** in one or more of their PRIMARY KEY columns. +** +** SQLITE_OK is returned if the call completes without error. Or, if an error +** occurs, an SQLite error code (e.g. SQLITE_NOMEM) is returned. +** +**

    Special sqlite_stat1 Handling

    +** +** As of SQLite version 3.22.0, the "sqlite_stat1" table is an exception to +** some of the rules above. In SQLite, the schema of sqlite_stat1 is: +** 
    +**        CREATE TABLE sqlite_stat1(tbl,idx,stat)
+**
    +** +** Even though sqlite_stat1 does not have a PRIMARY KEY, changes are +** recorded for it as if the PRIMARY KEY is (tbl,idx). Additionally, changes +** are recorded for rows for which (idx IS NULL) is true. However, for such +** rows a zero-length blob (SQL value X'') is stored in the changeset or +** patchset instead of a NULL value. This allows such changesets to be +** manipulated by legacy implementations of sqlite3changeset_invert(), +** concat() and similar. +** +** The sqlite3changeset_apply() function automatically converts the +** zero-length blob back to a NULL value when updating the sqlite_stat1 +** table. However, if the application calls sqlite3changeset_new(), +** sqlite3changeset_old() or sqlite3changeset_conflict on a changeset +** iterator directly (including on a changeset iterator passed to a +** conflict-handler callback) then the X'' value is returned. The application +** must translate X'' to NULL itself if required. +** +** Legacy (older than 3.22.0) versions of the sessions module cannot capture +** changes made to the sqlite_stat1 table. Legacy versions of the +** sqlite3changeset_apply() function silently ignore any modifications to the +** sqlite_stat1 table that are part of a changeset or patchset. +*/ +SQLITE_API int sqlite3session_attach( + sqlite3_session *pSession, /* Session object */ + const char *zTab /* Table name */ +); + +/* +** CAPI3REF: Set a table filter on a Session Object. +** METHOD: sqlite3_session +** +** The second argument (xFilter) is the "filter callback". For changes to rows +** in tables that are not attached to the Session object, the filter is called +** to determine whether changes to the table's rows should be tracked or not. +** If xFilter returns 0, changes are not tracked. Note that once a table is +** attached, xFilter will not be called again. +*/ +SQLITE_API void sqlite3session_table_filter( + sqlite3_session *pSession, /* Session object */ + int(*xFilter)( + void *pCtx, /* Copy of third arg to _filter_table() */ + const char *zTab /* Table name */ + ), + void *pCtx /* First argument passed to xFilter */ +); + +/* +** CAPI3REF: Generate A Changeset From A Session Object +** METHOD: sqlite3_session +** +** Obtain a changeset containing changes to the tables attached to the +** session object passed as the first argument. If successful, +** set *ppChangeset to point to a buffer containing the changeset +** and *pnChangeset to the size of the changeset in bytes before returning +** SQLITE_OK. If an error occurs, set both *ppChangeset and *pnChangeset to +** zero and return an SQLite error code. +** +** A changeset consists of zero or more INSERT, UPDATE and/or DELETE changes, +** each representing a change to a single row of an attached table. An INSERT +** change contains the values of each field of a new database row. A DELETE +** contains the original values of each field of a deleted database row. An +** UPDATE change contains the original values of each field of an updated +** database row along with the updated values for each updated non-primary-key +** column. It is not possible for an UPDATE change to represent a change that +** modifies the values of primary key columns. If such a change is made, it +** is represented in a changeset as a DELETE followed by an INSERT. +** +** Changes are not recorded for rows that have NULL values stored in one or +** more of their PRIMARY KEY columns. If such a row is inserted or deleted, +** no corresponding change is present in the changesets returned by this +** function. If an existing row with one or more NULL values stored in +** PRIMARY KEY columns is updated so that all PRIMARY KEY columns are non-NULL, +** only an INSERT is appears in the changeset. Similarly, if an existing row +** with non-NULL PRIMARY KEY values is updated so that one or more of its +** PRIMARY KEY columns are set to NULL, the resulting changeset contains a +** DELETE change only. +** +** The contents of a changeset may be traversed using an iterator created +** using the [sqlite3changeset_start()] API. A changeset may be applied to +** a database with a compatible schema using the [sqlite3changeset_apply()] +** API. +** +** Within a changeset generated by this function, all changes related to a +** single table are grouped together. In other words, when iterating through +** a changeset or when applying a changeset to a database, all changes related +** to a single table are processed before moving on to the next table. Tables +** are sorted in the same order in which they were attached (or auto-attached) +** to the sqlite3_session object. The order in which the changes related to +** a single table are stored is undefined. +** +** Following a successful call to this function, it is the responsibility of +** the caller to eventually free the buffer that *ppChangeset points to using +** [sqlite3_free()]. +** +**

    Changeset Generation

    +** +** Once a table has been attached to a session object, the session object +** records the primary key values of all new rows inserted into the table. +** It also records the original primary key and other column values of any +** deleted or updated rows. For each unique primary key value, data is only +** recorded once - the first time a row with said primary key is inserted, +** updated or deleted in the lifetime of the session. +** +** There is one exception to the previous paragraph: when a row is inserted, +** updated or deleted, if one or more of its primary key columns contain a +** NULL value, no record of the change is made. +** +** The session object therefore accumulates two types of records - those +** that consist of primary key values only (created when the user inserts +** a new record) and those that consist of the primary key values and the +** original values of other table columns (created when the users deletes +** or updates a record). +** +** When this function is called, the requested changeset is created using +** both the accumulated records and the current contents of the database +** file. Specifically: +** +**
      +**
    • For each record generated by an insert, the database is queried +** for a row with a matching primary key. If one is found, an INSERT +** change is added to the changeset. If no such row is found, no change +** is added to the changeset. +** +**
    • For each record generated by an update or delete, the database is +** queried for a row with a matching primary key. If such a row is +** found and one or more of the non-primary key fields have been +** modified from their original values, an UPDATE change is added to +** the changeset. Or, if no such row is found in the table, a DELETE +** change is added to the changeset. If there is a row with a matching +** primary key in the database, but all fields contain their original +** values, no change is added to the changeset. +**
    +** +** This means, amongst other things, that if a row is inserted and then later +** deleted while a session object is active, neither the insert nor the delete +** will be present in the changeset. Or if a row is deleted and then later a +** row with the same primary key values inserted while a session object is +** active, the resulting changeset will contain an UPDATE change instead of +** a DELETE and an INSERT. +** +** When a session object is disabled (see the [sqlite3session_enable()] API), +** it does not accumulate records when rows are inserted, updated or deleted. +** This may appear to have some counter-intuitive effects if a single row +** is written to more than once during a session. For example, if a row +** is inserted while a session object is enabled, then later deleted while +** the same session object is disabled, no INSERT record will appear in the +** changeset, even though the delete took place while the session was disabled. +** Or, if one field of a row is updated while a session is disabled, and +** another field of the same row is updated while the session is enabled, the +** resulting changeset will contain an UPDATE change that updates both fields. +*/ +SQLITE_API int sqlite3session_changeset( + sqlite3_session *pSession, /* Session object */ + int *pnChangeset, /* OUT: Size of buffer at *ppChangeset */ + void **ppChangeset /* OUT: Buffer containing changeset */ +); + +/* +** CAPI3REF: Load The Difference Between Tables Into A Session +** METHOD: sqlite3_session +** +** If it is not already attached to the session object passed as the first +** argument, this function attaches table zTbl in the same manner as the +** [sqlite3session_attach()] function. If zTbl does not exist, or if it +** does not have a primary key, this function is a no-op (but does not return +** an error). +** +** Argument zFromDb must be the name of a database ("main", "temp" etc.) +** attached to the same database handle as the session object that contains +** a table compatible with the table attached to the session by this function. +** A table is considered compatible if it: +** +**
      +**
    • Has the same name, +**
    • Has the same set of columns declared in the same order, and +**
    • Has the same PRIMARY KEY definition. +**
    +** +** If the tables are not compatible, SQLITE_SCHEMA is returned. If the tables +** are compatible but do not have any PRIMARY KEY columns, it is not an error +** but no changes are added to the session object. As with other session +** APIs, tables without PRIMARY KEYs are simply ignored. +** +** This function adds a set of changes to the session object that could be +** used to update the table in database zFrom (call this the "from-table") +** so that its content is the same as the table attached to the session +** object (call this the "to-table"). Specifically: +** +**
      +**
    • For each row (primary key) that exists in the to-table but not in +** the from-table, an INSERT record is added to the session object. +** +**
    • For each row (primary key) that exists in the to-table but not in +** the from-table, a DELETE record is added to the session object. +** +**
    • For each row (primary key) that exists in both tables, but features +** different non-PK values in each, an UPDATE record is added to the +** session. +**
    +** +** To clarify, if this function is called and then a changeset constructed +** using [sqlite3session_changeset()], then after applying that changeset to +** database zFrom the contents of the two compatible tables would be +** identical. +** +** It an error if database zFrom does not exist or does not contain the +** required compatible table. +** +** If the operation is successful, SQLITE_OK is returned. Otherwise, an SQLite +** error code. In this case, if argument pzErrMsg is not NULL, *pzErrMsg +** may be set to point to a buffer containing an English language error +** message. It is the responsibility of the caller to free this buffer using +** sqlite3_free(). +*/ +SQLITE_API int sqlite3session_diff( + sqlite3_session *pSession, + const char *zFromDb, + const char *zTbl, + char **pzErrMsg +); + + +/* +** CAPI3REF: Generate A Patchset From A Session Object +** METHOD: sqlite3_session +** +** The differences between a patchset and a changeset are that: +** +**
      +**
    • DELETE records consist of the primary key fields only. The +** original values of other fields are omitted. +**
    • The original values of any modified fields are omitted from +** UPDATE records. +**
    +** +** A patchset blob may be used with up to date versions of all +** sqlite3changeset_xxx API functions except for sqlite3changeset_invert(), +** which returns SQLITE_CORRUPT if it is passed a patchset. Similarly, +** attempting to use a patchset blob with old versions of the +** sqlite3changeset_xxx APIs also provokes an SQLITE_CORRUPT error. +** +** Because the non-primary key "old.*" fields are omitted, no +** SQLITE_CHANGESET_DATA conflicts can be detected or reported if a patchset +** is passed to the sqlite3changeset_apply() API. Other conflict types work +** in the same way as for changesets. +** +** Changes within a patchset are ordered in the same way as for changesets +** generated by the sqlite3session_changeset() function (i.e. all changes for +** a single table are grouped together, tables appear in the order in which +** they were attached to the session object). +*/ +SQLITE_API int sqlite3session_patchset( + sqlite3_session *pSession, /* Session object */ + int *pnPatchset, /* OUT: Size of buffer at *ppPatchset */ + void **ppPatchset /* OUT: Buffer containing patchset */ +); + +/* +** CAPI3REF: Test if a changeset has recorded any changes. +** +** Return non-zero if no changes to attached tables have been recorded by +** the session object passed as the first argument. Otherwise, if one or +** more changes have been recorded, return zero. +** +** Even if this function returns zero, it is possible that calling +** [sqlite3session_changeset()] on the session handle may still return a +** changeset that contains no changes. This can happen when a row in +** an attached table is modified and then later on the original values +** are restored. However, if this function returns non-zero, then it is +** guaranteed that a call to sqlite3session_changeset() will return a +** changeset containing zero changes. +*/ +SQLITE_API int sqlite3session_isempty(sqlite3_session *pSession); + +/* +** CAPI3REF: Create An Iterator To Traverse A Changeset +** CONSTRUCTOR: sqlite3_changeset_iter +** +** Create an iterator used to iterate through the contents of a changeset. +** If successful, *pp is set to point to the iterator handle and SQLITE_OK +** is returned. Otherwise, if an error occurs, *pp is set to zero and an +** SQLite error code is returned. +** +** The following functions can be used to advance and query a changeset +** iterator created by this function: +** +**
      +**
    • [sqlite3changeset_next()] +**
    • [sqlite3changeset_op()] +**
    • [sqlite3changeset_new()] +**
    • [sqlite3changeset_old()] +**
    +** +** It is the responsibility of the caller to eventually destroy the iterator +** by passing it to [sqlite3changeset_finalize()]. The buffer containing the +** changeset (pChangeset) must remain valid until after the iterator is +** destroyed. +** +** Assuming the changeset blob was created by one of the +** [sqlite3session_changeset()], [sqlite3changeset_concat()] or +** [sqlite3changeset_invert()] functions, all changes within the changeset +** that apply to a single table are grouped together. This means that when +** an application iterates through a changeset using an iterator created by +** this function, all changes that relate to a single table are visited +** consecutively. There is no chance that the iterator will visit a change +** the applies to table X, then one for table Y, and then later on visit +** another change for table X. +** +** The behavior of sqlite3changeset_start_v2() and its streaming equivalent +** may be modified by passing a combination of +** [SQLITE_CHANGESETSTART_INVERT | supported flags] as the 4th parameter. +** +** Note that the sqlite3changeset_start_v2() API is still experimental +** and therefore subject to change. +*/ +SQLITE_API int sqlite3changeset_start( + sqlite3_changeset_iter **pp, /* OUT: New changeset iterator handle */ + int nChangeset, /* Size of changeset blob in bytes */ + void *pChangeset /* Pointer to blob containing changeset */ +); +SQLITE_API int sqlite3changeset_start_v2( + sqlite3_changeset_iter **pp, /* OUT: New changeset iterator handle */ + int nChangeset, /* Size of changeset blob in bytes */ + void *pChangeset, /* Pointer to blob containing changeset */ + int flags /* SESSION_CHANGESETSTART_* flags */ +); + +/* +** CAPI3REF: Flags for sqlite3changeset_start_v2 +** +** The following flags may passed via the 4th parameter to +** [sqlite3changeset_start_v2] and [sqlite3changeset_start_v2_strm]: +** +**
    SQLITE_CHANGESETAPPLY_INVERT
    +** Invert the changeset while iterating through it. This is equivalent to +** inverting a changeset using sqlite3changeset_invert() before applying it. +** It is an error to specify this flag with a patchset. +*/ +#define SQLITE_CHANGESETSTART_INVERT 0x0002 + + +/* +** CAPI3REF: Advance A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** This function may only be used with iterators created by the function +** [sqlite3changeset_start()]. If it is called on an iterator passed to +** a conflict-handler callback by [sqlite3changeset_apply()], SQLITE_MISUSE +** is returned and the call has no effect. +** +** Immediately after an iterator is created by sqlite3changeset_start(), it +** does not point to any change in the changeset. Assuming the changeset +** is not empty, the first call to this function advances the iterator to +** point to the first change in the changeset. Each subsequent call advances +** the iterator to point to the next change in the changeset (if any). If +** no error occurs and the iterator points to a valid change after a call +** to sqlite3changeset_next() has advanced it, SQLITE_ROW is returned. +** Otherwise, if all changes in the changeset have already been visited, +** SQLITE_DONE is returned. +** +** If an error occurs, an SQLite error code is returned. Possible error +** codes include SQLITE_CORRUPT (if the changeset buffer is corrupt) or +** SQLITE_NOMEM. +*/ +SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter); + +/* +** CAPI3REF: Obtain The Current Operation From A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** The pIter argument passed to this function may either be an iterator +** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator +** created by [sqlite3changeset_start()]. In the latter case, the most recent +** call to [sqlite3changeset_next()] must have returned [SQLITE_ROW]. If this +** is not the case, this function returns [SQLITE_MISUSE]. +** +** If argument pzTab is not NULL, then *pzTab is set to point to a +** nul-terminated utf-8 encoded string containing the name of the table +** affected by the current change. The buffer remains valid until either +** sqlite3changeset_next() is called on the iterator or until the +** conflict-handler function returns. If pnCol is not NULL, then *pnCol is +** set to the number of columns in the table affected by the change. If +** pbIndirect is not NULL, then *pbIndirect is set to true (1) if the change +** is an indirect change, or false (0) otherwise. See the documentation for +** [sqlite3session_indirect()] for a description of direct and indirect +** changes. Finally, if pOp is not NULL, then *pOp is set to one of +** [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE], depending on the +** type of change that the iterator currently points to. +** +** If no error occurs, SQLITE_OK is returned. If an error does occur, an +** SQLite error code is returned. The values of the output variables may not +** be trusted in this case. +*/ +SQLITE_API int sqlite3changeset_op( + sqlite3_changeset_iter *pIter, /* Iterator object */ + const char **pzTab, /* OUT: Pointer to table name */ + int *pnCol, /* OUT: Number of columns in table */ + int *pOp, /* OUT: SQLITE_INSERT, DELETE or UPDATE */ + int *pbIndirect /* OUT: True for an 'indirect' change */ +); + +/* +** CAPI3REF: Obtain The Primary Key Definition Of A Table +** METHOD: sqlite3_changeset_iter +** +** For each modified table, a changeset includes the following: +** +**
      +**
    • The number of columns in the table, and +**
    • Which of those columns make up the tables PRIMARY KEY. +**
    +** +** This function is used to find which columns comprise the PRIMARY KEY of +** the table modified by the change that iterator pIter currently points to. +** If successful, *pabPK is set to point to an array of nCol entries, where +** nCol is the number of columns in the table. Elements of *pabPK are set to +** 0x01 if the corresponding column is part of the tables primary key, or +** 0x00 if it is not. +** +** If argument pnCol is not NULL, then *pnCol is set to the number of columns +** in the table. +** +** If this function is called when the iterator does not point to a valid +** entry, SQLITE_MISUSE is returned and the output variables zeroed. Otherwise, +** SQLITE_OK is returned and the output variables populated as described +** above. +*/ +SQLITE_API int sqlite3changeset_pk( + sqlite3_changeset_iter *pIter, /* Iterator object */ + unsigned char **pabPK, /* OUT: Array of boolean - true for PK cols */ + int *pnCol /* OUT: Number of entries in output array */ +); + +/* +** CAPI3REF: Obtain old.* Values From A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** The pIter argument passed to this function may either be an iterator +** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator +** created by [sqlite3changeset_start()]. In the latter case, the most recent +** call to [sqlite3changeset_next()] must have returned SQLITE_ROW. +** Furthermore, it may only be called if the type of change that the iterator +** currently points to is either [SQLITE_DELETE] or [SQLITE_UPDATE]. Otherwise, +** this function returns [SQLITE_MISUSE] and sets *ppValue to NULL. +** +** Argument iVal must be greater than or equal to 0, and less than the number +** of columns in the table affected by the current change. Otherwise, +** [SQLITE_RANGE] is returned and *ppValue is set to NULL. +** +** If successful, this function sets *ppValue to point to a protected +** sqlite3_value object containing the iVal'th value from the vector of +** original row values stored as part of the UPDATE or DELETE change and +** returns SQLITE_OK. The name of the function comes from the fact that this +** is similar to the "old.*" columns available to update or delete triggers. +** +** If some other error occurs (e.g. an OOM condition), an SQLite error code +** is returned and *ppValue is set to NULL. +*/ +SQLITE_API int sqlite3changeset_old( + sqlite3_changeset_iter *pIter, /* Changeset iterator */ + int iVal, /* Column number */ + sqlite3_value **ppValue /* OUT: Old value (or NULL pointer) */ +); + +/* +** CAPI3REF: Obtain new.* Values From A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** The pIter argument passed to this function may either be an iterator +** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator +** created by [sqlite3changeset_start()]. In the latter case, the most recent +** call to [sqlite3changeset_next()] must have returned SQLITE_ROW. +** Furthermore, it may only be called if the type of change that the iterator +** currently points to is either [SQLITE_UPDATE] or [SQLITE_INSERT]. Otherwise, +** this function returns [SQLITE_MISUSE] and sets *ppValue to NULL. +** +** Argument iVal must be greater than or equal to 0, and less than the number +** of columns in the table affected by the current change. Otherwise, +** [SQLITE_RANGE] is returned and *ppValue is set to NULL. +** +** If successful, this function sets *ppValue to point to a protected +** sqlite3_value object containing the iVal'th value from the vector of +** new row values stored as part of the UPDATE or INSERT change and +** returns SQLITE_OK. If the change is an UPDATE and does not include +** a new value for the requested column, *ppValue is set to NULL and +** SQLITE_OK returned. The name of the function comes from the fact that +** this is similar to the "new.*" columns available to update or delete +** triggers. +** +** If some other error occurs (e.g. an OOM condition), an SQLite error code +** is returned and *ppValue is set to NULL. +*/ +SQLITE_API int sqlite3changeset_new( + sqlite3_changeset_iter *pIter, /* Changeset iterator */ + int iVal, /* Column number */ + sqlite3_value **ppValue /* OUT: New value (or NULL pointer) */ +); + +/* +** CAPI3REF: Obtain Conflicting Row Values From A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** This function should only be used with iterator objects passed to a +** conflict-handler callback by [sqlite3changeset_apply()] with either +** [SQLITE_CHANGESET_DATA] or [SQLITE_CHANGESET_CONFLICT]. If this function +** is called on any other iterator, [SQLITE_MISUSE] is returned and *ppValue +** is set to NULL. +** +** Argument iVal must be greater than or equal to 0, and less than the number +** of columns in the table affected by the current change. Otherwise, +** [SQLITE_RANGE] is returned and *ppValue is set to NULL. +** +** If successful, this function sets *ppValue to point to a protected +** sqlite3_value object containing the iVal'th value from the +** "conflicting row" associated with the current conflict-handler callback +** and returns SQLITE_OK. +** +** If some other error occurs (e.g. an OOM condition), an SQLite error code +** is returned and *ppValue is set to NULL. +*/ +SQLITE_API int sqlite3changeset_conflict( + sqlite3_changeset_iter *pIter, /* Changeset iterator */ + int iVal, /* Column number */ + sqlite3_value **ppValue /* OUT: Value from conflicting row */ +); + +/* +** CAPI3REF: Determine The Number Of Foreign Key Constraint Violations +** METHOD: sqlite3_changeset_iter +** +** This function may only be called with an iterator passed to an +** SQLITE_CHANGESET_FOREIGN_KEY conflict handler callback. In this case +** it sets the output variable to the total number of known foreign key +** violations in the destination database and returns SQLITE_OK. +** +** In all other cases this function returns SQLITE_MISUSE. +*/ +SQLITE_API int sqlite3changeset_fk_conflicts( + sqlite3_changeset_iter *pIter, /* Changeset iterator */ + int *pnOut /* OUT: Number of FK violations */ +); + + +/* +** CAPI3REF: Finalize A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** This function is used to finalize an iterator allocated with +** [sqlite3changeset_start()]. +** +** This function should only be called on iterators created using the +** [sqlite3changeset_start()] function. If an application calls this +** function with an iterator passed to a conflict-handler by +** [sqlite3changeset_apply()], [SQLITE_MISUSE] is immediately returned and the +** call has no effect. +** +** If an error was encountered within a call to an sqlite3changeset_xxx() +** function (for example an [SQLITE_CORRUPT] in [sqlite3changeset_next()] or an +** [SQLITE_NOMEM] in [sqlite3changeset_new()]) then an error code corresponding +** to that error is returned by this function. Otherwise, SQLITE_OK is +** returned. This is to allow the following pattern (pseudo-code): +** +** 
    +**   sqlite3changeset_start();
+**   while( SQLITE_ROW==sqlite3changeset_next() ){
+**     // Do something with change.
+**   }
+**   rc = sqlite3changeset_finalize();
+**   if( rc!=SQLITE_OK ){
+**     // An error has occurred
+**   }
+**
    +*/ +SQLITE_API int sqlite3changeset_finalize(sqlite3_changeset_iter *pIter); + +/* +** CAPI3REF: Invert A Changeset +** +** This function is used to "invert" a changeset object. Applying an inverted +** changeset to a database reverses the effects of applying the uninverted +** changeset. Specifically: +** +**
      +**
    • Each DELETE change is changed to an INSERT, and +**
    • Each INSERT change is changed to a DELETE, and +**
    • For each UPDATE change, the old.* and new.* values are exchanged. +**
    +** +** This function does not change the order in which changes appear within +** the changeset. It merely reverses the sense of each individual change. +** +** If successful, a pointer to a buffer containing the inverted changeset +** is stored in *ppOut, the size of the same buffer is stored in *pnOut, and +** SQLITE_OK is returned. If an error occurs, both *pnOut and *ppOut are +** zeroed and an SQLite error code returned. +** +** It is the responsibility of the caller to eventually call sqlite3_free() +** on the *ppOut pointer to free the buffer allocation following a successful +** call to this function. +** +** WARNING/TODO: This function currently assumes that the input is a valid +** changeset. If it is not, the results are undefined. +*/ +SQLITE_API int sqlite3changeset_invert( + int nIn, const void *pIn, /* Input changeset */ + int *pnOut, void **ppOut /* OUT: Inverse of input */ +); + +/* +** CAPI3REF: Concatenate Two Changeset Objects +** +** This function is used to concatenate two changesets, A and B, into a +** single changeset. The result is a changeset equivalent to applying +** changeset A followed by changeset B. +** +** This function combines the two input changesets using an +** sqlite3_changegroup object. Calling it produces similar results as the +** following code fragment: +** +** 
    +**   sqlite3_changegroup *pGrp;
+**   rc = sqlite3_changegroup_new(&pGrp);
+**   if( rc==SQLITE_OK ) rc = sqlite3changegroup_add(pGrp, nA, pA);
+**   if( rc==SQLITE_OK ) rc = sqlite3changegroup_add(pGrp, nB, pB);
+**   if( rc==SQLITE_OK ){
+**     rc = sqlite3changegroup_output(pGrp, pnOut, ppOut);
+**   }else{
+**     *ppOut = 0;
+**     *pnOut = 0;
+**   }
+**
    +** +** Refer to the sqlite3_changegroup documentation below for details. +*/ +SQLITE_API int sqlite3changeset_concat( + int nA, /* Number of bytes in buffer pA */ + void *pA, /* Pointer to buffer containing changeset A */ + int nB, /* Number of bytes in buffer pB */ + void *pB, /* Pointer to buffer containing changeset B */ + int *pnOut, /* OUT: Number of bytes in output changeset */ + void **ppOut /* OUT: Buffer containing output changeset */ +); + + +/* +** CAPI3REF: Changegroup Handle +** +** A changegroup is an object used to combine two or more +** [changesets] or [patchsets] +*/ +typedef struct sqlite3_changegroup sqlite3_changegroup; + +/* +** CAPI3REF: Create A New Changegroup Object +** CONSTRUCTOR: sqlite3_changegroup +** +** An sqlite3_changegroup object is used to combine two or more changesets +** (or patchsets) into a single changeset (or patchset). A single changegroup +** object may combine changesets or patchsets, but not both. The output is +** always in the same format as the input. +** +** If successful, this function returns SQLITE_OK and populates (*pp) with +** a pointer to a new sqlite3_changegroup object before returning. The caller +** should eventually free the returned object using a call to +** sqlite3changegroup_delete(). If an error occurs, an SQLite error code +** (i.e. SQLITE_NOMEM) is returned and *pp is set to NULL. +** +** The usual usage pattern for an sqlite3_changegroup object is as follows: +** +**
      +**
    • It is created using a call to sqlite3changegroup_new(). +** +**
    • Zero or more changesets (or patchsets) are added to the object +** by calling sqlite3changegroup_add(). +** +**
    • The result of combining all input changesets together is obtained +** by the application via a call to sqlite3changegroup_output(). +** +**
    • The object is deleted using a call to sqlite3changegroup_delete(). +**
    +** +** Any number of calls to add() and output() may be made between the calls to +** new() and delete(), and in any order. +** +** As well as the regular sqlite3changegroup_add() and +** sqlite3changegroup_output() functions, also available are the streaming +** versions sqlite3changegroup_add_strm() and sqlite3changegroup_output_strm(). +*/ +SQLITE_API int sqlite3changegroup_new(sqlite3_changegroup **pp); + +/* +** CAPI3REF: Add A Changeset To A Changegroup +** METHOD: sqlite3_changegroup +** +** Add all changes within the changeset (or patchset) in buffer pData (size +** nData bytes) to the changegroup. +** +** If the buffer contains a patchset, then all prior calls to this function +** on the same changegroup object must also have specified patchsets. Or, if +** the buffer contains a changeset, so must have the earlier calls to this +** function. Otherwise, SQLITE_ERROR is returned and no changes are added +** to the changegroup. +** +** Rows within the changeset and changegroup are identified by the values in +** their PRIMARY KEY columns. A change in the changeset is considered to +** apply to the same row as a change already present in the changegroup if +** the two rows have the same primary key. +** +** Changes to rows that do not already appear in the changegroup are +** simply copied into it. Or, if both the new changeset and the changegroup +** contain changes that apply to a single row, the final contents of the +** changegroup depends on the type of each change, as follows: +** +** +** +** +**
    Existing Change New Change Output Change +**
    INSERT INSERT +** The new change is ignored. This case does not occur if the new +** changeset was recorded immediately after the changesets already +** added to the changegroup. +**
    INSERT UPDATE +** The INSERT change remains in the changegroup. The values in the +** INSERT change are modified as if the row was inserted by the +** existing change and then updated according to the new change. +**
    INSERT DELETE +** The existing INSERT is removed from the changegroup. The DELETE is +** not added. +**
    UPDATE INSERT +** The new change is ignored. This case does not occur if the new +** changeset was recorded immediately after the changesets already +** added to the changegroup. +**
    UPDATE UPDATE +** The existing UPDATE remains within the changegroup. It is amended +** so that the accompanying values are as if the row was updated once +** by the existing change and then again by the new change. +**
    UPDATE DELETE +** The existing UPDATE is replaced by the new DELETE within the +** changegroup. +**
    DELETE INSERT +** If one or more of the column values in the row inserted by the +** new change differ from those in the row deleted by the existing +** change, the existing DELETE is replaced by an UPDATE within the +** changegroup. Otherwise, if the inserted row is exactly the same +** as the deleted row, the existing DELETE is simply discarded. +**
    DELETE UPDATE +** The new change is ignored. This case does not occur if the new +** changeset was recorded immediately after the changesets already +** added to the changegroup. +**
    DELETE DELETE +** The new change is ignored. This case does not occur if the new +** changeset was recorded immediately after the changesets already +** added to the changegroup. +**
    +** +** If the new changeset contains changes to a table that is already present +** in the changegroup, then the number of columns and the position of the +** primary key columns for the table must be consistent. If this is not the +** case, this function fails with SQLITE_SCHEMA. If the input changeset +** appears to be corrupt and the corruption is detected, SQLITE_CORRUPT is +** returned. Or, if an out-of-memory condition occurs during processing, this +** function returns SQLITE_NOMEM. In all cases, if an error occurs the state +** of the final contents of the changegroup is undefined. +** +** If no error occurs, SQLITE_OK is returned. +*/ +SQLITE_API int sqlite3changegroup_add(sqlite3_changegroup*, int nData, void *pData); + +/* +** CAPI3REF: Obtain A Composite Changeset From A Changegroup +** METHOD: sqlite3_changegroup +** +** Obtain a buffer containing a changeset (or patchset) representing the +** current contents of the changegroup. If the inputs to the changegroup +** were themselves changesets, the output is a changeset. Or, if the +** inputs were patchsets, the output is also a patchset. +** +** As with the output of the sqlite3session_changeset() and +** sqlite3session_patchset() functions, all changes related to a single +** table are grouped together in the output of this function. Tables appear +** in the same order as for the very first changeset added to the changegroup. +** If the second or subsequent changesets added to the changegroup contain +** changes for tables that do not appear in the first changeset, they are +** appended onto the end of the output changeset, again in the order in +** which they are first encountered. +** +** If an error occurs, an SQLite error code is returned and the output +** variables (*pnData) and (*ppData) are set to 0. Otherwise, SQLITE_OK +** is returned and the output variables are set to the size of and a +** pointer to the output buffer, respectively. In this case it is the +** responsibility of the caller to eventually free the buffer using a +** call to sqlite3_free(). +*/ +SQLITE_API int sqlite3changegroup_output( + sqlite3_changegroup*, + int *pnData, /* OUT: Size of output buffer in bytes */ + void **ppData /* OUT: Pointer to output buffer */ +); + +/* +** CAPI3REF: Delete A Changegroup Object +** DESTRUCTOR: sqlite3_changegroup +*/ +SQLITE_API void sqlite3changegroup_delete(sqlite3_changegroup*); + +/* +** CAPI3REF: Apply A Changeset To A Database +** +** Apply a changeset or patchset to a database. These functions attempt to +** update the "main" database attached to handle db with the changes found in +** the changeset passed via the second and third arguments. +** +** The fourth argument (xFilter) passed to these functions is the "filter +** callback". If it is not NULL, then for each table affected by at least one +** change in the changeset, the filter callback is invoked with +** the table name as the second argument, and a copy of the context pointer +** passed as the sixth argument as the first. If the "filter callback" +** returns zero, then no attempt is made to apply any changes to the table. +** Otherwise, if the return value is non-zero or the xFilter argument to +** is NULL, all changes related to the table are attempted. +** +** For each table that is not excluded by the filter callback, this function +** tests that the target database contains a compatible table. A table is +** considered compatible if all of the following are true: +** +**
      +**
    • The table has the same name as the name recorded in the +** changeset, and +**
    • The table has at least as many columns as recorded in the +** changeset, and +**
    • The table has primary key columns in the same position as +** recorded in the changeset. +**
    +** +** If there is no compatible table, it is not an error, but none of the +** changes associated with the table are applied. A warning message is issued +** via the sqlite3_log() mechanism with the error code SQLITE_SCHEMA. At most +** one such warning is issued for each table in the changeset. +** +** For each change for which there is a compatible table, an attempt is made +** to modify the table contents according to the UPDATE, INSERT or DELETE +** change. If a change cannot be applied cleanly, the conflict handler +** function passed as the fifth argument to sqlite3changeset_apply() may be +** invoked. A description of exactly when the conflict handler is invoked for +** each type of change is below. +** +** Unlike the xFilter argument, xConflict may not be passed NULL. The results +** of passing anything other than a valid function pointer as the xConflict +** argument are undefined. +** +** Each time the conflict handler function is invoked, it must return one +** of [SQLITE_CHANGESET_OMIT], [SQLITE_CHANGESET_ABORT] or +** [SQLITE_CHANGESET_REPLACE]. SQLITE_CHANGESET_REPLACE may only be returned +** if the second argument passed to the conflict handler is either +** SQLITE_CHANGESET_DATA or SQLITE_CHANGESET_CONFLICT. If the conflict-handler +** returns an illegal value, any changes already made are rolled back and +** the call to sqlite3changeset_apply() returns SQLITE_MISUSE. Different +** actions are taken by sqlite3changeset_apply() depending on the value +** returned by each invocation of the conflict-handler function. Refer to +** the documentation for the three +** [SQLITE_CHANGESET_OMIT|available return values] for details. +** +**
    +**
    DELETE Changes
    +** For each DELETE change, the function checks if the target database +** contains a row with the same primary key value (or values) as the +** original row values stored in the changeset. If it does, and the values +** stored in all non-primary key columns also match the values stored in +** the changeset the row is deleted from the target database. +** +** If a row with matching primary key values is found, but one or more of +** the non-primary key fields contains a value different from the original +** row value stored in the changeset, the conflict-handler function is +** invoked with [SQLITE_CHANGESET_DATA] as the second argument. If the +** database table has more columns than are recorded in the changeset, +** only the values of those non-primary key fields are compared against +** the current database contents - any trailing database table columns +** are ignored. +** +** If no row with matching primary key values is found in the database, +** the conflict-handler function is invoked with [SQLITE_CHANGESET_NOTFOUND] +** passed as the second argument. +** +** If the DELETE operation is attempted, but SQLite returns SQLITE_CONSTRAINT +** (which can only happen if a foreign key constraint is violated), the +** conflict-handler function is invoked with [SQLITE_CHANGESET_CONSTRAINT] +** passed as the second argument. This includes the case where the DELETE +** operation is attempted because an earlier call to the conflict handler +** function returned [SQLITE_CHANGESET_REPLACE]. +** +**
    INSERT Changes
    +** For each INSERT change, an attempt is made to insert the new row into +** the database. If the changeset row contains fewer fields than the +** database table, the trailing fields are populated with their default +** values. +** +** If the attempt to insert the row fails because the database already +** contains a row with the same primary key values, the conflict handler +** function is invoked with the second argument set to +** [SQLITE_CHANGESET_CONFLICT]. +** +** If the attempt to insert the row fails because of some other constraint +** violation (e.g. NOT NULL or UNIQUE), the conflict handler function is +** invoked with the second argument set to [SQLITE_CHANGESET_CONSTRAINT]. +** This includes the case where the INSERT operation is re-attempted because +** an earlier call to the conflict handler function returned +** [SQLITE_CHANGESET_REPLACE]. +** +**
    UPDATE Changes
    +** For each UPDATE change, the function checks if the target database +** contains a row with the same primary key value (or values) as the +** original row values stored in the changeset. If it does, and the values +** stored in all modified non-primary key columns also match the values +** stored in the changeset the row is updated within the target database. +** +** If a row with matching primary key values is found, but one or more of +** the modified non-primary key fields contains a value different from an +** original row value stored in the changeset, the conflict-handler function +** is invoked with [SQLITE_CHANGESET_DATA] as the second argument. Since +** UPDATE changes only contain values for non-primary key fields that are +** to be modified, only those fields need to match the original values to +** avoid the SQLITE_CHANGESET_DATA conflict-handler callback. +** +** If no row with matching primary key values is found in the database, +** the conflict-handler function is invoked with [SQLITE_CHANGESET_NOTFOUND] +** passed as the second argument. +** +** If the UPDATE operation is attempted, but SQLite returns +** SQLITE_CONSTRAINT, the conflict-handler function is invoked with +** [SQLITE_CHANGESET_CONSTRAINT] passed as the second argument. +** This includes the case where the UPDATE operation is attempted after +** an earlier call to the conflict handler function returned +** [SQLITE_CHANGESET_REPLACE]. +**
    +** +** It is safe to execute SQL statements, including those that write to the +** table that the callback related to, from within the xConflict callback. +** This can be used to further customize the application's conflict +** resolution strategy. +** +** All changes made by these functions are enclosed in a savepoint transaction. +** If any other error (aside from a constraint failure when attempting to +** write to the target database) occurs, then the savepoint transaction is +** rolled back, restoring the target database to its original state, and an +** SQLite error code returned. +** +** If the output parameters (ppRebase) and (pnRebase) are non-NULL and +** the input is a changeset (not a patchset), then sqlite3changeset_apply_v2() +** may set (*ppRebase) to point to a "rebase" that may be used with the +** sqlite3_rebaser APIs buffer before returning. In this case (*pnRebase) +** is set to the size of the buffer in bytes. It is the responsibility of the +** caller to eventually free any such buffer using sqlite3_free(). The buffer +** is only allocated and populated if one or more conflicts were encountered +** while applying the patchset. See comments surrounding the sqlite3_rebaser +** APIs for further details. +** +** The behavior of sqlite3changeset_apply_v2() and its streaming equivalent +** may be modified by passing a combination of +** [SQLITE_CHANGESETAPPLY_NOSAVEPOINT | supported flags] as the 9th parameter. +** +** Note that the sqlite3changeset_apply_v2() API is still experimental +** and therefore subject to change. +*/ +SQLITE_API int sqlite3changeset_apply( + sqlite3 *db, /* Apply change to "main" db of this handle */ + int nChangeset, /* Size of changeset in bytes */ + void *pChangeset, /* Changeset blob */ + int(*xFilter)( + void *pCtx, /* Copy of sixth arg to _apply() */ + const char *zTab /* Table name */ + ), + int(*xConflict)( + void *pCtx, /* Copy of sixth arg to _apply() */ + int eConflict, /* DATA, MISSING, CONFLICT, CONSTRAINT */ + sqlite3_changeset_iter *p /* Handle describing change and conflict */ + ), + void *pCtx /* First argument passed to xConflict */ +); +SQLITE_API int sqlite3changeset_apply_v2( + sqlite3 *db, /* Apply change to "main" db of this handle */ + int nChangeset, /* Size of changeset in bytes */ + void *pChangeset, /* Changeset blob */ + int(*xFilter)( + void *pCtx, /* Copy of sixth arg to _apply() */ + const char *zTab /* Table name */ + ), + int(*xConflict)( + void *pCtx, /* Copy of sixth arg to _apply() */ + int eConflict, /* DATA, MISSING, CONFLICT, CONSTRAINT */ + sqlite3_changeset_iter *p /* Handle describing change and conflict */ + ), + void *pCtx, /* First argument passed to xConflict */ + void **ppRebase, int *pnRebase, /* OUT: Rebase data */ + int flags /* SESSION_CHANGESETAPPLY_* flags */ +); + +/* +** CAPI3REF: Flags for sqlite3changeset_apply_v2 +** +** The following flags may passed via the 9th parameter to +** [sqlite3changeset_apply_v2] and [sqlite3changeset_apply_v2_strm]: +** +**
    +**
    SQLITE_CHANGESETAPPLY_NOSAVEPOINT
    +** Usually, the sessions module encloses all operations performed by +** a single call to apply_v2() or apply_v2_strm() in a [SAVEPOINT]. The +** SAVEPOINT is committed if the changeset or patchset is successfully +** applied, or rolled back if an error occurs. Specifying this flag +** causes the sessions module to omit this savepoint. In this case, if the +** caller has an open transaction or savepoint when apply_v2() is called, +** it may revert the partially applied changeset by rolling it back. +** +**
    SQLITE_CHANGESETAPPLY_INVERT
    +** Invert the changeset before applying it. This is equivalent to inverting +** a changeset using sqlite3changeset_invert() before applying it. It is +** an error to specify this flag with a patchset. +*/ +#define SQLITE_CHANGESETAPPLY_NOSAVEPOINT 0x0001 +#define SQLITE_CHANGESETAPPLY_INVERT 0x0002 + +/* +** CAPI3REF: Constants Passed To The Conflict Handler +** +** Values that may be passed as the second argument to a conflict-handler. +** +**
    +**
    SQLITE_CHANGESET_DATA
    +** The conflict handler is invoked with CHANGESET_DATA as the second argument +** when processing a DELETE or UPDATE change if a row with the required +** PRIMARY KEY fields is present in the database, but one or more other +** (non primary-key) fields modified by the update do not contain the +** expected "before" values. +** +** The conflicting row, in this case, is the database row with the matching +** primary key. +** +**
    SQLITE_CHANGESET_NOTFOUND
    +** The conflict handler is invoked with CHANGESET_NOTFOUND as the second +** argument when processing a DELETE or UPDATE change if a row with the +** required PRIMARY KEY fields is not present in the database. +** +** There is no conflicting row in this case. The results of invoking the +** sqlite3changeset_conflict() API are undefined. +** +**
    SQLITE_CHANGESET_CONFLICT
    +** CHANGESET_CONFLICT is passed as the second argument to the conflict +** handler while processing an INSERT change if the operation would result +** in duplicate primary key values. +** +** The conflicting row in this case is the database row with the matching +** primary key. +** +**
    SQLITE_CHANGESET_FOREIGN_KEY
    +** If foreign key handling is enabled, and applying a changeset leaves the +** database in a state containing foreign key violations, the conflict +** handler is invoked with CHANGESET_FOREIGN_KEY as the second argument +** exactly once before the changeset is committed. If the conflict handler +** returns CHANGESET_OMIT, the changes, including those that caused the +** foreign key constraint violation, are committed. Or, if it returns +** CHANGESET_ABORT, the changeset is rolled back. +** +** No current or conflicting row information is provided. The only function +** it is possible to call on the supplied sqlite3_changeset_iter handle +** is sqlite3changeset_fk_conflicts(). +** +**
    SQLITE_CHANGESET_CONSTRAINT
    +** If any other constraint violation occurs while applying a change (i.e. +** a UNIQUE, CHECK or NOT NULL constraint), the conflict handler is +** invoked with CHANGESET_CONSTRAINT as the second argument. +** +** There is no conflicting row in this case. The results of invoking the +** sqlite3changeset_conflict() API are undefined. +** +**
    +*/ +#define SQLITE_CHANGESET_DATA 1 +#define SQLITE_CHANGESET_NOTFOUND 2 +#define SQLITE_CHANGESET_CONFLICT 3 +#define SQLITE_CHANGESET_CONSTRAINT 4 +#define SQLITE_CHANGESET_FOREIGN_KEY 5 + +/* +** CAPI3REF: Constants Returned By The Conflict Handler +** +** A conflict handler callback must return one of the following three values. +** +**
    +**
    SQLITE_CHANGESET_OMIT
    +** If a conflict handler returns this value no special action is taken. The +** change that caused the conflict is not applied. The session module +** continues to the next change in the changeset. +** +**
    SQLITE_CHANGESET_REPLACE
    +** This value may only be returned if the second argument to the conflict +** handler was SQLITE_CHANGESET_DATA or SQLITE_CHANGESET_CONFLICT. If this +** is not the case, any changes applied so far are rolled back and the +** call to sqlite3changeset_apply() returns SQLITE_MISUSE. +** +** If CHANGESET_REPLACE is returned by an SQLITE_CHANGESET_DATA conflict +** handler, then the conflicting row is either updated or deleted, depending +** on the type of change. +** +** If CHANGESET_REPLACE is returned by an SQLITE_CHANGESET_CONFLICT conflict +** handler, then the conflicting row is removed from the database and a +** second attempt to apply the change is made. If this second attempt fails, +** the original row is restored to the database before continuing. +** +**
    SQLITE_CHANGESET_ABORT
    +** If this value is returned, any changes applied so far are rolled back +** and the call to sqlite3changeset_apply() returns SQLITE_ABORT. +**
    +*/ +#define SQLITE_CHANGESET_OMIT 0 +#define SQLITE_CHANGESET_REPLACE 1 +#define SQLITE_CHANGESET_ABORT 2 + +/* +** CAPI3REF: Rebasing changesets +** EXPERIMENTAL +** +** Suppose there is a site hosting a database in state S0. And that +** modifications are made that move that database to state S1 and a +** changeset recorded (the "local" changeset). Then, a changeset based +** on S0 is received from another site (the "remote" changeset) and +** applied to the database. The database is then in state +** (S1+"remote"), where the exact state depends on any conflict +** resolution decisions (OMIT or REPLACE) made while applying "remote". +** Rebasing a changeset is to update it to take those conflict +** resolution decisions into account, so that the same conflicts +** do not have to be resolved elsewhere in the network. +** +** For example, if both the local and remote changesets contain an +** INSERT of the same key on "CREATE TABLE t1(a PRIMARY KEY, b)": +** +** local: INSERT INTO t1 VALUES(1, 'v1'); +** remote: INSERT INTO t1 VALUES(1, 'v2'); +** +** and the conflict resolution is REPLACE, then the INSERT change is +** removed from the local changeset (it was overridden). Or, if the +** conflict resolution was "OMIT", then the local changeset is modified +** to instead contain: +** +** UPDATE t1 SET b = 'v2' WHERE a=1; +** +** Changes within the local changeset are rebased as follows: +** +**
    +**
    Local INSERT
    +** This may only conflict with a remote INSERT. If the conflict +** resolution was OMIT, then add an UPDATE change to the rebased +** changeset. Or, if the conflict resolution was REPLACE, add +** nothing to the rebased changeset. +** +**
    Local DELETE
    +** This may conflict with a remote UPDATE or DELETE. In both cases the +** only possible resolution is OMIT. If the remote operation was a +** DELETE, then add no change to the rebased changeset. If the remote +** operation was an UPDATE, then the old.* fields of change are updated +** to reflect the new.* values in the UPDATE. +** +**
    Local UPDATE
    +** This may conflict with a remote UPDATE or DELETE. If it conflicts +** with a DELETE, and the conflict resolution was OMIT, then the update +** is changed into an INSERT. Any undefined values in the new.* record +** from the update change are filled in using the old.* values from +** the conflicting DELETE. Or, if the conflict resolution was REPLACE, +** the UPDATE change is simply omitted from the rebased changeset. +** +** If conflict is with a remote UPDATE and the resolution is OMIT, then +** the old.* values are rebased using the new.* values in the remote +** change. Or, if the resolution is REPLACE, then the change is copied +** into the rebased changeset with updates to columns also updated by +** the conflicting remote UPDATE removed. If this means no columns would +** be updated, the change is omitted. +**
    +** +** A local change may be rebased against multiple remote changes +** simultaneously. If a single key is modified by multiple remote +** changesets, they are combined as follows before the local changeset +** is rebased: +** +**
      +**
    • If there has been one or more REPLACE resolutions on a +** key, it is rebased according to a REPLACE. +** +**
    • If there have been no REPLACE resolutions on a key, then +** the local changeset is rebased according to the most recent +** of the OMIT resolutions. +**
    +** +** Note that conflict resolutions from multiple remote changesets are +** combined on a per-field basis, not per-row. This means that in the +** case of multiple remote UPDATE operations, some fields of a single +** local change may be rebased for REPLACE while others are rebased for +** OMIT. +** +** In order to rebase a local changeset, the remote changeset must first +** be applied to the local database using sqlite3changeset_apply_v2() and +** the buffer of rebase information captured. Then: +** +**
      +**
    1. An sqlite3_rebaser object is created by calling +** sqlite3rebaser_create(). +**
    2. The new object is configured with the rebase buffer obtained from +** sqlite3changeset_apply_v2() by calling sqlite3rebaser_configure(). +** If the local changeset is to be rebased against multiple remote +** changesets, then sqlite3rebaser_configure() should be called +** multiple times, in the same order that the multiple +** sqlite3changeset_apply_v2() calls were made. +**
    3. Each local changeset is rebased by calling sqlite3rebaser_rebase(). +**
    4. The sqlite3_rebaser object is deleted by calling +** sqlite3rebaser_delete(). +**
    +*/ +typedef struct sqlite3_rebaser sqlite3_rebaser; + +/* +** CAPI3REF: Create a changeset rebaser object. +** EXPERIMENTAL +** +** Allocate a new changeset rebaser object. If successful, set (*ppNew) to +** point to the new object and return SQLITE_OK. Otherwise, if an error +** occurs, return an SQLite error code (e.g. SQLITE_NOMEM) and set (*ppNew) +** to NULL. +*/ +SQLITE_API int sqlite3rebaser_create(sqlite3_rebaser **ppNew); + +/* +** CAPI3REF: Configure a changeset rebaser object. +** EXPERIMENTAL +** +** Configure the changeset rebaser object to rebase changesets according +** to the conflict resolutions described by buffer pRebase (size nRebase +** bytes), which must have been obtained from a previous call to +** sqlite3changeset_apply_v2(). +*/ +SQLITE_API int sqlite3rebaser_configure( + sqlite3_rebaser*, + int nRebase, const void *pRebase +); + +/* +** CAPI3REF: Rebase a changeset +** EXPERIMENTAL +** +** Argument pIn must point to a buffer containing a changeset nIn bytes +** in size. This function allocates and populates a buffer with a copy +** of the changeset rebased according to the configuration of the +** rebaser object passed as the first argument. If successful, (*ppOut) +** is set to point to the new buffer containing the rebased changeset and +** (*pnOut) to its size in bytes and SQLITE_OK returned. It is the +** responsibility of the caller to eventually free the new buffer using +** sqlite3_free(). Otherwise, if an error occurs, (*ppOut) and (*pnOut) +** are set to zero and an SQLite error code returned. +*/ +SQLITE_API int sqlite3rebaser_rebase( + sqlite3_rebaser*, + int nIn, const void *pIn, + int *pnOut, void **ppOut +); + +/* +** CAPI3REF: Delete a changeset rebaser object. +** EXPERIMENTAL +** +** Delete the changeset rebaser object and all associated resources. There +** should be one call to this function for each successful invocation +** of sqlite3rebaser_create(). +*/ +SQLITE_API void sqlite3rebaser_delete(sqlite3_rebaser *p); + +/* +** CAPI3REF: Streaming Versions of API functions. +** +** The six streaming API xxx_strm() functions serve similar purposes to the +** corresponding non-streaming API functions: +** +** +** +**
    Streaming functionNon-streaming equivalent
    sqlite3changeset_apply_strm[sqlite3changeset_apply] +**
    sqlite3changeset_apply_strm_v2[sqlite3changeset_apply_v2] +**
    sqlite3changeset_concat_strm[sqlite3changeset_concat] +**
    sqlite3changeset_invert_strm[sqlite3changeset_invert] +**
    sqlite3changeset_start_strm[sqlite3changeset_start] +**
    sqlite3session_changeset_strm[sqlite3session_changeset] +**
    sqlite3session_patchset_strm[sqlite3session_patchset] +**
    +** +** Non-streaming functions that accept changesets (or patchsets) as input +** require that the entire changeset be stored in a single buffer in memory. +** Similarly, those that return a changeset or patchset do so by returning +** a pointer to a single large buffer allocated using sqlite3_malloc(). +** Normally this is convenient. However, if an application running in a +** low-memory environment is required to handle very large changesets, the +** large contiguous memory allocations required can become onerous. +** +** In order to avoid this problem, instead of a single large buffer, input +** is passed to a streaming API functions by way of a callback function that +** the sessions module invokes to incrementally request input data as it is +** required. In all cases, a pair of API function parameters such as +** +** 
    +**        int nChangeset,
+**        void *pChangeset,
+**
    +** +** Is replaced by: +** +** 
    +**        int (*xInput)(void *pIn, void *pData, int *pnData),
+**        void *pIn,
+**
    +** +** Each time the xInput callback is invoked by the sessions module, the first +** argument passed is a copy of the supplied pIn context pointer. The second +** argument, pData, points to a buffer (*pnData) bytes in size. Assuming no +** error occurs the xInput method should copy up to (*pnData) bytes of data +** into the buffer and set (*pnData) to the actual number of bytes copied +** before returning SQLITE_OK. If the input is completely exhausted, (*pnData) +** should be set to zero to indicate this. Or, if an error occurs, an SQLite +** error code should be returned. In all cases, if an xInput callback returns +** an error, all processing is abandoned and the streaming API function +** returns a copy of the error code to the caller. +** +** In the case of sqlite3changeset_start_strm(), the xInput callback may be +** invoked by the sessions module at any point during the lifetime of the +** iterator. If such an xInput callback returns an error, the iterator enters +** an error state, whereby all subsequent calls to iterator functions +** immediately fail with the same error code as returned by xInput. +** +** Similarly, streaming API functions that return changesets (or patchsets) +** return them in chunks by way of a callback function instead of via a +** pointer to a single large buffer. In this case, a pair of parameters such +** as: +** +** 
    +**        int *pnChangeset,
+**        void **ppChangeset,
+**
    +** +** Is replaced by: +** +** 
    +**        int (*xOutput)(void *pOut, const void *pData, int nData),
+**        void *pOut
+**
    +** +** The xOutput callback is invoked zero or more times to return data to +** the application. The first parameter passed to each call is a copy of the +** pOut pointer supplied by the application. The second parameter, pData, +** points to a buffer nData bytes in size containing the chunk of output +** data being returned. If the xOutput callback successfully processes the +** supplied data, it should return SQLITE_OK to indicate success. Otherwise, +** it should return some other SQLite error code. In this case processing +** is immediately abandoned and the streaming API function returns a copy +** of the xOutput error code to the application. +** +** The sessions module never invokes an xOutput callback with the third +** parameter set to a value less than or equal to zero. Other than this, +** no guarantees are made as to the size of the chunks of data returned. +*/ +SQLITE_API int sqlite3changeset_apply_strm( + sqlite3 *db, /* Apply change to "main" db of this handle */ + int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */ + void *pIn, /* First arg for xInput */ + int(*xFilter)( + void *pCtx, /* Copy of sixth arg to _apply() */ + const char *zTab /* Table name */ + ), + int(*xConflict)( + void *pCtx, /* Copy of sixth arg to _apply() */ + int eConflict, /* DATA, MISSING, CONFLICT, CONSTRAINT */ + sqlite3_changeset_iter *p /* Handle describing change and conflict */ + ), + void *pCtx /* First argument passed to xConflict */ +); +SQLITE_API int sqlite3changeset_apply_v2_strm( + sqlite3 *db, /* Apply change to "main" db of this handle */ + int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */ + void *pIn, /* First arg for xInput */ + int(*xFilter)( + void *pCtx, /* Copy of sixth arg to _apply() */ + const char *zTab /* Table name */ + ), + int(*xConflict)( + void *pCtx, /* Copy of sixth arg to _apply() */ + int eConflict, /* DATA, MISSING, CONFLICT, CONSTRAINT */ + sqlite3_changeset_iter *p /* Handle describing change and conflict */ + ), + void *pCtx, /* First argument passed to xConflict */ + void **ppRebase, int *pnRebase, + int flags +); +SQLITE_API int sqlite3changeset_concat_strm( + int (*xInputA)(void *pIn, void *pData, int *pnData), + void *pInA, + int (*xInputB)(void *pIn, void *pData, int *pnData), + void *pInB, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); +SQLITE_API int sqlite3changeset_invert_strm( + int (*xInput)(void *pIn, void *pData, int *pnData), + void *pIn, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); +SQLITE_API int sqlite3changeset_start_strm( + sqlite3_changeset_iter **pp, + int (*xInput)(void *pIn, void *pData, int *pnData), + void *pIn +); +SQLITE_API int sqlite3changeset_start_v2_strm( + sqlite3_changeset_iter **pp, + int (*xInput)(void *pIn, void *pData, int *pnData), + void *pIn, + int flags +); +SQLITE_API int sqlite3session_changeset_strm( + sqlite3_session *pSession, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); +SQLITE_API int sqlite3session_patchset_strm( + sqlite3_session *pSession, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); +SQLITE_API int sqlite3changegroup_add_strm(sqlite3_changegroup*, + int (*xInput)(void *pIn, void *pData, int *pnData), + void *pIn +); +SQLITE_API int sqlite3changegroup_output_strm(sqlite3_changegroup*, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); +SQLITE_API int sqlite3rebaser_rebase_strm( + sqlite3_rebaser *pRebaser, + int (*xInput)(void *pIn, void *pData, int *pnData), + void *pIn, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); + +/* +** CAPI3REF: Configure global parameters +** +** The sqlite3session_config() interface is used to make global configuration +** changes to the sessions module in order to tune it to the specific needs +** of the application. +** +** The sqlite3session_config() interface is not threadsafe. If it is invoked +** while any other thread is inside any other sessions method then the +** results are undefined. Furthermore, if it is invoked after any sessions +** related objects have been created, the results are also undefined. +** +** The first argument to the sqlite3session_config() function must be one +** of the SQLITE_SESSION_CONFIG_XXX constants defined below. The +** interpretation of the (void*) value passed as the second parameter and +** the effect of calling this function depends on the value of the first +** parameter. +** +**
    +**
    SQLITE_SESSION_CONFIG_STRMSIZE
    +** By default, the sessions module streaming interfaces attempt to input +** and output data in approximately 1 KiB chunks. This operand may be used +** to set and query the value of this configuration setting. The pointer +** passed as the second argument must point to a value of type (int). +** If this value is greater than 0, it is used as the new streaming data +** chunk size for both input and output. Before returning, the (int) value +** pointed to by pArg is set to the final value of the streaming interface +** chunk size. +**
    +** +** This function returns SQLITE_OK if successful, or an SQLite error code +** otherwise. +*/ +SQLITE_API int sqlite3session_config(int op, void *pArg); + +/* +** CAPI3REF: Values for sqlite3session_config(). +*/ +#define SQLITE_SESSION_CONFIG_STRMSIZE 1 + +/* +** Make sure we can call this stuff from C++. +*/ +#if 0 +} +#endif + +#endif /* !defined(__SQLITESESSION_H_) && defined(SQLITE_ENABLE_SESSION) */ + +/******** End of sqlite3session.h *********/ +/******** Begin file fts5.h *********/ +/* +** 2014 May 31 +** +** 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. +** +****************************************************************************** +** +** Interfaces to extend FTS5. Using the interfaces defined in this file, +** FTS5 may be extended with: +** +** * custom tokenizers, and +** * custom auxiliary functions. +*/ + + +#ifndef _FTS5_H +#define _FTS5_H + + +#if 0 +extern "C" { +#endif + +/************************************************************************* +** CUSTOM AUXILIARY FUNCTIONS +** +** Virtual table implementations may overload SQL functions by implementing +** the sqlite3_module.xFindFunction() method. +*/ + +typedef struct Fts5ExtensionApi Fts5ExtensionApi; +typedef struct Fts5Context Fts5Context; +typedef struct Fts5PhraseIter Fts5PhraseIter; + +typedef void (*fts5_extension_function)( + const Fts5ExtensionApi *pApi, /* API offered by current FTS version */ + Fts5Context *pFts, /* First arg to pass to pApi functions */ + sqlite3_context *pCtx, /* Context for returning result/error */ + int nVal, /* Number of values in apVal[] array */ + sqlite3_value **apVal /* Array of trailing arguments */ +); + +struct Fts5PhraseIter { + const unsigned char *a; + const unsigned char *b; +}; + +/* +** EXTENSION API FUNCTIONS +** +** xUserData(pFts): +** Return a copy of the context pointer the extension function was +** registered with. +** +** xColumnTotalSize(pFts, iCol, pnToken): +** If parameter iCol is less than zero, set output variable *pnToken +** to the total number of tokens in the FTS5 table. Or, if iCol is +** non-negative but less than the number of columns in the table, return +** the total number of tokens in column iCol, considering all rows in +** the FTS5 table. +** +** If parameter iCol is greater than or equal to the number of columns +** in the table, SQLITE_RANGE is returned. Or, if an error occurs (e.g. +** an OOM condition or IO error), an appropriate SQLite error code is +** returned. +** +** xColumnCount(pFts): +** Return the number of columns in the table. +** +** xColumnSize(pFts, iCol, pnToken): +** If parameter iCol is less than zero, set output variable *pnToken +** to the total number of tokens in the current row. Or, if iCol is +** non-negative but less than the number of columns in the table, set +** *pnToken to the number of tokens in column iCol of the current row. +** +** If parameter iCol is greater than or equal to the number of columns +** in the table, SQLITE_RANGE is returned. Or, if an error occurs (e.g. +** an OOM condition or IO error), an appropriate SQLite error code is +** returned. +** +** This function may be quite inefficient if used with an FTS5 table +** created with the "columnsize=0" option. +** +** xColumnText: +** This function attempts to retrieve the text of column iCol of the +** current document. If successful, (*pz) is set to point to a buffer +** containing the text in utf-8 encoding, (*pn) is set to the size in bytes +** (not characters) of the buffer and SQLITE_OK is returned. Otherwise, +** if an error occurs, an SQLite error code is returned and the final values +** of (*pz) and (*pn) are undefined. +** +** xPhraseCount: +** Returns the number of phrases in the current query expression. +** +** xPhraseSize: +** Returns the number of tokens in phrase iPhrase of the query. Phrases +** are numbered starting from zero. +** +** xInstCount: +** Set *pnInst to the total number of occurrences of all phrases within +** the query within the current row. Return SQLITE_OK if successful, or +** an error code (i.e. SQLITE_NOMEM) if an error occurs. +** +** This API can be quite slow if used with an FTS5 table created with the +** "detail=none" or "detail=column" option. If the FTS5 table is created +** with either "detail=none" or "detail=column" and "content=" option +** (i.e. if it is a contentless table), then this API always returns 0. +** +** xInst: +** Query for the details of phrase match iIdx within the current row. +** Phrase matches are numbered starting from zero, so the iIdx argument +** should be greater than or equal to zero and smaller than the value +** output by xInstCount(). +** +** Usually, output parameter *piPhrase is set to the phrase number, *piCol +** to the column in which it occurs and *piOff the token offset of the +** first token of the phrase. Returns SQLITE_OK if successful, or an error +** code (i.e. SQLITE_NOMEM) if an error occurs. +** +** This API can be quite slow if used with an FTS5 table created with the +** "detail=none" or "detail=column" option. +** +** xRowid: +** Returns the rowid of the current row. +** +** xTokenize: +** Tokenize text using the tokenizer belonging to the FTS5 table. +** +** xQueryPhrase(pFts5, iPhrase, pUserData, xCallback): +** This API function is used to query the FTS table for phrase iPhrase +** of the current query. Specifically, a query equivalent to: +** +** ... FROM ftstable WHERE ftstable MATCH $p ORDER BY rowid +** +** with $p set to a phrase equivalent to the phrase iPhrase of the +** current query is executed. Any column filter that applies to +** phrase iPhrase of the current query is included in $p. For each +** row visited, the callback function passed as the fourth argument +** is invoked. The context and API objects passed to the callback +** function may be used to access the properties of each matched row. +** Invoking Api.xUserData() returns a copy of the pointer passed as +** the third argument to pUserData. +** +** If the callback function returns any value other than SQLITE_OK, the +** query is abandoned and the xQueryPhrase function returns immediately. +** If the returned value is SQLITE_DONE, xQueryPhrase returns SQLITE_OK. +** Otherwise, the error code is propagated upwards. +** +** If the query runs to completion without incident, SQLITE_OK is returned. +** Or, if some error occurs before the query completes or is aborted by +** the callback, an SQLite error code is returned. +** +** +** xSetAuxdata(pFts5, pAux, xDelete) +** +** Save the pointer passed as the second argument as the extension function's +** "auxiliary data". The pointer may then be retrieved by the current or any +** future invocation of the same fts5 extension function made as part of +** the same MATCH query using the xGetAuxdata() API. +** +** Each extension function is allocated a single auxiliary data slot for +** each FTS query (MATCH expression). If the extension function is invoked +** more than once for a single FTS query, then all invocations share a +** single auxiliary data context. +** +** If there is already an auxiliary data pointer when this function is +** invoked, then it is replaced by the new pointer. If an xDelete callback +** was specified along with the original pointer, it is invoked at this +** point. +** +** The xDelete callback, if one is specified, is also invoked on the +** auxiliary data pointer after the FTS5 query has finished. +** +** If an error (e.g. an OOM condition) occurs within this function, +** the auxiliary data is set to NULL and an error code returned. If the +** xDelete parameter was not NULL, it is invoked on the auxiliary data +** pointer before returning. +** +** +** xGetAuxdata(pFts5, bClear) +** +** Returns the current auxiliary data pointer for the fts5 extension +** function. See the xSetAuxdata() method for details. +** +** If the bClear argument is non-zero, then the auxiliary data is cleared +** (set to NULL) before this function returns. In this case the xDelete, +** if any, is not invoked. +** +** +** xRowCount(pFts5, pnRow) +** +** This function is used to retrieve the total number of rows in the table. +** In other words, the same value that would be returned by: +** +** SELECT count(*) FROM ftstable; +** +** xPhraseFirst() +** This function is used, along with type Fts5PhraseIter and the xPhraseNext +** method, to iterate through all instances of a single query phrase within +** the current row. This is the same information as is accessible via the +** xInstCount/xInst APIs. While the xInstCount/xInst APIs are more convenient +** to use, this API may be faster under some circumstances. To iterate +** through instances of phrase iPhrase, use the following code: +** +** Fts5PhraseIter iter; +** int iCol, iOff; +** for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff); +** iCol>=0; +** pApi->xPhraseNext(pFts, &iter, &iCol, &iOff) +** ){ +** // An instance of phrase iPhrase at offset iOff of column iCol +** } +** +** The Fts5PhraseIter structure is defined above. Applications should not +** modify this structure directly - it should only be used as shown above +** with the xPhraseFirst() and xPhraseNext() API methods (and by +** xPhraseFirstColumn() and xPhraseNextColumn() as illustrated below). +** +** This API can be quite slow if used with an FTS5 table created with the +** "detail=none" or "detail=column" option. If the FTS5 table is created +** with either "detail=none" or "detail=column" and "content=" option +** (i.e. if it is a contentless table), then this API always iterates +** through an empty set (all calls to xPhraseFirst() set iCol to -1). +** +** xPhraseNext() +** See xPhraseFirst above. +** +** xPhraseFirstColumn() +** This function and xPhraseNextColumn() are similar to the xPhraseFirst() +** and xPhraseNext() APIs described above. The difference is that instead +** of iterating through all instances of a phrase in the current row, these +** APIs are used to iterate through the set of columns in the current row +** that contain one or more instances of a specified phrase. For example: +** +** Fts5PhraseIter iter; +** int iCol; +** for(pApi->xPhraseFirstColumn(pFts, iPhrase, &iter, &iCol); +** iCol>=0; +** pApi->xPhraseNextColumn(pFts, &iter, &iCol) +** ){ +** // Column iCol contains at least one instance of phrase iPhrase +** } +** +** This API can be quite slow if used with an FTS5 table created with the +** "detail=none" option. If the FTS5 table is created with either +** "detail=none" "content=" option (i.e. if it is a contentless table), +** then this API always iterates through an empty set (all calls to +** xPhraseFirstColumn() set iCol to -1). +** +** The information accessed using this API and its companion +** xPhraseFirstColumn() may also be obtained using xPhraseFirst/xPhraseNext +** (or xInst/xInstCount). The chief advantage of this API is that it is +** significantly more efficient than those alternatives when used with +** "detail=column" tables. +** +** xPhraseNextColumn() +** See xPhraseFirstColumn above. +*/ +struct Fts5ExtensionApi { + int iVersion; /* Currently always set to 3 */ + + void *(*xUserData)(Fts5Context*); + + int (*xColumnCount)(Fts5Context*); + int (*xRowCount)(Fts5Context*, sqlite3_int64 *pnRow); + int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken); + + int (*xTokenize)(Fts5Context*, + const char *pText, int nText, /* Text to tokenize */ + void *pCtx, /* Context passed to xToken() */ + int (*xToken)(void*, int, const char*, int, int, int) /* Callback */ + ); + + int (*xPhraseCount)(Fts5Context*); + int (*xPhraseSize)(Fts5Context*, int iPhrase); + + int (*xInstCount)(Fts5Context*, int *pnInst); + int (*xInst)(Fts5Context*, int iIdx, int *piPhrase, int *piCol, int *piOff); + + sqlite3_int64 (*xRowid)(Fts5Context*); + int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn); + int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken); + + int (*xQueryPhrase)(Fts5Context*, int iPhrase, void *pUserData, + int(*)(const Fts5ExtensionApi*,Fts5Context*,void*) + ); + int (*xSetAuxdata)(Fts5Context*, void *pAux, void(*xDelete)(void*)); + void *(*xGetAuxdata)(Fts5Context*, int bClear); + + int (*xPhraseFirst)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*, int*); + void (*xPhraseNext)(Fts5Context*, Fts5PhraseIter*, int *piCol, int *piOff); + + int (*xPhraseFirstColumn)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*); + void (*xPhraseNextColumn)(Fts5Context*, Fts5PhraseIter*, int *piCol); +}; + +/* +** CUSTOM AUXILIARY FUNCTIONS +*************************************************************************/ + +/************************************************************************* +** CUSTOM TOKENIZERS +** +** Applications may also register custom tokenizer types. A tokenizer +** is registered by providing fts5 with a populated instance of the +** following structure. All structure methods must be defined, setting +** any member of the fts5_tokenizer struct to NULL leads to undefined +** behaviour. The structure methods are expected to function as follows: +** +** xCreate: +** This function is used to allocate and initialize a tokenizer instance. +** A tokenizer instance is required to actually tokenize text. +** +** The first argument passed to this function is a copy of the (void*) +** pointer provided by the application when the fts5_tokenizer object +** was registered with FTS5 (the third argument to xCreateTokenizer()). +** The second and third arguments are an array of nul-terminated strings +** containing the tokenizer arguments, if any, specified following the +** tokenizer name as part of the CREATE VIRTUAL TABLE statement used +** to create the FTS5 table. +** +** The final argument is an output variable. If successful, (*ppOut) +** should be set to point to the new tokenizer handle and SQLITE_OK +** returned. If an error occurs, some value other than SQLITE_OK should +** be returned. In this case, fts5 assumes that the final value of *ppOut +** is undefined. +** +** xDelete: +** This function is invoked to delete a tokenizer handle previously +** allocated using xCreate(). Fts5 guarantees that this function will +** be invoked exactly once for each successful call to xCreate(). +** +** xTokenize: +** This function is expected to tokenize the nText byte string indicated +** by argument pText. pText may or may not be nul-terminated. The first +** argument passed to this function is a pointer to an Fts5Tokenizer object +** returned by an earlier call to xCreate(). +** +** The second argument indicates the reason that FTS5 is requesting +** tokenization of the supplied text. This is always one of the following +** four values: +** +**
    • FTS5_TOKENIZE_DOCUMENT - A document is being inserted into +** or removed from the FTS table. The tokenizer is being invoked to +** determine the set of tokens to add to (or delete from) the +** FTS index. +** +**
    • FTS5_TOKENIZE_QUERY - A MATCH query is being executed +** against the FTS index. The tokenizer is being called to tokenize +** a bareword or quoted string specified as part of the query. +** +**
    • (FTS5_TOKENIZE_QUERY | FTS5_TOKENIZE_PREFIX) - Same as +** FTS5_TOKENIZE_QUERY, except that the bareword or quoted string is +** followed by a "*" character, indicating that the last token +** returned by the tokenizer will be treated as a token prefix. +** +**
    • FTS5_TOKENIZE_AUX - The tokenizer is being invoked to +** satisfy an fts5_api.xTokenize() request made by an auxiliary +** function. Or an fts5_api.xColumnSize() request made by the same +** on a columnsize=0 database. +**
    +** +** For each token in the input string, the supplied callback xToken() must +** be invoked. The first argument to it should be a copy of the pointer +** passed as the second argument to xTokenize(). The third and fourth +** arguments are a pointer to a buffer containing the token text, and the +** size of the token in bytes. The 4th and 5th arguments are the byte offsets +** of the first byte of and first byte immediately following the text from +** which the token is derived within the input. +** +** The second argument passed to the xToken() callback ("tflags") should +** normally be set to 0. The exception is if the tokenizer supports +** synonyms. In this case see the discussion below for details. +** +** FTS5 assumes the xToken() callback is invoked for each token in the +** order that they occur within the input text. +** +** If an xToken() callback returns any value other than SQLITE_OK, then +** the tokenization should be abandoned and the xTokenize() method should +** immediately return a copy of the xToken() return value. Or, if the +** input buffer is exhausted, xTokenize() should return SQLITE_OK. Finally, +** if an error occurs with the xTokenize() implementation itself, it +** may abandon the tokenization and return any error code other than +** SQLITE_OK or SQLITE_DONE. +** +** SYNONYM SUPPORT +** +** Custom tokenizers may also support synonyms. Consider a case in which a +** user wishes to query for a phrase such as "first place". Using the +** built-in tokenizers, the FTS5 query 'first + place' will match instances +** of "first place" within the document set, but not alternative forms +** such as "1st place". In some applications, it would be better to match +** all instances of "first place" or "1st place" regardless of which form +** the user specified in the MATCH query text. +** +** There are several ways to approach this in FTS5: +** +**
    1. By mapping all synonyms to a single token. In this case, using +** the above example, this means that the tokenizer returns the +** same token for inputs "first" and "1st". Say that token is in +** fact "first", so that when the user inserts the document "I won +** 1st place" entries are added to the index for tokens "i", "won", +** "first" and "place". If the user then queries for '1st + place', +** the tokenizer substitutes "first" for "1st" and the query works +** as expected. +** +**
    2. By querying the index for all synonyms of each query term +** separately. In this case, when tokenizing query text, the +** tokenizer may provide multiple synonyms for a single term +** within the document. FTS5 then queries the index for each +** synonym individually. For example, faced with the query: +** +** +** ... MATCH 'first place' +** +** the tokenizer offers both "1st" and "first" as synonyms for the +** first token in the MATCH query and FTS5 effectively runs a query +** similar to: +** +** +** ... MATCH '(first OR 1st) place' +** +** except that, for the purposes of auxiliary functions, the query +** still appears to contain just two phrases - "(first OR 1st)" +** being treated as a single phrase. +** +**
    3. By adding multiple synonyms for a single term to the FTS index. +** Using this method, when tokenizing document text, the tokenizer +** provides multiple synonyms for each token. So that when a +** document such as "I won first place" is tokenized, entries are +** added to the FTS index for "i", "won", "first", "1st" and +** "place". +** +** This way, even if the tokenizer does not provide synonyms +** when tokenizing query text (it should not - to do so would be +** inefficient), it doesn't matter if the user queries for +** 'first + place' or '1st + place', as there are entries in the +** FTS index corresponding to both forms of the first token. +**
    +** +** Whether it is parsing document or query text, any call to xToken that +** specifies a tflags argument with the FTS5_TOKEN_COLOCATED bit +** is considered to supply a synonym for the previous token. For example, +** when parsing the document "I won first place", a tokenizer that supports +** synonyms would call xToken() 5 times, as follows: +** +** +** xToken(pCtx, 0, "i", 1, 0, 1); +** xToken(pCtx, 0, "won", 3, 2, 5); +** xToken(pCtx, 0, "first", 5, 6, 11); +** xToken(pCtx, FTS5_TOKEN_COLOCATED, "1st", 3, 6, 11); +** xToken(pCtx, 0, "place", 5, 12, 17); +** +** +** It is an error to specify the FTS5_TOKEN_COLOCATED flag the first time +** xToken() is called. Multiple synonyms may be specified for a single token +** by making multiple calls to xToken(FTS5_TOKEN_COLOCATED) in sequence. +** There is no limit to the number of synonyms that may be provided for a +** single token. +** +** In many cases, method (1) above is the best approach. It does not add +** extra data to the FTS index or require FTS5 to query for multiple terms, +** so it is efficient in terms of disk space and query speed. However, it +** does not support prefix queries very well. If, as suggested above, the +** token "first" is substituted for "1st" by the tokenizer, then the query: +** +** +** ... MATCH '1s*' +** +** will not match documents that contain the token "1st" (as the tokenizer +** will probably not map "1s" to any prefix of "first"). +** +** For full prefix support, method (3) may be preferred. In this case, +** because the index contains entries for both "first" and "1st", prefix +** queries such as 'fi*' or '1s*' will match correctly. However, because +** extra entries are added to the FTS index, this method uses more space +** within the database. +** +** Method (2) offers a midpoint between (1) and (3). Using this method, +** a query such as '1s*' will match documents that contain the literal +** token "1st", but not "first" (assuming the tokenizer is not able to +** provide synonyms for prefixes). However, a non-prefix query like '1st' +** will match against "1st" and "first". This method does not require +** extra disk space, as no extra entries are added to the FTS index. +** On the other hand, it may require more CPU cycles to run MATCH queries, +** as separate queries of the FTS index are required for each synonym. +** +** When using methods (2) or (3), it is important that the tokenizer only +** provide synonyms when tokenizing document text (method (2)) or query +** text (method (3)), not both. Doing so will not cause any errors, but is +** inefficient. +*/ +typedef struct Fts5Tokenizer Fts5Tokenizer; +typedef struct fts5_tokenizer fts5_tokenizer; +struct fts5_tokenizer { + int (*xCreate)(void*, const char **azArg, int nArg, Fts5Tokenizer **ppOut); + void (*xDelete)(Fts5Tokenizer*); + int (*xTokenize)(Fts5Tokenizer*, + void *pCtx, + int flags, /* Mask of FTS5_TOKENIZE_* flags */ + const char *pText, int nText, + int (*xToken)( + void *pCtx, /* Copy of 2nd argument to xTokenize() */ + int tflags, /* Mask of FTS5_TOKEN_* flags */ + const char *pToken, /* Pointer to buffer containing token */ + int nToken, /* Size of token in bytes */ + int iStart, /* Byte offset of token within input text */ + int iEnd /* Byte offset of end of token within input text */ + ) + ); +}; + +/* Flags that may be passed as the third argument to xTokenize() */ +#define FTS5_TOKENIZE_QUERY 0x0001 +#define FTS5_TOKENIZE_PREFIX 0x0002 +#define FTS5_TOKENIZE_DOCUMENT 0x0004 +#define FTS5_TOKENIZE_AUX 0x0008 + +/* Flags that may be passed by the tokenizer implementation back to FTS5 +** as the third argument to the supplied xToken callback. */ +#define FTS5_TOKEN_COLOCATED 0x0001 /* Same position as prev. token */ + +/* +** END OF CUSTOM TOKENIZERS +*************************************************************************/ + +/************************************************************************* +** FTS5 EXTENSION REGISTRATION API +*/ +typedef struct fts5_api fts5_api; +struct fts5_api { + int iVersion; /* Currently always set to 2 */ + + /* Create a new tokenizer */ + int (*xCreateTokenizer)( + fts5_api *pApi, + const char *zName, + void *pContext, + fts5_tokenizer *pTokenizer, + void (*xDestroy)(void*) + ); + + /* Find an existing tokenizer */ + int (*xFindTokenizer)( + fts5_api *pApi, + const char *zName, + void **ppContext, + fts5_tokenizer *pTokenizer + ); + + /* Create a new auxiliary function */ + int (*xCreateFunction)( + fts5_api *pApi, + const char *zName, + void *pContext, + fts5_extension_function xFunction, + void (*xDestroy)(void*) + ); +}; + +/* +** END OF REGISTRATION API +*************************************************************************/ + +#if 0 +} /* end of the 'extern "C"' block */ +#endif + +#endif /* _FTS5_H */ + +/******** End of fts5.h *********/ + +/************** End of sqlite3.h *********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + +/* +** Include the configuration header output by 'configure' if we're using the +** autoconf-based build +*/ +#if defined(_HAVE_SQLITE_CONFIG_H) && !defined(SQLITECONFIG_H) +/* #include "config.h" */ +#define SQLITECONFIG_H 1 +#endif + +/************** Include sqliteLimit.h in the middle of sqliteInt.h ***********/ +/************** Begin file sqliteLimit.h *************************************/ +/* +** 2007 May 7 +** +** 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 defines various limits of what SQLite can process. +*/ + +/* +** The maximum length of a TEXT or BLOB in bytes. This also +** limits the size of a row in a table or index. +** +** The hard limit is the ability of a 32-bit signed integer +** to count the size: 2^31-1 or 2147483647. +*/ +#ifndef SQLITE_MAX_LENGTH +# define SQLITE_MAX_LENGTH 1000000000 +#endif + +/* +** This is the maximum number of +** +** * Columns in a table +** * Columns in an index +** * Columns in a view +** * Terms in the SET clause of an UPDATE statement +** * Terms in the result set of a SELECT statement +** * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement. +** * Terms in the VALUES clause of an INSERT statement +** +** The hard upper limit here is 32676. Most database people will +** tell you that in a well-normalized database, you usually should +** not have more than a dozen or so columns in any table. And if +** that is the case, there is no point in having more than a few +** dozen values in any of the other situations described above. +*/ +#ifndef SQLITE_MAX_COLUMN +# define SQLITE_MAX_COLUMN 2000 +#endif + +/* +** The maximum length of a single SQL statement in bytes. +** +** It used to be the case that setting this value to zero would +** turn the limit off. That is no longer true. It is not possible +** to turn this limit off. +*/ +#ifndef SQLITE_MAX_SQL_LENGTH +# define SQLITE_MAX_SQL_LENGTH 1000000000 +#endif + +/* +** The maximum depth of an expression tree. This is limited to +** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might +** want to place more severe limits on the complexity of an +** expression. A value of 0 means that there is no limit. +*/ +#ifndef SQLITE_MAX_EXPR_DEPTH +# define SQLITE_MAX_EXPR_DEPTH 1000 +#endif + +/* +** The maximum number of terms in a compound SELECT statement. +** The code generator for compound SELECT statements does one +** level of recursion for each term. A stack overflow can result +** if the number of terms is too large. In practice, most SQL +** never has more than 3 or 4 terms. Use a value of 0 to disable +** any limit on the number of terms in a compount SELECT. +*/ +#ifndef SQLITE_MAX_COMPOUND_SELECT +# define SQLITE_MAX_COMPOUND_SELECT 500 +#endif + +/* +** The maximum number of opcodes in a VDBE program. +** Not currently enforced. +*/ +#ifndef SQLITE_MAX_VDBE_OP +# define SQLITE_MAX_VDBE_OP 250000000 +#endif + +/* +** The maximum number of arguments to an SQL function. +*/ +#ifndef SQLITE_MAX_FUNCTION_ARG +# define SQLITE_MAX_FUNCTION_ARG 127 +#endif + +/* +** The suggested maximum number of in-memory pages to use for +** the main database table and for temporary tables. +** +** IMPLEMENTATION-OF: R-30185-15359 The default suggested cache size is -2000, +** which means the cache size is limited to 2048000 bytes of memory. +** IMPLEMENTATION-OF: R-48205-43578 The default suggested cache size can be +** altered using the SQLITE_DEFAULT_CACHE_SIZE compile-time options. +*/ +#ifndef SQLITE_DEFAULT_CACHE_SIZE +# define SQLITE_DEFAULT_CACHE_SIZE -2000 +#endif + +/* +** The default number of frames to accumulate in the log file before +** checkpointing the database in WAL mode. +*/ +#ifndef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT +# define SQLITE_DEFAULT_WAL_AUTOCHECKPOINT 1000 +#endif + +/* +** The maximum number of attached databases. This must be between 0 +** and 125. The upper bound of 125 is because the attached databases are +** counted using a signed 8-bit integer which has a maximum value of 127 +** and we have to allow 2 extra counts for the "main" and "temp" databases. +*/ +#ifndef SQLITE_MAX_ATTACHED +# define SQLITE_MAX_ATTACHED 10 +#endif + + +/* +** The maximum value of a ?nnn wildcard that the parser will accept. +** If the value exceeds 32767 then extra space is required for the Expr +** structure. But otherwise, we believe that the number can be as large +** as a signed 32-bit integer can hold. +*/ +#ifndef SQLITE_MAX_VARIABLE_NUMBER +# define SQLITE_MAX_VARIABLE_NUMBER 32766 +#endif + +/* Maximum page size. The upper bound on this value is 65536. This a limit +** imposed by the use of 16-bit offsets within each page. +** +** Earlier versions of SQLite allowed the user to change this value at +** compile time. This is no longer permitted, on the grounds that it creates +** a library that is technically incompatible with an SQLite library +** compiled with a different limit. If a process operating on a database +** with a page-size of 65536 bytes crashes, then an instance of SQLite +** compiled with the default page-size limit will not be able to rollback +** the aborted transaction. This could lead to database corruption. +*/ +#ifdef SQLITE_MAX_PAGE_SIZE +# undef SQLITE_MAX_PAGE_SIZE +#endif +#define SQLITE_MAX_PAGE_SIZE 65536 + + +/* +** The default size of a database page. +*/ +#ifndef SQLITE_DEFAULT_PAGE_SIZE +# define SQLITE_DEFAULT_PAGE_SIZE 4096 +#endif +#if SQLITE_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE +# undef SQLITE_DEFAULT_PAGE_SIZE +# define SQLITE_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE +#endif + +/* +** Ordinarily, if no value is explicitly provided, SQLite creates databases +** with page size SQLITE_DEFAULT_PAGE_SIZE. However, based on certain +** device characteristics (sector-size and atomic write() support), +** SQLite may choose a larger value. This constant is the maximum value +** SQLite will choose on its own. +*/ +#ifndef SQLITE_MAX_DEFAULT_PAGE_SIZE +# define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192 +#endif +#if SQLITE_MAX_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE +# undef SQLITE_MAX_DEFAULT_PAGE_SIZE +# define SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE +#endif + + +/* +** Maximum number of pages in one database file. +** +** This is really just the default value for the max_page_count pragma. +** This value can be lowered (or raised) at run-time using that the +** max_page_count macro. +*/ +#ifndef SQLITE_MAX_PAGE_COUNT +# define SQLITE_MAX_PAGE_COUNT 1073741823 +#endif + +/* +** Maximum length (in bytes) of the pattern in a LIKE or GLOB +** operator. +*/ +#ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH +# define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000 +#endif + +/* +** Maximum depth of recursion for triggers. +** +** A value of 1 means that a trigger program will not be able to itself +** fire any triggers. A value of 0 means that no trigger programs at all +** may be executed. +*/ +#ifndef SQLITE_MAX_TRIGGER_DEPTH +# define SQLITE_MAX_TRIGGER_DEPTH 1000 +#endif + +/************** End of sqliteLimit.h *****************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + +/* Disable nuisance warnings on Borland compilers */ +#if defined(__BORLANDC__) +#pragma warn -rch /* unreachable code */ +#pragma warn -ccc /* Condition is always true or false */ +#pragma warn -aus /* Assigned value is never used */ +#pragma warn -csu /* Comparing signed and unsigned */ +#pragma warn -spa /* Suspicious pointer arithmetic */ +#endif + +/* +** WAL mode depends on atomic aligned 32-bit loads and stores in a few +** places. The following macros try to make this explicit. +*/ +#ifndef __has_extension +# define __has_extension(x) 0 /* compatibility with non-clang compilers */ +#endif +#if GCC_VERSION>=4007000 || __has_extension(c_atomic) +# define AtomicLoad(PTR) __atomic_load_n((PTR),__ATOMIC_RELAXED) +# define AtomicStore(PTR,VAL) __atomic_store_n((PTR),(VAL),__ATOMIC_RELAXED) +#else +# define AtomicLoad(PTR) (*(PTR)) +# define AtomicStore(PTR,VAL) (*(PTR) = (VAL)) +#endif + +/* +** Include standard header files as necessary +*/ +#ifdef HAVE_STDINT_H +#include +#endif +#ifdef HAVE_INTTYPES_H +#include +#endif + +/* +** The following macros are used to cast pointers to integers and +** integers to pointers. The way you do this varies from one compiler +** to the next, so we have developed the following set of #if statements +** to generate appropriate macros for a wide range of compilers. +** +** The correct "ANSI" way to do this is to use the intptr_t type. +** Unfortunately, that typedef is not available on all compilers, or +** if it is available, it requires an #include of specific headers +** that vary from one machine to the next. +** +** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on +** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)). +** So we have to define the macros in different ways depending on the +** compiler. +*/ +#if defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */ +# define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X)) +# define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X)) +#elif defined(__PTRDIFF_TYPE__) /* This case should work for GCC */ +# define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X)) +# define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X)) +#elif !defined(__GNUC__) /* Works for compilers other than LLVM */ +# define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X]) +# define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0)) +#else /* Generates a warning - but it always works */ +# define SQLITE_INT_TO_PTR(X) ((void*)(X)) +# define SQLITE_PTR_TO_INT(X) ((int)(X)) +#endif + +/* +** A macro to hint to the compiler that a function should not be +** inlined. +*/ +#if defined(__GNUC__) +# define SQLITE_NOINLINE __attribute__((noinline)) +#elif defined(_MSC_VER) && _MSC_VER>=1310 +# define SQLITE_NOINLINE __declspec(noinline) +#else +# define SQLITE_NOINLINE +#endif + +/* +** Make sure that the compiler intrinsics we desire are enabled when +** compiling with an appropriate version of MSVC unless prevented by +** the SQLITE_DISABLE_INTRINSIC define. +*/ +#if !defined(SQLITE_DISABLE_INTRINSIC) +# if defined(_MSC_VER) && _MSC_VER>=1400 +# if !defined(_WIN32_WCE) +# include +# pragma intrinsic(_byteswap_ushort) +# pragma intrinsic(_byteswap_ulong) +# pragma intrinsic(_byteswap_uint64) +# pragma intrinsic(_ReadWriteBarrier) +# else +# include +# endif +# endif +#endif + +/* +** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2. +** 0 means mutexes are permanently disable and the library is never +** threadsafe. 1 means the library is serialized which is the highest +** level of threadsafety. 2 means the library is multithreaded - multiple +** threads can use SQLite as long as no two threads try to use the same +** database connection at the same time. +** +** Older versions of SQLite used an optional THREADSAFE macro. +** We support that for legacy. +** +** To ensure that the correct value of "THREADSAFE" is reported when querying +** for compile-time options at runtime (e.g. "PRAGMA compile_options"), this +** logic is partially replicated in ctime.c. If it is updated here, it should +** also be updated there. +*/ +#if !defined(SQLITE_THREADSAFE) +# if defined(THREADSAFE) +# define SQLITE_THREADSAFE THREADSAFE +# else +# define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */ +# endif +#endif + +/* +** Powersafe overwrite is on by default. But can be turned off using +** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option. +*/ +#ifndef SQLITE_POWERSAFE_OVERWRITE +# define SQLITE_POWERSAFE_OVERWRITE 1 +#endif + +/* +** EVIDENCE-OF: R-25715-37072 Memory allocation statistics are enabled by +** default unless SQLite is compiled with SQLITE_DEFAULT_MEMSTATUS=0 in +** which case memory allocation statistics are disabled by default. +*/ +#if !defined(SQLITE_DEFAULT_MEMSTATUS) +# define SQLITE_DEFAULT_MEMSTATUS 1 +#endif + +/* +** Exactly one of the following macros must be defined in order to +** specify which memory allocation subsystem to use. +** +** SQLITE_SYSTEM_MALLOC // Use normal system malloc() +** SQLITE_WIN32_MALLOC // Use Win32 native heap API +** SQLITE_ZERO_MALLOC // Use a stub allocator that always fails +** SQLITE_MEMDEBUG // Debugging version of system malloc() +** +** On Windows, if the SQLITE_WIN32_MALLOC_VALIDATE macro is defined and the +** assert() macro is enabled, each call into the Win32 native heap subsystem +** will cause HeapValidate to be called. If heap validation should fail, an +** assertion will be triggered. +** +** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as +** the default. +*/ +#if defined(SQLITE_SYSTEM_MALLOC) \ + + defined(SQLITE_WIN32_MALLOC) \ + + defined(SQLITE_ZERO_MALLOC) \ + + defined(SQLITE_MEMDEBUG)>1 +# error "Two or more of the following compile-time configuration options\ + are defined but at most one is allowed:\ + SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG,\ + SQLITE_ZERO_MALLOC" +#endif +#if defined(SQLITE_SYSTEM_MALLOC) \ + + defined(SQLITE_WIN32_MALLOC) \ + + defined(SQLITE_ZERO_MALLOC) \ + + defined(SQLITE_MEMDEBUG)==0 +# define SQLITE_SYSTEM_MALLOC 1 +#endif + +/* +** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the +** sizes of memory allocations below this value where possible. +*/ +#if !defined(SQLITE_MALLOC_SOFT_LIMIT) +# define SQLITE_MALLOC_SOFT_LIMIT 1024 +#endif + +/* +** We need to define _XOPEN_SOURCE as follows in order to enable +** recursive mutexes on most Unix systems and fchmod() on OpenBSD. +** But _XOPEN_SOURCE define causes problems for Mac OS X, so omit +** it. +*/ +#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__) +# define _XOPEN_SOURCE 600 +#endif + +/* +** NDEBUG and SQLITE_DEBUG are opposites. It should always be true that +** defined(NDEBUG)==!defined(SQLITE_DEBUG). If this is not currently true, +** make it true by defining or undefining NDEBUG. +** +** Setting NDEBUG makes the code smaller and faster by disabling the +** assert() statements in the code. So we want the default action +** to be for NDEBUG to be set and NDEBUG to be undefined only if SQLITE_DEBUG +** is set. Thus NDEBUG becomes an opt-in rather than an opt-out +** feature. +*/ +#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) +# define NDEBUG 1 +#endif +#if defined(NDEBUG) && defined(SQLITE_DEBUG) +# undef NDEBUG +#endif + +/* +** Enable SQLITE_ENABLE_EXPLAIN_COMMENTS if SQLITE_DEBUG is turned on. +*/ +#if !defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) && defined(SQLITE_DEBUG) +# define SQLITE_ENABLE_EXPLAIN_COMMENTS 1 +#endif + +/* +** The testcase() macro is used to aid in coverage testing. When +** doing coverage testing, the condition inside the argument to +** testcase() must be evaluated both true and false in order to +** get full branch coverage. The testcase() macro is inserted +** to help ensure adequate test coverage in places where simple +** condition/decision coverage is inadequate. For example, testcase() +** can be used to make sure boundary values are tested. For +** bitmask tests, testcase() can be used to make sure each bit +** is significant and used at least once. On switch statements +** where multiple cases go to the same block of code, testcase() +** can insure that all cases are evaluated. +** +*/ +#ifdef SQLITE_COVERAGE_TEST +SQLITE_PRIVATE void sqlite3Coverage(int); +# define testcase(X) if( X ){ sqlite3Coverage(__LINE__); } +#else +# define testcase(X) +#endif + +/* +** The TESTONLY macro is used to enclose variable declarations or +** other bits of code that are needed to support the arguments +** within testcase() and assert() macros. +*/ +#if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST) +# define TESTONLY(X) X +#else +# define TESTONLY(X) +#endif + +/* +** Sometimes we need a small amount of code such as a variable initialization +** to setup for a later assert() statement. We do not want this code to +** appear when assert() is disabled. The following macro is therefore +** used to contain that setup code. The "VVA" acronym stands for +** "Verification, Validation, and Accreditation". In other words, the +** code within VVA_ONLY() will only run during verification processes. +*/ +#ifndef NDEBUG +# define VVA_ONLY(X) X +#else +# define VVA_ONLY(X) +#endif + +/* +** The ALWAYS and NEVER macros surround boolean expressions which +** are intended to always be true or false, respectively. Such +** expressions could be omitted from the code completely. But they +** are included in a few cases in order to enhance the resilience +** of SQLite to unexpected behavior - to make the code "self-healing" +** or "ductile" rather than being "brittle" and crashing at the first +** hint of unplanned behavior. +** +** In other words, ALWAYS and NEVER are added for defensive code. +** +** When doing coverage testing ALWAYS and NEVER are hard-coded to +** be true and false so that the unreachable code they specify will +** not be counted as untested code. +*/ +#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST) +# define ALWAYS(X) (1) +# define NEVER(X) (0) +#elif !defined(NDEBUG) +# define ALWAYS(X) ((X)?1:(assert(0),0)) +# define NEVER(X) ((X)?(assert(0),1):0) +#else +# define ALWAYS(X) (X) +# define NEVER(X) (X) +#endif + +/* +** The harmless(X) macro indicates that expression X is usually false +** but can be true without causing any problems, but we don't know of +** any way to cause X to be true. +** +** In debugging and testing builds, this macro will abort if X is ever +** true. In this way, developers are alerted to a possible test case +** that causes X to be true. If a harmless macro ever fails, that is +** an opportunity to change the macro into a testcase() and add a new +** test case to the test suite. +** +** For normal production builds, harmless(X) is a no-op, since it does +** not matter whether expression X is true or false. +*/ +#ifdef SQLITE_DEBUG +# define harmless(X) assert(!(X)); +#else +# define harmless(X) +#endif + +/* +** Some conditionals are optimizations only. In other words, if the +** conditionals are replaced with a constant 1 (true) or 0 (false) then +** the correct answer is still obtained, though perhaps not as quickly. +** +** The following macros mark these optimizations conditionals. +*/ +#if defined(SQLITE_MUTATION_TEST) +# define OK_IF_ALWAYS_TRUE(X) (1) +# define OK_IF_ALWAYS_FALSE(X) (0) +#else +# define OK_IF_ALWAYS_TRUE(X) (X) +# define OK_IF_ALWAYS_FALSE(X) (X) +#endif + +/* +** Some malloc failures are only possible if SQLITE_TEST_REALLOC_STRESS is +** defined. We need to defend against those failures when testing with +** SQLITE_TEST_REALLOC_STRESS, but we don't want the unreachable branches +** during a normal build. The following macro can be used to disable tests +** that are always false except when SQLITE_TEST_REALLOC_STRESS is set. +*/ +#if defined(SQLITE_TEST_REALLOC_STRESS) +# define ONLY_IF_REALLOC_STRESS(X) (X) +#elif !defined(NDEBUG) +# define ONLY_IF_REALLOC_STRESS(X) ((X)?(assert(0),1):0) +#else +# define ONLY_IF_REALLOC_STRESS(X) (0) +#endif + +/* +** Declarations used for tracing the operating system interfaces. +*/ +#if defined(SQLITE_FORCE_OS_TRACE) || defined(SQLITE_TEST) || \ + (defined(SQLITE_DEBUG) && SQLITE_OS_WIN) + extern int sqlite3OSTrace; +# define OSTRACE(X) if( sqlite3OSTrace ) sqlite3DebugPrintf X +# define SQLITE_HAVE_OS_TRACE +#else +# define OSTRACE(X) +# undef SQLITE_HAVE_OS_TRACE +#endif + +/* +** Is the sqlite3ErrName() function needed in the build? Currently, +** it is needed by "mutex_w32.c" (when debugging), "os_win.c" (when +** OSTRACE is enabled), and by several "test*.c" files (which are +** compiled using SQLITE_TEST). +*/ +#if defined(SQLITE_HAVE_OS_TRACE) || defined(SQLITE_TEST) || \ + (defined(SQLITE_DEBUG) && SQLITE_OS_WIN) +# define SQLITE_NEED_ERR_NAME +#else +# undef SQLITE_NEED_ERR_NAME +#endif + +/* +** SQLITE_ENABLE_EXPLAIN_COMMENTS is incompatible with SQLITE_OMIT_EXPLAIN +*/ +#ifdef SQLITE_OMIT_EXPLAIN +# undef SQLITE_ENABLE_EXPLAIN_COMMENTS +#endif + +/* +** Return true (non-zero) if the input is an integer that is too large +** to fit in 32-bits. This macro is used inside of various testcase() +** macros to verify that we have tested SQLite for large-file support. +*/ +#define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0) + +/* +** The macro unlikely() is a hint that surrounds a boolean +** expression that is usually false. Macro likely() surrounds +** a boolean expression that is usually true. These hints could, +** in theory, be used by the compiler to generate better code, but +** currently they are just comments for human readers. +*/ +#define likely(X) (X) +#define unlikely(X) (X) + +/************** Include hash.h in the middle of sqliteInt.h ******************/ +/************** Begin file hash.h ********************************************/ +/* +** 2001 September 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the header file for the generic hash-table implementation +** used in SQLite. +*/ +#ifndef SQLITE_HASH_H +#define SQLITE_HASH_H + +/* Forward declarations of structures. */ +typedef struct Hash Hash; +typedef struct HashElem HashElem; + +/* A complete hash table is an instance of the following structure. +** The internals of this structure are intended to be opaque -- client +** code should not attempt to access or modify the fields of this structure +** directly. Change this structure only by using the routines below. +** However, some of the "procedures" and "functions" for modifying and +** accessing this structure are really macros, so we can't really make +** this structure opaque. +** +** All elements of the hash table are on a single doubly-linked list. +** Hash.first points to the head of this list. +** +** There are Hash.htsize buckets. Each bucket points to a spot in +** the global doubly-linked list. The contents of the bucket are the +** element pointed to plus the next _ht.count-1 elements in the list. +** +** Hash.htsize and Hash.ht may be zero. In that case lookup is done +** by a linear search of the global list. For small tables, the +** Hash.ht table is never allocated because if there are few elements +** in the table, it is faster to do a linear search than to manage +** the hash table. +*/ +struct Hash { + unsigned int htsize; /* Number of buckets in the hash table */ + unsigned int count; /* Number of entries in this table */ + HashElem *first; /* The first element of the array */ + struct _ht { /* the hash table */ + unsigned int count; /* Number of entries with this hash */ + HashElem *chain; /* Pointer to first entry with this hash */ + } *ht; +}; + +/* Each element in the hash table is an instance of the following +** structure. All elements are stored on a single doubly-linked list. +** +** Again, this structure is intended to be opaque, but it can't really +** be opaque because it is used by macros. +*/ +struct HashElem { + HashElem *next, *prev; /* Next and previous elements in the table */ + void *data; /* Data associated with this element */ + const char *pKey; /* Key associated with this element */ +}; + +/* +** Access routines. To delete, insert a NULL pointer. +*/ +SQLITE_PRIVATE void sqlite3HashInit(Hash*); +SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, void *pData); +SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey); +SQLITE_PRIVATE void sqlite3HashClear(Hash*); + +/* +** Macros for looping over all elements of a hash table. The idiom is +** like this: +** +** Hash h; +** HashElem *p; +** ... +** for(p=sqliteHashFirst(&h); p; p=sqliteHashNext(p)){ +** SomeStructure *pData = sqliteHashData(p); +** // do something with pData +** } +*/ +#define sqliteHashFirst(H) ((H)->first) +#define sqliteHashNext(E) ((E)->next) +#define sqliteHashData(E) ((E)->data) +/* #define sqliteHashKey(E) ((E)->pKey) // NOT USED */ +/* #define sqliteHashKeysize(E) ((E)->nKey) // NOT USED */ + +/* +** Number of entries in a hash table +*/ +/* #define sqliteHashCount(H) ((H)->count) // NOT USED */ + +#endif /* SQLITE_HASH_H */ + +/************** End of hash.h ************************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include parse.h in the middle of sqliteInt.h *****************/ +/************** Begin file parse.h *******************************************/ +#define TK_SEMI 1 +#define TK_EXPLAIN 2 +#define TK_QUERY 3 +#define TK_PLAN 4 +#define TK_BEGIN 5 +#define TK_TRANSACTION 6 +#define TK_DEFERRED 7 +#define TK_IMMEDIATE 8 +#define TK_EXCLUSIVE 9 +#define TK_COMMIT 10 +#define TK_END 11 +#define TK_ROLLBACK 12 +#define TK_SAVEPOINT 13 +#define TK_RELEASE 14 +#define TK_TO 15 +#define TK_TABLE 16 +#define TK_CREATE 17 +#define TK_IF 18 +#define TK_NOT 19 +#define TK_EXISTS 20 +#define TK_TEMP 21 +#define TK_LP 22 +#define TK_RP 23 +#define TK_AS 24 +#define TK_WITHOUT 25 +#define TK_COMMA 26 +#define TK_ABORT 27 +#define TK_ACTION 28 +#define TK_AFTER 29 +#define TK_ANALYZE 30 +#define TK_ASC 31 +#define TK_ATTACH 32 +#define TK_BEFORE 33 +#define TK_BY 34 +#define TK_CASCADE 35 +#define TK_CAST 36 +#define TK_CONFLICT 37 +#define TK_DATABASE 38 +#define TK_DESC 39 +#define TK_DETACH 40 +#define TK_EACH 41 +#define TK_FAIL 42 +#define TK_OR 43 +#define TK_AND 44 +#define TK_IS 45 +#define TK_MATCH 46 +#define TK_LIKE_KW 47 +#define TK_BETWEEN 48 +#define TK_IN 49 +#define TK_ISNULL 50 +#define TK_NOTNULL 51 +#define TK_NE 52 +#define TK_EQ 53 +#define TK_GT 54 +#define TK_LE 55 +#define TK_LT 56 +#define TK_GE 57 +#define TK_ESCAPE 58 +#define TK_ID 59 +#define TK_COLUMNKW 60 +#define TK_DO 61 +#define TK_FOR 62 +#define TK_IGNORE 63 +#define TK_INITIALLY 64 +#define TK_INSTEAD 65 +#define TK_NO 66 +#define TK_KEY 67 +#define TK_OF 68 +#define TK_OFFSET 69 +#define TK_PRAGMA 70 +#define TK_RAISE 71 +#define TK_RECURSIVE 72 +#define TK_REPLACE 73 +#define TK_RESTRICT 74 +#define TK_ROW 75 +#define TK_ROWS 76 +#define TK_TRIGGER 77 +#define TK_VACUUM 78 +#define TK_VIEW 79 +#define TK_VIRTUAL 80 +#define TK_WITH 81 +#define TK_NULLS 82 +#define TK_FIRST 83 +#define TK_LAST 84 +#define TK_CURRENT 85 +#define TK_FOLLOWING 86 +#define TK_PARTITION 87 +#define TK_PRECEDING 88 +#define TK_RANGE 89 +#define TK_UNBOUNDED 90 +#define TK_EXCLUDE 91 +#define TK_GROUPS 92 +#define TK_OTHERS 93 +#define TK_TIES 94 +#define TK_GENERATED 95 +#define TK_ALWAYS 96 +#define TK_REINDEX 97 +#define TK_RENAME 98 +#define TK_CTIME_KW 99 +#define TK_ANY 100 +#define TK_BITAND 101 +#define TK_BITOR 102 +#define TK_LSHIFT 103 +#define TK_RSHIFT 104 +#define TK_PLUS 105 +#define TK_MINUS 106 +#define TK_STAR 107 +#define TK_SLASH 108 +#define TK_REM 109 +#define TK_CONCAT 110 +#define TK_COLLATE 111 +#define TK_BITNOT 112 +#define TK_ON 113 +#define TK_INDEXED 114 +#define TK_STRING 115 +#define TK_JOIN_KW 116 +#define TK_CONSTRAINT 117 +#define TK_DEFAULT 118 +#define TK_NULL 119 +#define TK_PRIMARY 120 +#define TK_UNIQUE 121 +#define TK_CHECK 122 +#define TK_REFERENCES 123 +#define TK_AUTOINCR 124 +#define TK_INSERT 125 +#define TK_DELETE 126 +#define TK_UPDATE 127 +#define TK_SET 128 +#define TK_DEFERRABLE 129 +#define TK_FOREIGN 130 +#define TK_DROP 131 +#define TK_UNION 132 +#define TK_ALL 133 +#define TK_EXCEPT 134 +#define TK_INTERSECT 135 +#define TK_SELECT 136 +#define TK_VALUES 137 +#define TK_DISTINCT 138 +#define TK_DOT 139 +#define TK_FROM 140 +#define TK_JOIN 141 +#define TK_USING 142 +#define TK_ORDER 143 +#define TK_GROUP 144 +#define TK_HAVING 145 +#define TK_LIMIT 146 +#define TK_WHERE 147 +#define TK_INTO 148 +#define TK_NOTHING 149 +#define TK_FLOAT 150 +#define TK_BLOB 151 +#define TK_INTEGER 152 +#define TK_VARIABLE 153 +#define TK_CASE 154 +#define TK_WHEN 155 +#define TK_THEN 156 +#define TK_ELSE 157 +#define TK_INDEX 158 +#define TK_ALTER 159 +#define TK_ADD 160 +#define TK_WINDOW 161 +#define TK_OVER 162 +#define TK_FILTER 163 +#define TK_COLUMN 164 +#define TK_AGG_FUNCTION 165 +#define TK_AGG_COLUMN 166 +#define TK_TRUEFALSE 167 +#define TK_ISNOT 168 +#define TK_FUNCTION 169 +#define TK_UMINUS 170 +#define TK_UPLUS 171 +#define TK_TRUTH 172 +#define TK_REGISTER 173 +#define TK_VECTOR 174 +#define TK_SELECT_COLUMN 175 +#define TK_IF_NULL_ROW 176 +#define TK_ASTERISK 177 +#define TK_SPAN 178 +#define TK_SPACE 179 +#define TK_ILLEGAL 180 + +/************** End of parse.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +#include +#include +#include +#include +#include + +/* +** Use a macro to replace memcpy() if compiled with SQLITE_INLINE_MEMCPY. +** This allows better measurements of where memcpy() is used when running +** cachegrind. But this macro version of memcpy() is very slow so it +** should not be used in production. This is a performance measurement +** hack only. +*/ +#ifdef SQLITE_INLINE_MEMCPY +# define memcpy(D,S,N) {char*xxd=(char*)(D);const char*xxs=(const char*)(S);\ + int xxn=(N);while(xxn-->0)*(xxd++)=*(xxs++);} +#endif + +/* +** If compiling for a processor that lacks floating point support, +** substitute integer for floating-point +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# define double sqlite_int64 +# define float sqlite_int64 +# define LONGDOUBLE_TYPE sqlite_int64 +# ifndef SQLITE_BIG_DBL +# define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50) +# endif +# define SQLITE_OMIT_DATETIME_FUNCS 1 +# define SQLITE_OMIT_TRACE 1 +# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT +# undef SQLITE_HAVE_ISNAN +#endif +#ifndef SQLITE_BIG_DBL +# define SQLITE_BIG_DBL (1e99) +#endif + +/* +** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0 +** afterward. Having this macro allows us to cause the C compiler +** to omit code used by TEMP tables without messy #ifndef statements. +*/ +#ifdef SQLITE_OMIT_TEMPDB +#define OMIT_TEMPDB 1 +#else +#define OMIT_TEMPDB 0 +#endif + +/* +** The "file format" number is an integer that is incremented whenever +** the VDBE-level file format changes. The following macros define the +** the default file format for new databases and the maximum file format +** that the library can read. +*/ +#define SQLITE_MAX_FILE_FORMAT 4 +#ifndef SQLITE_DEFAULT_FILE_FORMAT +# define SQLITE_DEFAULT_FILE_FORMAT 4 +#endif + +/* +** Determine whether triggers are recursive by default. This can be +** changed at run-time using a pragma. +*/ +#ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS +# define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0 +#endif + +/* +** Provide a default value for SQLITE_TEMP_STORE in case it is not specified +** on the command-line +*/ +#ifndef SQLITE_TEMP_STORE +# define SQLITE_TEMP_STORE 1 +#endif + +/* +** If no value has been provided for SQLITE_MAX_WORKER_THREADS, or if +** SQLITE_TEMP_STORE is set to 3 (never use temporary files), set it +** to zero. +*/ +#if SQLITE_TEMP_STORE==3 || SQLITE_THREADSAFE==0 +# undef SQLITE_MAX_WORKER_THREADS +# define SQLITE_MAX_WORKER_THREADS 0 +#endif +#ifndef SQLITE_MAX_WORKER_THREADS +# define SQLITE_MAX_WORKER_THREADS 8 +#endif +#ifndef SQLITE_DEFAULT_WORKER_THREADS +# define SQLITE_DEFAULT_WORKER_THREADS 0 +#endif +#if SQLITE_DEFAULT_WORKER_THREADS>SQLITE_MAX_WORKER_THREADS +# undef SQLITE_MAX_WORKER_THREADS +# define SQLITE_MAX_WORKER_THREADS SQLITE_DEFAULT_WORKER_THREADS +#endif + +/* +** The default initial allocation for the pagecache when using separate +** pagecaches for each database connection. A positive number is the +** number of pages. A negative number N translations means that a buffer +** of -1024*N bytes is allocated and used for as many pages as it will hold. +** +** The default value of "20" was choosen to minimize the run-time of the +** speedtest1 test program with options: --shrink-memory --reprepare +*/ +#ifndef SQLITE_DEFAULT_PCACHE_INITSZ +# define SQLITE_DEFAULT_PCACHE_INITSZ 20 +#endif + +/* +** Default value for the SQLITE_CONFIG_SORTERREF_SIZE option. +*/ +#ifndef SQLITE_DEFAULT_SORTERREF_SIZE +# define SQLITE_DEFAULT_SORTERREF_SIZE 0x7fffffff +#endif + +/* +** The compile-time options SQLITE_MMAP_READWRITE and +** SQLITE_ENABLE_BATCH_ATOMIC_WRITE are not compatible with one another. +** You must choose one or the other (or neither) but not both. +*/ +#if defined(SQLITE_MMAP_READWRITE) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE) +#error Cannot use both SQLITE_MMAP_READWRITE and SQLITE_ENABLE_BATCH_ATOMIC_WRITE +#endif + +/* +** GCC does not define the offsetof() macro so we'll have to do it +** ourselves. +*/ +#ifndef offsetof +#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD)) +#endif + +/* +** Macros to compute minimum and maximum of two numbers. +*/ +#ifndef MIN +# define MIN(A,B) ((A)<(B)?(A):(B)) +#endif +#ifndef MAX +# define MAX(A,B) ((A)>(B)?(A):(B)) +#endif + +/* +** Swap two objects of type TYPE. +*/ +#define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;} + +/* +** Check to see if this machine uses EBCDIC. (Yes, believe it or +** not, there are still machines out there that use EBCDIC.) +*/ +#if 'A' == '\301' +# define SQLITE_EBCDIC 1 +#else +# define SQLITE_ASCII 1 +#endif + +/* +** Integers of known sizes. These typedefs might change for architectures +** where the sizes very. Preprocessor macros are available so that the +** types can be conveniently redefined at compile-type. Like this: +** +** cc '-DUINTPTR_TYPE=long long int' ... +*/ +#ifndef UINT32_TYPE +# ifdef HAVE_UINT32_T +# define UINT32_TYPE uint32_t +# else +# define UINT32_TYPE unsigned int +# endif +#endif +#ifndef UINT16_TYPE +# ifdef HAVE_UINT16_T +# define UINT16_TYPE uint16_t +# else +# define UINT16_TYPE unsigned short int +# endif +#endif +#ifndef INT16_TYPE +# ifdef HAVE_INT16_T +# define INT16_TYPE int16_t +# else +# define INT16_TYPE short int +# endif +#endif +#ifndef UINT8_TYPE +# ifdef HAVE_UINT8_T +# define UINT8_TYPE uint8_t +# else +# define UINT8_TYPE unsigned char +# endif +#endif +#ifndef INT8_TYPE +# ifdef HAVE_INT8_T +# define INT8_TYPE int8_t +# else +# define INT8_TYPE signed char +# endif +#endif +#ifndef LONGDOUBLE_TYPE +# define LONGDOUBLE_TYPE long double +#endif +typedef sqlite_int64 i64; /* 8-byte signed integer */ +typedef sqlite_uint64 u64; /* 8-byte unsigned integer */ +typedef UINT32_TYPE u32; /* 4-byte unsigned integer */ +typedef UINT16_TYPE u16; /* 2-byte unsigned integer */ +typedef INT16_TYPE i16; /* 2-byte signed integer */ +typedef UINT8_TYPE u8; /* 1-byte unsigned integer */ +typedef INT8_TYPE i8; /* 1-byte signed integer */ + +/* +** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value +** that can be stored in a u32 without loss of data. The value +** is 0x00000000ffffffff. But because of quirks of some compilers, we +** have to specify the value in the less intuitive manner shown: +*/ +#define SQLITE_MAX_U32 ((((u64)1)<<32)-1) + +/* +** The datatype used to store estimates of the number of rows in a +** table or index. This is an unsigned integer type. For 99.9% of +** the world, a 32-bit integer is sufficient. But a 64-bit integer +** can be used at compile-time if desired. +*/ +#ifdef SQLITE_64BIT_STATS + typedef u64 tRowcnt; /* 64-bit only if requested at compile-time */ +#else + typedef u32 tRowcnt; /* 32-bit is the default */ +#endif + +/* +** Estimated quantities used for query planning are stored as 16-bit +** logarithms. For quantity X, the value stored is 10*log2(X). This +** gives a possible range of values of approximately 1.0e986 to 1e-986. +** But the allowed values are "grainy". Not every value is representable. +** For example, quantities 16 and 17 are both represented by a LogEst +** of 40. However, since LogEst quantities are suppose to be estimates, +** not exact values, this imprecision is not a problem. +** +** "LogEst" is short for "Logarithmic Estimate". +** +** Examples: +** 1 -> 0 20 -> 43 10000 -> 132 +** 2 -> 10 25 -> 46 25000 -> 146 +** 3 -> 16 100 -> 66 1000000 -> 199 +** 4 -> 20 1000 -> 99 1048576 -> 200 +** 10 -> 33 1024 -> 100 4294967296 -> 320 +** +** The LogEst can be negative to indicate fractional values. +** Examples: +** +** 0.5 -> -10 0.1 -> -33 0.0625 -> -40 +*/ +typedef INT16_TYPE LogEst; + +/* +** Set the SQLITE_PTRSIZE macro to the number of bytes in a pointer +*/ +#ifndef SQLITE_PTRSIZE +# if defined(__SIZEOF_POINTER__) +# define SQLITE_PTRSIZE __SIZEOF_POINTER__ +# elif defined(i386) || defined(__i386__) || defined(_M_IX86) || \ + defined(_M_ARM) || defined(__arm__) || defined(__x86) || \ + (defined(__TOS_AIX__) && !defined(__64BIT__)) +# define SQLITE_PTRSIZE 4 +# else +# define SQLITE_PTRSIZE 8 +# endif +#endif + +/* The uptr type is an unsigned integer large enough to hold a pointer +*/ +#if defined(HAVE_STDINT_H) + typedef uintptr_t uptr; +#elif SQLITE_PTRSIZE==4 + typedef u32 uptr; +#else + typedef u64 uptr; +#endif + +/* +** The SQLITE_WITHIN(P,S,E) macro checks to see if pointer P points to +** something between S (inclusive) and E (exclusive). +** +** In other words, S is a buffer and E is a pointer to the first byte after +** the end of buffer S. This macro returns true if P points to something +** contained within the buffer S. +*/ +#define SQLITE_WITHIN(P,S,E) (((uptr)(P)>=(uptr)(S))&&((uptr)(P)<(uptr)(E))) + + +/* +** Macros to determine whether the machine is big or little endian, +** and whether or not that determination is run-time or compile-time. +** +** For best performance, an attempt is made to guess at the byte-order +** using C-preprocessor macros. If that is unsuccessful, or if +** -DSQLITE_BYTEORDER=0 is set, then byte-order is determined +** at run-time. +*/ +#ifndef SQLITE_BYTEORDER +# if defined(i386) || defined(__i386__) || defined(_M_IX86) || \ + defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \ + defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \ + defined(__ARMEL__) || defined(__AARCH64EL__) || defined(_M_ARM64) +# define SQLITE_BYTEORDER 1234 +# elif defined(sparc) || defined(__ppc__) || \ + defined(__ARMEB__) || defined(__AARCH64EB__) +# define SQLITE_BYTEORDER 4321 +# else +# define SQLITE_BYTEORDER 0 +# endif +#endif +#if SQLITE_BYTEORDER==4321 +# define SQLITE_BIGENDIAN 1 +# define SQLITE_LITTLEENDIAN 0 +# define SQLITE_UTF16NATIVE SQLITE_UTF16BE +#elif SQLITE_BYTEORDER==1234 +# define SQLITE_BIGENDIAN 0 +# define SQLITE_LITTLEENDIAN 1 +# define SQLITE_UTF16NATIVE SQLITE_UTF16LE +#else +# ifdef SQLITE_AMALGAMATION + const int sqlite3one = 1; +# else + extern const int sqlite3one; +# endif +# define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0) +# define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1) +# define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE) +#endif + +/* +** Constants for the largest and smallest possible 64-bit signed integers. +** These macros are designed to work correctly on both 32-bit and 64-bit +** compilers. +*/ +#define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32)) +#define LARGEST_UINT64 (0xffffffff|(((u64)0xffffffff)<<32)) +#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64) + +/* +** Round up a number to the next larger multiple of 8. This is used +** to force 8-byte alignment on 64-bit architectures. +*/ +#define ROUND8(x) (((x)+7)&~7) + +/* +** Round down to the nearest multiple of 8 +*/ +#define ROUNDDOWN8(x) ((x)&~7) + +/* +** Assert that the pointer X is aligned to an 8-byte boundary. This +** macro is used only within assert() to verify that the code gets +** all alignment restrictions correct. +** +** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the +** underlying malloc() implementation might return us 4-byte aligned +** pointers. In that case, only verify 4-byte alignment. +*/ +#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC +# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&3)==0) +#else +# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0) +#endif + +/* +** Disable MMAP on platforms where it is known to not work +*/ +#if defined(__OpenBSD__) || defined(__QNXNTO__) +# undef SQLITE_MAX_MMAP_SIZE +# define SQLITE_MAX_MMAP_SIZE 0 +#endif + +/* +** Default maximum size of memory used by memory-mapped I/O in the VFS +*/ +#ifdef __APPLE__ +# include +#endif +#ifndef SQLITE_MAX_MMAP_SIZE +# if defined(__linux__) \ + || defined(_WIN32) \ + || (defined(__APPLE__) && defined(__MACH__)) \ + || defined(__sun) \ + || defined(__FreeBSD__) \ + || defined(__DragonFly__) +# define SQLITE_MAX_MMAP_SIZE 0x7fff0000 /* 2147418112 */ +# else +# define SQLITE_MAX_MMAP_SIZE 0 +# endif +#endif + +/* +** The default MMAP_SIZE is zero on all platforms. Or, even if a larger +** default MMAP_SIZE is specified at compile-time, make sure that it does +** not exceed the maximum mmap size. +*/ +#ifndef SQLITE_DEFAULT_MMAP_SIZE +# define SQLITE_DEFAULT_MMAP_SIZE 0 +#endif +#if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE +# undef SQLITE_DEFAULT_MMAP_SIZE +# define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE +#endif + +/* +** SELECTTRACE_ENABLED will be either 1 or 0 depending on whether or not +** the Select query generator tracing logic is turned on. +*/ +#if defined(SQLITE_ENABLE_SELECTTRACE) +# define SELECTTRACE_ENABLED 1 +#else +# define SELECTTRACE_ENABLED 0 +#endif +#if defined(SQLITE_ENABLE_SELECTTRACE) +# define SELECTTRACE_ENABLED 1 +# define SELECTTRACE(K,P,S,X) \ + if(sqlite3_unsupported_selecttrace&(K)) \ + sqlite3DebugPrintf("%u/%d/%p: ",(S)->selId,(P)->addrExplain,(S)),\ + sqlite3DebugPrintf X +#else +# define SELECTTRACE(K,P,S,X) +# define SELECTTRACE_ENABLED 0 +#endif + +/* +** An instance of the following structure is used to store the busy-handler +** callback for a given sqlite handle. +** +** The sqlite.busyHandler member of the sqlite struct contains the busy +** callback for the database handle. Each pager opened via the sqlite +** handle is passed a pointer to sqlite.busyHandler. The busy-handler +** callback is currently invoked only from within pager.c. +*/ +typedef struct BusyHandler BusyHandler; +struct BusyHandler { + int (*xBusyHandler)(void *,int); /* The busy callback */ + void *pBusyArg; /* First arg to busy callback */ + int nBusy; /* Incremented with each busy call */ +}; + +/* +** Name of table that holds the database schema. +*/ +#define DFLT_SCHEMA_TABLE "sqlite_master" +#define DFLT_TEMP_SCHEMA_TABLE "sqlite_temp_master" +#define ALT_SCHEMA_TABLE "sqlite_schema" +#define ALT_TEMP_SCHEMA_TABLE "sqlite_temp_schema" + + +/* +** The root-page of the schema table. +*/ +#define SCHEMA_ROOT 1 + +/* +** The name of the schema table. The name is different for TEMP. +*/ +#define SCHEMA_TABLE(x) \ + ((!OMIT_TEMPDB)&&(x==1)?DFLT_TEMP_SCHEMA_TABLE:DFLT_SCHEMA_TABLE) + +/* +** A convenience macro that returns the number of elements in +** an array. +*/ +#define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0]))) + +/* +** Determine if the argument is a power of two +*/ +#define IsPowerOfTwo(X) (((X)&((X)-1))==0) + +/* +** The following value as a destructor means to use sqlite3DbFree(). +** The sqlite3DbFree() routine requires two parameters instead of the +** one parameter that destructors normally want. So we have to introduce +** this magic value that the code knows to handle differently. Any +** pointer will work here as long as it is distinct from SQLITE_STATIC +** and SQLITE_TRANSIENT. +*/ +#define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3OomFault) + +/* +** When SQLITE_OMIT_WSD is defined, it means that the target platform does +** not support Writable Static Data (WSD) such as global and static variables. +** All variables must either be on the stack or dynamically allocated from +** the heap. When WSD is unsupported, the variable declarations scattered +** throughout the SQLite code must become constants instead. The SQLITE_WSD +** macro is used for this purpose. And instead of referencing the variable +** directly, we use its constant as a key to lookup the run-time allocated +** buffer that holds real variable. The constant is also the initializer +** for the run-time allocated buffer. +** +** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL +** macros become no-ops and have zero performance impact. +*/ +#ifdef SQLITE_OMIT_WSD + #define SQLITE_WSD const + #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v))) + #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config) +SQLITE_API int sqlite3_wsd_init(int N, int J); +SQLITE_API void *sqlite3_wsd_find(void *K, int L); +#else + #define SQLITE_WSD + #define GLOBAL(t,v) v + #define sqlite3GlobalConfig sqlite3Config +#endif + +/* +** The following macros are used to suppress compiler warnings and to +** make it clear to human readers when a function parameter is deliberately +** left unused within the body of a function. This usually happens when +** a function is called via a function pointer. For example the +** implementation of an SQL aggregate step callback may not use the +** parameter indicating the number of arguments passed to the aggregate, +** if it knows that this is enforced elsewhere. +** +** When a function parameter is not used at all within the body of a function, +** it is generally named "NotUsed" or "NotUsed2" to make things even clearer. +** However, these macros may also be used to suppress warnings related to +** parameters that may or may not be used depending on compilation options. +** For example those parameters only used in assert() statements. In these +** cases the parameters are named as per the usual conventions. +*/ +#define UNUSED_PARAMETER(x) (void)(x) +#define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y) + +/* +** Forward references to structures +*/ +typedef struct AggInfo AggInfo; +typedef struct AuthContext AuthContext; +typedef struct AutoincInfo AutoincInfo; +typedef struct Bitvec Bitvec; +typedef struct CollSeq CollSeq; +typedef struct Column Column; +typedef struct Db Db; +typedef struct Schema Schema; +typedef struct Expr Expr; +typedef struct ExprList ExprList; +typedef struct FKey FKey; +typedef struct FuncDestructor FuncDestructor; +typedef struct FuncDef FuncDef; +typedef struct FuncDefHash FuncDefHash; +typedef struct IdList IdList; +typedef struct Index Index; +typedef struct IndexSample IndexSample; +typedef struct KeyClass KeyClass; +typedef struct KeyInfo KeyInfo; +typedef struct Lookaside Lookaside; +typedef struct LookasideSlot LookasideSlot; +typedef struct Module Module; +typedef struct NameContext NameContext; +typedef struct Parse Parse; +typedef struct PreUpdate PreUpdate; +typedef struct PrintfArguments PrintfArguments; +typedef struct RenameToken RenameToken; +typedef struct RowSet RowSet; +typedef struct Savepoint Savepoint; +typedef struct Select Select; +typedef struct SQLiteThread SQLiteThread; +typedef struct SelectDest SelectDest; +typedef struct SrcList SrcList; +typedef struct sqlite3_str StrAccum; /* Internal alias for sqlite3_str */ +typedef struct Table Table; +typedef struct TableLock TableLock; +typedef struct Token Token; +typedef struct TreeView TreeView; +typedef struct Trigger Trigger; +typedef struct TriggerPrg TriggerPrg; +typedef struct TriggerStep TriggerStep; +typedef struct UnpackedRecord UnpackedRecord; +typedef struct Upsert Upsert; +typedef struct VTable VTable; +typedef struct VtabCtx VtabCtx; +typedef struct Walker Walker; +typedef struct WhereInfo WhereInfo; +typedef struct Window Window; +typedef struct With With; + + +/* +** The bitmask datatype defined below is used for various optimizations. +** +** Changing this from a 64-bit to a 32-bit type limits the number of +** tables in a join to 32 instead of 64. But it also reduces the size +** of the library by 738 bytes on ix86. +*/ +#ifdef SQLITE_BITMASK_TYPE + typedef SQLITE_BITMASK_TYPE Bitmask; +#else + typedef u64 Bitmask; +#endif + +/* +** The number of bits in a Bitmask. "BMS" means "BitMask Size". +*/ +#define BMS ((int)(sizeof(Bitmask)*8)) + +/* +** A bit in a Bitmask +*/ +#define MASKBIT(n) (((Bitmask)1)<<(n)) +#define MASKBIT64(n) (((u64)1)<<(n)) +#define MASKBIT32(n) (((unsigned int)1)<<(n)) +#define ALLBITS ((Bitmask)-1) + +/* A VList object records a mapping between parameters/variables/wildcards +** in the SQL statement (such as $abc, @pqr, or :xyz) and the integer +** variable number associated with that parameter. See the format description +** on the sqlite3VListAdd() routine for more information. A VList is really +** just an array of integers. +*/ +typedef int VList; + +/* +** Defer sourcing vdbe.h and btree.h until after the "u8" and +** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque +** pointer types (i.e. FuncDef) defined above. +*/ +/************** Include pager.h in the middle of sqliteInt.h *****************/ +/************** Begin file pager.h *******************************************/ +/* +** 2001 September 15 +** +** 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 header file defines the interface that the sqlite page cache +** subsystem. The page cache subsystem reads and writes a file a page +** at a time and provides a journal for rollback. +*/ + +#ifndef SQLITE_PAGER_H +#define SQLITE_PAGER_H + +/* +** Default maximum size for persistent journal files. A negative +** value means no limit. This value may be overridden using the +** sqlite3PagerJournalSizeLimit() API. See also "PRAGMA journal_size_limit". +*/ +#ifndef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT + #define SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT -1 +#endif + +/* +** The type used to represent a page number. The first page in a file +** is called page 1. 0 is used to represent "not a page". +*/ +typedef u32 Pgno; + +/* +** Each open file is managed by a separate instance of the "Pager" structure. +*/ +typedef struct Pager Pager; + +/* +** Handle type for pages. +*/ +typedef struct PgHdr DbPage; + +/* +** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is +** reserved for working around a windows/posix incompatibility). It is +** used in the journal to signify that the remainder of the journal file +** is devoted to storing a super-journal name - there are no more pages to +** roll back. See comments for function writeSuperJournal() in pager.c +** for details. +*/ +#define PAGER_MJ_PGNO(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1)) + +/* +** Allowed values for the flags parameter to sqlite3PagerOpen(). +** +** NOTE: These values must match the corresponding BTREE_ values in btree.h. +*/ +#define PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */ +#define PAGER_MEMORY 0x0002 /* In-memory database */ + +/* +** Valid values for the second argument to sqlite3PagerLockingMode(). +*/ +#define PAGER_LOCKINGMODE_QUERY -1 +#define PAGER_LOCKINGMODE_NORMAL 0 +#define PAGER_LOCKINGMODE_EXCLUSIVE 1 + +/* +** Numeric constants that encode the journalmode. +** +** The numeric values encoded here (other than PAGER_JOURNALMODE_QUERY) +** are exposed in the API via the "PRAGMA journal_mode" command and +** therefore cannot be changed without a compatibility break. +*/ +#define PAGER_JOURNALMODE_QUERY (-1) /* Query the value of journalmode */ +#define PAGER_JOURNALMODE_DELETE 0 /* Commit by deleting journal file */ +#define PAGER_JOURNALMODE_PERSIST 1 /* Commit by zeroing journal header */ +#define PAGER_JOURNALMODE_OFF 2 /* Journal omitted. */ +#define PAGER_JOURNALMODE_TRUNCATE 3 /* Commit by truncating journal */ +#define PAGER_JOURNALMODE_MEMORY 4 /* In-memory journal file */ +#define PAGER_JOURNALMODE_WAL 5 /* Use write-ahead logging */ + +/* +** Flags that make up the mask passed to sqlite3PagerGet(). +*/ +#define PAGER_GET_NOCONTENT 0x01 /* Do not load data from disk */ +#define PAGER_GET_READONLY 0x02 /* Read-only page is acceptable */ + +/* +** Flags for sqlite3PagerSetFlags() +** +** Value constraints (enforced via assert()): +** PAGER_FULLFSYNC == SQLITE_FullFSync +** PAGER_CKPT_FULLFSYNC == SQLITE_CkptFullFSync +** PAGER_CACHE_SPILL == SQLITE_CacheSpill +*/ +#define PAGER_SYNCHRONOUS_OFF 0x01 /* PRAGMA synchronous=OFF */ +#define PAGER_SYNCHRONOUS_NORMAL 0x02 /* PRAGMA synchronous=NORMAL */ +#define PAGER_SYNCHRONOUS_FULL 0x03 /* PRAGMA synchronous=FULL */ +#define PAGER_SYNCHRONOUS_EXTRA 0x04 /* PRAGMA synchronous=EXTRA */ +#define PAGER_SYNCHRONOUS_MASK 0x07 /* Mask for four values above */ +#define PAGER_FULLFSYNC 0x08 /* PRAGMA fullfsync=ON */ +#define PAGER_CKPT_FULLFSYNC 0x10 /* PRAGMA checkpoint_fullfsync=ON */ +#define PAGER_CACHESPILL 0x20 /* PRAGMA cache_spill=ON */ +#define PAGER_FLAGS_MASK 0x38 /* All above except SYNCHRONOUS */ + +/* +** The remainder of this file contains the declarations of the functions +** that make up the Pager sub-system API. See source code comments for +** a detailed description of each routine. +*/ + +/* Open and close a Pager connection. */ +SQLITE_PRIVATE int sqlite3PagerOpen( + sqlite3_vfs*, + Pager **ppPager, + const char*, + int, + int, + int, + void(*)(DbPage*) +); +SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager, sqlite3*); +SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager*, int, unsigned char*); + +/* Functions used to configure a Pager object. */ +SQLITE_PRIVATE void sqlite3PagerSetBusyHandler(Pager*, int(*)(void *), void *); +SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager*, u32*, int); +SQLITE_PRIVATE Pgno sqlite3PagerMaxPageCount(Pager*, Pgno); +SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager*, int); +SQLITE_PRIVATE int sqlite3PagerSetSpillsize(Pager*, int); +SQLITE_PRIVATE void sqlite3PagerSetMmapLimit(Pager *, sqlite3_int64); +SQLITE_PRIVATE void sqlite3PagerShrink(Pager*); +SQLITE_PRIVATE void sqlite3PagerSetFlags(Pager*,unsigned); +SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *, int); +SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *, int); +SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager*); +SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager*); +SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *, i64); +SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager*); +SQLITE_PRIVATE int sqlite3PagerFlush(Pager*); + +/* Functions used to obtain and release page references. */ +SQLITE_PRIVATE int sqlite3PagerGet(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag); +SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno); +SQLITE_PRIVATE void sqlite3PagerRef(DbPage*); +SQLITE_PRIVATE void sqlite3PagerUnref(DbPage*); +SQLITE_PRIVATE void sqlite3PagerUnrefNotNull(DbPage*); +SQLITE_PRIVATE void sqlite3PagerUnrefPageOne(DbPage*); + +/* Operations on page references. */ +SQLITE_PRIVATE int sqlite3PagerWrite(DbPage*); +SQLITE_PRIVATE void sqlite3PagerDontWrite(DbPage*); +SQLITE_PRIVATE int sqlite3PagerMovepage(Pager*,DbPage*,Pgno,int); +SQLITE_PRIVATE int sqlite3PagerPageRefcount(DbPage*); +SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *); +SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *); + +/* Functions used to manage pager transactions and savepoints. */ +SQLITE_PRIVATE void sqlite3PagerPagecount(Pager*, int*); +SQLITE_PRIVATE int sqlite3PagerBegin(Pager*, int exFlag, int); +SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(Pager*,const char *zSuper, int); +SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager*); +SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zSuper); +SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager*); +SQLITE_PRIVATE int sqlite3PagerRollback(Pager*); +SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n); +SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint); +SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager); + +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager, sqlite3*, int, int*, int*); +SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager); +SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager); +SQLITE_PRIVATE int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen); +SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager, sqlite3*); +# ifdef SQLITE_ENABLE_SNAPSHOT +SQLITE_PRIVATE int sqlite3PagerSnapshotGet(Pager*, sqlite3_snapshot **ppSnapshot); +SQLITE_PRIVATE int sqlite3PagerSnapshotOpen(Pager*, sqlite3_snapshot *pSnapshot); +SQLITE_PRIVATE int sqlite3PagerSnapshotRecover(Pager *pPager); +SQLITE_PRIVATE int sqlite3PagerSnapshotCheck(Pager *pPager, sqlite3_snapshot *pSnapshot); +SQLITE_PRIVATE void sqlite3PagerSnapshotUnlock(Pager *pPager); +# endif +#endif + +#if !defined(SQLITE_OMIT_WAL) && defined(SQLITE_ENABLE_SETLK_TIMEOUT) +SQLITE_PRIVATE int sqlite3PagerWalWriteLock(Pager*, int); +SQLITE_PRIVATE void sqlite3PagerWalDb(Pager*, sqlite3*); +#else +# define sqlite3PagerWalWriteLock(y,z) SQLITE_OK +# define sqlite3PagerWalDb(x,y) +#endif + +#ifdef SQLITE_DIRECT_OVERFLOW_READ +SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno); +#endif + +#ifdef SQLITE_ENABLE_ZIPVFS +SQLITE_PRIVATE int sqlite3PagerWalFramesize(Pager *pPager); +#endif + +/* Functions used to query pager state and configuration. */ +SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager*); +SQLITE_PRIVATE u32 sqlite3PagerDataVersion(Pager*); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3PagerRefcount(Pager*); +#endif +SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager*); +SQLITE_PRIVATE const char *sqlite3PagerFilename(const Pager*, int); +SQLITE_PRIVATE sqlite3_vfs *sqlite3PagerVfs(Pager*); +SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager*); +SQLITE_PRIVATE sqlite3_file *sqlite3PagerJrnlFile(Pager*); +SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager*); +SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager*); +SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager*); +SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *, int, int, int *); +SQLITE_PRIVATE void sqlite3PagerClearCache(Pager*); +SQLITE_PRIVATE int sqlite3SectorSize(sqlite3_file *); + +/* Functions used to truncate the database file. */ +SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno); + +SQLITE_PRIVATE void sqlite3PagerRekey(DbPage*, Pgno, u16); + +/* Functions to support testing and debugging. */ +#if !defined(NDEBUG) || defined(SQLITE_TEST) +SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage*); +SQLITE_PRIVATE int sqlite3PagerIswriteable(DbPage*); +#endif +#ifdef SQLITE_TEST +SQLITE_PRIVATE int *sqlite3PagerStats(Pager*); +SQLITE_PRIVATE void sqlite3PagerRefdump(Pager*); + void disable_simulated_io_errors(void); + void enable_simulated_io_errors(void); +#else +# define disable_simulated_io_errors() +# define enable_simulated_io_errors() +#endif + +#endif /* SQLITE_PAGER_H */ + +/************** End of pager.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include btree.h in the middle of sqliteInt.h *****************/ +/************** Begin file btree.h *******************************************/ +/* +** 2001 September 15 +** +** 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 header file defines the interface that the sqlite B-Tree file +** subsystem. See comments in the source code for a detailed description +** of what each interface routine does. +*/ +#ifndef SQLITE_BTREE_H +#define SQLITE_BTREE_H + +/* TODO: This definition is just included so other modules compile. It +** needs to be revisited. +*/ +#define SQLITE_N_BTREE_META 16 + +/* +** If defined as non-zero, auto-vacuum is enabled by default. Otherwise +** it must be turned on for each database using "PRAGMA auto_vacuum = 1". +*/ +#ifndef SQLITE_DEFAULT_AUTOVACUUM + #define SQLITE_DEFAULT_AUTOVACUUM 0 +#endif + +#define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */ +#define BTREE_AUTOVACUUM_FULL 1 /* Do full auto-vacuum */ +#define BTREE_AUTOVACUUM_INCR 2 /* Incremental vacuum */ + +/* +** Forward declarations of structure +*/ +typedef struct Btree Btree; +typedef struct BtCursor BtCursor; +typedef struct BtShared BtShared; +typedef struct BtreePayload BtreePayload; + + +SQLITE_PRIVATE int sqlite3BtreeOpen( + sqlite3_vfs *pVfs, /* VFS to use with this b-tree */ + const char *zFilename, /* Name of database file to open */ + sqlite3 *db, /* Associated database connection */ + Btree **ppBtree, /* Return open Btree* here */ + int flags, /* Flags */ + int vfsFlags /* Flags passed through to VFS open */ +); + +/* The flags parameter to sqlite3BtreeOpen can be the bitwise or of the +** following values. +** +** NOTE: These values must match the corresponding PAGER_ values in +** pager.h. +*/ +#define BTREE_OMIT_JOURNAL 1 /* Do not create or use a rollback journal */ +#define BTREE_MEMORY 2 /* This is an in-memory DB */ +#define BTREE_SINGLE 4 /* The file contains at most 1 b-tree */ +#define BTREE_UNORDERED 8 /* Use of a hash implementation is OK */ + +SQLITE_PRIVATE int sqlite3BtreeClose(Btree*); +SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree*,int); +SQLITE_PRIVATE int sqlite3BtreeSetSpillSize(Btree*,int); +#if SQLITE_MAX_MMAP_SIZE>0 +SQLITE_PRIVATE int sqlite3BtreeSetMmapLimit(Btree*,sqlite3_int64); +#endif +SQLITE_PRIVATE int sqlite3BtreeSetPagerFlags(Btree*,unsigned); +SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int nPagesize, int nReserve, int eFix); +SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree*); +SQLITE_PRIVATE Pgno sqlite3BtreeMaxPageCount(Btree*,Pgno); +SQLITE_PRIVATE Pgno sqlite3BtreeLastPage(Btree*); +SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree*,int); +SQLITE_PRIVATE int sqlite3BtreeGetRequestedReserve(Btree*); +SQLITE_PRIVATE int sqlite3BtreeGetReserveNoMutex(Btree *p); +SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *, int); +SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *); +SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree*,int,int*); +SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree*, const char*); +SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree*, int); +SQLITE_PRIVATE int sqlite3BtreeCommit(Btree*); +SQLITE_PRIVATE int sqlite3BtreeRollback(Btree*,int,int); +SQLITE_PRIVATE int sqlite3BtreeBeginStmt(Btree*,int); +SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree*, Pgno*, int flags); +SQLITE_PRIVATE int sqlite3BtreeTxnState(Btree*); +SQLITE_PRIVATE int sqlite3BtreeIsInBackup(Btree*); + +SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *, int, void(*)(void *)); +SQLITE_PRIVATE int sqlite3BtreeSchemaLocked(Btree *pBtree); +#ifndef SQLITE_OMIT_SHARED_CACHE +SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *pBtree, int iTab, u8 isWriteLock); +#endif + +/* Savepoints are named, nestable SQL transactions mostly implemented */ +/* in vdbe.c and pager.c See https://sqlite.org/lang_savepoint.html */ +SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *, int, int); + +/* "Checkpoint" only refers to WAL. See https://sqlite.org/wal.html#ckpt */ +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3BtreeCheckpoint(Btree*, int, int *, int *); +#endif + +SQLITE_PRIVATE const char *sqlite3BtreeGetFilename(Btree *); +SQLITE_PRIVATE const char *sqlite3BtreeGetJournalname(Btree *); +SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *, Btree *); + +SQLITE_PRIVATE int sqlite3BtreeIncrVacuum(Btree *); + +/* The flags parameter to sqlite3BtreeCreateTable can be the bitwise OR +** of the flags shown below. +** +** Every SQLite table must have either BTREE_INTKEY or BTREE_BLOBKEY set. +** With BTREE_INTKEY, the table key is a 64-bit integer and arbitrary data +** is stored in the leaves. (BTREE_INTKEY is used for SQL tables.) With +** BTREE_BLOBKEY, the key is an arbitrary BLOB and no content is stored +** anywhere - the key is the content. (BTREE_BLOBKEY is used for SQL +** indices.) +*/ +#define BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */ +#define BTREE_BLOBKEY 2 /* Table has keys only - no data */ + +SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree*, int, int*); +SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree*, int, int*); +SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreeTripAllCursors(Btree*, int, int); + +SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *pBtree, int idx, u32 *pValue); +SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value); + +SQLITE_PRIVATE int sqlite3BtreeNewDb(Btree *p); + +/* +** The second parameter to sqlite3BtreeGetMeta or sqlite3BtreeUpdateMeta +** should be one of the following values. The integer values are assigned +** to constants so that the offset of the corresponding field in an +** SQLite database header may be found using the following formula: +** +** offset = 36 + (idx * 4) +** +** For example, the free-page-count field is located at byte offset 36 of +** the database file header. The incr-vacuum-flag field is located at +** byte offset 64 (== 36+4*7). +** +** The BTREE_DATA_VERSION value is not really a value stored in the header. +** It is a read-only number computed by the pager. But we merge it with +** the header value access routines since its access pattern is the same. +** Call it a "virtual meta value". +*/ +#define BTREE_FREE_PAGE_COUNT 0 +#define BTREE_SCHEMA_VERSION 1 +#define BTREE_FILE_FORMAT 2 +#define BTREE_DEFAULT_CACHE_SIZE 3 +#define BTREE_LARGEST_ROOT_PAGE 4 +#define BTREE_TEXT_ENCODING 5 +#define BTREE_USER_VERSION 6 +#define BTREE_INCR_VACUUM 7 +#define BTREE_APPLICATION_ID 8 +#define BTREE_DATA_VERSION 15 /* A virtual meta-value */ + +/* +** Kinds of hints that can be passed into the sqlite3BtreeCursorHint() +** interface. +** +** BTREE_HINT_RANGE (arguments: Expr*, Mem*) +** +** The first argument is an Expr* (which is guaranteed to be constant for +** the lifetime of the cursor) that defines constraints on which rows +** might be fetched with this cursor. The Expr* tree may contain +** TK_REGISTER nodes that refer to values stored in the array of registers +** passed as the second parameter. In other words, if Expr.op==TK_REGISTER +** then the value of the node is the value in Mem[pExpr.iTable]. Any +** TK_COLUMN node in the expression tree refers to the Expr.iColumn-th +** column of the b-tree of the cursor. The Expr tree will not contain +** any function calls nor subqueries nor references to b-trees other than +** the cursor being hinted. +** +** The design of the _RANGE hint is aid b-tree implementations that try +** to prefetch content from remote machines - to provide those +** implementations with limits on what needs to be prefetched and thereby +** reduce network bandwidth. +** +** Note that BTREE_HINT_FLAGS with BTREE_BULKLOAD is the only hint used by +** standard SQLite. The other hints are provided for extentions that use +** the SQLite parser and code generator but substitute their own storage +** engine. +*/ +#define BTREE_HINT_RANGE 0 /* Range constraints on queries */ + +/* +** Values that may be OR'd together to form the argument to the +** BTREE_HINT_FLAGS hint for sqlite3BtreeCursorHint(): +** +** The BTREE_BULKLOAD flag is set on index cursors when the index is going +** to be filled with content that is already in sorted order. +** +** The BTREE_SEEK_EQ flag is set on cursors that will get OP_SeekGE or +** OP_SeekLE opcodes for a range search, but where the range of entries +** selected will all have the same key. In other words, the cursor will +** be used only for equality key searches. +** +*/ +#define BTREE_BULKLOAD 0x00000001 /* Used to full index in sorted order */ +#define BTREE_SEEK_EQ 0x00000002 /* EQ seeks only - no range seeks */ + +/* +** Flags passed as the third argument to sqlite3BtreeCursor(). +** +** For read-only cursors the wrFlag argument is always zero. For read-write +** cursors it may be set to either (BTREE_WRCSR|BTREE_FORDELETE) or just +** (BTREE_WRCSR). If the BTREE_FORDELETE bit is set, then the cursor will +** only be used by SQLite for the following: +** +** * to seek to and then delete specific entries, and/or +** +** * to read values that will be used to create keys that other +** BTREE_FORDELETE cursors will seek to and delete. +** +** The BTREE_FORDELETE flag is an optimization hint. It is not used by +** by this, the native b-tree engine of SQLite, but it is available to +** alternative storage engines that might be substituted in place of this +** b-tree system. For alternative storage engines in which a delete of +** the main table row automatically deletes corresponding index rows, +** the FORDELETE flag hint allows those alternative storage engines to +** skip a lot of work. Namely: FORDELETE cursors may treat all SEEK +** and DELETE operations as no-ops, and any READ operation against a +** FORDELETE cursor may return a null row: 0x01 0x00. +*/ +#define BTREE_WRCSR 0x00000004 /* read-write cursor */ +#define BTREE_FORDELETE 0x00000008 /* Cursor is for seek/delete only */ + +SQLITE_PRIVATE int sqlite3BtreeCursor( + Btree*, /* BTree containing table to open */ + Pgno iTable, /* Index of root page */ + int wrFlag, /* 1 for writing. 0 for read-only */ + struct KeyInfo*, /* First argument to compare function */ + BtCursor *pCursor /* Space to write cursor structure */ +); +SQLITE_PRIVATE BtCursor *sqlite3BtreeFakeValidCursor(void); +SQLITE_PRIVATE int sqlite3BtreeCursorSize(void); +SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor*); +SQLITE_PRIVATE void sqlite3BtreeCursorHintFlags(BtCursor*, unsigned); +#ifdef SQLITE_ENABLE_CURSOR_HINTS +SQLITE_PRIVATE void sqlite3BtreeCursorHint(BtCursor*, int, ...); +#endif + +SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked( + BtCursor*, + UnpackedRecord *pUnKey, + i64 intKey, + int bias, + int *pRes +); +SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor*, int*); +SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*, u8 flags); + +/* Allowed flags for sqlite3BtreeDelete() and sqlite3BtreeInsert() */ +#define BTREE_SAVEPOSITION 0x02 /* Leave cursor pointing at NEXT or PREV */ +#define BTREE_AUXDELETE 0x04 /* not the primary delete operation */ +#define BTREE_APPEND 0x08 /* Insert is likely an append */ + +/* An instance of the BtreePayload object describes the content of a single +** entry in either an index or table btree. +** +** Index btrees (used for indexes and also WITHOUT ROWID tables) contain +** an arbitrary key and no data. These btrees have pKey,nKey set to the +** key and the pData,nData,nZero fields are uninitialized. The aMem,nMem +** fields give an array of Mem objects that are a decomposition of the key. +** The nMem field might be zero, indicating that no decomposition is available. +** +** Table btrees (used for rowid tables) contain an integer rowid used as +** the key and passed in the nKey field. The pKey field is zero. +** pData,nData hold the content of the new entry. nZero extra zero bytes +** are appended to the end of the content when constructing the entry. +** The aMem,nMem fields are uninitialized for table btrees. +** +** Field usage summary: +** +** Table BTrees Index Btrees +** +** pKey always NULL encoded key +** nKey the ROWID length of pKey +** pData data not used +** aMem not used decomposed key value +** nMem not used entries in aMem +** nData length of pData not used +** nZero extra zeros after pData not used +** +** This object is used to pass information into sqlite3BtreeInsert(). The +** same information used to be passed as five separate parameters. But placing +** the information into this object helps to keep the interface more +** organized and understandable, and it also helps the resulting code to +** run a little faster by using fewer registers for parameter passing. +*/ +struct BtreePayload { + const void *pKey; /* Key content for indexes. NULL for tables */ + sqlite3_int64 nKey; /* Size of pKey for indexes. PRIMARY KEY for tabs */ + const void *pData; /* Data for tables. */ + sqlite3_value *aMem; /* First of nMem value in the unpacked pKey */ + u16 nMem; /* Number of aMem[] value. Might be zero */ + int nData; /* Size of pData. 0 if none. */ + int nZero; /* Extra zero data appended after pData,nData */ +}; + +SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const BtreePayload *pPayload, + int flags, int seekResult); +SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor*, int *pRes); +SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor*, int *pRes); +SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor*, int flags); +SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor*, int flags); +SQLITE_PRIVATE i64 sqlite3BtreeIntegerKey(BtCursor*); +SQLITE_PRIVATE void sqlite3BtreeCursorPin(BtCursor*); +SQLITE_PRIVATE void sqlite3BtreeCursorUnpin(BtCursor*); +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC +SQLITE_PRIVATE i64 sqlite3BtreeOffset(BtCursor*); +#endif +SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor*, u32 offset, u32 amt, void*); +SQLITE_PRIVATE const void *sqlite3BtreePayloadFetch(BtCursor*, u32 *pAmt); +SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor*); +SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeMaxRecordSize(BtCursor*); + +SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(sqlite3*,Btree*,Pgno*aRoot,int nRoot,int,int*); +SQLITE_PRIVATE struct Pager *sqlite3BtreePager(Btree*); +SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor*); + +#ifndef SQLITE_OMIT_INCRBLOB +SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor*, u32 offset, u32 amt, void*); +SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*); +SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *); +#endif +SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *); +SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBt, int iVersion); +SQLITE_PRIVATE int sqlite3BtreeCursorHasHint(BtCursor*, unsigned int mask); +SQLITE_PRIVATE int sqlite3BtreeIsReadonly(Btree *pBt); +SQLITE_PRIVATE int sqlite3HeaderSizeBtree(void); + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE sqlite3_uint64 sqlite3BtreeSeekCount(Btree*); +#else +# define sqlite3BtreeSeekCount(X) 0 +#endif + +#ifndef NDEBUG +SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor*); +#endif +SQLITE_PRIVATE int sqlite3BtreeCursorIsValidNN(BtCursor*); + +SQLITE_PRIVATE int sqlite3BtreeCount(sqlite3*, BtCursor*, i64*); + +#ifdef SQLITE_TEST +SQLITE_PRIVATE int sqlite3BtreeCursorInfo(BtCursor*, int*, int); +SQLITE_PRIVATE void sqlite3BtreeCursorList(Btree*); +#endif + +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3BtreeCheckpoint(Btree*, int, int *, int *); +#endif + +/* +** If we are not using shared cache, then there is no need to +** use mutexes to access the BtShared structures. So make the +** Enter and Leave procedures no-ops. +*/ +#ifndef SQLITE_OMIT_SHARED_CACHE +SQLITE_PRIVATE void sqlite3BtreeEnter(Btree*); +SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3*); +SQLITE_PRIVATE int sqlite3BtreeSharable(Btree*); +SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreeConnectionCount(Btree*); +#else +# define sqlite3BtreeEnter(X) +# define sqlite3BtreeEnterAll(X) +# define sqlite3BtreeSharable(X) 0 +# define sqlite3BtreeEnterCursor(X) +# define sqlite3BtreeConnectionCount(X) 1 +#endif + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE +SQLITE_PRIVATE void sqlite3BtreeLeave(Btree*); +SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor*); +SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3*); +#ifndef NDEBUG + /* These routines are used inside assert() statements only. */ +SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree*); +SQLITE_PRIVATE int sqlite3BtreeHoldsAllMutexes(sqlite3*); +SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3*,int,Schema*); +#endif +#else + +# define sqlite3BtreeLeave(X) +# define sqlite3BtreeLeaveCursor(X) +# define sqlite3BtreeLeaveAll(X) + +# define sqlite3BtreeHoldsMutex(X) 1 +# define sqlite3BtreeHoldsAllMutexes(X) 1 +# define sqlite3SchemaMutexHeld(X,Y,Z) 1 +#endif + + +#endif /* SQLITE_BTREE_H */ + +/************** End of btree.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include vdbe.h in the middle of sqliteInt.h ******************/ +/************** Begin file vdbe.h ********************************************/ +/* +** 2001 September 15 +** +** 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. +** +************************************************************************* +** Header file for the Virtual DataBase Engine (VDBE) +** +** This header defines the interface to the virtual database engine +** or VDBE. The VDBE implements an abstract machine that runs a +** simple program to access and modify the underlying database. +*/ +#ifndef SQLITE_VDBE_H +#define SQLITE_VDBE_H +/* #include */ + +/* +** A single VDBE is an opaque structure named "Vdbe". Only routines +** in the source file sqliteVdbe.c are allowed to see the insides +** of this structure. +*/ +typedef struct Vdbe Vdbe; + +/* +** The names of the following types declared in vdbeInt.h are required +** for the VdbeOp definition. +*/ +typedef struct sqlite3_value Mem; +typedef struct SubProgram SubProgram; + +/* +** A single instruction of the virtual machine has an opcode +** and as many as three operands. The instruction is recorded +** as an instance of the following structure: +*/ +struct VdbeOp { + u8 opcode; /* What operation to perform */ + signed char p4type; /* One of the P4_xxx constants for p4 */ + u16 p5; /* Fifth parameter is an unsigned 16-bit integer */ + int p1; /* First operand */ + int p2; /* Second parameter (often the jump destination) */ + int p3; /* The third parameter */ + union p4union { /* fourth parameter */ + int i; /* Integer value if p4type==P4_INT32 */ + void *p; /* Generic pointer */ + char *z; /* Pointer to data for string (char array) types */ + i64 *pI64; /* Used when p4type is P4_INT64 */ + double *pReal; /* Used when p4type is P4_REAL */ + FuncDef *pFunc; /* Used when p4type is P4_FUNCDEF */ + sqlite3_context *pCtx; /* Used when p4type is P4_FUNCCTX */ + CollSeq *pColl; /* Used when p4type is P4_COLLSEQ */ + Mem *pMem; /* Used when p4type is P4_MEM */ + VTable *pVtab; /* Used when p4type is P4_VTAB */ + KeyInfo *pKeyInfo; /* Used when p4type is P4_KEYINFO */ + u32 *ai; /* Used when p4type is P4_INTARRAY */ + SubProgram *pProgram; /* Used when p4type is P4_SUBPROGRAM */ + Table *pTab; /* Used when p4type is P4_TABLE */ +#ifdef SQLITE_ENABLE_CURSOR_HINTS + Expr *pExpr; /* Used when p4type is P4_EXPR */ +#endif + int (*xAdvance)(BtCursor *, int); + } p4; +#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 */ +#endif +}; +typedef struct VdbeOp VdbeOp; + + +/* +** A sub-routine used to implement a trigger program. +*/ +struct SubProgram { + VdbeOp *aOp; /* Array of opcodes for sub-program */ + int nOp; /* Elements in aOp[] */ + int nMem; /* Number of memory cells required */ + int nCsr; /* Number of cursors required */ + u8 *aOnce; /* Array of OP_Once flags */ + void *token; /* id that may be used to recursive triggers */ + SubProgram *pNext; /* Next sub-program already visited */ +}; + +/* +** A smaller version of VdbeOp used for the VdbeAddOpList() function because +** it takes up less space. +*/ +struct VdbeOpList { + u8 opcode; /* What operation to perform */ + signed char p1; /* First operand */ + signed char p2; /* Second parameter (often the jump destination) */ + signed char p3; /* Third parameter */ +}; +typedef struct VdbeOpList VdbeOpList; + +/* +** Allowed values of VdbeOp.p4type +*/ +#define P4_NOTUSED 0 /* The P4 parameter is not used */ +#define P4_TRANSIENT 0 /* P4 is a pointer to a transient string */ +#define P4_STATIC (-1) /* Pointer to a static string */ +#define P4_COLLSEQ (-2) /* P4 is a pointer to a CollSeq structure */ +#define P4_INT32 (-3) /* P4 is a 32-bit signed integer */ +#define P4_SUBPROGRAM (-4) /* P4 is a pointer to a SubProgram structure */ +#define P4_ADVANCE (-5) /* P4 is a pointer to BtreeNext() or BtreePrev() */ +#define P4_TABLE (-6) /* P4 is a pointer to a Table structure */ +/* Above do not own any resources. Must free those below */ +#define P4_FREE_IF_LE (-7) +#define P4_DYNAMIC (-7) /* Pointer to memory from sqliteMalloc() */ +#define P4_FUNCDEF (-8) /* P4 is a pointer to a FuncDef structure */ +#define P4_KEYINFO (-9) /* P4 is a pointer to a KeyInfo structure */ +#define P4_EXPR (-10) /* P4 is a pointer to an Expr tree */ +#define P4_MEM (-11) /* P4 is a pointer to a Mem* structure */ +#define P4_VTAB (-12) /* P4 is a pointer to an sqlite3_vtab structure */ +#define P4_REAL (-13) /* P4 is a 64-bit floating point value */ +#define P4_INT64 (-14) /* P4 is a 64-bit signed integer */ +#define P4_INTARRAY (-15) /* P4 is a vector of 32-bit integers */ +#define P4_FUNCCTX (-16) /* P4 is a pointer to an sqlite3_context object */ +#define P4_DYNBLOB (-17) /* Pointer to memory from sqliteMalloc() */ + +/* Error message codes for OP_Halt */ +#define P5_ConstraintNotNull 1 +#define P5_ConstraintUnique 2 +#define P5_ConstraintCheck 3 +#define P5_ConstraintFK 4 + +/* +** The Vdbe.aColName array contains 5n Mem structures, where n is the +** number of columns of data returned by the statement. +*/ +#define COLNAME_NAME 0 +#define COLNAME_DECLTYPE 1 +#define COLNAME_DATABASE 2 +#define COLNAME_TABLE 3 +#define COLNAME_COLUMN 4 +#ifdef SQLITE_ENABLE_COLUMN_METADATA +# define COLNAME_N 5 /* Number of COLNAME_xxx symbols */ +#else +# ifdef SQLITE_OMIT_DECLTYPE +# define COLNAME_N 1 /* Store only the name */ +# else +# define COLNAME_N 2 /* Store the name and decltype */ +# endif +#endif + +/* +** The following macro converts a label returned by sqlite3VdbeMakeLabel() +** into an index into the Parse.aLabel[] array that contains the resolved +** address of that label. +*/ +#define ADDR(X) (~(X)) + +/* +** The makefile scans the vdbe.c source file and creates the "opcodes.h" +** header file that defines a number for each opcode used by the VDBE. +*/ +/************** Include opcodes.h in the middle of vdbe.h ********************/ +/************** Begin file opcodes.h *****************************************/ +/* Automatically generated. Do not edit */ +/* See the tool/mkopcodeh.tcl script for details */ +#define OP_Savepoint 0 +#define OP_AutoCommit 1 +#define OP_Transaction 2 +#define OP_SorterNext 3 /* jump */ +#define OP_Prev 4 /* jump */ +#define OP_Next 5 /* jump */ +#define OP_Checkpoint 6 +#define OP_JournalMode 7 +#define OP_Vacuum 8 +#define OP_VFilter 9 /* jump, synopsis: iplan=r[P3] zplan='P4' */ +#define OP_VUpdate 10 /* synopsis: data=r[P3@P2] */ +#define OP_Goto 11 /* jump */ +#define OP_Gosub 12 /* jump */ +#define OP_InitCoroutine 13 /* jump */ +#define OP_Yield 14 /* jump */ +#define OP_MustBeInt 15 /* jump */ +#define OP_Jump 16 /* jump */ +#define OP_Once 17 /* jump */ +#define OP_If 18 /* jump */ +#define OP_Not 19 /* same as TK_NOT, synopsis: r[P2]= !r[P1] */ +#define OP_IfNot 20 /* jump */ +#define OP_IfNullRow 21 /* jump, synopsis: if P1.nullRow then r[P3]=NULL, goto P2 */ +#define OP_SeekLT 22 /* jump, synopsis: key=r[P3@P4] */ +#define OP_SeekLE 23 /* jump, synopsis: key=r[P3@P4] */ +#define OP_SeekGE 24 /* jump, synopsis: key=r[P3@P4] */ +#define OP_SeekGT 25 /* jump, synopsis: key=r[P3@P4] */ +#define OP_IfNotOpen 26 /* jump, synopsis: if( !csr[P1] ) goto P2 */ +#define OP_IfNoHope 27 /* jump, synopsis: key=r[P3@P4] */ +#define OP_NoConflict 28 /* jump, synopsis: key=r[P3@P4] */ +#define OP_NotFound 29 /* jump, synopsis: key=r[P3@P4] */ +#define OP_Found 30 /* jump, synopsis: key=r[P3@P4] */ +#define OP_SeekRowid 31 /* jump, synopsis: intkey=r[P3] */ +#define OP_NotExists 32 /* jump, synopsis: intkey=r[P3] */ +#define OP_Last 33 /* jump */ +#define OP_IfSmaller 34 /* jump */ +#define OP_SorterSort 35 /* jump */ +#define OP_Sort 36 /* jump */ +#define OP_Rewind 37 /* jump */ +#define OP_IdxLE 38 /* jump, synopsis: key=r[P3@P4] */ +#define OP_IdxGT 39 /* jump, synopsis: key=r[P3@P4] */ +#define OP_IdxLT 40 /* jump, synopsis: key=r[P3@P4] */ +#define OP_IdxGE 41 /* jump, synopsis: key=r[P3@P4] */ +#define OP_RowSetRead 42 /* jump, synopsis: r[P3]=rowset(P1) */ +#define OP_Or 43 /* same as TK_OR, synopsis: r[P3]=(r[P1] || r[P2]) */ +#define OP_And 44 /* same as TK_AND, synopsis: r[P3]=(r[P1] && r[P2]) */ +#define OP_RowSetTest 45 /* jump, synopsis: if r[P3] in rowset(P1) goto P2 */ +#define OP_Program 46 /* jump */ +#define OP_FkIfZero 47 /* jump, synopsis: if fkctr[P1]==0 goto P2 */ +#define OP_IfPos 48 /* jump, synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */ +#define OP_IfNotZero 49 /* jump, synopsis: if r[P1]!=0 then r[P1]--, goto P2 */ +#define OP_IsNull 50 /* jump, same as TK_ISNULL, synopsis: if r[P1]==NULL goto P2 */ +#define OP_NotNull 51 /* jump, same as TK_NOTNULL, synopsis: if r[P1]!=NULL goto P2 */ +#define OP_Ne 52 /* jump, same as TK_NE, synopsis: IF r[P3]!=r[P1] */ +#define OP_Eq 53 /* jump, same as TK_EQ, synopsis: IF r[P3]==r[P1] */ +#define OP_Gt 54 /* jump, same as TK_GT, synopsis: IF r[P3]>r[P1] */ +#define OP_Le 55 /* jump, same as TK_LE, synopsis: IF r[P3]<=r[P1] */ +#define OP_Lt 56 /* jump, same as TK_LT, synopsis: IF r[P3]=r[P1] */ +#define OP_ElseNotEq 58 /* jump, same as TK_ESCAPE */ +#define OP_DecrJumpZero 59 /* jump, synopsis: if (--r[P1])==0 goto P2 */ +#define OP_IncrVacuum 60 /* jump */ +#define OP_VNext 61 /* jump */ +#define OP_Init 62 /* jump, synopsis: Start at P2 */ +#define OP_PureFunc 63 /* synopsis: r[P3]=func(r[P2@NP]) */ +#define OP_Function 64 /* synopsis: r[P3]=func(r[P2@NP]) */ +#define OP_Return 65 +#define OP_EndCoroutine 66 +#define OP_HaltIfNull 67 /* synopsis: if r[P3]=null halt */ +#define OP_Halt 68 +#define OP_Integer 69 /* synopsis: r[P2]=P1 */ +#define OP_Int64 70 /* synopsis: r[P2]=P4 */ +#define OP_String 71 /* synopsis: r[P2]='P4' (len=P1) */ +#define OP_Null 72 /* synopsis: r[P2..P3]=NULL */ +#define OP_SoftNull 73 /* synopsis: r[P1]=NULL */ +#define OP_Blob 74 /* synopsis: r[P2]=P4 (len=P1) */ +#define OP_Variable 75 /* synopsis: r[P2]=parameter(P1,P4) */ +#define OP_Move 76 /* synopsis: r[P2@P3]=r[P1@P3] */ +#define OP_Copy 77 /* synopsis: r[P2@P3+1]=r[P1@P3+1] */ +#define OP_SCopy 78 /* synopsis: r[P2]=r[P1] */ +#define OP_IntCopy 79 /* synopsis: r[P2]=r[P1] */ +#define OP_ResultRow 80 /* synopsis: output=r[P1@P2] */ +#define OP_CollSeq 81 +#define OP_AddImm 82 /* synopsis: r[P1]=r[P1]+P2 */ +#define OP_RealAffinity 83 +#define OP_Cast 84 /* synopsis: affinity(r[P1]) */ +#define OP_Permutation 85 +#define OP_Compare 86 /* synopsis: r[P1@P3] <-> r[P2@P3] */ +#define OP_IsTrue 87 /* synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4 */ +#define OP_Offset 88 /* synopsis: r[P3] = sqlite_offset(P1) */ +#define OP_Column 89 /* synopsis: r[P3]=PX */ +#define OP_Affinity 90 /* synopsis: affinity(r[P1@P2]) */ +#define OP_MakeRecord 91 /* synopsis: r[P3]=mkrec(r[P1@P2]) */ +#define OP_Count 92 /* synopsis: r[P2]=count() */ +#define OP_ReadCookie 93 +#define OP_SetCookie 94 +#define OP_ReopenIdx 95 /* synopsis: root=P2 iDb=P3 */ +#define OP_OpenRead 96 /* synopsis: root=P2 iDb=P3 */ +#define OP_OpenWrite 97 /* synopsis: root=P2 iDb=P3 */ +#define OP_OpenDup 98 +#define OP_OpenAutoindex 99 /* synopsis: nColumn=P2 */ +#define OP_OpenEphemeral 100 /* synopsis: nColumn=P2 */ +#define OP_BitAnd 101 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */ +#define OP_BitOr 102 /* same as TK_BITOR, synopsis: r[P3]=r[P1]|r[P2] */ +#define OP_ShiftLeft 103 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<>r[P1] */ +#define OP_Add 105 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */ +#define OP_Subtract 106 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */ +#define OP_Multiply 107 /* same as TK_STAR, synopsis: r[P3]=r[P1]*r[P2] */ +#define OP_Divide 108 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */ +#define OP_Remainder 109 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */ +#define OP_Concat 110 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */ +#define OP_SorterOpen 111 +#define OP_BitNot 112 /* same as TK_BITNOT, synopsis: r[P2]= ~r[P1] */ +#define OP_SequenceTest 113 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */ +#define OP_OpenPseudo 114 /* synopsis: P3 columns in r[P2] */ +#define OP_String8 115 /* same as TK_STRING, synopsis: r[P2]='P4' */ +#define OP_Close 116 +#define OP_ColumnsUsed 117 +#define OP_SeekScan 118 /* synopsis: Scan-ahead up to P1 rows */ +#define OP_SeekHit 119 /* synopsis: set P2<=seekHit<=P3 */ +#define OP_Sequence 120 /* synopsis: r[P2]=cursor[P1].ctr++ */ +#define OP_NewRowid 121 /* synopsis: r[P2]=rowid */ +#define OP_Insert 122 /* synopsis: intkey=r[P3] data=r[P2] */ +#define OP_Delete 123 +#define OP_ResetCount 124 +#define OP_SorterCompare 125 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */ +#define OP_SorterData 126 /* synopsis: r[P2]=data */ +#define OP_RowData 127 /* synopsis: r[P2]=data */ +#define OP_Rowid 128 /* synopsis: r[P2]=rowid */ +#define OP_NullRow 129 +#define OP_SeekEnd 130 +#define OP_IdxInsert 131 /* synopsis: key=r[P2] */ +#define OP_SorterInsert 132 /* synopsis: key=r[P2] */ +#define OP_IdxDelete 133 /* synopsis: key=r[P2@P3] */ +#define OP_DeferredSeek 134 /* synopsis: Move P3 to P1.rowid if needed */ +#define OP_IdxRowid 135 /* synopsis: r[P2]=rowid */ +#define OP_FinishSeek 136 +#define OP_Destroy 137 +#define OP_Clear 138 +#define OP_ResetSorter 139 +#define OP_CreateBtree 140 /* synopsis: r[P2]=root iDb=P1 flags=P3 */ +#define OP_SqlExec 141 +#define OP_ParseSchema 142 +#define OP_LoadAnalysis 143 +#define OP_DropTable 144 +#define OP_DropIndex 145 +#define OP_DropTrigger 146 +#define OP_IntegrityCk 147 +#define OP_RowSetAdd 148 /* synopsis: rowset(P1)=r[P2] */ +#define OP_Param 149 +#define OP_Real 150 /* same as TK_FLOAT, synopsis: r[P2]=P4 */ +#define OP_FkCounter 151 /* synopsis: fkctr[P1]+=P2 */ +#define OP_MemMax 152 /* synopsis: r[P1]=max(r[P1],r[P2]) */ +#define OP_OffsetLimit 153 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */ +#define OP_AggInverse 154 /* synopsis: accum=r[P3] inverse(r[P2@P5]) */ +#define OP_AggStep 155 /* synopsis: accum=r[P3] step(r[P2@P5]) */ +#define OP_AggStep1 156 /* synopsis: accum=r[P3] step(r[P2@P5]) */ +#define OP_AggValue 157 /* synopsis: r[P3]=value N=P2 */ +#define OP_AggFinal 158 /* synopsis: accum=r[P1] N=P2 */ +#define OP_Expire 159 +#define OP_CursorLock 160 +#define OP_CursorUnlock 161 +#define OP_TableLock 162 /* synopsis: iDb=P1 root=P2 write=P3 */ +#define OP_VBegin 163 +#define OP_VCreate 164 +#define OP_VDestroy 165 +#define OP_VOpen 166 +#define OP_VColumn 167 /* synopsis: r[P3]=vcolumn(P2) */ +#define OP_VRename 168 +#define OP_Pagecount 169 +#define OP_MaxPgcnt 170 +#define OP_Trace 171 +#define OP_CursorHint 172 +#define OP_ReleaseReg 173 /* synopsis: release r[P1@P2] mask P3 */ +#define OP_Noop 174 +#define OP_Explain 175 +#define OP_Abortable 176 + +/* Properties such as "out2" or "jump" that are specified in +** comments following the "case" for each opcode in the vdbe.c +** are encoded into bitvectors as follows: +*/ +#define OPFLG_JUMP 0x01 /* jump: P2 holds jmp target */ +#define OPFLG_IN1 0x02 /* in1: P1 is an input */ +#define OPFLG_IN2 0x04 /* in2: P2 is an input */ +#define OPFLG_IN3 0x08 /* in3: P3 is an input */ +#define OPFLG_OUT2 0x10 /* out2: P2 is an output */ +#define OPFLG_OUT3 0x20 /* out3: P3 is an output */ +#define OPFLG_INITIALIZER {\ +/* 0 */ 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x10,\ +/* 8 */ 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x03, 0x03,\ +/* 16 */ 0x01, 0x01, 0x03, 0x12, 0x03, 0x01, 0x09, 0x09,\ +/* 24 */ 0x09, 0x09, 0x01, 0x09, 0x09, 0x09, 0x09, 0x09,\ +/* 32 */ 0x09, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,\ +/* 40 */ 0x01, 0x01, 0x23, 0x26, 0x26, 0x0b, 0x01, 0x01,\ +/* 48 */ 0x03, 0x03, 0x03, 0x03, 0x0b, 0x0b, 0x0b, 0x0b,\ +/* 56 */ 0x0b, 0x0b, 0x01, 0x03, 0x01, 0x01, 0x01, 0x00,\ +/* 64 */ 0x00, 0x02, 0x02, 0x08, 0x00, 0x10, 0x10, 0x10,\ +/* 72 */ 0x10, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10,\ +/* 80 */ 0x00, 0x00, 0x02, 0x02, 0x02, 0x00, 0x00, 0x12,\ +/* 88 */ 0x20, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00,\ +/* 96 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x26, 0x26,\ +/* 104 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x00,\ +/* 112 */ 0x12, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,\ +/* 120 */ 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ +/* 128 */ 0x10, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x10,\ +/* 136 */ 0x00, 0x10, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,\ +/* 144 */ 0x00, 0x00, 0x00, 0x00, 0x06, 0x10, 0x10, 0x00,\ +/* 152 */ 0x04, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ +/* 160 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ +/* 168 */ 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,\ +/* 176 */ 0x00,} + +/* The sqlite3P2Values() routine is able to run faster if it knows +** the value of the largest JUMP opcode. The smaller the maximum +** JUMP opcode the better, so the mkopcodeh.tcl script that +** generated this include file strives to group all JUMP opcodes +** together near the beginning of the list. +*/ +#define SQLITE_MX_JUMP_OPCODE 62 /* Maximum JUMP opcode */ + +/************** End of opcodes.h *********************************************/ +/************** Continuing where we left off in vdbe.h ***********************/ + +/* +** Additional non-public SQLITE_PREPARE_* flags +*/ +#define SQLITE_PREPARE_SAVESQL 0x80 /* Preserve SQL text */ +#define SQLITE_PREPARE_MASK 0x0f /* Mask of public flags */ + +/* +** Prototypes for the VDBE interface. See comments on the implementation +** for a description of what each of these routines does. +*/ +SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse*); +SQLITE_PRIVATE Parse *sqlite3VdbeParser(Vdbe*); +SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe*,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe*,int,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe*,int,int,int); +SQLITE_PRIVATE int sqlite3VdbeGoto(Vdbe*,int); +SQLITE_PRIVATE int sqlite3VdbeLoadString(Vdbe*,int,const char*); +SQLITE_PRIVATE void sqlite3VdbeMultiLoad(Vdbe*,int,const char*,...); +SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe*,int,int,int,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp4(Vdbe*,int,int,int,int,const char *zP4,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp4Dup8(Vdbe*,int,int,int,int,const u8*,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(Vdbe*,int,int,int,int,int); +SQLITE_PRIVATE int sqlite3VdbeAddFunctionCall(Parse*,int,int,int,int,const FuncDef*,int); +SQLITE_PRIVATE void sqlite3VdbeEndCoroutine(Vdbe*,int); +#if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS) +SQLITE_PRIVATE void sqlite3VdbeVerifyNoMallocRequired(Vdbe *p, int N); +SQLITE_PRIVATE void sqlite3VdbeVerifyNoResultRow(Vdbe *p); +#else +# define sqlite3VdbeVerifyNoMallocRequired(A,B) +# define sqlite3VdbeVerifyNoResultRow(A) +#endif +#if defined(SQLITE_DEBUG) +SQLITE_PRIVATE void sqlite3VdbeVerifyAbortable(Vdbe *p, int); +#else +# define sqlite3VdbeVerifyAbortable(A,B) +#endif +SQLITE_PRIVATE VdbeOp *sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp,int iLineno); +#ifndef SQLITE_OMIT_EXPLAIN +SQLITE_PRIVATE void sqlite3VdbeExplain(Parse*,u8,const char*,...); +SQLITE_PRIVATE void sqlite3VdbeExplainPop(Parse*); +SQLITE_PRIVATE int sqlite3VdbeExplainParent(Parse*); +# define ExplainQueryPlan(P) sqlite3VdbeExplain P +# define ExplainQueryPlanPop(P) sqlite3VdbeExplainPop(P) +# define ExplainQueryPlanParent(P) sqlite3VdbeExplainParent(P) +#else +# define ExplainQueryPlan(P) +# define ExplainQueryPlanPop(P) +# define ExplainQueryPlanParent(P) 0 +# define sqlite3ExplainBreakpoint(A,B) /*no-op*/ +#endif +#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_EXPLAIN) +SQLITE_PRIVATE void sqlite3ExplainBreakpoint(const char*,const char*); +#else +# define sqlite3ExplainBreakpoint(A,B) /*no-op*/ +#endif +SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe*,int,char*); +SQLITE_PRIVATE void sqlite3VdbeChangeOpcode(Vdbe*, int addr, u8); +SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, int addr, int P1); +SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, int addr, int P2); +SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, int addr, int P3); +SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u16 P5); +SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe*, int addr); +SQLITE_PRIVATE void sqlite3VdbeJumpHereOrPopInst(Vdbe*, int addr); +SQLITE_PRIVATE int sqlite3VdbeChangeToNoop(Vdbe*, int addr); +SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode(Vdbe*, u8 op); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE void sqlite3VdbeReleaseRegisters(Parse*,int addr, int n, u32 mask, int); +#else +# define sqlite3VdbeReleaseRegisters(P,A,N,M,F) +#endif +SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N); +SQLITE_PRIVATE void sqlite3VdbeAppendP4(Vdbe*, void *pP4, int p4type); +SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo(Parse*, Index*); +SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe*, int); +SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe*, int); +SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Parse*); +SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeReusable(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3*,Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeMakeReady(Vdbe*,Parse*); +SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe*, int); +SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe*); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *, int); +#endif +SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe*); +SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe*,int); +SQLITE_PRIVATE int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*)); +SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe*); +SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe*); +SQLITE_PRIVATE u8 sqlite3VdbePrepareFlags(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, u8); +#ifdef SQLITE_ENABLE_NORMALIZE +SQLITE_PRIVATE void sqlite3VdbeAddDblquoteStr(sqlite3*,Vdbe*,const char*); +SQLITE_PRIVATE int sqlite3VdbeUsesDoubleQuotedString(Vdbe*,const char*); +#endif +SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe*,Vdbe*); +SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe*, int*, int*); +SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe*, int, u8); +SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe*, int); +#ifndef SQLITE_OMIT_TRACE +SQLITE_PRIVATE char *sqlite3VdbeExpandSql(Vdbe*, const char*); +#endif +SQLITE_PRIVATE int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*); +SQLITE_PRIVATE int sqlite3BlobCompare(const Mem*, const Mem*); + +SQLITE_PRIVATE void sqlite3VdbeRecordUnpack(KeyInfo*,int,const void*,UnpackedRecord*); +SQLITE_PRIVATE int sqlite3VdbeRecordCompare(int,const void*,UnpackedRecord*); +SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip(int, const void *, UnpackedRecord *, int); +SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(KeyInfo*); + +typedef int (*RecordCompare)(int,const void*,UnpackedRecord*); +SQLITE_PRIVATE RecordCompare sqlite3VdbeFindCompare(UnpackedRecord*); + +SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *, SubProgram *); +SQLITE_PRIVATE int sqlite3VdbeHasSubProgram(Vdbe*); + +SQLITE_PRIVATE int sqlite3NotPureFunc(sqlite3_context*); +#ifdef SQLITE_ENABLE_BYTECODE_VTAB +SQLITE_PRIVATE int sqlite3VdbeBytecodeVtabInit(sqlite3*); +#endif + +/* Use SQLITE_ENABLE_COMMENTS to enable generation of extra comments on +** each VDBE opcode. +** +** Use the SQLITE_ENABLE_MODULE_COMMENTS macro to see some extra no-op +** comments in VDBE programs that show key decision points in the code +** generator. +*/ +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS +SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe*, const char*, ...); +# define VdbeComment(X) sqlite3VdbeComment X +SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe*, const char*, ...); +# define VdbeNoopComment(X) sqlite3VdbeNoopComment X +# ifdef SQLITE_ENABLE_MODULE_COMMENTS +# define VdbeModuleComment(X) sqlite3VdbeNoopComment X +# else +# define VdbeModuleComment(X) +# endif +#else +# define VdbeComment(X) +# define VdbeNoopComment(X) +# define VdbeModuleComment(X) +#endif + +/* +** The VdbeCoverage macros are used to set a coverage testing point +** for VDBE branch instructions. The coverage testing points are line +** numbers in the sqlite3.c source file. VDBE branch coverage testing +** only works with an amalagmation build. That's ok since a VDBE branch +** coverage build designed for testing the test suite only. No application +** should ever ship with VDBE branch coverage measuring turned on. +** +** VdbeCoverage(v) // Mark the previously coded instruction +** // as a branch +** +** VdbeCoverageIf(v, conditional) // Mark previous if conditional true +** +** VdbeCoverageAlwaysTaken(v) // Previous branch is always taken +** +** VdbeCoverageNeverTaken(v) // Previous branch is never taken +** +** VdbeCoverageNeverNull(v) // Previous three-way branch is only +** // taken on the first two ways. The +** // NULL option is not possible +** +** VdbeCoverageEqNe(v) // Previous OP_Jump is only interested +** // in distingishing equal and not-equal. +** +** Every VDBE branch operation must be tagged with one of the macros above. +** If not, then when "make test" is run with -DSQLITE_VDBE_COVERAGE and +** -DSQLITE_DEBUG then an ALWAYS() will fail in the vdbeTakeBranch() +** routine in vdbe.c, alerting the developer to the missed tag. +** +** During testing, the test application will invoke +** sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE,...) to set a callback +** routine that is invoked as each bytecode branch is taken. The callback +** contains the sqlite3.c source line number ov the VdbeCoverage macro and +** flags to indicate whether or not the branch was taken. The test application +** is responsible for keeping track of this and reporting byte-code branches +** that are never taken. +** +** See the VdbeBranchTaken() macro and vdbeTakeBranch() function in the +** vdbe.c source file for additional information. +*/ +#ifdef SQLITE_VDBE_COVERAGE +SQLITE_PRIVATE void sqlite3VdbeSetLineNumber(Vdbe*,int); +# define VdbeCoverage(v) sqlite3VdbeSetLineNumber(v,__LINE__) +# define VdbeCoverageIf(v,x) if(x)sqlite3VdbeSetLineNumber(v,__LINE__) +# define VdbeCoverageAlwaysTaken(v) \ + sqlite3VdbeSetLineNumber(v,__LINE__|0x5000000); +# define VdbeCoverageNeverTaken(v) \ + sqlite3VdbeSetLineNumber(v,__LINE__|0x6000000); +# define VdbeCoverageNeverNull(v) \ + sqlite3VdbeSetLineNumber(v,__LINE__|0x4000000); +# define VdbeCoverageNeverNullIf(v,x) \ + if(x)sqlite3VdbeSetLineNumber(v,__LINE__|0x4000000); +# define VdbeCoverageEqNe(v) \ + sqlite3VdbeSetLineNumber(v,__LINE__|0x8000000); +# define VDBE_OFFSET_LINENO(x) (__LINE__+x) +#else +# define VdbeCoverage(v) +# define VdbeCoverageIf(v,x) +# define VdbeCoverageAlwaysTaken(v) +# define VdbeCoverageNeverTaken(v) +# define VdbeCoverageNeverNull(v) +# define VdbeCoverageNeverNullIf(v,x) +# define VdbeCoverageEqNe(v) +# define VDBE_OFFSET_LINENO(x) 0 +#endif + +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS +SQLITE_PRIVATE void sqlite3VdbeScanStatus(Vdbe*, int, int, int, LogEst, const char*); +#else +# define sqlite3VdbeScanStatus(a,b,c,d,e) +#endif + +#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) +SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE*, int, VdbeOp*); +#endif + +#endif /* SQLITE_VDBE_H */ + +/************** End of vdbe.h ************************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include pcache.h in the middle of sqliteInt.h ****************/ +/************** Begin file pcache.h ******************************************/ +/* +** 2008 August 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 header file defines the interface that the sqlite page cache +** subsystem. +*/ + +#ifndef _PCACHE_H_ + +typedef struct PgHdr PgHdr; +typedef struct PCache PCache; + +/* +** Every page in the cache is controlled by an instance of the following +** structure. +*/ +struct PgHdr { + sqlite3_pcache_page *pPage; /* Pcache object page handle */ + void *pData; /* Page data */ + void *pExtra; /* Extra content */ + PCache *pCache; /* PRIVATE: Cache that owns this page */ + PgHdr *pDirty; /* Transient list of dirty sorted by pgno */ + Pager *pPager; /* The pager this page is part of */ + Pgno pgno; /* Page number for this page */ +#ifdef SQLITE_CHECK_PAGES + u32 pageHash; /* Hash of page content */ +#endif + u16 flags; /* PGHDR flags defined below */ + + /********************************************************************** + ** Elements above, except pCache, are public. All that follow are + ** private to pcache.c and should not be accessed by other modules. + ** pCache is grouped with the public elements for efficiency. + */ + i16 nRef; /* Number of users of this page */ + PgHdr *pDirtyNext; /* Next element in list of dirty pages */ + PgHdr *pDirtyPrev; /* Previous element in list of dirty pages */ + /* NB: pDirtyNext and pDirtyPrev are undefined if the + ** PgHdr object is not dirty */ +}; + +/* Bit values for PgHdr.flags */ +#define PGHDR_CLEAN 0x001 /* Page not on the PCache.pDirty list */ +#define PGHDR_DIRTY 0x002 /* Page is on the PCache.pDirty list */ +#define PGHDR_WRITEABLE 0x004 /* Journaled and ready to modify */ +#define PGHDR_NEED_SYNC 0x008 /* Fsync the rollback journal before + ** writing this page to the database */ +#define PGHDR_DONT_WRITE 0x010 /* Do not write content to disk */ +#define PGHDR_MMAP 0x020 /* This is an mmap page object */ + +#define PGHDR_WAL_APPEND 0x040 /* Appended to wal file */ + +/* Initialize and shutdown the page cache subsystem */ +SQLITE_PRIVATE int sqlite3PcacheInitialize(void); +SQLITE_PRIVATE void sqlite3PcacheShutdown(void); + +/* Page cache buffer management: +** These routines implement SQLITE_CONFIG_PAGECACHE. +*/ +SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *, int sz, int n); + +/* Create a new pager cache. +** Under memory stress, invoke xStress to try to make pages clean. +** Only clean and unpinned pages can be reclaimed. +*/ +SQLITE_PRIVATE int sqlite3PcacheOpen( + int szPage, /* Size of every page */ + int szExtra, /* Extra space associated with each page */ + int bPurgeable, /* True if pages are on backing store */ + int (*xStress)(void*, PgHdr*), /* Call to try to make pages clean */ + void *pStress, /* Argument to xStress */ + PCache *pToInit /* Preallocated space for the PCache */ +); + +/* Modify the page-size after the cache has been created. */ +SQLITE_PRIVATE int sqlite3PcacheSetPageSize(PCache *, int); + +/* Return the size in bytes of a PCache object. Used to preallocate +** storage space. +*/ +SQLITE_PRIVATE int sqlite3PcacheSize(void); + +/* One release per successful fetch. Page is pinned until released. +** Reference counted. +*/ +SQLITE_PRIVATE sqlite3_pcache_page *sqlite3PcacheFetch(PCache*, Pgno, int createFlag); +SQLITE_PRIVATE int sqlite3PcacheFetchStress(PCache*, Pgno, sqlite3_pcache_page**); +SQLITE_PRIVATE PgHdr *sqlite3PcacheFetchFinish(PCache*, Pgno, sqlite3_pcache_page *pPage); +SQLITE_PRIVATE void sqlite3PcacheRelease(PgHdr*); + +SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr*); /* Remove page from cache */ +SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr*); /* Make sure page is marked dirty */ +SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr*); /* Mark a single page as clean */ +SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache*); /* Mark all dirty list pages as clean */ +SQLITE_PRIVATE void sqlite3PcacheClearWritable(PCache*); + +/* Change a page number. Used by incr-vacuum. */ +SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr*, Pgno); + +/* Remove all pages with pgno>x. Reset the cache if x==0 */ +SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache*, Pgno x); + +/* Get a list of all dirty pages in the cache, sorted by page number */ +SQLITE_PRIVATE PgHdr *sqlite3PcacheDirtyList(PCache*); + +/* Reset and close the cache object */ +SQLITE_PRIVATE void sqlite3PcacheClose(PCache*); + +/* Clear flags from pages of the page cache */ +SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *); + +/* Discard the contents of the cache */ +SQLITE_PRIVATE void sqlite3PcacheClear(PCache*); + +/* Return the total number of outstanding page references */ +SQLITE_PRIVATE int sqlite3PcacheRefCount(PCache*); + +/* Increment the reference count of an existing page */ +SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr*); + +SQLITE_PRIVATE int sqlite3PcachePageRefcount(PgHdr*); + +/* Return the total number of pages stored in the cache */ +SQLITE_PRIVATE int sqlite3PcachePagecount(PCache*); + +#if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG) +/* Iterate through all dirty pages currently stored in the cache. This +** interface is only available if SQLITE_CHECK_PAGES is defined when the +** library is built. +*/ +SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *)); +#endif + +#if defined(SQLITE_DEBUG) +/* Check invariants on a PgHdr object */ +SQLITE_PRIVATE int sqlite3PcachePageSanity(PgHdr*); +#endif + +/* Set and get the suggested cache-size for the specified pager-cache. +** +** If no global maximum is configured, then the system attempts to limit +** the total number of pages cached by purgeable pager-caches to the sum +** of the suggested cache-sizes. +*/ +SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *, int); +#ifdef SQLITE_TEST +SQLITE_PRIVATE int sqlite3PcacheGetCachesize(PCache *); +#endif + +/* Set or get the suggested spill-size for the specified pager-cache. +** +** The spill-size is the minimum number of pages in cache before the cache +** will attempt to spill dirty pages by calling xStress. +*/ +SQLITE_PRIVATE int sqlite3PcacheSetSpillsize(PCache *, int); + +/* Free up as much memory as possible from the page cache */ +SQLITE_PRIVATE void sqlite3PcacheShrink(PCache*); + +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT +/* Try to return memory used by the pcache module to the main memory heap */ +SQLITE_PRIVATE int sqlite3PcacheReleaseMemory(int); +#endif + +#ifdef SQLITE_TEST +SQLITE_PRIVATE void sqlite3PcacheStats(int*,int*,int*,int*); +#endif + +SQLITE_PRIVATE void sqlite3PCacheSetDefault(void); + +/* Return the header size */ +SQLITE_PRIVATE int sqlite3HeaderSizePcache(void); +SQLITE_PRIVATE int sqlite3HeaderSizePcache1(void); + +/* Number of dirty pages as a percentage of the configured cache size */ +SQLITE_PRIVATE int sqlite3PCachePercentDirty(PCache*); + +#ifdef SQLITE_DIRECT_OVERFLOW_READ +SQLITE_PRIVATE int sqlite3PCacheIsDirty(PCache *pCache); +#endif + +#endif /* _PCACHE_H_ */ + +/************** End of pcache.h **********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include os.h in the middle of sqliteInt.h ********************/ +/************** Begin file os.h **********************************************/ +/* +** 2001 September 16 +** +** 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 header file (together with is companion C source-code file +** "os.c") attempt to abstract the underlying operating system so that +** the SQLite library will work on both POSIX and windows systems. +** +** This header file is #include-ed by sqliteInt.h and thus ends up +** being included by every source file. +*/ +#ifndef _SQLITE_OS_H_ +#define _SQLITE_OS_H_ + +/* +** Attempt to automatically detect the operating system and setup the +** necessary pre-processor macros for it. +*/ +/************** Include os_setup.h in the middle of os.h *********************/ +/************** Begin file os_setup.h ****************************************/ +/* +** 2013 November 25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains pre-processor directives related to operating system +** detection and/or setup. +*/ +#ifndef SQLITE_OS_SETUP_H +#define SQLITE_OS_SETUP_H + +/* +** Figure out if we are dealing with Unix, Windows, or some other operating +** system. +** +** After the following block of preprocess macros, all of SQLITE_OS_UNIX, +** SQLITE_OS_WIN, and SQLITE_OS_OTHER will defined to either 1 or 0. One of +** the three will be 1. The other two will be 0. +*/ +#if defined(SQLITE_OS_OTHER) +# if SQLITE_OS_OTHER==1 +# undef SQLITE_OS_UNIX +# define SQLITE_OS_UNIX 0 +# undef SQLITE_OS_WIN +# define SQLITE_OS_WIN 0 +# else +# undef SQLITE_OS_OTHER +# endif +#endif +#if !defined(SQLITE_OS_UNIX) && !defined(SQLITE_OS_OTHER) +# define SQLITE_OS_OTHER 0 +# ifndef SQLITE_OS_WIN +# if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || \ + defined(__MINGW32__) || defined(__BORLANDC__) +# define SQLITE_OS_WIN 1 +# define SQLITE_OS_UNIX 0 +# else +# define SQLITE_OS_WIN 0 +# define SQLITE_OS_UNIX 1 +# endif +# else +# define SQLITE_OS_UNIX 0 +# endif +#else +# ifndef SQLITE_OS_WIN +# define SQLITE_OS_WIN 0 +# endif +#endif + +#endif /* SQLITE_OS_SETUP_H */ + +/************** End of os_setup.h ********************************************/ +/************** Continuing where we left off in os.h *************************/ + +/* If the SET_FULLSYNC macro is not defined above, then make it +** a no-op +*/ +#ifndef SET_FULLSYNC +# define SET_FULLSYNC(x,y) +#endif + +/* +** The default size of a disk sector +*/ +#ifndef SQLITE_DEFAULT_SECTOR_SIZE +# define SQLITE_DEFAULT_SECTOR_SIZE 4096 +#endif + +/* +** Temporary files are named starting with this prefix followed by 16 random +** alphanumeric characters, and no file extension. They are stored in the +** OS's standard temporary file directory, and are deleted prior to exit. +** If sqlite is being embedded in another program, you may wish to change the +** prefix to reflect your program's name, so that if your program exits +** prematurely, old temporary files can be easily identified. This can be done +** using -DSQLITE_TEMP_FILE_PREFIX=myprefix_ on the compiler command line. +** +** 2006-10-31: The default prefix used to be "sqlite_". But then +** Mcafee started using SQLite in their anti-virus product and it +** started putting files with the "sqlite" name in the c:/temp folder. +** This annoyed many windows users. Those users would then do a +** Google search for "sqlite", find the telephone numbers of the +** developers and call to wake them up at night and complain. +** For this reason, the default name prefix is changed to be "sqlite" +** spelled backwards. So the temp files are still identified, but +** anybody smart enough to figure out the code is also likely smart +** enough to know that calling the developer will not help get rid +** of the file. +*/ +#ifndef SQLITE_TEMP_FILE_PREFIX +# define SQLITE_TEMP_FILE_PREFIX "etilqs_" +#endif + +/* +** The following values may be passed as the second argument to +** sqlite3OsLock(). The various locks exhibit the following semantics: +** +** SHARED: Any number of processes may hold a SHARED lock simultaneously. +** RESERVED: A single process may hold a RESERVED lock on a file at +** any time. Other processes may hold and obtain new SHARED locks. +** PENDING: A single process may hold a PENDING lock on a file at +** any one time. Existing SHARED locks may persist, but no new +** SHARED locks may be obtained by other processes. +** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks. +** +** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a +** process that requests an EXCLUSIVE lock may actually obtain a PENDING +** lock. This can be upgraded to an EXCLUSIVE lock by a subsequent call to +** sqlite3OsLock(). +*/ +#define NO_LOCK 0 +#define SHARED_LOCK 1 +#define RESERVED_LOCK 2 +#define PENDING_LOCK 3 +#define EXCLUSIVE_LOCK 4 + +/* +** File Locking Notes: (Mostly about windows but also some info for Unix) +** +** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because +** those functions are not available. So we use only LockFile() and +** UnlockFile(). +** +** LockFile() prevents not just writing but also reading by other processes. +** A SHARED_LOCK is obtained by locking a single randomly-chosen +** byte out of a specific range of bytes. The lock byte is obtained at +** random so two separate readers can probably access the file at the +** same time, unless they are unlucky and choose the same lock byte. +** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range. +** There can only be one writer. A RESERVED_LOCK is obtained by locking +** a single byte of the file that is designated as the reserved lock byte. +** A PENDING_LOCK is obtained by locking a designated byte different from +** the RESERVED_LOCK byte. +** +** On WinNT/2K/XP systems, LockFileEx() and UnlockFileEx() are available, +** which means we can use reader/writer locks. When reader/writer locks +** are used, the lock is placed on the same range of bytes that is used +** for probabilistic locking in Win95/98/ME. Hence, the locking scheme +** will support two or more Win95 readers or two or more WinNT readers. +** But a single Win95 reader will lock out all WinNT readers and a single +** WinNT reader will lock out all other Win95 readers. +** +** The following #defines specify the range of bytes used for locking. +** SHARED_SIZE is the number of bytes available in the pool from which +** a random byte is selected for a shared lock. The pool of bytes for +** shared locks begins at SHARED_FIRST. +** +** The same locking strategy and +** byte ranges are used for Unix. This leaves open the possibility of having +** clients on win95, winNT, and unix all talking to the same shared file +** and all locking correctly. To do so would require that samba (or whatever +** tool is being used for file sharing) implements locks correctly between +** windows and unix. I'm guessing that isn't likely to happen, but by +** using the same locking range we are at least open to the possibility. +** +** Locking in windows is manditory. For this reason, we cannot store +** actual data in the bytes used for locking. The pager never allocates +** the pages involved in locking therefore. SHARED_SIZE is selected so +** that all locks will fit on a single page even at the minimum page size. +** PENDING_BYTE defines the beginning of the locks. By default PENDING_BYTE +** is set high so that we don't have to allocate an unused page except +** for very large databases. But one should test the page skipping logic +** by setting PENDING_BYTE low and running the entire regression suite. +** +** Changing the value of PENDING_BYTE results in a subtly incompatible +** file format. Depending on how it is changed, you might not notice +** the incompatibility right away, even running a full regression test. +** The default location of PENDING_BYTE is the first byte past the +** 1GB boundary. +** +*/ +#ifdef SQLITE_OMIT_WSD +# define PENDING_BYTE (0x40000000) +#else +# define PENDING_BYTE sqlite3PendingByte +#endif +#define RESERVED_BYTE (PENDING_BYTE+1) +#define SHARED_FIRST (PENDING_BYTE+2) +#define SHARED_SIZE 510 + +/* +** Wrapper around OS specific sqlite3_os_init() function. +*/ +SQLITE_PRIVATE int sqlite3OsInit(void); + +/* +** Functions for accessing sqlite3_file methods +*/ +SQLITE_PRIVATE void sqlite3OsClose(sqlite3_file*); +SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file*, void*, int amt, i64 offset); +SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file*, const void*, int amt, i64 offset); +SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file*, i64 size); +SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file*, int); +SQLITE_PRIVATE int sqlite3OsFileSize(sqlite3_file*, i64 *pSize); +SQLITE_PRIVATE int sqlite3OsLock(sqlite3_file*, int); +SQLITE_PRIVATE int sqlite3OsUnlock(sqlite3_file*, int); +SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut); +SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file*,int,void*); +SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file*,int,void*); +#define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0 +SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id); +SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id); +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3OsShmMap(sqlite3_file *,int,int,int,void volatile **); +SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int, int, int); +SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id); +SQLITE_PRIVATE int sqlite3OsShmUnmap(sqlite3_file *id, int); +#endif /* SQLITE_OMIT_WAL */ +SQLITE_PRIVATE int sqlite3OsFetch(sqlite3_file *id, i64, int, void **); +SQLITE_PRIVATE int sqlite3OsUnfetch(sqlite3_file *, i64, void *); + + +/* +** Functions for accessing sqlite3_vfs methods +*/ +SQLITE_PRIVATE int sqlite3OsOpen(sqlite3_vfs *, const char *, sqlite3_file*, int, int *); +SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *, const char *, int); +SQLITE_PRIVATE int sqlite3OsAccess(sqlite3_vfs *, const char *, int, int *pResOut); +SQLITE_PRIVATE int sqlite3OsFullPathname(sqlite3_vfs *, const char *, int, char *); +#ifndef SQLITE_OMIT_LOAD_EXTENSION +SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *, const char *); +SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *, int, char *); +SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *, void *, const char *))(void); +SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *, void *); +#endif /* SQLITE_OMIT_LOAD_EXTENSION */ +SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *, int, char *); +SQLITE_PRIVATE int sqlite3OsSleep(sqlite3_vfs *, int); +SQLITE_PRIVATE int sqlite3OsGetLastError(sqlite3_vfs*); +SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *, sqlite3_int64*); + +/* +** Convenience functions for opening and closing files using +** sqlite3_malloc() to obtain space for the file-handle structure. +*/ +SQLITE_PRIVATE int sqlite3OsOpenMalloc(sqlite3_vfs *, const char *, sqlite3_file **, int,int*); +SQLITE_PRIVATE void sqlite3OsCloseFree(sqlite3_file *); + +#endif /* _SQLITE_OS_H_ */ + +/************** End of os.h **************************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include mutex.h in the middle of sqliteInt.h *****************/ +/************** Begin file mutex.h *******************************************/ +/* +** 2007 August 28 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains the common header for all mutex implementations. +** The sqliteInt.h header #includes this file so that it is available +** to all source files. We break it out in an effort to keep the code +** better organized. +** +** NOTE: source files should *not* #include this header file directly. +** Source files should #include the sqliteInt.h file and let that file +** include this one indirectly. +*/ + + +/* +** Figure out what version of the code to use. The choices are +** +** SQLITE_MUTEX_OMIT No mutex logic. Not even stubs. The +** mutexes implementation cannot be overridden +** at start-time. +** +** SQLITE_MUTEX_NOOP For single-threaded applications. No +** mutual exclusion is provided. But this +** implementation can be overridden at +** start-time. +** +** SQLITE_MUTEX_PTHREADS For multi-threaded applications on Unix. +** +** SQLITE_MUTEX_W32 For multi-threaded applications on Win32. +*/ +#if !SQLITE_THREADSAFE +# define SQLITE_MUTEX_OMIT +#endif +#if SQLITE_THREADSAFE && !defined(SQLITE_MUTEX_NOOP) +# if SQLITE_OS_UNIX +# define SQLITE_MUTEX_PTHREADS +# elif SQLITE_OS_WIN +# define SQLITE_MUTEX_W32 +# else +# define SQLITE_MUTEX_NOOP +# endif +#endif + +#ifdef SQLITE_MUTEX_OMIT +/* +** If this is a no-op implementation, implement everything as macros. +*/ +#define sqlite3_mutex_alloc(X) ((sqlite3_mutex*)8) +#define sqlite3_mutex_free(X) +#define sqlite3_mutex_enter(X) +#define sqlite3_mutex_try(X) SQLITE_OK +#define sqlite3_mutex_leave(X) +#define sqlite3_mutex_held(X) ((void)(X),1) +#define sqlite3_mutex_notheld(X) ((void)(X),1) +#define sqlite3MutexAlloc(X) ((sqlite3_mutex*)8) +#define sqlite3MutexInit() SQLITE_OK +#define sqlite3MutexEnd() +#define MUTEX_LOGIC(X) +#else +#define MUTEX_LOGIC(X) X +SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*); +#endif /* defined(SQLITE_MUTEX_OMIT) */ + +/************** End of mutex.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + +/* The SQLITE_EXTRA_DURABLE compile-time option used to set the default +** synchronous setting to EXTRA. It is no longer supported. +*/ +#ifdef SQLITE_EXTRA_DURABLE +# warning Use SQLITE_DEFAULT_SYNCHRONOUS=3 instead of SQLITE_EXTRA_DURABLE +# define SQLITE_DEFAULT_SYNCHRONOUS 3 +#endif + +/* +** Default synchronous levels. +** +** Note that (for historcal reasons) the PAGER_SYNCHRONOUS_* macros differ +** from the SQLITE_DEFAULT_SYNCHRONOUS value by 1. +** +** PAGER_SYNCHRONOUS DEFAULT_SYNCHRONOUS +** OFF 1 0 +** NORMAL 2 1 +** FULL 3 2 +** EXTRA 4 3 +** +** The "PRAGMA synchronous" statement also uses the zero-based numbers. +** In other words, the zero-based numbers are used for all external interfaces +** and the one-based values are used internally. +*/ +#ifndef SQLITE_DEFAULT_SYNCHRONOUS +# define SQLITE_DEFAULT_SYNCHRONOUS 2 +#endif +#ifndef SQLITE_DEFAULT_WAL_SYNCHRONOUS +# define SQLITE_DEFAULT_WAL_SYNCHRONOUS SQLITE_DEFAULT_SYNCHRONOUS +#endif + +/* +** Each database file to be accessed by the system is an instance +** of the following structure. There are normally two of these structures +** in the sqlite.aDb[] array. aDb[0] is the main database file and +** aDb[1] is the database file used to hold temporary tables. Additional +** databases may be attached. +*/ +struct Db { + char *zDbSName; /* Name of this database. (schema name, not filename) */ + Btree *pBt; /* The B*Tree structure for this database file */ + u8 safety_level; /* How aggressive at syncing data to disk */ + u8 bSyncSet; /* True if "PRAGMA synchronous=N" has been run */ + Schema *pSchema; /* Pointer to database schema (possibly shared) */ +}; + +/* +** An instance of the following structure stores a database schema. +** +** Most Schema objects are associated with a Btree. The exception is +** the Schema for the TEMP databaes (sqlite3.aDb[1]) which is free-standing. +** In shared cache mode, a single Schema object can be shared by multiple +** Btrees that refer to the same underlying BtShared object. +** +** Schema objects are automatically deallocated when the last Btree that +** references them is destroyed. The TEMP Schema is manually freed by +** sqlite3_close(). +* +** A thread must be holding a mutex on the corresponding Btree in order +** to access Schema content. This implies that the thread must also be +** holding a mutex on the sqlite3 connection pointer that owns the Btree. +** For a TEMP Schema, only the connection mutex is required. +*/ +struct Schema { + int schema_cookie; /* Database schema version number for this file */ + int iGeneration; /* Generation counter. Incremented with each change */ + Hash tblHash; /* All tables indexed by name */ + Hash idxHash; /* All (named) indices indexed by name */ + Hash trigHash; /* All triggers indexed by name */ + Hash fkeyHash; /* All foreign keys by referenced table name */ + Table *pSeqTab; /* The sqlite_sequence table used by AUTOINCREMENT */ + u8 file_format; /* Schema format version for this file */ + u8 enc; /* Text encoding used by this database */ + u16 schemaFlags; /* Flags associated with this schema */ + int cache_size; /* Number of pages to use in the cache */ +}; + +/* +** These macros can be used to test, set, or clear bits in the +** Db.pSchema->flags field. +*/ +#define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))==(P)) +#define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))!=0) +#define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags|=(P) +#define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags&=~(P) + +/* +** Allowed values for the DB.pSchema->flags field. +** +** The DB_SchemaLoaded flag is set after the database schema has been +** read into internal hash tables. +** +** DB_UnresetViews means that one or more views have column names that +** have been filled out. If the schema changes, these column names might +** changes and so the view will need to be reset. +*/ +#define DB_SchemaLoaded 0x0001 /* The schema has been loaded */ +#define DB_UnresetViews 0x0002 /* Some views have defined column names */ +#define DB_ResetWanted 0x0008 /* Reset the schema when nSchemaLock==0 */ + +/* +** The number of different kinds of things that can be limited +** using the sqlite3_limit() interface. +*/ +#define SQLITE_N_LIMIT (SQLITE_LIMIT_WORKER_THREADS+1) + +/* +** Lookaside malloc is a set of fixed-size buffers that can be used +** to satisfy small transient memory allocation requests for objects +** associated with a particular database connection. The use of +** lookaside malloc provides a significant performance enhancement +** (approx 10%) by avoiding numerous malloc/free requests while parsing +** SQL statements. +** +** The Lookaside structure holds configuration information about the +** lookaside malloc subsystem. Each available memory allocation in +** the lookaside subsystem is stored on a linked list of LookasideSlot +** objects. +** +** Lookaside allocations are only allowed for objects that are associated +** with a particular database connection. Hence, schema information cannot +** be stored in lookaside because in shared cache mode the schema information +** is shared by multiple database connections. Therefore, while parsing +** schema information, the Lookaside.bEnabled flag is cleared so that +** lookaside allocations are not used to construct the schema objects. +** +** New lookaside allocations are only allowed if bDisable==0. When +** bDisable is greater than zero, sz is set to zero which effectively +** disables lookaside without adding a new test for the bDisable flag +** in a performance-critical path. sz should be set by to szTrue whenever +** bDisable changes back to zero. +** +** Lookaside buffers are initially held on the pInit list. As they are +** used and freed, they are added back to the pFree list. New allocations +** come off of pFree first, then pInit as a fallback. This dual-list +** allows use to compute a high-water mark - the maximum number of allocations +** outstanding at any point in the past - by subtracting the number of +** allocations on the pInit list from the total number of allocations. +** +** Enhancement on 2019-12-12: Two-size-lookaside +** The default lookaside configuration is 100 slots of 1200 bytes each. +** The larger slot sizes are important for performance, but they waste +** a lot of space, as most lookaside allocations are less than 128 bytes. +** The two-size-lookaside enhancement breaks up the lookaside allocation +** into two pools: One of 128-byte slots and the other of the default size +** (1200-byte) slots. Allocations are filled from the small-pool first, +** failing over to the full-size pool if that does not work. Thus more +** lookaside slots are available while also using less memory. +** This enhancement can be omitted by compiling with +** SQLITE_OMIT_TWOSIZE_LOOKASIDE. +*/ +struct Lookaside { + u32 bDisable; /* Only operate the lookaside when zero */ + u16 sz; /* Size of each buffer in bytes */ + u16 szTrue; /* True value of sz, even if disabled */ + u8 bMalloced; /* True if pStart obtained from sqlite3_malloc() */ + u32 nSlot; /* Number of lookaside slots allocated */ + u32 anStat[3]; /* 0: hits. 1: size misses. 2: full misses */ + LookasideSlot *pInit; /* List of buffers not previously used */ + LookasideSlot *pFree; /* List of available buffers */ +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + LookasideSlot *pSmallInit; /* List of small buffers not prediously used */ + LookasideSlot *pSmallFree; /* List of available small buffers */ + void *pMiddle; /* First byte past end of full-size buffers and + ** the first byte of LOOKASIDE_SMALL buffers */ +#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */ + void *pStart; /* First byte of available memory space */ + void *pEnd; /* First byte past end of available space */ +}; +struct LookasideSlot { + LookasideSlot *pNext; /* Next buffer in the list of free buffers */ +}; + +#define DisableLookaside db->lookaside.bDisable++;db->lookaside.sz=0 +#define EnableLookaside db->lookaside.bDisable--;\ + db->lookaside.sz=db->lookaside.bDisable?0:db->lookaside.szTrue + +/* Size of the smaller allocations in two-size lookside */ +#ifdef SQLITE_OMIT_TWOSIZE_LOOKASIDE +# define LOOKASIDE_SMALL 0 +#else +# define LOOKASIDE_SMALL 128 +#endif + +/* +** A hash table for built-in function definitions. (Application-defined +** functions use a regular table table from hash.h.) +** +** Hash each FuncDef structure into one of the FuncDefHash.a[] slots. +** Collisions are on the FuncDef.u.pHash chain. Use the SQLITE_FUNC_HASH() +** macro to compute a hash on the function name. +*/ +#define SQLITE_FUNC_HASH_SZ 23 +struct FuncDefHash { + FuncDef *a[SQLITE_FUNC_HASH_SZ]; /* Hash table for functions */ +}; +#define SQLITE_FUNC_HASH(C,L) (((C)+(L))%SQLITE_FUNC_HASH_SZ) + +#ifdef SQLITE_USER_AUTHENTICATION +/* +** Information held in the "sqlite3" database connection object and used +** to manage user authentication. +*/ +typedef struct sqlite3_userauth sqlite3_userauth; +struct sqlite3_userauth { + u8 authLevel; /* Current authentication level */ + int nAuthPW; /* Size of the zAuthPW in bytes */ + char *zAuthPW; /* Password used to authenticate */ + char *zAuthUser; /* User name used to authenticate */ +}; + +/* Allowed values for sqlite3_userauth.authLevel */ +#define UAUTH_Unknown 0 /* Authentication not yet checked */ +#define UAUTH_Fail 1 /* User authentication failed */ +#define UAUTH_User 2 /* Authenticated as a normal user */ +#define UAUTH_Admin 3 /* Authenticated as an administrator */ + +/* Functions used only by user authorization logic */ +SQLITE_PRIVATE int sqlite3UserAuthTable(const char*); +SQLITE_PRIVATE int sqlite3UserAuthCheckLogin(sqlite3*,const char*,u8*); +SQLITE_PRIVATE void sqlite3UserAuthInit(sqlite3*); +SQLITE_PRIVATE void sqlite3CryptFunc(sqlite3_context*,int,sqlite3_value**); + +#endif /* SQLITE_USER_AUTHENTICATION */ + +/* +** typedef for the authorization callback function. +*/ +#ifdef SQLITE_USER_AUTHENTICATION + typedef int (*sqlite3_xauth)(void*,int,const char*,const char*,const char*, + const char*, const char*); +#else + typedef int (*sqlite3_xauth)(void*,int,const char*,const char*,const char*, + const char*); +#endif + +#ifndef SQLITE_OMIT_DEPRECATED +/* This is an extra SQLITE_TRACE macro that indicates "legacy" tracing +** in the style of sqlite3_trace() +*/ +#define SQLITE_TRACE_LEGACY 0x40 /* Use the legacy xTrace */ +#define SQLITE_TRACE_XPROFILE 0x80 /* Use the legacy xProfile */ +#else +#define SQLITE_TRACE_LEGACY 0 +#define SQLITE_TRACE_XPROFILE 0 +#endif /* SQLITE_OMIT_DEPRECATED */ +#define SQLITE_TRACE_NONLEGACY_MASK 0x0f /* Normal flags */ + + +/* +** Each database connection is an instance of the following structure. +*/ +struct sqlite3 { + sqlite3_vfs *pVfs; /* OS Interface */ + struct Vdbe *pVdbe; /* List of active virtual machines */ + CollSeq *pDfltColl; /* BINARY collseq for the database encoding */ + sqlite3_mutex *mutex; /* Connection mutex */ + Db *aDb; /* All backends */ + int nDb; /* Number of backends currently in use */ + u32 mDbFlags; /* flags recording internal state */ + u64 flags; /* flags settable by pragmas. See below */ + i64 lastRowid; /* ROWID of most recent insert (see above) */ + i64 szMmap; /* Default mmap_size setting */ + u32 nSchemaLock; /* Do not reset the schema when non-zero */ + unsigned int openFlags; /* Flags passed to sqlite3_vfs.xOpen() */ + int errCode; /* Most recent error code (SQLITE_*) */ + int errMask; /* & result codes with this before returning */ + int iSysErrno; /* Errno value from last system error */ + u16 dbOptFlags; /* Flags to enable/disable optimizations */ + u8 enc; /* Text encoding */ + u8 autoCommit; /* The auto-commit flag. */ + u8 temp_store; /* 1: file 2: memory 0: default */ + u8 mallocFailed; /* True if we have seen a malloc failure */ + u8 bBenignMalloc; /* Do not require OOMs if true */ + u8 dfltLockMode; /* Default locking-mode for attached dbs */ + signed char nextAutovac; /* Autovac setting after VACUUM if >=0 */ + u8 suppressErr; /* Do not issue error messages if true */ + u8 vtabOnConflict; /* Value to return for s3_vtab_on_conflict() */ + u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */ + u8 mTrace; /* zero or more SQLITE_TRACE flags */ + u8 noSharedCache; /* True if no shared-cache backends */ + u8 nSqlExec; /* Number of pending OP_SqlExec opcodes */ + int nextPagesize; /* Pagesize after VACUUM if >0 */ + u32 magic; /* Magic number for detect library misuse */ + int nChange; /* Value returned by sqlite3_changes() */ + int nTotalChange; /* Value returned by sqlite3_total_changes() */ + int aLimit[SQLITE_N_LIMIT]; /* Limits */ + int nMaxSorterMmap; /* Maximum size of regions mapped by sorter */ + struct sqlite3InitInfo { /* Information used during initialization */ + Pgno newTnum; /* Rootpage of table being initialized */ + u8 iDb; /* Which db file is being initialized */ + u8 busy; /* TRUE if currently initializing */ + unsigned orphanTrigger : 1; /* Last statement is orphaned TEMP trigger */ + unsigned imposterTable : 1; /* Building an imposter table */ + unsigned reopenMemdb : 1; /* ATTACH is really a reopen using MemDB */ + char **azInit; /* "type", "name", and "tbl_name" columns */ + } init; + int nVdbeActive; /* Number of VDBEs currently running */ + int nVdbeRead; /* Number of active VDBEs that read or write */ + int nVdbeWrite; /* Number of active VDBEs that read and write */ + int nVdbeExec; /* Number of nested calls to VdbeExec() */ + int nVDestroy; /* Number of active OP_VDestroy operations */ + int nExtension; /* Number of loaded extensions */ + void **aExtension; /* Array of shared library handles */ + union { + void (*xLegacy)(void*,const char*); /* Legacy trace function */ + int (*xV2)(u32,void*,void*,void*); /* V2 Trace function */ + } trace; + void *pTraceArg; /* Argument to the trace function */ +#ifndef SQLITE_OMIT_DEPRECATED + void (*xProfile)(void*,const char*,u64); /* Profiling function */ + void *pProfileArg; /* Argument to profile function */ +#endif + void *pCommitArg; /* Argument to xCommitCallback() */ + int (*xCommitCallback)(void*); /* Invoked at every commit. */ + void *pRollbackArg; /* Argument to xRollbackCallback() */ + void (*xRollbackCallback)(void*); /* Invoked at every commit. */ + void *pUpdateArg; + void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64); + Parse *pParse; /* Current parse */ +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + void *pPreUpdateArg; /* First argument to xPreUpdateCallback */ + void (*xPreUpdateCallback)( /* Registered using sqlite3_preupdate_hook() */ + void*,sqlite3*,int,char const*,char const*,sqlite3_int64,sqlite3_int64 + ); + PreUpdate *pPreUpdate; /* Context for active pre-update callback */ +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ +#ifndef SQLITE_OMIT_WAL + int (*xWalCallback)(void *, sqlite3 *, const char *, int); + void *pWalArg; +#endif + void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*); + void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*); + void *pCollNeededArg; + sqlite3_value *pErr; /* Most recent error message */ + union { + volatile int isInterrupted; /* True if sqlite3_interrupt has been called */ + double notUsed1; /* Spacer */ + } u1; + Lookaside lookaside; /* Lookaside malloc configuration */ +#ifndef SQLITE_OMIT_AUTHORIZATION + sqlite3_xauth xAuth; /* Access authorization function */ + void *pAuthArg; /* 1st argument to the access auth function */ +#endif +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + int (*xProgress)(void *); /* The progress callback */ + void *pProgressArg; /* Argument to the progress callback */ + unsigned nProgressOps; /* Number of opcodes for progress callback */ +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + int nVTrans; /* Allocated size of aVTrans */ + Hash aModule; /* populated by sqlite3_create_module() */ + VtabCtx *pVtabCtx; /* Context for active vtab connect/create */ + VTable **aVTrans; /* Virtual tables with open transactions */ + VTable *pDisconnect; /* Disconnect these in next sqlite3_prepare() */ +#endif + Hash aFunc; /* Hash table of connection functions */ + Hash aCollSeq; /* All collating sequences */ + BusyHandler busyHandler; /* Busy callback */ + Db aDbStatic[2]; /* Static space for the 2 default backends */ + Savepoint *pSavepoint; /* List of active savepoints */ + int nAnalysisLimit; /* Number of index rows to ANALYZE */ + int busyTimeout; /* Busy handler timeout, in msec */ + int nSavepoint; /* Number of non-transaction savepoints */ + int nStatement; /* Number of nested statement-transactions */ + i64 nDeferredCons; /* Net deferred constraints this transaction. */ + i64 nDeferredImmCons; /* Net deferred immediate constraints */ + int *pnBytesFreed; /* If not NULL, increment this in DbFree() */ +#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY + /* The following variables are all protected by the STATIC_MAIN + ** mutex, not by sqlite3.mutex. They are used by code in notify.c. + ** + ** When X.pUnlockConnection==Y, that means that X is waiting for Y to + ** unlock so that it can proceed. + ** + ** When X.pBlockingConnection==Y, that means that something that X tried + ** tried to do recently failed with an SQLITE_LOCKED error due to locks + ** held by Y. + */ + sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */ + sqlite3 *pUnlockConnection; /* Connection to watch for unlock */ + void *pUnlockArg; /* Argument to xUnlockNotify */ + void (*xUnlockNotify)(void **, int); /* Unlock notify callback */ + sqlite3 *pNextBlocked; /* Next in list of all blocked connections */ +#endif +#ifdef SQLITE_USER_AUTHENTICATION + sqlite3_userauth auth; /* User authentication information */ +#endif +}; + +/* +** A macro to discover the encoding of a database. +*/ +#define SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc) +#define ENC(db) ((db)->enc) + +/* +** A u64 constant where the lower 32 bits are all zeros. Only the +** upper 32 bits are included in the argument. Necessary because some +** C-compilers still do not accept LL integer literals. +*/ +#define HI(X) ((u64)(X)<<32) + +/* +** Possible values for the sqlite3.flags. +** +** Value constraints (enforced via assert()): +** SQLITE_FullFSync == PAGER_FULLFSYNC +** SQLITE_CkptFullFSync == PAGER_CKPT_FULLFSYNC +** SQLITE_CacheSpill == PAGER_CACHE_SPILL +*/ +#define SQLITE_WriteSchema 0x00000001 /* OK to update SQLITE_SCHEMA */ +#define SQLITE_LegacyFileFmt 0x00000002 /* Create new databases in format 1 */ +#define SQLITE_FullColNames 0x00000004 /* Show full column names on SELECT */ +#define SQLITE_FullFSync 0x00000008 /* Use full fsync on the backend */ +#define SQLITE_CkptFullFSync 0x00000010 /* Use full fsync for checkpoint */ +#define SQLITE_CacheSpill 0x00000020 /* OK to spill pager cache */ +#define SQLITE_ShortColNames 0x00000040 /* Show short columns names */ +#define SQLITE_TrustedSchema 0x00000080 /* Allow unsafe functions and + ** vtabs in the schema definition */ +#define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */ + /* result set is empty */ +#define SQLITE_IgnoreChecks 0x00000200 /* Do not enforce check constraints */ +#define SQLITE_ReadUncommit 0x00000400 /* READ UNCOMMITTED in shared-cache */ +#define SQLITE_NoCkptOnClose 0x00000800 /* No checkpoint on close()/DETACH */ +#define SQLITE_ReverseOrder 0x00001000 /* Reverse unordered SELECTs */ +#define SQLITE_RecTriggers 0x00002000 /* Enable recursive triggers */ +#define SQLITE_ForeignKeys 0x00004000 /* Enforce foreign key constraints */ +#define SQLITE_AutoIndex 0x00008000 /* Enable automatic indexes */ +#define SQLITE_LoadExtension 0x00010000 /* Enable load_extension */ +#define SQLITE_LoadExtFunc 0x00020000 /* Enable load_extension() SQL func */ +#define SQLITE_EnableTrigger 0x00040000 /* True to enable triggers */ +#define SQLITE_DeferFKs 0x00080000 /* Defer all FK constraints */ +#define SQLITE_QueryOnly 0x00100000 /* Disable database changes */ +#define SQLITE_CellSizeCk 0x00200000 /* Check btree cell sizes on load */ +#define SQLITE_Fts3Tokenizer 0x00400000 /* Enable fts3_tokenizer(2) */ +#define SQLITE_EnableQPSG 0x00800000 /* Query Planner Stability Guarantee*/ +#define SQLITE_TriggerEQP 0x01000000 /* Show trigger EXPLAIN QUERY PLAN */ +#define SQLITE_ResetDatabase 0x02000000 /* Reset the database */ +#define SQLITE_LegacyAlter 0x04000000 /* Legacy ALTER TABLE behaviour */ +#define SQLITE_NoSchemaError 0x08000000 /* Do not report schema parse errors*/ +#define SQLITE_Defensive 0x10000000 /* Input SQL is likely hostile */ +#define SQLITE_DqsDDL 0x20000000 /* dbl-quoted strings allowed in DDL*/ +#define SQLITE_DqsDML 0x40000000 /* dbl-quoted strings allowed in DML*/ +#define SQLITE_EnableView 0x80000000 /* Enable the use of views */ +#define SQLITE_CountRows HI(0x00001) /* Count rows changed by INSERT, */ + /* DELETE, or UPDATE and return */ + /* the count using a callback. */ + +/* Flags used only if debugging */ +#ifdef SQLITE_DEBUG +#define SQLITE_SqlTrace HI(0x0100000) /* Debug print SQL as it executes */ +#define SQLITE_VdbeListing HI(0x0200000) /* Debug listings of VDBE progs */ +#define SQLITE_VdbeTrace HI(0x0400000) /* True to trace VDBE execution */ +#define SQLITE_VdbeAddopTrace HI(0x0800000) /* Trace sqlite3VdbeAddOp() calls */ +#define SQLITE_VdbeEQP HI(0x1000000) /* Debug EXPLAIN QUERY PLAN */ +#define SQLITE_ParserTrace HI(0x2000000) /* PRAGMA parser_trace=ON */ +#endif + +/* +** Allowed values for sqlite3.mDbFlags +*/ +#define DBFLAG_SchemaChange 0x0001 /* Uncommitted Hash table changes */ +#define DBFLAG_PreferBuiltin 0x0002 /* Preference to built-in funcs */ +#define DBFLAG_Vacuum 0x0004 /* Currently in a VACUUM */ +#define DBFLAG_VacuumInto 0x0008 /* Currently running VACUUM INTO */ +#define DBFLAG_SchemaKnownOk 0x0010 /* Schema is known to be valid */ +#define DBFLAG_InternalFunc 0x0020 /* Allow use of internal functions */ +#define DBFLAG_EncodingFixed 0x0040 /* No longer possible to change enc. */ + +/* +** Bits of the sqlite3.dbOptFlags field that are used by the +** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface to +** selectively disable various optimizations. +*/ +#define SQLITE_QueryFlattener 0x0001 /* Query flattening */ +#define SQLITE_WindowFunc 0x0002 /* Use xInverse for window functions */ +#define SQLITE_GroupByOrder 0x0004 /* GROUPBY cover of ORDERBY */ +#define SQLITE_FactorOutConst 0x0008 /* Constant factoring */ +#define SQLITE_DistinctOpt 0x0010 /* DISTINCT using indexes */ +#define SQLITE_CoverIdxScan 0x0020 /* Covering index scans */ +#define SQLITE_OrderByIdxJoin 0x0040 /* ORDER BY of joins via index */ +#define SQLITE_Transitive 0x0080 /* Transitive constraints */ +#define SQLITE_OmitNoopJoin 0x0100 /* Omit unused tables in joins */ +#define SQLITE_CountOfView 0x0200 /* The count-of-view optimization */ +#define SQLITE_CursorHints 0x0400 /* Add OP_CursorHint opcodes */ +#define SQLITE_Stat4 0x0800 /* Use STAT4 data */ + /* TH3 expects the Stat4 ^^^^^^ value to be 0x0800. Don't change it */ +#define SQLITE_PushDown 0x1000 /* The push-down optimization */ +#define SQLITE_SimplifyJoin 0x2000 /* Convert LEFT JOIN to JOIN */ +#define SQLITE_SkipScan 0x4000 /* Skip-scans */ +#define SQLITE_PropagateConst 0x8000 /* The constant propagation opt */ +#define SQLITE_AllOpts 0xffff /* All optimizations */ + +/* +** Macros for testing whether or not optimizations are enabled or disabled. +*/ +#define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0) +#define OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0) + +/* +** Return true if it OK to factor constant expressions into the initialization +** code. The argument is a Parse object for the code generator. +*/ +#define ConstFactorOk(P) ((P)->okConstFactor) + +/* +** Possible values for the sqlite.magic field. +** The numbers are obtained at random and have no special meaning, other +** than being distinct from one another. +*/ +#define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */ +#define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */ +#define SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */ +#define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */ +#define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */ +#define SQLITE_MAGIC_ZOMBIE 0x64cffc7f /* Close with last statement close */ + +/* +** Each SQL function is defined by an instance of the following +** structure. For global built-in functions (ex: substr(), max(), count()) +** a pointer to this structure is held in the sqlite3BuiltinFunctions object. +** For per-connection application-defined functions, a pointer to this +** structure is held in the db->aHash hash table. +** +** The u.pHash field is used by the global built-ins. The u.pDestructor +** field is used by per-connection app-def functions. +*/ +struct FuncDef { + i8 nArg; /* Number of arguments. -1 means unlimited */ + u32 funcFlags; /* Some combination of SQLITE_FUNC_* */ + void *pUserData; /* User data parameter */ + FuncDef *pNext; /* Next function with same name */ + void (*xSFunc)(sqlite3_context*,int,sqlite3_value**); /* func or agg-step */ + void (*xFinalize)(sqlite3_context*); /* Agg finalizer */ + void (*xValue)(sqlite3_context*); /* Current agg value */ + void (*xInverse)(sqlite3_context*,int,sqlite3_value**); /* inverse agg-step */ + const char *zName; /* SQL name of the function. */ + union { + FuncDef *pHash; /* Next with a different name but the same hash */ + FuncDestructor *pDestructor; /* Reference counted destructor function */ + } u; +}; + +/* +** This structure encapsulates a user-function destructor callback (as +** configured using create_function_v2()) and a reference counter. When +** create_function_v2() is called to create a function with a destructor, +** a single object of this type is allocated. FuncDestructor.nRef is set to +** the number of FuncDef objects created (either 1 or 3, depending on whether +** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor +** member of each of the new FuncDef objects is set to point to the allocated +** FuncDestructor. +** +** Thereafter, when one of the FuncDef objects is deleted, the reference +** count on this object is decremented. When it reaches 0, the destructor +** is invoked and the FuncDestructor structure freed. +*/ +struct FuncDestructor { + int nRef; + void (*xDestroy)(void *); + void *pUserData; +}; + +/* +** Possible values for FuncDef.flags. Note that the _LENGTH and _TYPEOF +** values must correspond to OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG. And +** SQLITE_FUNC_CONSTANT must be the same as SQLITE_DETERMINISTIC. There +** are assert() statements in the code to verify this. +** +** Value constraints (enforced via assert()): +** SQLITE_FUNC_MINMAX == NC_MinMaxAgg == SF_MinMaxAgg +** SQLITE_FUNC_LENGTH == OPFLAG_LENGTHARG +** SQLITE_FUNC_TYPEOF == OPFLAG_TYPEOFARG +** SQLITE_FUNC_CONSTANT == SQLITE_DETERMINISTIC from the API +** SQLITE_FUNC_DIRECT == SQLITE_DIRECTONLY from the API +** SQLITE_FUNC_UNSAFE == SQLITE_INNOCUOUS +** SQLITE_FUNC_ENCMASK depends on SQLITE_UTF* macros in the API +*/ +#define SQLITE_FUNC_ENCMASK 0x0003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */ +#define SQLITE_FUNC_LIKE 0x0004 /* Candidate for the LIKE optimization */ +#define SQLITE_FUNC_CASE 0x0008 /* Case-sensitive LIKE-type function */ +#define SQLITE_FUNC_EPHEM 0x0010 /* Ephemeral. Delete with VDBE */ +#define SQLITE_FUNC_NEEDCOLL 0x0020 /* sqlite3GetFuncCollSeq() might be called*/ +#define SQLITE_FUNC_LENGTH 0x0040 /* Built-in length() function */ +#define SQLITE_FUNC_TYPEOF 0x0080 /* Built-in typeof() function */ +#define SQLITE_FUNC_COUNT 0x0100 /* Built-in count(*) aggregate */ +/* 0x0200 -- available for reuse */ +#define SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */ +#define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */ +#define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */ +#define SQLITE_FUNC_SLOCHNG 0x2000 /* "Slow Change". Value constant during a + ** single query - might change over time */ +#define SQLITE_FUNC_TEST 0x4000 /* Built-in testing functions */ +#define SQLITE_FUNC_OFFSET 0x8000 /* Built-in sqlite_offset() function */ +#define SQLITE_FUNC_WINDOW 0x00010000 /* Built-in window-only function */ +#define SQLITE_FUNC_INTERNAL 0x00040000 /* For use by NestedParse() only */ +#define SQLITE_FUNC_DIRECT 0x00080000 /* Not for use in TRIGGERs or VIEWs */ +#define SQLITE_FUNC_SUBTYPE 0x00100000 /* Result likely to have sub-type */ +#define SQLITE_FUNC_UNSAFE 0x00200000 /* Function has side effects */ +#define SQLITE_FUNC_INLINE 0x00400000 /* Functions implemented in-line */ + +/* Identifier numbers for each in-line function */ +#define INLINEFUNC_coalesce 0 +#define INLINEFUNC_implies_nonnull_row 1 +#define INLINEFUNC_expr_implies_expr 2 +#define INLINEFUNC_expr_compare 3 +#define INLINEFUNC_affinity 4 +#define INLINEFUNC_iif 5 +#define INLINEFUNC_unlikely 99 /* Default case */ + +/* +** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are +** used to create the initializers for the FuncDef structures. +** +** FUNCTION(zName, nArg, iArg, bNC, xFunc) +** Used to create a scalar function definition of a function zName +** implemented by C function xFunc that accepts nArg arguments. The +** value passed as iArg is cast to a (void*) and made available +** as the user-data (sqlite3_user_data()) for the function. If +** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set. +** +** VFUNCTION(zName, nArg, iArg, bNC, xFunc) +** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag. +** +** SFUNCTION(zName, nArg, iArg, bNC, xFunc) +** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and +** adds the SQLITE_DIRECTONLY flag. +** +** INLINE_FUNC(zName, nArg, iFuncId, mFlags) +** zName is the name of a function that is implemented by in-line +** byte code rather than by the usual callbacks. The iFuncId +** parameter determines the function id. The mFlags parameter is +** optional SQLITE_FUNC_ flags for this function. +** +** TEST_FUNC(zName, nArg, iFuncId, mFlags) +** zName is the name of a test-only function implemented by in-line +** byte code rather than by the usual callbacks. The iFuncId +** parameter determines the function id. The mFlags parameter is +** optional SQLITE_FUNC_ flags for this function. +** +** DFUNCTION(zName, nArg, iArg, bNC, xFunc) +** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and +** adds the SQLITE_FUNC_SLOCHNG flag. Used for date & time functions +** and functions like sqlite_version() that can change, but not during +** a single query. The iArg is ignored. The user-data is always set +** to a NULL pointer. The bNC parameter is not used. +** +** PURE_DATE(zName, nArg, iArg, bNC, xFunc) +** Used for "pure" date/time functions, this macro is like DFUNCTION +** except that it does set the SQLITE_FUNC_CONSTANT flags. iArg is +** ignored and the user-data for these functions is set to an +** arbitrary non-NULL pointer. The bNC parameter is not used. +** +** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal) +** Used to create an aggregate function definition implemented by +** the C functions xStep and xFinal. The first four parameters +** are interpreted in the same way as the first 4 parameters to +** FUNCTION(). +** +** WFUNCTION(zName, nArg, iArg, xStep, xFinal, xValue, xInverse) +** Used to create an aggregate function definition implemented by +** the C functions xStep and xFinal. The first four parameters +** are interpreted in the same way as the first 4 parameters to +** FUNCTION(). +** +** LIKEFUNC(zName, nArg, pArg, flags) +** Used to create a scalar function definition of a function zName +** that accepts nArg arguments and is implemented by a call to C +** function likeFunc. Argument pArg is cast to a (void *) and made +** available as the function user-data (sqlite3_user_data()). The +** FuncDef.flags variable is set to the value passed as the flags +** parameter. +*/ +#define FUNCTION(zName, nArg, iArg, bNC, xFunc) \ + {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } +#define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \ + {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } +#define SFUNCTION(zName, nArg, iArg, bNC, xFunc) \ + {nArg, SQLITE_UTF8|SQLITE_DIRECTONLY|SQLITE_FUNC_UNSAFE, \ + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } +#define INLINE_FUNC(zName, nArg, iArg, mFlags) \ + {nArg, SQLITE_UTF8|SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \ + SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} } +#define TEST_FUNC(zName, nArg, iArg, mFlags) \ + {nArg, SQLITE_UTF8|SQLITE_FUNC_INTERNAL|SQLITE_FUNC_TEST| \ + SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \ + SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} } +#define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \ + {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8, \ + 0, 0, xFunc, 0, 0, 0, #zName, {0} } +#define PURE_DATE(zName, nArg, iArg, bNC, xFunc) \ + {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \ + (void*)&sqlite3Config, 0, xFunc, 0, 0, 0, #zName, {0} } +#define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \ + {nArg,SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\ + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } +#define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \ + {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ + pArg, 0, xFunc, 0, 0, 0, #zName, } +#define LIKEFUNC(zName, nArg, arg, flags) \ + {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \ + (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} } +#define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \ + {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|f, \ + SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}} +#define INTERNAL_FUNCTION(zName, nArg, xFunc) \ + {nArg, SQLITE_FUNC_INTERNAL|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \ + 0, 0, xFunc, 0, 0, 0, #zName, {0} } + + +/* +** All current savepoints are stored in a linked list starting at +** sqlite3.pSavepoint. The first element in the list is the most recently +** opened savepoint. Savepoints are added to the list by the vdbe +** OP_Savepoint instruction. +*/ +struct Savepoint { + char *zName; /* Savepoint name (nul-terminated) */ + i64 nDeferredCons; /* Number of deferred fk violations */ + i64 nDeferredImmCons; /* Number of deferred imm fk. */ + Savepoint *pNext; /* Parent savepoint (if any) */ +}; + +/* +** The following are used as the second parameter to sqlite3Savepoint(), +** and as the P1 argument to the OP_Savepoint instruction. +*/ +#define SAVEPOINT_BEGIN 0 +#define SAVEPOINT_RELEASE 1 +#define SAVEPOINT_ROLLBACK 2 + + +/* +** Each SQLite module (virtual table definition) is defined by an +** instance of the following structure, stored in the sqlite3.aModule +** hash table. +*/ +struct Module { + const sqlite3_module *pModule; /* Callback pointers */ + const char *zName; /* Name passed to create_module() */ + int nRefModule; /* Number of pointers to this object */ + void *pAux; /* pAux passed to create_module() */ + void (*xDestroy)(void *); /* Module destructor function */ + Table *pEpoTab; /* Eponymous table for this module */ +}; + +/* +** Information about each column of an SQL table is held in an instance +** of the Column structure, in the Table.aCol[] array. +** +** Definitions: +** +** "table column index" This is the index of the column in the +** Table.aCol[] array, and also the index of +** the column in the original CREATE TABLE stmt. +** +** "storage column index" This is the index of the column in the +** record BLOB generated by the OP_MakeRecord +** opcode. The storage column index is less than +** or equal to the table column index. It is +** equal if and only if there are no VIRTUAL +** columns to the left. +*/ +struct Column { + char *zName; /* Name of this column, \000, then the type */ + Expr *pDflt; /* Default value or GENERATED ALWAYS AS value */ + char *zColl; /* Collating sequence. If NULL, use the default */ + u8 notNull; /* An OE_ code for handling a NOT NULL constraint */ + char affinity; /* One of the SQLITE_AFF_... values */ + u8 szEst; /* Estimated size of value in this column. sizeof(INT)==1 */ + u8 hName; /* Column name hash for faster lookup */ + u16 colFlags; /* Boolean properties. See COLFLAG_ defines below */ +}; + +/* Allowed values for Column.colFlags: +*/ +#define COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */ +#define COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */ +#define COLFLAG_HASTYPE 0x0004 /* Type name follows column name */ +#define COLFLAG_UNIQUE 0x0008 /* Column def contains "UNIQUE" or "PK" */ +#define COLFLAG_SORTERREF 0x0010 /* Use sorter-refs with this column */ +#define COLFLAG_VIRTUAL 0x0020 /* GENERATED ALWAYS AS ... VIRTUAL */ +#define COLFLAG_STORED 0x0040 /* GENERATED ALWAYS AS ... STORED */ +#define COLFLAG_NOTAVAIL 0x0080 /* STORED column not yet calculated */ +#define COLFLAG_BUSY 0x0100 /* Blocks recursion on GENERATED columns */ +#define COLFLAG_GENERATED 0x0060 /* Combo: _STORED, _VIRTUAL */ +#define COLFLAG_NOINSERT 0x0062 /* Combo: _HIDDEN, _STORED, _VIRTUAL */ + +/* +** A "Collating Sequence" is defined by an instance of the following +** structure. Conceptually, a collating sequence consists of a name and +** a comparison routine that defines the order of that sequence. +** +** If CollSeq.xCmp is NULL, it means that the +** collating sequence is undefined. Indices built on an undefined +** collating sequence may not be read or written. +*/ +struct CollSeq { + char *zName; /* Name of the collating sequence, UTF-8 encoded */ + u8 enc; /* Text encoding handled by xCmp() */ + void *pUser; /* First argument to xCmp() */ + int (*xCmp)(void*,int, const void*, int, const void*); + void (*xDel)(void*); /* Destructor for pUser */ +}; + +/* +** A sort order can be either ASC or DESC. +*/ +#define SQLITE_SO_ASC 0 /* Sort in ascending order */ +#define SQLITE_SO_DESC 1 /* Sort in ascending order */ +#define SQLITE_SO_UNDEFINED -1 /* No sort order specified */ + +/* +** Column affinity types. +** +** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and +** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve +** the speed a little by numbering the values consecutively. +** +** But rather than start with 0 or 1, we begin with 'A'. That way, +** when multiple affinity types are concatenated into a string and +** used as the P4 operand, they will be more readable. +** +** Note also that the numeric types are grouped together so that testing +** for a numeric type is a single comparison. And the BLOB type is first. +*/ +#define SQLITE_AFF_NONE 0x40 /* '@' */ +#define SQLITE_AFF_BLOB 0x41 /* 'A' */ +#define SQLITE_AFF_TEXT 0x42 /* 'B' */ +#define SQLITE_AFF_NUMERIC 0x43 /* 'C' */ +#define SQLITE_AFF_INTEGER 0x44 /* 'D' */ +#define SQLITE_AFF_REAL 0x45 /* 'E' */ + +#define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC) + +/* +** The SQLITE_AFF_MASK values masks off the significant bits of an +** affinity value. +*/ +#define SQLITE_AFF_MASK 0x47 + +/* +** Additional bit values that can be ORed with an affinity without +** changing the affinity. +** +** The SQLITE_NOTNULL flag is a combination of NULLEQ and JUMPIFNULL. +** It causes an assert() to fire if either operand to a comparison +** operator is NULL. It is added to certain comparison operators to +** prove that the operands are always NOT NULL. +*/ +#define SQLITE_KEEPNULL 0x08 /* Used by vector == or <> */ +#define SQLITE_JUMPIFNULL 0x10 /* jumps if either operand is NULL */ +#define SQLITE_STOREP2 0x20 /* Store result in reg[P2] rather than jump */ +#define SQLITE_NULLEQ 0x80 /* NULL=NULL */ +#define SQLITE_NOTNULL 0x90 /* Assert that operands are never NULL */ + +/* +** An object of this type is created for each virtual table present in +** the database schema. +** +** If the database schema is shared, then there is one instance of this +** structure for each database connection (sqlite3*) that uses the shared +** schema. This is because each database connection requires its own unique +** instance of the sqlite3_vtab* handle used to access the virtual table +** implementation. sqlite3_vtab* handles can not be shared between +** database connections, even when the rest of the in-memory database +** schema is shared, as the implementation often stores the database +** connection handle passed to it via the xConnect() or xCreate() method +** during initialization internally. This database connection handle may +** then be used by the virtual table implementation to access real tables +** within the database. So that they appear as part of the callers +** transaction, these accesses need to be made via the same database +** connection as that used to execute SQL operations on the virtual table. +** +** All VTable objects that correspond to a single table in a shared +** database schema are initially stored in a linked-list pointed to by +** the Table.pVTable member variable of the corresponding Table object. +** When an sqlite3_prepare() operation is required to access the virtual +** table, it searches the list for the VTable that corresponds to the +** database connection doing the preparing so as to use the correct +** sqlite3_vtab* handle in the compiled query. +** +** When an in-memory Table object is deleted (for example when the +** schema is being reloaded for some reason), the VTable objects are not +** deleted and the sqlite3_vtab* handles are not xDisconnect()ed +** immediately. Instead, they are moved from the Table.pVTable list to +** another linked list headed by the sqlite3.pDisconnect member of the +** corresponding sqlite3 structure. They are then deleted/xDisconnected +** next time a statement is prepared using said sqlite3*. This is done +** to avoid deadlock issues involving multiple sqlite3.mutex mutexes. +** Refer to comments above function sqlite3VtabUnlockList() for an +** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect +** list without holding the corresponding sqlite3.mutex mutex. +** +** The memory for objects of this type is always allocated by +** sqlite3DbMalloc(), using the connection handle stored in VTable.db as +** the first argument. +*/ +struct VTable { + sqlite3 *db; /* Database connection associated with this table */ + Module *pMod; /* Pointer to module implementation */ + sqlite3_vtab *pVtab; /* Pointer to vtab instance */ + int nRef; /* Number of pointers to this structure */ + u8 bConstraint; /* True if constraints are supported */ + u8 eVtabRisk; /* Riskiness of allowing hacker access */ + int iSavepoint; /* Depth of the SAVEPOINT stack */ + VTable *pNext; /* Next in linked list (see above) */ +}; + +/* Allowed values for VTable.eVtabRisk +*/ +#define SQLITE_VTABRISK_Low 0 +#define SQLITE_VTABRISK_Normal 1 +#define SQLITE_VTABRISK_High 2 + +/* +** The schema for each SQL table and view is represented in memory +** by an instance of the following structure. +*/ +struct Table { + char *zName; /* Name of the table or view */ + Column *aCol; /* Information about each column */ + Index *pIndex; /* List of SQL indexes on this table. */ + Select *pSelect; /* NULL for tables. Points to definition if a view. */ + FKey *pFKey; /* Linked list of all foreign keys in this table */ + char *zColAff; /* String defining the affinity of each column */ + ExprList *pCheck; /* All CHECK constraints */ + /* ... also used as column name list in a VIEW */ + Pgno tnum; /* Root BTree page for this table */ + u32 nTabRef; /* Number of pointers to this Table */ + u32 tabFlags; /* Mask of TF_* values */ + i16 iPKey; /* If not negative, use aCol[iPKey] as the rowid */ + i16 nCol; /* Number of columns in this table */ + i16 nNVCol; /* Number of columns that are not VIRTUAL */ + LogEst nRowLogEst; /* Estimated rows in table - from sqlite_stat1 table */ + LogEst szTabRow; /* Estimated size of each table row in bytes */ +#ifdef SQLITE_ENABLE_COSTMULT + LogEst costMult; /* Cost multiplier for using this table */ +#endif + u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */ +#ifndef SQLITE_OMIT_ALTERTABLE + int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */ +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + int nModuleArg; /* Number of arguments to the module */ + char **azModuleArg; /* 0: module 1: schema 2: vtab name 3...: args */ + VTable *pVTable; /* List of VTable objects. */ +#endif + Trigger *pTrigger; /* List of triggers stored in pSchema */ + Schema *pSchema; /* Schema that contains this table */ + Table *pNextZombie; /* Next on the Parse.pZombieTab list */ +}; + +/* +** Allowed values for Table.tabFlags. +** +** TF_OOOHidden applies to tables or view that have hidden columns that are +** followed by non-hidden columns. Example: "CREATE VIRTUAL TABLE x USING +** vtab1(a HIDDEN, b);". Since "b" is a non-hidden column but "a" is hidden, +** the TF_OOOHidden attribute would apply in this case. Such tables require +** special handling during INSERT processing. The "OOO" means "Out Of Order". +** +** Constraints: +** +** TF_HasVirtual == COLFLAG_Virtual +** TF_HasStored == COLFLAG_Stored +*/ +#define TF_Readonly 0x0001 /* Read-only system table */ +#define TF_Ephemeral 0x0002 /* An ephemeral table */ +#define TF_HasPrimaryKey 0x0004 /* Table has a primary key */ +#define TF_Autoincrement 0x0008 /* Integer primary key is autoincrement */ +#define TF_HasStat1 0x0010 /* nRowLogEst set from sqlite_stat1 */ +#define TF_HasVirtual 0x0020 /* Has one or more VIRTUAL columns */ +#define TF_HasStored 0x0040 /* Has one or more STORED columns */ +#define TF_HasGenerated 0x0060 /* Combo: HasVirtual + HasStored */ +#define TF_WithoutRowid 0x0080 /* No rowid. PRIMARY KEY is the key */ +#define TF_StatsUsed 0x0100 /* Query planner decisions affected by + ** Index.aiRowLogEst[] values */ +#define TF_NoVisibleRowid 0x0200 /* No user-visible "rowid" column */ +#define TF_OOOHidden 0x0400 /* Out-of-Order hidden columns */ +#define TF_HasNotNull 0x0800 /* Contains NOT NULL constraints */ +#define TF_Shadow 0x1000 /* True for a shadow table */ +#define TF_HasStat4 0x2000 /* STAT4 info available for this table */ + +/* +** Test to see whether or not a table is a virtual table. This is +** done as a macro so that it will be optimized out when virtual +** table support is omitted from the build. +*/ +#ifndef SQLITE_OMIT_VIRTUALTABLE +# define IsVirtual(X) ((X)->nModuleArg) +# define ExprIsVtab(X) \ + ((X)->op==TK_COLUMN && (X)->y.pTab!=0 && (X)->y.pTab->nModuleArg) +#else +# define IsVirtual(X) 0 +# define ExprIsVtab(X) 0 +#endif + +/* +** Macros to determine if a column is hidden. IsOrdinaryHiddenColumn() +** only works for non-virtual tables (ordinary tables and views) and is +** always false unless SQLITE_ENABLE_HIDDEN_COLUMNS is defined. The +** IsHiddenColumn() macro is general purpose. +*/ +#if defined(SQLITE_ENABLE_HIDDEN_COLUMNS) +# define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0) +# define IsOrdinaryHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0) +#elif !defined(SQLITE_OMIT_VIRTUALTABLE) +# define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0) +# define IsOrdinaryHiddenColumn(X) 0 +#else +# define IsHiddenColumn(X) 0 +# define IsOrdinaryHiddenColumn(X) 0 +#endif + + +/* Does the table have a rowid */ +#define HasRowid(X) (((X)->tabFlags & TF_WithoutRowid)==0) +#define VisibleRowid(X) (((X)->tabFlags & TF_NoVisibleRowid)==0) + +/* +** Each foreign key constraint is an instance of the following structure. +** +** A foreign key is associated with two tables. The "from" table is +** the table that contains the REFERENCES clause that creates the foreign +** key. The "to" table is the table that is named in the REFERENCES clause. +** Consider this example: +** +** CREATE TABLE ex1( +** a INTEGER PRIMARY KEY, +** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x) +** ); +** +** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2". +** Equivalent names: +** +** from-table == child-table +** to-table == parent-table +** +** Each REFERENCES clause generates an instance of the following structure +** which is attached to the from-table. The to-table need not exist when +** the from-table is created. The existence of the to-table is not checked. +** +** The list of all parents for child Table X is held at X.pFKey. +** +** A list of all children for a table named Z (which might not even exist) +** is held in Schema.fkeyHash with a hash key of Z. +*/ +struct FKey { + Table *pFrom; /* Table containing the REFERENCES clause (aka: Child) */ + FKey *pNextFrom; /* Next FKey with the same in pFrom. Next parent of pFrom */ + char *zTo; /* Name of table that the key points to (aka: Parent) */ + FKey *pNextTo; /* Next with the same zTo. Next child of zTo. */ + FKey *pPrevTo; /* Previous with the same zTo */ + int nCol; /* Number of columns in this key */ + /* EV: R-30323-21917 */ + u8 isDeferred; /* True if constraint checking is deferred till COMMIT */ + u8 aAction[2]; /* ON DELETE and ON UPDATE actions, respectively */ + Trigger *apTrigger[2];/* Triggers for aAction[] actions */ + struct sColMap { /* Mapping of columns in pFrom to columns in zTo */ + int iFrom; /* Index of column in pFrom */ + char *zCol; /* Name of column in zTo. If NULL use PRIMARY KEY */ + } aCol[1]; /* One entry for each of nCol columns */ +}; + +/* +** SQLite supports many different ways to resolve a constraint +** error. ROLLBACK processing means that a constraint violation +** causes the operation in process to fail and for the current transaction +** to be rolled back. ABORT processing means the operation in process +** fails and any prior changes from that one operation are backed out, +** but the transaction is not rolled back. FAIL processing means that +** the operation in progress stops and returns an error code. But prior +** changes due to the same operation are not backed out and no rollback +** occurs. IGNORE means that the particular row that caused the constraint +** error is not inserted or updated. Processing continues and no error +** is returned. REPLACE means that preexisting database rows that caused +** a UNIQUE constraint violation are removed so that the new insert or +** update can proceed. Processing continues and no error is reported. +** +** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys. +** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the +** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign +** key is set to NULL. CASCADE means that a DELETE or UPDATE of the +** referenced table row is propagated into the row that holds the +** foreign key. +** +** The following symbolic values are used to record which type +** of action to take. +*/ +#define OE_None 0 /* There is no constraint to check */ +#define OE_Rollback 1 /* Fail the operation and rollback the transaction */ +#define OE_Abort 2 /* Back out changes but do no rollback transaction */ +#define OE_Fail 3 /* Stop the operation but leave all prior changes */ +#define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */ +#define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */ +#define OE_Update 6 /* Process as a DO UPDATE in an upsert */ +#define OE_Restrict 7 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */ +#define OE_SetNull 8 /* Set the foreign key value to NULL */ +#define OE_SetDflt 9 /* Set the foreign key value to its default */ +#define OE_Cascade 10 /* Cascade the changes */ +#define OE_Default 11 /* Do whatever the default action is */ + + +/* +** An instance of the following structure is passed as the first +** argument to sqlite3VdbeKeyCompare and is used to control the +** comparison of the two index keys. +** +** Note that aSortOrder[] and aColl[] have nField+1 slots. There +** are nField slots for the columns of an index then one extra slot +** for the rowid at the end. +*/ +struct KeyInfo { + u32 nRef; /* Number of references to this KeyInfo object */ + u8 enc; /* Text encoding - one of the SQLITE_UTF* values */ + u16 nKeyField; /* Number of key columns in the index */ + u16 nAllField; /* Total columns, including key plus others */ + sqlite3 *db; /* The database connection */ + u8 *aSortFlags; /* Sort order for each column. */ + CollSeq *aColl[1]; /* Collating sequence for each term of the key */ +}; + +/* +** Allowed bit values for entries in the KeyInfo.aSortFlags[] array. +*/ +#define KEYINFO_ORDER_DESC 0x01 /* DESC sort order */ +#define KEYINFO_ORDER_BIGNULL 0x02 /* NULL is larger than any other value */ + +/* +** This object holds a record which has been parsed out into individual +** fields, for the purposes of doing a comparison. +** +** A record is an object that contains one or more fields of data. +** Records are used to store the content of a table row and to store +** the key of an index. A blob encoding of a record is created by +** the OP_MakeRecord opcode of the VDBE and is disassembled by the +** OP_Column opcode. +** +** An instance of this object serves as a "key" for doing a search on +** an index b+tree. The goal of the search is to find the entry that +** is closed to the key described by this object. This object might hold +** just a prefix of the key. The number of fields is given by +** pKeyInfo->nField. +** +** The r1 and r2 fields are the values to return if this key is less than +** or greater than a key in the btree, respectively. These are normally +** -1 and +1 respectively, but might be inverted to +1 and -1 if the b-tree +** is in DESC order. +** +** The key comparison functions actually return default_rc when they find +** an equals comparison. default_rc can be -1, 0, or +1. If there are +** multiple entries in the b-tree with the same key (when only looking +** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to +** cause the search to find the last match, or +1 to cause the search to +** find the first match. +** +** The key comparison functions will set eqSeen to true if they ever +** get and equal results when comparing this structure to a b-tree record. +** When default_rc!=0, the search might end up on the record immediately +** before the first match or immediately after the last match. The +** eqSeen field will indicate whether or not an exact match exists in the +** b-tree. +*/ +struct UnpackedRecord { + KeyInfo *pKeyInfo; /* Collation and sort-order information */ + Mem *aMem; /* Values */ + u16 nField; /* Number of entries in apMem[] */ + i8 default_rc; /* Comparison result if keys are equal */ + u8 errCode; /* Error detected by xRecordCompare (CORRUPT or NOMEM) */ + i8 r1; /* Value to return if (lhs < rhs) */ + i8 r2; /* Value to return if (lhs > rhs) */ + u8 eqSeen; /* True if an equality comparison has been seen */ +}; + + +/* +** Each SQL index is represented in memory by an +** instance of the following structure. +** +** The columns of the table that are to be indexed are described +** by the aiColumn[] field of this structure. For example, suppose +** we have the following table and index: +** +** CREATE TABLE Ex1(c1 int, c2 int, c3 text); +** CREATE INDEX Ex2 ON Ex1(c3,c1); +** +** In the Table structure describing Ex1, nCol==3 because there are +** three columns in the table. In the Index structure describing +** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed. +** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the +** first column to be indexed (c3) has an index of 2 in Ex1.aCol[]. +** The second column to be indexed (c1) has an index of 0 in +** Ex1.aCol[], hence Ex2.aiColumn[1]==0. +** +** The Index.onError field determines whether or not the indexed columns +** must be unique and what to do if they are not. When Index.onError=OE_None, +** it means this is not a unique index. Otherwise it is a unique index +** and the value of Index.onError indicate the which conflict resolution +** algorithm to employ whenever an attempt is made to insert a non-unique +** element. +** +** While parsing a CREATE TABLE or CREATE INDEX statement in order to +** generate VDBE code (as opposed to parsing one read from an sqlite_schema +** table as part of parsing an existing database schema), transient instances +** of this structure may be created. In this case the Index.tnum variable is +** used to store the address of a VDBE instruction, not a database page +** number (it cannot - the database page is not allocated until the VDBE +** program is executed). See convertToWithoutRowidTable() for details. +*/ +struct Index { + char *zName; /* Name of this index */ + i16 *aiColumn; /* Which columns are used by this index. 1st is 0 */ + LogEst *aiRowLogEst; /* From ANALYZE: Est. rows selected by each column */ + Table *pTable; /* The SQL table being indexed */ + char *zColAff; /* String defining the affinity of each column */ + Index *pNext; /* The next index associated with the same table */ + Schema *pSchema; /* Schema containing this index */ + u8 *aSortOrder; /* for each column: True==DESC, False==ASC */ + const char **azColl; /* Array of collation sequence names for index */ + Expr *pPartIdxWhere; /* WHERE clause for partial indices */ + ExprList *aColExpr; /* Column expressions */ + Pgno tnum; /* DB Page containing root of this index */ + LogEst szIdxRow; /* Estimated average row size in bytes */ + u16 nKeyCol; /* Number of columns forming the key */ + u16 nColumn; /* Number of columns stored in the index */ + u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ + unsigned idxType:2; /* 0:Normal 1:UNIQUE, 2:PRIMARY KEY, 3:IPK */ + unsigned bUnordered:1; /* Use this index for == or IN queries only */ + unsigned uniqNotNull:1; /* True if UNIQUE and NOT NULL for all columns */ + unsigned isResized:1; /* True if resizeIndexObject() has been called */ + unsigned isCovering:1; /* True if this is a covering index */ + unsigned noSkipScan:1; /* Do not try to use skip-scan if true */ + unsigned hasStat1:1; /* aiRowLogEst values come from sqlite_stat1 */ + unsigned bNoQuery:1; /* Do not use this index to optimize queries */ + unsigned bAscKeyBug:1; /* True if the bba7b69f9849b5bf bug applies */ + unsigned bHasVCol:1; /* Index references one or more VIRTUAL columns */ +#ifdef SQLITE_ENABLE_STAT4 + int nSample; /* Number of elements in aSample[] */ + int nSampleCol; /* Size of IndexSample.anEq[] and so on */ + tRowcnt *aAvgEq; /* Average nEq values for keys not in aSample */ + IndexSample *aSample; /* Samples of the left-most key */ + tRowcnt *aiRowEst; /* Non-logarithmic stat1 data for this index */ + tRowcnt nRowEst0; /* Non-logarithmic number of rows in the index */ +#endif + Bitmask colNotIdxed; /* 0 for unindexed columns in pTab */ +}; + +/* +** Allowed values for Index.idxType +*/ +#define SQLITE_IDXTYPE_APPDEF 0 /* Created using CREATE INDEX */ +#define SQLITE_IDXTYPE_UNIQUE 1 /* Implements a UNIQUE constraint */ +#define SQLITE_IDXTYPE_PRIMARYKEY 2 /* Is the PRIMARY KEY for the table */ +#define SQLITE_IDXTYPE_IPK 3 /* INTEGER PRIMARY KEY index */ + +/* Return true if index X is a PRIMARY KEY index */ +#define IsPrimaryKeyIndex(X) ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY) + +/* Return true if index X is a UNIQUE index */ +#define IsUniqueIndex(X) ((X)->onError!=OE_None) + +/* The Index.aiColumn[] values are normally positive integer. But +** there are some negative values that have special meaning: +*/ +#define XN_ROWID (-1) /* Indexed column is the rowid */ +#define XN_EXPR (-2) /* Indexed column is an expression */ + +/* +** Each sample stored in the sqlite_stat4 table is represented in memory +** using a structure of this type. See documentation at the top of the +** analyze.c source file for additional information. +*/ +struct IndexSample { + void *p; /* Pointer to sampled record */ + int n; /* Size of record in bytes */ + tRowcnt *anEq; /* Est. number of rows where the key equals this sample */ + tRowcnt *anLt; /* Est. number of rows where key is less than this sample */ + tRowcnt *anDLt; /* Est. number of distinct keys less than this sample */ +}; + +/* +** Possible values to use within the flags argument to sqlite3GetToken(). +*/ +#define SQLITE_TOKEN_QUOTED 0x1 /* Token is a quoted identifier. */ +#define SQLITE_TOKEN_KEYWORD 0x2 /* Token is a keyword. */ + +/* +** Each token coming out of the lexer is an instance of +** this structure. Tokens are also used as part of an expression. +** +** The memory that "z" points to is owned by other objects. Take care +** that the owner of the "z" string does not deallocate the string before +** the Token goes out of scope! Very often, the "z" points to some place +** in the middle of the Parse.zSql text. But it might also point to a +** static string. +*/ +struct Token { + const char *z; /* Text of the token. Not NULL-terminated! */ + unsigned int n; /* Number of characters in this token */ +}; + +/* +** An instance of this structure contains information needed to generate +** code for a SELECT that contains aggregate functions. +** +** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a +** pointer to this structure. The Expr.iAgg field is the index in +** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate +** code for that node. +** +** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the +** original Select structure that describes the SELECT statement. These +** fields do not need to be freed when deallocating the AggInfo structure. +*/ +struct AggInfo { + u8 directMode; /* Direct rendering mode means take data directly + ** from source tables rather than from accumulators */ + u8 useSortingIdx; /* In direct mode, reference the sorting index rather + ** than the source table */ + int sortingIdx; /* Cursor number of the sorting index */ + int sortingIdxPTab; /* Cursor number of pseudo-table */ + int nSortingColumn; /* Number of columns in the sorting index */ + int mnReg, mxReg; /* Range of registers allocated for aCol and aFunc */ + ExprList *pGroupBy; /* The group by clause */ + struct AggInfo_col { /* For each column used in source tables */ + Table *pTab; /* Source table */ + Expr *pCExpr; /* The original expression */ + int iTable; /* Cursor number of the source table */ + int iMem; /* Memory location that acts as accumulator */ + i16 iColumn; /* Column number within the source table */ + i16 iSorterColumn; /* Column number in the sorting index */ + } *aCol; + int nColumn; /* Number of used entries in aCol[] */ + int nAccumulator; /* Number of columns that show through to the output. + ** Additional columns are used only as parameters to + ** aggregate functions */ + struct AggInfo_func { /* For each aggregate function */ + Expr *pFExpr; /* Expression encoding the function */ + FuncDef *pFunc; /* The aggregate function implementation */ + int iMem; /* Memory location that acts as accumulator */ + int iDistinct; /* Ephemeral table used to enforce DISTINCT */ + } *aFunc; + int nFunc; /* Number of entries in aFunc[] */ + u32 selId; /* Select to which this AggInfo belongs */ + AggInfo *pNext; /* Next in list of them all */ +}; + +/* +** The datatype ynVar is a signed integer, either 16-bit or 32-bit. +** Usually it is 16-bits. But if SQLITE_MAX_VARIABLE_NUMBER is greater +** than 32767 we have to make it 32-bit. 16-bit is preferred because +** it uses less memory in the Expr object, which is a big memory user +** in systems with lots of prepared statements. And few applications +** need more than about 10 or 20 variables. But some extreme users want +** to have prepared statements with over 32766 variables, and for them +** the option is available (at compile-time). +*/ +#if SQLITE_MAX_VARIABLE_NUMBER<32767 +typedef i16 ynVar; +#else +typedef int ynVar; +#endif + +/* +** Each node of an expression in the parse tree is an instance +** of this structure. +** +** Expr.op is the opcode. The integer parser token codes are reused +** as opcodes here. For example, the parser defines TK_GE to be an integer +** code representing the ">=" operator. This same integer code is reused +** to represent the greater-than-or-equal-to operator in the expression +** tree. +** +** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB, +** or TK_STRING), then Expr.token contains the text of the SQL literal. If +** the expression is a variable (TK_VARIABLE), then Expr.token contains the +** variable name. Finally, if the expression is an SQL function (TK_FUNCTION), +** then Expr.token contains the name of the function. +** +** Expr.pRight and Expr.pLeft are the left and right subexpressions of a +** binary operator. Either or both may be NULL. +** +** Expr.x.pList is a list of arguments if the expression is an SQL function, +** a CASE expression or an IN expression of the form " IN (, ...)". +** Expr.x.pSelect is used if the expression is a sub-select or an expression of +** the form " IN (SELECT ...)". If the EP_xIsSelect bit is set in the +** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is +** valid. +** +** An expression of the form ID or ID.ID refers to a column in a table. +** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is +** the integer cursor number of a VDBE cursor pointing to that table and +** Expr.iColumn is the column number for the specific column. If the +** expression is used as a result in an aggregate SELECT, then the +** value is also stored in the Expr.iAgg column in the aggregate so that +** it can be accessed after all aggregates are computed. +** +** If the expression is an unbound variable marker (a question mark +** character '?' in the original SQL) then the Expr.iTable holds the index +** number for that variable. +** +** If the expression is a subquery then Expr.iColumn holds an integer +** register number containing the result of the subquery. If the +** subquery gives a constant result, then iTable is -1. If the subquery +** gives a different answer at different times during statement processing +** then iTable is the address of a subroutine that computes the subquery. +** +** If the Expr is of type OP_Column, and the table it is selecting from +** is a disk table or the "old.*" pseudo-table, then pTab points to the +** corresponding table definition. +** +** ALLOCATION NOTES: +** +** Expr objects can use a lot of memory space in database schema. To +** help reduce memory requirements, sometimes an Expr object will be +** truncated. And to reduce the number of memory allocations, sometimes +** two or more Expr objects will be stored in a single memory allocation, +** together with Expr.zToken strings. +** +** If the EP_Reduced and EP_TokenOnly flags are set when +** an Expr object is truncated. When EP_Reduced is set, then all +** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees +** are contained within the same memory allocation. Note, however, that +** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately +** allocated, regardless of whether or not EP_Reduced is set. +*/ +struct Expr { + u8 op; /* Operation performed by this node */ + char affExpr; /* affinity, or RAISE type */ + u8 op2; /* TK_REGISTER/TK_TRUTH: original value of Expr.op + ** TK_COLUMN: the value of p5 for OP_Column + ** TK_AGG_FUNCTION: nesting depth + ** TK_FUNCTION: NC_SelfRef flag if needs OP_PureFunc */ +#ifdef SQLITE_DEBUG + u8 vvaFlags; /* Verification flags. */ +#endif + u32 flags; /* Various flags. EP_* See below */ + union { + char *zToken; /* Token value. Zero terminated and dequoted */ + int iValue; /* Non-negative integer value if EP_IntValue */ + } u; + + /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no + ** space is allocated for the fields below this point. An attempt to + ** access them will result in a segfault or malfunction. + *********************************************************************/ + + Expr *pLeft; /* Left subnode */ + Expr *pRight; /* Right subnode */ + union { + ExprList *pList; /* op = IN, EXISTS, SELECT, CASE, FUNCTION, BETWEEN */ + Select *pSelect; /* EP_xIsSelect and op = IN, EXISTS, SELECT */ + } x; + + /* If the EP_Reduced flag is set in the Expr.flags mask, then no + ** space is allocated for the fields below this point. An attempt to + ** access them will result in a segfault or malfunction. + *********************************************************************/ + +#if SQLITE_MAX_EXPR_DEPTH>0 + int nHeight; /* Height of the tree headed by this node */ +#endif + int iTable; /* TK_COLUMN: cursor number of table holding column + ** TK_REGISTER: register number + ** TK_TRIGGER: 1 -> new, 0 -> old + ** EP_Unlikely: 134217728 times likelihood + ** TK_IN: ephemerial table holding RHS + ** TK_SELECT_COLUMN: Number of columns on the LHS + ** TK_SELECT: 1st register of result vector */ + ynVar iColumn; /* TK_COLUMN: column index. -1 for rowid. + ** TK_VARIABLE: variable number (always >= 1). + ** TK_SELECT_COLUMN: column of the result vector */ + i16 iAgg; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */ + i16 iRightJoinTable; /* If EP_FromJoin, the right table of the join */ + AggInfo *pAggInfo; /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */ + union { + Table *pTab; /* TK_COLUMN: Table containing column. Can be NULL + ** for a column of an index on an expression */ + Window *pWin; /* EP_WinFunc: Window/Filter defn for a function */ + struct { /* TK_IN, TK_SELECT, and TK_EXISTS */ + int iAddr; /* Subroutine entry address */ + int regReturn; /* Register used to hold return address */ + } sub; + } y; +}; + +/* +** The following are the meanings of bits in the Expr.flags field. +** Value restrictions: +** +** EP_Agg == NC_HasAgg == SF_HasAgg +** EP_Win == NC_HasWin +*/ +#define EP_FromJoin 0x000001 /* Originates in ON/USING clause of outer join */ +#define EP_Distinct 0x000002 /* Aggregate function with DISTINCT keyword */ +#define EP_HasFunc 0x000004 /* Contains one or more functions of any kind */ +#define EP_FixedCol 0x000008 /* TK_Column with a known fixed value */ +#define EP_Agg 0x000010 /* Contains one or more aggregate functions */ +#define EP_VarSelect 0x000020 /* pSelect is correlated, not constant */ +#define EP_DblQuoted 0x000040 /* token.z was originally in "..." */ +#define EP_InfixFunc 0x000080 /* True for an infix function: LIKE, GLOB, etc */ +#define EP_Collate 0x000100 /* Tree contains a TK_COLLATE operator */ +#define EP_Commuted 0x000200 /* Comparison operator has been commuted */ +#define EP_IntValue 0x000400 /* Integer value contained in u.iValue */ +#define EP_xIsSelect 0x000800 /* x.pSelect is valid (otherwise x.pList is) */ +#define EP_Skip 0x001000 /* Operator does not contribute to affinity */ +#define EP_Reduced 0x002000 /* Expr struct EXPR_REDUCEDSIZE bytes only */ +#define EP_TokenOnly 0x004000 /* Expr struct EXPR_TOKENONLYSIZE bytes only */ +#define EP_Win 0x008000 /* Contains window functions */ +#define EP_MemToken 0x010000 /* Need to sqlite3DbFree() Expr.zToken */ +#define EP_IfNullRow 0x020000 /* The TK_IF_NULL_ROW opcode */ +#define EP_Unlikely 0x040000 /* unlikely() or likelihood() function */ +#define EP_ConstFunc 0x080000 /* A SQLITE_FUNC_CONSTANT or _SLOCHNG function */ +#define EP_CanBeNull 0x100000 /* Can be null despite NOT NULL constraint */ +#define EP_Subquery 0x200000 /* Tree contains a TK_SELECT operator */ +#define EP_Alias 0x400000 /* Is an alias for a result set column */ +#define EP_Leaf 0x800000 /* Expr.pLeft, .pRight, .u.pSelect all NULL */ +#define EP_WinFunc 0x1000000 /* TK_FUNCTION with Expr.y.pWin set */ +#define EP_Subrtn 0x2000000 /* Uses Expr.y.sub. TK_IN, _SELECT, or _EXISTS */ +#define EP_Quoted 0x4000000 /* TK_ID was originally quoted */ +#define EP_Static 0x8000000 /* Held in memory not obtained from malloc() */ +#define EP_IsTrue 0x10000000 /* Always has boolean value of TRUE */ +#define EP_IsFalse 0x20000000 /* Always has boolean value of FALSE */ +#define EP_FromDDL 0x40000000 /* Originates from sqlite_schema */ + /* 0x80000000 // Available */ + +/* +** The EP_Propagate mask is a set of properties that automatically propagate +** upwards into parent nodes. +*/ +#define EP_Propagate (EP_Collate|EP_Subquery|EP_HasFunc) + +/* +** These macros can be used to test, set, or clear bits in the +** Expr.flags field. +*/ +#define ExprHasProperty(E,P) (((E)->flags&(P))!=0) +#define ExprHasAllProperty(E,P) (((E)->flags&(P))==(P)) +#define ExprSetProperty(E,P) (E)->flags|=(P) +#define ExprClearProperty(E,P) (E)->flags&=~(P) +#define ExprAlwaysTrue(E) (((E)->flags&(EP_FromJoin|EP_IsTrue))==EP_IsTrue) +#define ExprAlwaysFalse(E) (((E)->flags&(EP_FromJoin|EP_IsFalse))==EP_IsFalse) + + +/* Flags for use with Expr.vvaFlags +*/ +#define EP_NoReduce 0x01 /* Cannot EXPRDUP_REDUCE this Expr */ +#define EP_Immutable 0x02 /* Do not change this Expr node */ + +/* The ExprSetVVAProperty() macro is used for Verification, Validation, +** and Accreditation only. It works like ExprSetProperty() during VVA +** processes but is a no-op for delivery. +*/ +#ifdef SQLITE_DEBUG +# define ExprSetVVAProperty(E,P) (E)->vvaFlags|=(P) +# define ExprHasVVAProperty(E,P) (((E)->vvaFlags&(P))!=0) +# define ExprClearVVAProperties(E) (E)->vvaFlags = 0 +#else +# define ExprSetVVAProperty(E,P) +# define ExprHasVVAProperty(E,P) 0 +# define ExprClearVVAProperties(E) +#endif + +/* +** Macros to determine the number of bytes required by a normal Expr +** struct, an Expr struct with the EP_Reduced flag set in Expr.flags +** and an Expr struct with the EP_TokenOnly flag set. +*/ +#define EXPR_FULLSIZE sizeof(Expr) /* Full size */ +#define EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */ +#define EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */ + +/* +** Flags passed to the sqlite3ExprDup() function. See the header comment +** above sqlite3ExprDup() for details. +*/ +#define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */ + +/* +** True if the expression passed as an argument was a function with +** an OVER() clause (a window function). +*/ +#ifdef SQLITE_OMIT_WINDOWFUNC +# define IsWindowFunc(p) 0 +#else +# define IsWindowFunc(p) ( \ + ExprHasProperty((p), EP_WinFunc) && p->y.pWin->eFrmType!=TK_FILTER \ + ) +#endif + +/* +** A list of expressions. Each expression may optionally have a +** name. An expr/name combination can be used in several ways, such +** as the list of "expr AS ID" fields following a "SELECT" or in the +** list of "ID = expr" items in an UPDATE. A list of expressions can +** also be used as the argument to a function, in which case the a.zName +** field is not used. +** +** In order to try to keep memory usage down, the Expr.a.zEName field +** is used for multiple purposes: +** +** eEName Usage +** ---------- ------------------------- +** ENAME_NAME (1) the AS of result set column +** (2) COLUMN= of an UPDATE +** +** ENAME_TAB DB.TABLE.NAME used to resolve names +** of subqueries +** +** ENAME_SPAN Text of the original result set +** expression. +*/ +struct ExprList { + int nExpr; /* Number of expressions on the list */ + struct ExprList_item { /* For each expression in the list */ + Expr *pExpr; /* The parse tree for this expression */ + char *zEName; /* Token associated with this expression */ + u8 sortFlags; /* Mask of KEYINFO_ORDER_* flags */ + unsigned eEName :2; /* Meaning of zEName */ + unsigned done :1; /* A flag to indicate when processing is finished */ + unsigned reusable :1; /* Constant expression is reusable */ + unsigned bSorterRef :1; /* Defer evaluation until after sorting */ + unsigned bNulls: 1; /* True if explicit "NULLS FIRST/LAST" */ + union { + struct { + u16 iOrderByCol; /* For ORDER BY, column number in result set */ + u16 iAlias; /* Index into Parse.aAlias[] for zName */ + } x; + int iConstExprReg; /* Register in which Expr value is cached */ + } u; + } a[1]; /* One slot for each expression in the list */ +}; + +/* +** Allowed values for Expr.a.eEName +*/ +#define ENAME_NAME 0 /* The AS clause of a result set */ +#define ENAME_SPAN 1 /* Complete text of the result set expression */ +#define ENAME_TAB 2 /* "DB.TABLE.NAME" for the result set */ + +/* +** An instance of this structure can hold a simple list of identifiers, +** such as the list "a,b,c" in the following statements: +** +** INSERT INTO t(a,b,c) VALUES ...; +** CREATE INDEX idx ON t(a,b,c); +** CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...; +** +** The IdList.a.idx field is used when the IdList represents the list of +** column names after a table name in an INSERT statement. In the statement +** +** INSERT INTO t(a,b,c) ... +** +** If "a" is the k-th column of table "t", then IdList.a[0].idx==k. +*/ +struct IdList { + struct IdList_item { + char *zName; /* Name of the identifier */ + int idx; /* Index in some Table.aCol[] of a column named zName */ + } *a; + int nId; /* Number of identifiers on the list */ +}; + +/* +** The following structure describes the FROM clause of a SELECT statement. +** Each table or subquery in the FROM clause is a separate element of +** the SrcList.a[] array. +** +** With the addition of multiple database support, the following structure +** can also be used to describe a particular table such as the table that +** is modified by an INSERT, DELETE, or UPDATE statement. In standard SQL, +** such a table must be a simple name: ID. But in SQLite, the table can +** now be identified by a database name, a dot, then the table name: ID.ID. +** +** The jointype starts out showing the join type between the current table +** and the next table on the list. The parser builds the list this way. +** But sqlite3SrcListShiftJoinType() later shifts the jointypes so that each +** jointype expresses the join between the table and the previous table. +** +** In the colUsed field, the high-order bit (bit 63) is set if the table +** contains more than 63 columns and the 64-th or later column is used. +*/ +struct SrcList { + int nSrc; /* Number of tables or subqueries in the FROM clause */ + u32 nAlloc; /* Number of entries allocated in a[] below */ + struct SrcList_item { + Schema *pSchema; /* Schema to which this item is fixed */ + char *zDatabase; /* Name of database holding this table */ + char *zName; /* Name of the table */ + char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */ + Table *pTab; /* An SQL table corresponding to zName */ + Select *pSelect; /* A SELECT statement used in place of a table name */ + int addrFillSub; /* Address of subroutine to manifest a subquery */ + int regReturn; /* Register holding return address of addrFillSub */ + int regResult; /* Registers holding results of a co-routine */ + struct { + u8 jointype; /* Type of join between this table and the previous */ + unsigned notIndexed :1; /* True if there is a NOT INDEXED clause */ + unsigned isIndexedBy :1; /* True if there is an INDEXED BY clause */ + unsigned isTabFunc :1; /* True if table-valued-function syntax */ + unsigned isCorrelated :1; /* True if sub-query is correlated */ + unsigned viaCoroutine :1; /* Implemented as a co-routine */ + unsigned isRecursive :1; /* True for recursive reference in WITH */ + unsigned fromDDL :1; /* Comes from sqlite_schema */ + } fg; + int iCursor; /* The VDBE cursor number used to access this table */ + Expr *pOn; /* The ON clause of a join */ + IdList *pUsing; /* The USING clause of a join */ + Bitmask colUsed; /* Bit N (1<" clause */ + ExprList *pFuncArg; /* Arguments to table-valued-function */ + } u1; + Index *pIBIndex; /* Index structure corresponding to u1.zIndexedBy */ + } a[1]; /* One entry for each identifier on the list */ +}; + +/* +** Permitted values of the SrcList.a.jointype field +*/ +#define JT_INNER 0x0001 /* Any kind of inner or cross join */ +#define JT_CROSS 0x0002 /* Explicit use of the CROSS keyword */ +#define JT_NATURAL 0x0004 /* True for a "natural" join */ +#define JT_LEFT 0x0008 /* Left outer join */ +#define JT_RIGHT 0x0010 /* Right outer join */ +#define JT_OUTER 0x0020 /* The "OUTER" keyword is present */ +#define JT_ERROR 0x0040 /* unknown or unsupported join type */ + + +/* +** Flags appropriate for the wctrlFlags parameter of sqlite3WhereBegin() +** and the WhereInfo.wctrlFlags member. +** +** Value constraints (enforced via assert()): +** WHERE_USE_LIMIT == SF_FixedLimit +*/ +#define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */ +#define WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */ +#define WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */ +#define WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */ +#define WHERE_ONEPASS_MULTIROW 0x0008 /* ONEPASS is ok with multiple rows */ +#define WHERE_DUPLICATES_OK 0x0010 /* Ok to return a row more than once */ +#define WHERE_OR_SUBCLAUSE 0x0020 /* Processing a sub-WHERE as part of + ** the OR optimization */ +#define WHERE_GROUPBY 0x0040 /* pOrderBy is really a GROUP BY */ +#define WHERE_DISTINCTBY 0x0080 /* pOrderby is really a DISTINCT clause */ +#define WHERE_WANT_DISTINCT 0x0100 /* All output needs to be distinct */ +#define WHERE_SORTBYGROUP 0x0200 /* Support sqlite3WhereIsSorted() */ + /* 0x0400 not currently used */ +#define WHERE_ORDERBY_LIMIT 0x0800 /* ORDERBY+LIMIT on the inner loop */ + /* 0x1000 not currently used */ + /* 0x2000 not currently used */ +#define WHERE_USE_LIMIT 0x4000 /* Use the LIMIT in cost estimates */ + /* 0x8000 not currently used */ + +/* Allowed return values from sqlite3WhereIsDistinct() +*/ +#define WHERE_DISTINCT_NOOP 0 /* DISTINCT keyword not used */ +#define WHERE_DISTINCT_UNIQUE 1 /* No duplicates */ +#define WHERE_DISTINCT_ORDERED 2 /* All duplicates are adjacent */ +#define WHERE_DISTINCT_UNORDERED 3 /* Duplicates are scattered */ + +/* +** A NameContext defines a context in which to resolve table and column +** names. The context consists of a list of tables (the pSrcList) field and +** a list of named expression (pEList). The named expression list may +** be NULL. The pSrc corresponds to the FROM clause of a SELECT or +** to the table being operated on by INSERT, UPDATE, or DELETE. The +** pEList corresponds to the result set of a SELECT and is NULL for +** other statements. +** +** NameContexts can be nested. When resolving names, the inner-most +** context is searched first. If no match is found, the next outer +** context is checked. If there is still no match, the next context +** is checked. This process continues until either a match is found +** or all contexts are check. When a match is found, the nRef member of +** the context containing the match is incremented. +** +** Each subquery gets a new NameContext. The pNext field points to the +** NameContext in the parent query. Thus the process of scanning the +** NameContext list corresponds to searching through successively outer +** subqueries looking for a match. +*/ +struct NameContext { + Parse *pParse; /* The parser */ + SrcList *pSrcList; /* One or more tables used to resolve names */ + union { + ExprList *pEList; /* Optional list of result-set columns */ + AggInfo *pAggInfo; /* Information about aggregates at this level */ + Upsert *pUpsert; /* ON CONFLICT clause information from an upsert */ + } uNC; + NameContext *pNext; /* Next outer name context. NULL for outermost */ + int nRef; /* Number of names resolved by this context */ + int nErr; /* Number of errors encountered while resolving names */ + int ncFlags; /* Zero or more NC_* flags defined below */ + Select *pWinSelect; /* SELECT statement for any window functions */ +}; + +/* +** Allowed values for the NameContext, ncFlags field. +** +** Value constraints (all checked via assert()): +** NC_HasAgg == SF_HasAgg == EP_Agg +** NC_MinMaxAgg == SF_MinMaxAgg == SQLITE_FUNC_MINMAX +** NC_HasWin == EP_Win +** +*/ +#define NC_AllowAgg 0x00001 /* Aggregate functions are allowed here */ +#define NC_PartIdx 0x00002 /* True if resolving a partial index WHERE */ +#define NC_IsCheck 0x00004 /* True if resolving a CHECK constraint */ +#define NC_GenCol 0x00008 /* True for a GENERATED ALWAYS AS clause */ +#define NC_HasAgg 0x00010 /* One or more aggregate functions seen */ +#define NC_IdxExpr 0x00020 /* True if resolving columns of CREATE INDEX */ +#define NC_SelfRef 0x0002e /* Combo: PartIdx, isCheck, GenCol, and IdxExpr */ +#define NC_VarSelect 0x00040 /* A correlated subquery has been seen */ +#define NC_UEList 0x00080 /* True if uNC.pEList is used */ +#define NC_UAggInfo 0x00100 /* True if uNC.pAggInfo is used */ +#define NC_UUpsert 0x00200 /* True if uNC.pUpsert is used */ +#define NC_MinMaxAgg 0x01000 /* min/max aggregates seen. See note above */ +#define NC_Complex 0x02000 /* True if a function or subquery seen */ +#define NC_AllowWin 0x04000 /* Window functions are allowed here */ +#define NC_HasWin 0x08000 /* One or more window functions seen */ +#define NC_IsDDL 0x10000 /* Resolving names in a CREATE statement */ +#define NC_InAggFunc 0x20000 /* True if analyzing arguments to an agg func */ +#define NC_FromDDL 0x40000 /* SQL text comes from sqlite_schema */ + +/* +** An instance of the following object describes a single ON CONFLICT +** clause in an upsert. +** +** The pUpsertTarget field is only set if the ON CONFLICT clause includes +** conflict-target clause. (In "ON CONFLICT(a,b)" the "(a,b)" is the +** conflict-target clause.) The pUpsertTargetWhere is the optional +** WHERE clause used to identify partial unique indexes. +** +** pUpsertSet is the list of column=expr terms of the UPDATE statement. +** The pUpsertSet field is NULL for a ON CONFLICT DO NOTHING. The +** pUpsertWhere is the WHERE clause for the UPDATE and is NULL if the +** WHERE clause is omitted. +*/ +struct Upsert { + ExprList *pUpsertTarget; /* Optional description of conflicting index */ + Expr *pUpsertTargetWhere; /* WHERE clause for partial index targets */ + ExprList *pUpsertSet; /* The SET clause from an ON CONFLICT UPDATE */ + Expr *pUpsertWhere; /* WHERE clause for the ON CONFLICT UPDATE */ + /* The fields above comprise the parse tree for the upsert clause. + ** The fields below are used to transfer information from the INSERT + ** processing down into the UPDATE processing while generating code. + ** Upsert owns the memory allocated above, but not the memory below. */ + Index *pUpsertIdx; /* Constraint that pUpsertTarget identifies */ + SrcList *pUpsertSrc; /* Table to be updated */ + int regData; /* First register holding array of VALUES */ + int iDataCur; /* Index of the data cursor */ + int iIdxCur; /* Index of the first index cursor */ +}; + +/* +** An instance of the following structure contains all information +** needed to generate code for a single SELECT statement. +** +** See the header comment on the computeLimitRegisters() routine for a +** detailed description of the meaning of the iLimit and iOffset fields. +** +** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes. +** These addresses must be stored so that we can go back and fill in +** the P4_KEYINFO and P2 parameters later. Neither the KeyInfo nor +** the number of columns in P2 can be computed at the same time +** as the OP_OpenEphm instruction is coded because not +** enough information about the compound query is known at that point. +** The KeyInfo for addrOpenTran[0] and [1] contains collating sequences +** for the result set. The KeyInfo for addrOpenEphm[2] contains collating +** sequences for the ORDER BY clause. +*/ +struct Select { + u8 op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */ + LogEst nSelectRow; /* Estimated number of result rows */ + u32 selFlags; /* Various SF_* values */ + int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */ + u32 selId; /* Unique identifier number for this SELECT */ + int addrOpenEphm[2]; /* OP_OpenEphem opcodes related to this select */ + ExprList *pEList; /* The fields of the result */ + SrcList *pSrc; /* The FROM clause */ + Expr *pWhere; /* The WHERE clause */ + ExprList *pGroupBy; /* The GROUP BY clause */ + Expr *pHaving; /* The HAVING clause */ + ExprList *pOrderBy; /* The ORDER BY clause */ + Select *pPrior; /* Prior select in a compound select statement */ + Select *pNext; /* Next select to the left in a compound */ + Expr *pLimit; /* LIMIT expression. NULL means not used. */ + With *pWith; /* WITH clause attached to this select. Or NULL. */ +#ifndef SQLITE_OMIT_WINDOWFUNC + Window *pWin; /* List of window functions */ + Window *pWinDefn; /* List of named window definitions */ +#endif +}; + +/* +** Allowed values for Select.selFlags. The "SF" prefix stands for +** "Select Flag". +** +** Value constraints (all checked via assert()) +** SF_HasAgg == NC_HasAgg +** SF_MinMaxAgg == NC_MinMaxAgg == SQLITE_FUNC_MINMAX +** SF_FixedLimit == WHERE_USE_LIMIT +*/ +#define SF_Distinct 0x0000001 /* Output should be DISTINCT */ +#define SF_All 0x0000002 /* Includes the ALL keyword */ +#define SF_Resolved 0x0000004 /* Identifiers have been resolved */ +#define SF_Aggregate 0x0000008 /* Contains agg functions or a GROUP BY */ +#define SF_HasAgg 0x0000010 /* Contains aggregate functions */ +#define SF_UsesEphemeral 0x0000020 /* Uses the OpenEphemeral opcode */ +#define SF_Expanded 0x0000040 /* sqlite3SelectExpand() called on this */ +#define SF_HasTypeInfo 0x0000080 /* FROM subqueries have Table metadata */ +#define SF_Compound 0x0000100 /* Part of a compound query */ +#define SF_Values 0x0000200 /* Synthesized from VALUES clause */ +#define SF_MultiValue 0x0000400 /* Single VALUES term with multiple rows */ +#define SF_NestedFrom 0x0000800 /* Part of a parenthesized FROM clause */ +#define SF_MinMaxAgg 0x0001000 /* Aggregate containing min() or max() */ +#define SF_Recursive 0x0002000 /* The recursive part of a recursive CTE */ +#define SF_FixedLimit 0x0004000 /* nSelectRow set by a constant LIMIT */ +#define SF_MaybeConvert 0x0008000 /* Need convertCompoundSelectToSubquery() */ +#define SF_Converted 0x0010000 /* By convertCompoundSelectToSubquery() */ +#define SF_IncludeHidden 0x0020000 /* Include hidden columns in output */ +#define SF_ComplexResult 0x0040000 /* Result contains subquery or function */ +#define SF_WhereBegin 0x0080000 /* Really a WhereBegin() call. Debug Only */ +#define SF_WinRewrite 0x0100000 /* Window function rewrite accomplished */ +#define SF_View 0x0200000 /* SELECT statement is a view */ +#define SF_NoopOrderBy 0x0400000 /* ORDER BY is ignored for this query */ +#define SF_UpdateFrom 0x0800000 /* Statement is an UPDATE...FROM */ + +/* +** The results of a SELECT can be distributed in several ways, as defined +** by one of the following macros. The "SRT" prefix means "SELECT Result +** Type". +** +** SRT_Union Store results as a key in a temporary index +** identified by pDest->iSDParm. +** +** SRT_Except Remove results from the temporary index pDest->iSDParm. +** +** SRT_Exists Store a 1 in memory cell pDest->iSDParm if the result +** set is not empty. +** +** SRT_Discard Throw the results away. This is used by SELECT +** statements within triggers whose only purpose is +** the side-effects of functions. +** +** SRT_Output Generate a row of output (using the OP_ResultRow +** opcode) for each row in the result set. +** +** SRT_Mem Only valid if the result is a single column. +** Store the first column of the first result row +** in register pDest->iSDParm then abandon the rest +** of the query. This destination implies "LIMIT 1". +** +** SRT_Set The result must be a single column. Store each +** row of result as the key in table pDest->iSDParm. +** Apply the affinity pDest->affSdst before storing +** results. Used to implement "IN (SELECT ...)". +** +** SRT_EphemTab Create an temporary table pDest->iSDParm and store +** the result there. The cursor is left open after +** returning. This is like SRT_Table except that +** this destination uses OP_OpenEphemeral to create +** the table first. +** +** SRT_Coroutine Generate a co-routine that returns a new row of +** results each time it is invoked. The entry point +** of the co-routine is stored in register pDest->iSDParm +** and the result row is stored in pDest->nDest registers +** starting with pDest->iSdst. +** +** SRT_Table Store results in temporary table pDest->iSDParm. +** SRT_Fifo This is like SRT_EphemTab except that the table +** is assumed to already be open. SRT_Fifo has +** the additional property of being able to ignore +** the ORDER BY clause. +** +** SRT_DistFifo Store results in a temporary table pDest->iSDParm. +** But also use temporary table pDest->iSDParm+1 as +** a record of all prior results and ignore any duplicate +** rows. Name means: "Distinct Fifo". +** +** SRT_Queue Store results in priority queue pDest->iSDParm (really +** an index). Append a sequence number so that all entries +** are distinct. +** +** SRT_DistQueue Store results in priority queue pDest->iSDParm only if +** the same record has never been stored before. The +** index at pDest->iSDParm+1 hold all prior stores. +** +** SRT_Upfrom Store results in the temporary table already opened by +** pDest->iSDParm. If (pDest->iSDParm<0), then the temp +** table is an intkey table - in this case the first +** column returned by the SELECT is used as the integer +** key. If (pDest->iSDParm>0), then the table is an index +** table. (pDest->iSDParm) is the number of key columns in +** each index record in this case. +*/ +#define SRT_Union 1 /* Store result as keys in an index */ +#define SRT_Except 2 /* Remove result from a UNION index */ +#define SRT_Exists 3 /* Store 1 if the result is not empty */ +#define SRT_Discard 4 /* Do not save the results anywhere */ +#define SRT_DistFifo 5 /* Like SRT_Fifo, but unique results only */ +#define SRT_DistQueue 6 /* Like SRT_Queue, but unique results only */ + +/* The DISTINCT clause is ignored for all of the above. Not that +** IgnorableDistinct() implies IgnorableOrderby() */ +#define IgnorableDistinct(X) ((X->eDest)<=SRT_DistQueue) + +#define SRT_Queue 7 /* Store result in an queue */ +#define SRT_Fifo 8 /* Store result as data with an automatic rowid */ + +/* The ORDER BY clause is ignored for all of the above */ +#define IgnorableOrderby(X) ((X->eDest)<=SRT_Fifo) + +#define SRT_Output 9 /* Output each row of result */ +#define SRT_Mem 10 /* Store result in a memory cell */ +#define SRT_Set 11 /* Store results as keys in an index */ +#define SRT_EphemTab 12 /* Create transient tab and store like SRT_Table */ +#define SRT_Coroutine 13 /* Generate a single row of result */ +#define SRT_Table 14 /* Store result as data with an automatic rowid */ +#define SRT_Upfrom 15 /* Store result as data with rowid */ + +/* +** An instance of this object describes where to put of the results of +** a SELECT statement. +*/ +struct SelectDest { + u8 eDest; /* How to dispose of the results. One of SRT_* above. */ + int iSDParm; /* A parameter used by the eDest disposal method */ + int iSDParm2; /* A second parameter for the eDest disposal method */ + int iSdst; /* Base register where results are written */ + int nSdst; /* Number of registers allocated */ + char *zAffSdst; /* Affinity used when eDest==SRT_Set */ + ExprList *pOrderBy; /* Key columns for SRT_Queue and SRT_DistQueue */ +}; + +/* +** During code generation of statements that do inserts into AUTOINCREMENT +** tables, the following information is attached to the Table.u.autoInc.p +** pointer of each autoincrement table to record some side information that +** the code generator needs. We have to keep per-table autoincrement +** information in case inserts are done within triggers. Triggers do not +** normally coordinate their activities, but we do need to coordinate the +** loading and saving of autoincrement information. +*/ +struct AutoincInfo { + AutoincInfo *pNext; /* Next info block in a list of them all */ + Table *pTab; /* Table this info block refers to */ + int iDb; /* Index in sqlite3.aDb[] of database holding pTab */ + int regCtr; /* Memory register holding the rowid counter */ +}; + +/* +** At least one instance of the following structure is created for each +** trigger that may be fired while parsing an INSERT, UPDATE or DELETE +** statement. All such objects are stored in the linked list headed at +** Parse.pTriggerPrg and deleted once statement compilation has been +** completed. +** +** A Vdbe sub-program that implements the body and WHEN clause of trigger +** TriggerPrg.pTrigger, assuming a default ON CONFLICT clause of +** TriggerPrg.orconf, is stored in the TriggerPrg.pProgram variable. +** The Parse.pTriggerPrg list never contains two entries with the same +** values for both pTrigger and orconf. +** +** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns +** accessed (or set to 0 for triggers fired as a result of INSERT +** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to +** a mask of new.* columns used by the program. +*/ +struct TriggerPrg { + Trigger *pTrigger; /* Trigger this program was coded from */ + TriggerPrg *pNext; /* Next entry in Parse.pTriggerPrg list */ + SubProgram *pProgram; /* Program implementing pTrigger/orconf */ + int orconf; /* Default ON CONFLICT policy */ + u32 aColmask[2]; /* Masks of old.*, new.* columns accessed */ +}; + +/* +** The yDbMask datatype for the bitmask of all attached databases. +*/ +#if SQLITE_MAX_ATTACHED>30 + typedef unsigned char yDbMask[(SQLITE_MAX_ATTACHED+9)/8]; +# define DbMaskTest(M,I) (((M)[(I)/8]&(1<<((I)&7)))!=0) +# define DbMaskZero(M) memset((M),0,sizeof(M)) +# define DbMaskSet(M,I) (M)[(I)/8]|=(1<<((I)&7)) +# define DbMaskAllZero(M) sqlite3DbMaskAllZero(M) +# define DbMaskNonZero(M) (sqlite3DbMaskAllZero(M)==0) +#else + typedef unsigned int yDbMask; +# define DbMaskTest(M,I) (((M)&(((yDbMask)1)<<(I)))!=0) +# define DbMaskZero(M) (M)=0 +# define DbMaskSet(M,I) (M)|=(((yDbMask)1)<<(I)) +# define DbMaskAllZero(M) (M)==0 +# define DbMaskNonZero(M) (M)!=0 +#endif + +/* +** An SQL parser context. A copy of this structure is passed through +** the parser and down into all the parser action routine in order to +** carry around information that is global to the entire parse. +** +** The structure is divided into two parts. When the parser and code +** generate call themselves recursively, the first part of the structure +** is constant but the second part is reset at the beginning and end of +** each recursion. +** +** The nTableLock and aTableLock variables are only used if the shared-cache +** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are +** used to store the set of table-locks required by the statement being +** compiled. Function sqlite3TableLock() is used to add entries to the +** list. +*/ +struct Parse { + sqlite3 *db; /* The main database structure */ + char *zErrMsg; /* An error message */ + Vdbe *pVdbe; /* An engine for executing database bytecode */ + int rc; /* Return code from execution */ + u8 colNamesSet; /* TRUE after OP_ColumnName has been issued to pVdbe */ + u8 checkSchema; /* Causes schema cookie check after an error */ + u8 nested; /* Number of nested calls to the parser/code generator */ + u8 nTempReg; /* Number of temporary registers in aTempReg[] */ + u8 isMultiWrite; /* True if statement may modify/insert multiple rows */ + u8 mayAbort; /* True if statement may throw an ABORT exception */ + u8 hasCompound; /* Need to invoke convertCompoundSelectToSubquery() */ + u8 okConstFactor; /* OK to factor out constants */ + u8 disableLookaside; /* Number of times lookaside has been disabled */ + u8 disableVtab; /* Disable all virtual tables for this parse */ + int nRangeReg; /* Size of the temporary register block */ + int iRangeReg; /* First register in temporary register block */ + int nErr; /* Number of errors seen */ + int nTab; /* Number of previously allocated VDBE cursors */ + int nMem; /* Number of memory cells used so far */ + int szOpAlloc; /* Bytes of memory space allocated for Vdbe.aOp[] */ + int iSelfTab; /* Table associated with an index on expr, or negative + ** of the base register during check-constraint eval */ + int nLabel; /* The *negative* of the number of labels used */ + int nLabelAlloc; /* Number of slots in aLabel */ + int *aLabel; /* Space to hold the labels */ + ExprList *pConstExpr;/* Constant expressions */ + Token constraintName;/* Name of the constraint currently being parsed */ + yDbMask writeMask; /* Start a write transaction on these databases */ + yDbMask cookieMask; /* Bitmask of schema verified databases */ + int regRowid; /* Register holding rowid of CREATE TABLE entry */ + int regRoot; /* Register holding root page number for new objects */ + int nMaxArg; /* Max args passed to user function by sub-program */ + int nSelect; /* Number of SELECT stmts. Counter for Select.selId */ +#ifndef SQLITE_OMIT_SHARED_CACHE + int nTableLock; /* Number of locks in aTableLock */ + TableLock *aTableLock; /* Required table locks for shared-cache mode */ +#endif + AutoincInfo *pAinc; /* Information about AUTOINCREMENT counters */ + Parse *pToplevel; /* Parse structure for main program (or NULL) */ + Table *pTriggerTab; /* Table triggers are being coded for */ + Parse *pParentParse; /* Parent parser if this parser is nested */ + AggInfo *pAggList; /* List of all AggInfo objects */ + int addrCrTab; /* Address of OP_CreateBtree opcode on CREATE TABLE */ + u32 nQueryLoop; /* Est number of iterations of a query (10*log2(N)) */ + u32 oldmask; /* Mask of old.* columns referenced */ + u32 newmask; /* Mask of new.* columns referenced */ + u8 eTriggerOp; /* TK_UPDATE, TK_INSERT or TK_DELETE */ + u8 eOrconf; /* Default ON CONFLICT policy for trigger steps */ + u8 disableTriggers; /* True to disable triggers */ + + /************************************************************************** + ** Fields above must be initialized to zero. The fields that follow, + ** down to the beginning of the recursive section, do not need to be + ** initialized as they will be set before being used. The boundary is + ** determined by offsetof(Parse,aTempReg). + **************************************************************************/ + + int aTempReg[8]; /* Holding area for temporary registers */ + Token sNameToken; /* Token with unqualified schema object name */ + + /************************************************************************ + ** Above is constant between recursions. Below is reset before and after + ** each recursion. The boundary between these two regions is determined + ** using offsetof(Parse,sLastToken) so the sLastToken field must be the + ** first field in the recursive region. + ************************************************************************/ + + Token sLastToken; /* The last token parsed */ + ynVar nVar; /* Number of '?' variables seen in the SQL so far */ + u8 iPkSortOrder; /* ASC or DESC for INTEGER PRIMARY KEY */ + u8 explain; /* True if the EXPLAIN flag is found on the query */ + u8 eParseMode; /* PARSE_MODE_XXX constant */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + int nVtabLock; /* Number of virtual tables to lock */ +#endif + int nHeight; /* Expression tree height of current sub-select */ +#ifndef SQLITE_OMIT_EXPLAIN + int addrExplain; /* Address of current OP_Explain opcode */ +#endif + VList *pVList; /* Mapping between variable names and numbers */ + Vdbe *pReprepare; /* VM being reprepared (sqlite3Reprepare()) */ + const char *zTail; /* All SQL text past the last semicolon parsed */ + Table *pNewTable; /* A table being constructed by CREATE TABLE */ + Index *pNewIndex; /* An index being constructed by CREATE INDEX. + ** Also used to hold redundant UNIQUE constraints + ** during a RENAME COLUMN */ + Trigger *pNewTrigger; /* Trigger under construct by a CREATE TRIGGER */ + const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + Token sArg; /* Complete text of a module argument */ + Table **apVtabLock; /* Pointer to virtual tables needing locking */ +#endif + Table *pZombieTab; /* List of Table objects to delete after code gen */ + TriggerPrg *pTriggerPrg; /* Linked list of coded triggers */ + With *pWith; /* Current WITH clause, or NULL */ + With *pWithToFree; /* Free this WITH object at the end of the parse */ +#ifndef SQLITE_OMIT_ALTERTABLE + RenameToken *pRename; /* Tokens subject to renaming by ALTER TABLE */ +#endif +}; + +#define PARSE_MODE_NORMAL 0 +#define PARSE_MODE_DECLARE_VTAB 1 +#define PARSE_MODE_RENAME 2 +#define PARSE_MODE_UNMAP 3 + +/* +** Sizes and pointers of various parts of the Parse object. +*/ +#define PARSE_HDR_SZ offsetof(Parse,aTempReg) /* Recursive part w/o aColCache*/ +#define PARSE_RECURSE_SZ offsetof(Parse,sLastToken) /* Recursive part */ +#define PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */ +#define PARSE_TAIL(X) (((char*)(X))+PARSE_RECURSE_SZ) /* Pointer to tail */ + +/* +** Return true if currently inside an sqlite3_declare_vtab() call. +*/ +#ifdef SQLITE_OMIT_VIRTUALTABLE + #define IN_DECLARE_VTAB 0 +#else + #define IN_DECLARE_VTAB (pParse->eParseMode==PARSE_MODE_DECLARE_VTAB) +#endif + +#if defined(SQLITE_OMIT_ALTERTABLE) + #define IN_RENAME_OBJECT 0 +#else + #define IN_RENAME_OBJECT (pParse->eParseMode>=PARSE_MODE_RENAME) +#endif + +#if defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_OMIT_ALTERTABLE) + #define IN_SPECIAL_PARSE 0 +#else + #define IN_SPECIAL_PARSE (pParse->eParseMode!=PARSE_MODE_NORMAL) +#endif + +/* +** An instance of the following structure can be declared on a stack and used +** to save the Parse.zAuthContext value so that it can be restored later. +*/ +struct AuthContext { + const char *zAuthContext; /* Put saved Parse.zAuthContext here */ + Parse *pParse; /* The Parse structure */ +}; + +/* +** Bitfield flags for P5 value in various opcodes. +** +** Value constraints (enforced via assert()): +** OPFLAG_LENGTHARG == SQLITE_FUNC_LENGTH +** OPFLAG_TYPEOFARG == SQLITE_FUNC_TYPEOF +** OPFLAG_BULKCSR == BTREE_BULKLOAD +** OPFLAG_SEEKEQ == BTREE_SEEK_EQ +** OPFLAG_FORDELETE == BTREE_FORDELETE +** OPFLAG_SAVEPOSITION == BTREE_SAVEPOSITION +** OPFLAG_AUXDELETE == BTREE_AUXDELETE +*/ +#define OPFLAG_NCHANGE 0x01 /* OP_Insert: Set to update db->nChange */ + /* Also used in P2 (not P5) of OP_Delete */ +#define OPFLAG_NOCHNG 0x01 /* OP_VColumn nochange for UPDATE */ +#define OPFLAG_EPHEM 0x01 /* OP_Column: Ephemeral output is ok */ +#define OPFLAG_LASTROWID 0x20 /* Set to update db->lastRowid */ +#define OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */ +#define OPFLAG_APPEND 0x08 /* This is likely to be an append */ +#define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */ +#define OPFLAG_ISNOOP 0x40 /* OP_Delete does pre-update-hook only */ +#define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */ +#define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */ +#define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */ +#define OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */ +#define OPFLAG_FORDELETE 0x08 /* OP_Open should use BTREE_FORDELETE */ +#define OPFLAG_P2ISREG 0x10 /* P2 to OP_Open** is a register number */ +#define OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */ +#define OPFLAG_SAVEPOSITION 0x02 /* OP_Delete/Insert: save cursor pos */ +#define OPFLAG_AUXDELETE 0x04 /* OP_Delete: index in a DELETE op */ +#define OPFLAG_NOCHNG_MAGIC 0x6d /* OP_MakeRecord: serialtype 10 is ok */ + +/* + * Each trigger present in the database schema is stored as an instance of + * struct Trigger. + * + * Pointers to instances of struct Trigger are stored in two ways. + * 1. In the "trigHash" hash table (part of the sqlite3* that represents the + * database). This allows Trigger structures to be retrieved by name. + * 2. All triggers associated with a single table form a linked list, using the + * pNext member of struct Trigger. A pointer to the first element of the + * linked list is stored as the "pTrigger" member of the associated + * struct Table. + * + * The "step_list" member points to the first element of a linked list + * containing the SQL statements specified as the trigger program. + */ +struct Trigger { + char *zName; /* The name of the trigger */ + char *table; /* The table or view to which the trigger applies */ + u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */ + u8 tr_tm; /* One of TRIGGER_BEFORE, TRIGGER_AFTER */ + Expr *pWhen; /* The WHEN clause of the expression (may be NULL) */ + IdList *pColumns; /* If this is an UPDATE OF trigger, + the is stored here */ + Schema *pSchema; /* Schema containing the trigger */ + Schema *pTabSchema; /* Schema containing the table */ + TriggerStep *step_list; /* Link list of trigger program steps */ + Trigger *pNext; /* Next trigger associated with the table */ +}; + +/* +** A trigger is either a BEFORE or an AFTER trigger. The following constants +** determine which. +** +** If there are multiple triggers, you might of some BEFORE and some AFTER. +** In that cases, the constants below can be ORed together. +*/ +#define TRIGGER_BEFORE 1 +#define TRIGGER_AFTER 2 + +/* + * An instance of struct TriggerStep is used to store a single SQL statement + * that is a part of a trigger-program. + * + * Instances of struct TriggerStep are stored in a singly linked list (linked + * using the "pNext" member) referenced by the "step_list" member of the + * associated struct Trigger instance. The first element of the linked list is + * the first step of the trigger-program. + * + * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or + * "SELECT" statement. The meanings of the other members is determined by the + * value of "op" as follows: + * + * (op == TK_INSERT) + * orconf -> stores the ON CONFLICT algorithm + * pSelect -> If this is an INSERT INTO ... SELECT ... statement, then + * this stores a pointer to the SELECT statement. Otherwise NULL. + * zTarget -> Dequoted name of the table to insert into. + * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then + * this stores values to be inserted. Otherwise NULL. + * pIdList -> If this is an INSERT INTO ... () VALUES ... + * statement, then this stores the column-names to be + * inserted into. + * + * (op == TK_DELETE) + * zTarget -> Dequoted name of the table to delete from. + * pWhere -> The WHERE clause of the DELETE statement if one is specified. + * Otherwise NULL. + * + * (op == TK_UPDATE) + * zTarget -> Dequoted name of the table to update. + * pWhere -> The WHERE clause of the UPDATE statement if one is specified. + * Otherwise NULL. + * pExprList -> A list of the columns to update and the expressions to update + * them to. See sqlite3Update() documentation of "pChanges" + * argument. + * + */ +struct TriggerStep { + u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */ + u8 orconf; /* OE_Rollback etc. */ + Trigger *pTrig; /* The trigger that this step is a part of */ + Select *pSelect; /* SELECT statement or RHS of INSERT INTO SELECT ... */ + char *zTarget; /* Target table for DELETE, UPDATE, INSERT */ + SrcList *pFrom; /* FROM clause for UPDATE statement (if any) */ + Expr *pWhere; /* The WHERE clause for DELETE or UPDATE steps */ + ExprList *pExprList; /* SET clause for UPDATE */ + IdList *pIdList; /* Column names for INSERT */ + Upsert *pUpsert; /* Upsert clauses on an INSERT */ + char *zSpan; /* Original SQL text of this command */ + TriggerStep *pNext; /* Next in the link-list */ + TriggerStep *pLast; /* Last element in link-list. Valid for 1st elem only */ +}; + +/* +** The following structure contains information used by the sqliteFix... +** routines as they walk the parse tree to make database references +** explicit. +*/ +typedef struct DbFixer DbFixer; +struct DbFixer { + Parse *pParse; /* The parsing context. Error messages written here */ + Schema *pSchema; /* Fix items to this schema */ + u8 bTemp; /* True for TEMP schema entries */ + const char *zDb; /* Make sure all objects are contained in this database */ + const char *zType; /* Type of the container - used for error messages */ + const Token *pName; /* Name of the container - used for error messages */ +}; + +/* +** An objected used to accumulate the text of a string where we +** do not necessarily know how big the string will be in the end. +*/ +struct sqlite3_str { + sqlite3 *db; /* Optional database for lookaside. Can be NULL */ + char *zText; /* The string collected so far */ + u32 nAlloc; /* Amount of space allocated in zText */ + u32 mxAlloc; /* Maximum allowed allocation. 0 for no malloc usage */ + u32 nChar; /* Length of the string so far */ + u8 accError; /* SQLITE_NOMEM or SQLITE_TOOBIG */ + u8 printfFlags; /* SQLITE_PRINTF flags below */ +}; +#define SQLITE_PRINTF_INTERNAL 0x01 /* Internal-use-only converters allowed */ +#define SQLITE_PRINTF_SQLFUNC 0x02 /* SQL function arguments to VXPrintf */ +#define SQLITE_PRINTF_MALLOCED 0x04 /* True if xText is allocated space */ + +#define isMalloced(X) (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0) + + +/* +** A pointer to this structure is used to communicate information +** from sqlite3Init and OP_ParseSchema into the sqlite3InitCallback. +*/ +typedef struct { + sqlite3 *db; /* The database being initialized */ + char **pzErrMsg; /* Error message stored here */ + int iDb; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */ + int rc; /* Result code stored here */ + u32 mInitFlags; /* Flags controlling error messages */ + u32 nInitRow; /* Number of rows processed */ + Pgno mxPage; /* Maximum page number. 0 for no limit. */ +} InitData; + +/* +** Allowed values for mInitFlags +*/ +#define INITFLAG_AlterTable 0x0001 /* This is a reparse after ALTER TABLE */ + +/* +** Structure containing global configuration data for the SQLite library. +** +** This structure also contains some state information. +*/ +struct Sqlite3Config { + int bMemstat; /* True to enable memory status */ + u8 bCoreMutex; /* True to enable core mutexing */ + u8 bFullMutex; /* True to enable full mutexing */ + u8 bOpenUri; /* True to interpret filenames as URIs */ + u8 bUseCis; /* Use covering indices for full-scans */ + u8 bSmallMalloc; /* Avoid large memory allocations if true */ + u8 bExtraSchemaChecks; /* Verify type,name,tbl_name in schema */ + int mxStrlen; /* Maximum string length */ + int neverCorrupt; /* Database is always well-formed */ + int szLookaside; /* Default lookaside buffer size */ + int nLookaside; /* Default lookaside buffer count */ + int nStmtSpill; /* Stmt-journal spill-to-disk threshold */ + sqlite3_mem_methods m; /* Low-level memory allocation interface */ + sqlite3_mutex_methods mutex; /* Low-level mutex interface */ + sqlite3_pcache_methods2 pcache2; /* Low-level page-cache interface */ + void *pHeap; /* Heap storage space */ + int nHeap; /* Size of pHeap[] */ + int mnReq, mxReq; /* Min and max heap requests sizes */ + sqlite3_int64 szMmap; /* mmap() space per open file */ + sqlite3_int64 mxMmap; /* Maximum value for szMmap */ + void *pPage; /* Page cache memory */ + int szPage; /* Size of each page in pPage[] */ + int nPage; /* Number of pages in pPage[] */ + int mxParserStack; /* maximum depth of the parser stack */ + int sharedCacheEnabled; /* true if shared-cache mode enabled */ + u32 szPma; /* Maximum Sorter PMA size */ + /* The above might be initialized to non-zero. The following need to always + ** initially be zero, however. */ + int isInit; /* True after initialization has finished */ + int inProgress; /* True while initialization in progress */ + int isMutexInit; /* True after mutexes are initialized */ + int isMallocInit; /* True after malloc is initialized */ + int isPCacheInit; /* True after malloc is initialized */ + int nRefInitMutex; /* Number of users of pInitMutex */ + sqlite3_mutex *pInitMutex; /* Mutex used by sqlite3_initialize() */ + void (*xLog)(void*,int,const char*); /* Function for logging */ + void *pLogArg; /* First argument to xLog() */ +#ifdef SQLITE_ENABLE_SQLLOG + void(*xSqllog)(void*,sqlite3*,const char*, int); + void *pSqllogArg; +#endif +#ifdef SQLITE_VDBE_COVERAGE + /* The following callback (if not NULL) is invoked on every VDBE branch + ** operation. Set the callback using SQLITE_TESTCTRL_VDBE_COVERAGE. + */ + void (*xVdbeBranch)(void*,unsigned iSrcLine,u8 eThis,u8 eMx); /* Callback */ + void *pVdbeBranchArg; /* 1st argument */ +#endif +#ifdef SQLITE_ENABLE_DESERIALIZE + sqlite3_int64 mxMemdbSize; /* Default max memdb size */ +#endif +#ifndef SQLITE_UNTESTABLE + int (*xTestCallback)(int); /* Invoked by sqlite3FaultSim() */ +#endif + int bLocaltimeFault; /* True to fail localtime() calls */ + int iOnceResetThreshold; /* When to reset OP_Once counters */ + u32 szSorterRef; /* Min size in bytes to use sorter-refs */ + unsigned int iPrngSeed; /* Alternative fixed seed for the PRNG */ +}; + +/* +** This macro is used inside of assert() statements to indicate that +** the assert is only valid on a well-formed database. Instead of: +** +** assert( X ); +** +** One writes: +** +** assert( X || CORRUPT_DB ); +** +** CORRUPT_DB is true during normal operation. CORRUPT_DB does not indicate +** that the database is definitely corrupt, only that it might be corrupt. +** For most test cases, CORRUPT_DB is set to false using a special +** sqlite3_test_control(). This enables assert() statements to prove +** things that are always true for well-formed databases. +*/ +#define CORRUPT_DB (sqlite3Config.neverCorrupt==0) + +/* +** Context pointer passed down through the tree-walk. +*/ +struct Walker { + Parse *pParse; /* Parser context. */ + int (*xExprCallback)(Walker*, Expr*); /* Callback for expressions */ + int (*xSelectCallback)(Walker*,Select*); /* Callback for SELECTs */ + void (*xSelectCallback2)(Walker*,Select*);/* Second callback for SELECTs */ + int walkerDepth; /* Number of subqueries */ + u16 eCode; /* A small processing code */ + union { /* Extra data for callback */ + NameContext *pNC; /* Naming context */ + int n; /* A counter */ + int iCur; /* A cursor number */ + SrcList *pSrcList; /* FROM clause */ + struct SrcCount *pSrcCount; /* Counting column references */ + struct CCurHint *pCCurHint; /* Used by codeCursorHint() */ + int *aiCol; /* array of column indexes */ + struct IdxCover *pIdxCover; /* Check for index coverage */ + struct IdxExprTrans *pIdxTrans; /* Convert idxed expr to column */ + ExprList *pGroupBy; /* GROUP BY clause */ + Select *pSelect; /* HAVING to WHERE clause ctx */ + struct WindowRewrite *pRewrite; /* Window rewrite context */ + struct WhereConst *pConst; /* WHERE clause constants */ + struct RenameCtx *pRename; /* RENAME COLUMN context */ + struct Table *pTab; /* Table of generated column */ + struct SrcList_item *pSrcItem; /* A single FROM clause item */ + } u; +}; + +/* Forward declarations */ +SQLITE_PRIVATE int sqlite3WalkExpr(Walker*, Expr*); +SQLITE_PRIVATE int sqlite3WalkExprList(Walker*, ExprList*); +SQLITE_PRIVATE int sqlite3WalkSelect(Walker*, Select*); +SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker*, Select*); +SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker*, Select*); +SQLITE_PRIVATE int sqlite3ExprWalkNoop(Walker*, Expr*); +SQLITE_PRIVATE int sqlite3SelectWalkNoop(Walker*, Select*); +SQLITE_PRIVATE int sqlite3SelectWalkFail(Walker*, Select*); +SQLITE_PRIVATE int sqlite3WalkerDepthIncrease(Walker*,Select*); +SQLITE_PRIVATE void sqlite3WalkerDepthDecrease(Walker*,Select*); + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE void sqlite3SelectWalkAssert2(Walker*, Select*); +#endif + +/* +** Return code from the parse-tree walking primitives and their +** callbacks. +*/ +#define WRC_Continue 0 /* Continue down into children */ +#define WRC_Prune 1 /* Omit children but continue walking siblings */ +#define WRC_Abort 2 /* Abandon the tree walk */ + +/* +** An instance of this structure represents a set of one or more CTEs +** (common table expressions) created by a single WITH clause. +*/ +struct With { + int nCte; /* Number of CTEs in the WITH clause */ + With *pOuter; /* Containing WITH clause, or NULL */ + struct Cte { /* For each CTE in the WITH clause.... */ + char *zName; /* Name of this CTE */ + ExprList *pCols; /* List of explicit column names, or NULL */ + Select *pSelect; /* The definition of this CTE */ + const char *zCteErr; /* Error message for circular references */ + } a[1]; +}; + +#ifdef SQLITE_DEBUG +/* +** An instance of the TreeView object is used for printing the content of +** data structures on sqlite3DebugPrintf() using a tree-like view. +*/ +struct TreeView { + int iLevel; /* Which level of the tree we are on */ + u8 bLine[100]; /* Draw vertical in column i if bLine[i] is true */ +}; +#endif /* SQLITE_DEBUG */ + +/* +** This object is used in various ways, most (but not all) related to window +** functions. +** +** (1) A single instance of this structure is attached to the +** the Expr.y.pWin field for each window function in an expression tree. +** This object holds the information contained in the OVER clause, +** plus additional fields used during code generation. +** +** (2) All window functions in a single SELECT form a linked-list +** attached to Select.pWin. The Window.pFunc and Window.pExpr +** fields point back to the expression that is the window function. +** +** (3) The terms of the WINDOW clause of a SELECT are instances of this +** object on a linked list attached to Select.pWinDefn. +** +** (4) For an aggregate function with a FILTER clause, an instance +** of this object is stored in Expr.y.pWin with eFrmType set to +** TK_FILTER. In this case the only field used is Window.pFilter. +** +** The uses (1) and (2) are really the same Window object that just happens +** to be accessible in two different ways. Use case (3) are separate objects. +*/ +struct Window { + char *zName; /* Name of window (may be NULL) */ + char *zBase; /* Name of base window for chaining (may be NULL) */ + ExprList *pPartition; /* PARTITION BY clause */ + ExprList *pOrderBy; /* ORDER BY clause */ + u8 eFrmType; /* TK_RANGE, TK_GROUPS, TK_ROWS, or 0 */ + u8 eStart; /* UNBOUNDED, CURRENT, PRECEDING or FOLLOWING */ + u8 eEnd; /* UNBOUNDED, CURRENT, PRECEDING or FOLLOWING */ + u8 bImplicitFrame; /* True if frame was implicitly specified */ + u8 eExclude; /* TK_NO, TK_CURRENT, TK_TIES, TK_GROUP, or 0 */ + Expr *pStart; /* Expression for " PRECEDING" */ + Expr *pEnd; /* Expression for " FOLLOWING" */ + Window **ppThis; /* Pointer to this object in Select.pWin list */ + Window *pNextWin; /* Next window function belonging to this SELECT */ + Expr *pFilter; /* The FILTER expression */ + FuncDef *pFunc; /* The function */ + int iEphCsr; /* Partition buffer or Peer buffer */ + int regAccum; /* Accumulator */ + int regResult; /* Interim result */ + int csrApp; /* Function cursor (used by min/max) */ + int regApp; /* Function register (also used by min/max) */ + int regPart; /* Array of registers for PARTITION BY values */ + Expr *pOwner; /* Expression object this window is attached to */ + int nBufferCol; /* Number of columns in buffer table */ + int iArgCol; /* Offset of first argument for this function */ + int regOne; /* Register containing constant value 1 */ + int regStartRowid; + int regEndRowid; + u8 bExprArgs; /* Defer evaluation of window function arguments + ** due to the SQLITE_SUBTYPE flag */ +}; + +#ifndef SQLITE_OMIT_WINDOWFUNC +SQLITE_PRIVATE void sqlite3WindowDelete(sqlite3*, Window*); +SQLITE_PRIVATE void sqlite3WindowUnlinkFromSelect(Window*); +SQLITE_PRIVATE void sqlite3WindowListDelete(sqlite3 *db, Window *p); +SQLITE_PRIVATE Window *sqlite3WindowAlloc(Parse*, int, int, Expr*, int , Expr*, u8); +SQLITE_PRIVATE void sqlite3WindowAttach(Parse*, Expr*, Window*); +SQLITE_PRIVATE void sqlite3WindowLink(Select *pSel, Window *pWin); +SQLITE_PRIVATE int sqlite3WindowCompare(Parse*, Window*, Window*, int); +SQLITE_PRIVATE void sqlite3WindowCodeInit(Parse*, Select*); +SQLITE_PRIVATE void sqlite3WindowCodeStep(Parse*, Select*, WhereInfo*, int, int); +SQLITE_PRIVATE int sqlite3WindowRewrite(Parse*, Select*); +SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse*, struct SrcList_item*); +SQLITE_PRIVATE void sqlite3WindowUpdate(Parse*, Window*, Window*, FuncDef*); +SQLITE_PRIVATE Window *sqlite3WindowDup(sqlite3 *db, Expr *pOwner, Window *p); +SQLITE_PRIVATE Window *sqlite3WindowListDup(sqlite3 *db, Window *p); +SQLITE_PRIVATE void sqlite3WindowFunctions(void); +SQLITE_PRIVATE void sqlite3WindowChain(Parse*, Window*, Window*); +SQLITE_PRIVATE Window *sqlite3WindowAssemble(Parse*, Window*, ExprList*, ExprList*, Token*); +#else +# define sqlite3WindowDelete(a,b) +# define sqlite3WindowFunctions() +# define sqlite3WindowAttach(a,b,c) +#endif + +/* +** Assuming zIn points to the first byte of a UTF-8 character, +** advance zIn to point to the first byte of the next UTF-8 character. +*/ +#define SQLITE_SKIP_UTF8(zIn) { \ + if( (*(zIn++))>=0xc0 ){ \ + while( (*zIn & 0xc0)==0x80 ){ zIn++; } \ + } \ +} + +/* +** The SQLITE_*_BKPT macros are substitutes for the error codes with +** the same name but without the _BKPT suffix. These macros invoke +** routines that report the line-number on which the error originated +** using sqlite3_log(). The routines also provide a convenient place +** to set a debugger breakpoint. +*/ +SQLITE_PRIVATE int sqlite3ReportError(int iErr, int lineno, const char *zType); +SQLITE_PRIVATE int sqlite3CorruptError(int); +SQLITE_PRIVATE int sqlite3MisuseError(int); +SQLITE_PRIVATE int sqlite3CantopenError(int); +#define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__) +#define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__) +#define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__) +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3NomemError(int); +SQLITE_PRIVATE int sqlite3IoerrnomemError(int); +# define SQLITE_NOMEM_BKPT sqlite3NomemError(__LINE__) +# define SQLITE_IOERR_NOMEM_BKPT sqlite3IoerrnomemError(__LINE__) +#else +# define SQLITE_NOMEM_BKPT SQLITE_NOMEM +# define SQLITE_IOERR_NOMEM_BKPT SQLITE_IOERR_NOMEM +#endif +#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_CORRUPT_PGNO) +SQLITE_PRIVATE int sqlite3CorruptPgnoError(int,Pgno); +# define SQLITE_CORRUPT_PGNO(P) sqlite3CorruptPgnoError(__LINE__,(P)) +#else +# define SQLITE_CORRUPT_PGNO(P) sqlite3CorruptError(__LINE__) +#endif + +/* +** FTS3 and FTS4 both require virtual table support +*/ +#if defined(SQLITE_OMIT_VIRTUALTABLE) +# undef SQLITE_ENABLE_FTS3 +# undef SQLITE_ENABLE_FTS4 +#endif + +/* +** FTS4 is really an extension for FTS3. It is enabled using the +** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also call +** the SQLITE_ENABLE_FTS4 macro to serve as an alias for SQLITE_ENABLE_FTS3. +*/ +#if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3) +# define SQLITE_ENABLE_FTS3 1 +#endif + +/* +** The ctype.h header is needed for non-ASCII systems. It is also +** needed by FTS3 when FTS3 is included in the amalgamation. +*/ +#if !defined(SQLITE_ASCII) || \ + (defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_AMALGAMATION)) +# include +#endif + +/* +** The following macros mimic the standard library functions toupper(), +** isspace(), isalnum(), isdigit() and isxdigit(), respectively. The +** sqlite versions only work for ASCII characters, regardless of locale. +*/ +#ifdef SQLITE_ASCII +# define sqlite3Toupper(x) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20)) +# define sqlite3Isspace(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x01) +# define sqlite3Isalnum(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x06) +# define sqlite3Isalpha(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x02) +# define sqlite3Isdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x04) +# define sqlite3Isxdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x08) +# define sqlite3Tolower(x) (sqlite3UpperToLower[(unsigned char)(x)]) +# define sqlite3Isquote(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x80) +#else +# define sqlite3Toupper(x) toupper((unsigned char)(x)) +# define sqlite3Isspace(x) isspace((unsigned char)(x)) +# define sqlite3Isalnum(x) isalnum((unsigned char)(x)) +# define sqlite3Isalpha(x) isalpha((unsigned char)(x)) +# define sqlite3Isdigit(x) isdigit((unsigned char)(x)) +# define sqlite3Isxdigit(x) isxdigit((unsigned char)(x)) +# define sqlite3Tolower(x) tolower((unsigned char)(x)) +# define sqlite3Isquote(x) ((x)=='"'||(x)=='\''||(x)=='['||(x)=='`') +#endif +SQLITE_PRIVATE int sqlite3IsIdChar(u8); + +/* +** Internal function prototypes +*/ +SQLITE_PRIVATE int sqlite3StrICmp(const char*,const char*); +SQLITE_PRIVATE int sqlite3Strlen30(const char*); +#define sqlite3Strlen30NN(C) (strlen(C)&0x3fffffff) +SQLITE_PRIVATE char *sqlite3ColumnType(Column*,char*); +#define sqlite3StrNICmp sqlite3_strnicmp + +SQLITE_PRIVATE int sqlite3MallocInit(void); +SQLITE_PRIVATE void sqlite3MallocEnd(void); +SQLITE_PRIVATE void *sqlite3Malloc(u64); +SQLITE_PRIVATE void *sqlite3MallocZero(u64); +SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3*, u64); +SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3*, u64); +SQLITE_PRIVATE void *sqlite3DbMallocRawNN(sqlite3*, u64); +SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3*,const char*); +SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3*,const char*, u64); +SQLITE_PRIVATE char *sqlite3DbSpanDup(sqlite3*,const char*,const char*); +SQLITE_PRIVATE void *sqlite3Realloc(void*, u64); +SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *, void *, u64); +SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *, void *, u64); +SQLITE_PRIVATE void sqlite3DbFree(sqlite3*, void*); +SQLITE_PRIVATE void sqlite3DbFreeNN(sqlite3*, void*); +SQLITE_PRIVATE int sqlite3MallocSize(void*); +SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3*, void*); +SQLITE_PRIVATE void *sqlite3PageMalloc(int); +SQLITE_PRIVATE void sqlite3PageFree(void*); +SQLITE_PRIVATE void sqlite3MemSetDefault(void); +#ifndef SQLITE_UNTESTABLE +SQLITE_PRIVATE void sqlite3BenignMallocHooks(void (*)(void), void (*)(void)); +#endif +SQLITE_PRIVATE int sqlite3HeapNearlyFull(void); + +/* +** On systems with ample stack space and that support alloca(), make +** use of alloca() to obtain space for large automatic objects. By default, +** obtain space from malloc(). +** +** The alloca() routine never returns NULL. This will cause code paths +** that deal with sqlite3StackAlloc() failures to be unreachable. +*/ +#ifdef SQLITE_USE_ALLOCA +# define sqlite3StackAllocRaw(D,N) alloca(N) +# define sqlite3StackAllocZero(D,N) memset(alloca(N), 0, N) +# define sqlite3StackFree(D,P) +#else +# define sqlite3StackAllocRaw(D,N) sqlite3DbMallocRaw(D,N) +# define sqlite3StackAllocZero(D,N) sqlite3DbMallocZero(D,N) +# define sqlite3StackFree(D,P) sqlite3DbFree(D,P) +#endif + +/* Do not allow both MEMSYS5 and MEMSYS3 to be defined together. If they +** are, disable MEMSYS3 +*/ +#ifdef SQLITE_ENABLE_MEMSYS5 +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys5(void); +#undef SQLITE_ENABLE_MEMSYS3 +#endif +#ifdef SQLITE_ENABLE_MEMSYS3 +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys3(void); +#endif + + +#ifndef SQLITE_MUTEX_OMIT +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void); +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void); +SQLITE_PRIVATE sqlite3_mutex *sqlite3MutexAlloc(int); +SQLITE_PRIVATE int sqlite3MutexInit(void); +SQLITE_PRIVATE int sqlite3MutexEnd(void); +#endif +#if !defined(SQLITE_MUTEX_OMIT) && !defined(SQLITE_MUTEX_NOOP) +SQLITE_PRIVATE void sqlite3MemoryBarrier(void); +#else +# define sqlite3MemoryBarrier() +#endif + +SQLITE_PRIVATE sqlite3_int64 sqlite3StatusValue(int); +SQLITE_PRIVATE void sqlite3StatusUp(int, int); +SQLITE_PRIVATE void sqlite3StatusDown(int, int); +SQLITE_PRIVATE void sqlite3StatusHighwater(int, int); +SQLITE_PRIVATE int sqlite3LookasideUsed(sqlite3*,int*); + +/* Access to mutexes used by sqlite3_status() */ +SQLITE_PRIVATE sqlite3_mutex *sqlite3Pcache1Mutex(void); +SQLITE_PRIVATE sqlite3_mutex *sqlite3MallocMutex(void); + +#if defined(SQLITE_ENABLE_MULTITHREADED_CHECKS) && !defined(SQLITE_MUTEX_OMIT) +SQLITE_PRIVATE void sqlite3MutexWarnOnContention(sqlite3_mutex*); +#else +# define sqlite3MutexWarnOnContention(x) +#endif + +#ifndef SQLITE_OMIT_FLOATING_POINT +# define EXP754 (((u64)0x7ff)<<52) +# define MAN754 ((((u64)1)<<52)-1) +# define IsNaN(X) (((X)&EXP754)==EXP754 && ((X)&MAN754)!=0) +SQLITE_PRIVATE int sqlite3IsNaN(double); +#else +# define IsNaN(X) 0 +# define sqlite3IsNaN(X) 0 +#endif + +/* +** An instance of the following structure holds information about SQL +** functions arguments that are the parameters to the printf() function. +*/ +struct PrintfArguments { + int nArg; /* Total number of arguments */ + int nUsed; /* Number of arguments used so far */ + sqlite3_value **apArg; /* The argument values */ +}; + +SQLITE_PRIVATE char *sqlite3MPrintf(sqlite3*,const char*, ...); +SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3*,const char*, va_list); +#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) +SQLITE_PRIVATE void sqlite3DebugPrintf(const char*, ...); +#endif +#if defined(SQLITE_TEST) +SQLITE_PRIVATE void *sqlite3TestTextToPtr(const char*); +#endif + +#if defined(SQLITE_DEBUG) +SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView*, const Expr*, u8); +SQLITE_PRIVATE void sqlite3TreeViewBareExprList(TreeView*, const ExprList*, const char*); +SQLITE_PRIVATE void sqlite3TreeViewExprList(TreeView*, const ExprList*, u8, const char*); +SQLITE_PRIVATE void sqlite3TreeViewSrcList(TreeView*, const SrcList*); +SQLITE_PRIVATE void sqlite3TreeViewSelect(TreeView*, const Select*, u8); +SQLITE_PRIVATE void sqlite3TreeViewWith(TreeView*, const With*, u8); +#ifndef SQLITE_OMIT_WINDOWFUNC +SQLITE_PRIVATE void sqlite3TreeViewWindow(TreeView*, const Window*, u8); +SQLITE_PRIVATE void sqlite3TreeViewWinFunc(TreeView*, const Window*, u8); +#endif +#endif + + +SQLITE_PRIVATE void sqlite3SetString(char **, sqlite3*, const char*); +SQLITE_PRIVATE void sqlite3ErrorMsg(Parse*, const char*, ...); +SQLITE_PRIVATE int sqlite3ErrorToParser(sqlite3*,int); +SQLITE_PRIVATE void sqlite3Dequote(char*); +SQLITE_PRIVATE void sqlite3DequoteExpr(Expr*); +SQLITE_PRIVATE void sqlite3TokenInit(Token*,char*); +SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char*, int); +SQLITE_PRIVATE int sqlite3RunParser(Parse*, const char*, char **); +SQLITE_PRIVATE void sqlite3FinishCoding(Parse*); +SQLITE_PRIVATE int sqlite3GetTempReg(Parse*); +SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse*,int); +SQLITE_PRIVATE int sqlite3GetTempRange(Parse*,int); +SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse*,int,int); +SQLITE_PRIVATE void sqlite3ClearTempRegCache(Parse*); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3NoTempsInRange(Parse*,int,int); +#endif +SQLITE_PRIVATE Expr *sqlite3ExprAlloc(sqlite3*,int,const Token*,int); +SQLITE_PRIVATE Expr *sqlite3Expr(sqlite3*,int,const char*); +SQLITE_PRIVATE void sqlite3ExprAttachSubtrees(sqlite3*,Expr*,Expr*,Expr*); +SQLITE_PRIVATE Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*); +SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse*, Expr*, Select*); +SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse*,Expr*, Expr*); +SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr*); +SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse*,ExprList*, Token*, int); +SQLITE_PRIVATE void sqlite3ExprFunctionUsable(Parse*,Expr*,FuncDef*); +SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse*, Expr*, u32); +SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3*, Expr*); +SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete(Parse*, Expr*); +SQLITE_PRIVATE ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*); +SQLITE_PRIVATE ExprList *sqlite3ExprListAppendVector(Parse*,ExprList*,IdList*,Expr*); +SQLITE_PRIVATE void sqlite3ExprListSetSortOrder(ExprList*,int,int); +SQLITE_PRIVATE void sqlite3ExprListSetName(Parse*,ExprList*,Token*,int); +SQLITE_PRIVATE void sqlite3ExprListSetSpan(Parse*,ExprList*,const char*,const char*); +SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3*, ExprList*); +SQLITE_PRIVATE u32 sqlite3ExprListFlags(const ExprList*); +SQLITE_PRIVATE int sqlite3IndexHasDuplicateRootPage(Index*); +SQLITE_PRIVATE int sqlite3Init(sqlite3*, char**); +SQLITE_PRIVATE int sqlite3InitCallback(void*, int, char**, char**); +SQLITE_PRIVATE int sqlite3InitOne(sqlite3*, int, char**, u32); +SQLITE_PRIVATE void sqlite3Pragma(Parse*,Token*,Token*,Token*,int); +#ifndef SQLITE_OMIT_VIRTUALTABLE +SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3*,const char *zName); +#endif +SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3*); +SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3*,int); +SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3*); +SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3*); +SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3*,Table*); +SQLITE_PRIVATE int sqlite3ColumnsFromExprList(Parse*,ExprList*,i16*,Column**); +SQLITE_PRIVATE void sqlite3SelectAddColumnTypeAndCollation(Parse*,Table*,Select*,char); +SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse*,Select*,char); +SQLITE_PRIVATE void sqlite3OpenSchemaTable(Parse *, int); +SQLITE_PRIVATE Index *sqlite3PrimaryKeyIndex(Table*); +SQLITE_PRIVATE i16 sqlite3TableColumnToIndex(Index*, i16); +#ifdef SQLITE_OMIT_GENERATED_COLUMNS +# define sqlite3TableColumnToStorage(T,X) (X) /* No-op pass-through */ +# define sqlite3StorageColumnToTable(T,X) (X) /* No-op pass-through */ +#else +SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table*, i16); +SQLITE_PRIVATE i16 sqlite3StorageColumnToTable(Table*, i16); +#endif +SQLITE_PRIVATE void sqlite3StartTable(Parse*,Token*,Token*,int,int,int,int); +#if SQLITE_ENABLE_HIDDEN_COLUMNS +SQLITE_PRIVATE void sqlite3ColumnPropertiesFromName(Table*, Column*); +#else +# define sqlite3ColumnPropertiesFromName(T,C) /* no-op */ +#endif +SQLITE_PRIVATE void sqlite3AddColumn(Parse*,Token*,Token*); +SQLITE_PRIVATE void sqlite3AddNotNull(Parse*, int); +SQLITE_PRIVATE void sqlite3AddPrimaryKey(Parse*, ExprList*, int, int, int); +SQLITE_PRIVATE void sqlite3AddCheckConstraint(Parse*, Expr*, const char*, const char*); +SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse*,Expr*,const char*,const char*); +SQLITE_PRIVATE void sqlite3AddCollateType(Parse*, Token*); +SQLITE_PRIVATE void sqlite3AddGenerated(Parse*,Expr*,Token*); +SQLITE_PRIVATE void sqlite3EndTable(Parse*,Token*,Token*,u8,Select*); +SQLITE_PRIVATE int sqlite3ParseUri(const char*,const char*,unsigned int*, + sqlite3_vfs**,char**,char **); +#define sqlite3CodecQueryParameters(A,B,C) 0 +SQLITE_PRIVATE Btree *sqlite3DbNameToBtree(sqlite3*,const char*); + +#ifdef SQLITE_UNTESTABLE +# define sqlite3FaultSim(X) SQLITE_OK +#else +SQLITE_PRIVATE int sqlite3FaultSim(int); +#endif + +SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32); +SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec*, u32); +SQLITE_PRIVATE int sqlite3BitvecTestNotNull(Bitvec*, u32); +SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec*, u32); +SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec*, u32, void*); +SQLITE_PRIVATE void sqlite3BitvecDestroy(Bitvec*); +SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec*); +#ifndef SQLITE_UNTESTABLE +SQLITE_PRIVATE int sqlite3BitvecBuiltinTest(int,int*); +#endif + +SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3*); +SQLITE_PRIVATE void sqlite3RowSetDelete(void*); +SQLITE_PRIVATE void sqlite3RowSetClear(void*); +SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet*, i64); +SQLITE_PRIVATE int sqlite3RowSetTest(RowSet*, int iBatch, i64); +SQLITE_PRIVATE int sqlite3RowSetNext(RowSet*, i64*); + +SQLITE_PRIVATE void sqlite3CreateView(Parse*,Token*,Token*,Token*,ExprList*,Select*,int,int); + +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) +SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse*,Table*); +#else +# define sqlite3ViewGetColumnNames(A,B) 0 +#endif + +#if SQLITE_MAX_ATTACHED>30 +SQLITE_PRIVATE int sqlite3DbMaskAllZero(yDbMask); +#endif +SQLITE_PRIVATE void sqlite3DropTable(Parse*, SrcList*, int, int); +SQLITE_PRIVATE void sqlite3CodeDropTable(Parse*, Table*, int, int); +SQLITE_PRIVATE void sqlite3DeleteTable(sqlite3*, Table*); +SQLITE_PRIVATE void sqlite3FreeIndex(sqlite3*, Index*); +#ifndef SQLITE_OMIT_AUTOINCREMENT +SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse); +SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse); +#else +# define sqlite3AutoincrementBegin(X) +# define sqlite3AutoincrementEnd(X) +#endif +SQLITE_PRIVATE void sqlite3Insert(Parse*, SrcList*, Select*, IdList*, int, Upsert*); +#ifndef SQLITE_OMIT_GENERATED_COLUMNS +SQLITE_PRIVATE void sqlite3ComputeGeneratedColumns(Parse*, int, Table*); +#endif +SQLITE_PRIVATE void *sqlite3ArrayAllocate(sqlite3*,void*,int,int*,int*); +SQLITE_PRIVATE IdList *sqlite3IdListAppend(Parse*, IdList*, Token*); +SQLITE_PRIVATE int sqlite3IdListIndex(IdList*,const char*); +SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(Parse*, SrcList*, int, int); +SQLITE_PRIVATE SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2); +SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(Parse*, SrcList*, Token*, Token*); +SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*, + Token*, Select*, Expr*, IdList*); +SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *); +SQLITE_PRIVATE void sqlite3SrcListFuncArgs(Parse*, SrcList*, ExprList*); +SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *, struct SrcList_item *); +SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList*); +SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse*, SrcList*); +SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3*, IdList*); +SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3*, SrcList*); +SQLITE_PRIVATE Index *sqlite3AllocateIndexObject(sqlite3*,i16,int,char**); +SQLITE_PRIVATE void sqlite3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,int,Token*, + Expr*, int, int, u8); +SQLITE_PRIVATE void sqlite3DropIndex(Parse*, SrcList*, int); +SQLITE_PRIVATE int sqlite3Select(Parse*, Select*, SelectDest*); +SQLITE_PRIVATE Select *sqlite3SelectNew(Parse*,ExprList*,SrcList*,Expr*,ExprList*, + Expr*,ExprList*,u32,Expr*); +SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3*, Select*); +SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse*, SrcList*); +SQLITE_PRIVATE int sqlite3IsReadOnly(Parse*, Table*, int); +SQLITE_PRIVATE void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int); +#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) +SQLITE_PRIVATE Expr *sqlite3LimitWhere(Parse*,SrcList*,Expr*,ExprList*,Expr*,char*); +#endif +SQLITE_PRIVATE void sqlite3DeleteFrom(Parse*, SrcList*, Expr*, ExprList*, Expr*); +SQLITE_PRIVATE void sqlite3Update(Parse*, SrcList*, ExprList*,Expr*,int,ExprList*,Expr*, + Upsert*); +SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(Parse*,SrcList*,Expr*,ExprList*,ExprList*,u16,int); +SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo*); +SQLITE_PRIVATE LogEst sqlite3WhereOutputRowCount(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereIsDistinct(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereIsOrdered(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereOrderByLimitOptLabel(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereIsSorted(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereContinueLabel(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereBreakLabel(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereOkOnePass(WhereInfo*, int*); +#define ONEPASS_OFF 0 /* Use of ONEPASS not allowed */ +#define ONEPASS_SINGLE 1 /* ONEPASS valid for a single row update */ +#define ONEPASS_MULTI 2 /* ONEPASS is valid for multiple rows */ +SQLITE_PRIVATE int sqlite3WhereUsesDeferredSeek(WhereInfo*); +SQLITE_PRIVATE void sqlite3ExprCodeLoadIndexColumn(Parse*, Index*, int, int, int); +SQLITE_PRIVATE int sqlite3ExprCodeGetColumn(Parse*, Table*, int, int, int, u8); +SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int); +SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse*, int, int, int); +SQLITE_PRIVATE void sqlite3ExprCode(Parse*, Expr*, int); +#ifndef SQLITE_OMIT_GENERATED_COLUMNS +SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn(Parse*, Column*, int); +#endif +SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse*, Expr*, int); +SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse*, Expr*, int); +SQLITE_PRIVATE int sqlite3ExprCodeRunJustOnce(Parse*, Expr*, int); +SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse*, Expr*, int*); +SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse*, Expr*, int); +SQLITE_PRIVATE int sqlite3ExprCodeExprList(Parse*, ExprList*, int, int, u8); +#define SQLITE_ECEL_DUP 0x01 /* Deep, not shallow copies */ +#define SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */ +#define SQLITE_ECEL_REF 0x04 /* Use ExprList.u.x.iOrderByCol */ +#define SQLITE_ECEL_OMITREF 0x08 /* Omit if ExprList.u.x.iOrderByCol */ +SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse*, Expr*, int, int); +SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse*, Expr*, int, int); +SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse*, Expr*, int, int); +SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3*,const char*, const char*); +#define LOCATE_VIEW 0x01 +#define LOCATE_NOERR 0x02 +SQLITE_PRIVATE Table *sqlite3LocateTable(Parse*,u32 flags,const char*, const char*); +SQLITE_PRIVATE Table *sqlite3LocateTableItem(Parse*,u32 flags,struct SrcList_item *); +SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3*,const char*, const char*); +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3*,int,const char*); +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3*,int,const char*); +SQLITE_PRIVATE void sqlite3Vacuum(Parse*,Token*,Expr*); +SQLITE_PRIVATE int sqlite3RunVacuum(char**, sqlite3*, int, sqlite3_value*); +SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3*, Token*); +SQLITE_PRIVATE int sqlite3ExprCompare(Parse*,Expr*, Expr*, int); +SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr*, Expr*, int); +SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList*, ExprList*, int); +SQLITE_PRIVATE int sqlite3ExprImpliesExpr(Parse*,Expr*, Expr*, int); +SQLITE_PRIVATE int sqlite3ExprImpliesNonNullRow(Expr*,int); +SQLITE_PRIVATE void sqlite3AggInfoPersistWalkerInit(Walker*,Parse*); +SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*); +SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*); +SQLITE_PRIVATE int sqlite3ExprCoveredByIndex(Expr*, int iCur, Index *pIdx); +SQLITE_PRIVATE int sqlite3FunctionUsesThisSrc(Expr*, SrcList*); +SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse*); +#ifndef SQLITE_UNTESTABLE +SQLITE_PRIVATE void sqlite3PrngSaveState(void); +SQLITE_PRIVATE void sqlite3PrngRestoreState(void); +#endif +SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3*,int); +SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse*, int); +SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse*, const char *zDb); +SQLITE_PRIVATE void sqlite3BeginTransaction(Parse*, int); +SQLITE_PRIVATE void sqlite3EndTransaction(Parse*,int); +SQLITE_PRIVATE void sqlite3Savepoint(Parse*, int, Token*); +SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *); +SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3*); +SQLITE_PRIVATE u32 sqlite3IsTrueOrFalse(const char*); +SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr*); +SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr*); +SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr*); +SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr*); +SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr*, u8); +SQLITE_PRIVATE int sqlite3ExprIsConstantOrGroupBy(Parse*, Expr*, ExprList*); +SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr*,int); +#ifdef SQLITE_ENABLE_CURSOR_HINTS +SQLITE_PRIVATE int sqlite3ExprContainsSubquery(Expr*); +#endif +SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr*, int*); +SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr*); +SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr*, char); +SQLITE_PRIVATE int sqlite3IsRowid(const char*); +SQLITE_PRIVATE void sqlite3GenerateRowDelete( + Parse*,Table*,Trigger*,int,int,int,i16,u8,u8,u8,int); +SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int, int*, int); +SQLITE_PRIVATE int sqlite3GenerateIndexKey(Parse*, Index*, int, int, int, int*,Index*,int); +SQLITE_PRIVATE void sqlite3ResolvePartIdxLabel(Parse*,int); +SQLITE_PRIVATE int sqlite3ExprReferencesUpdatedColumn(Expr*,int*,int); +SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(Parse*,Table*,int*,int,int,int,int, + u8,u8,int,int*,int*,Upsert*); +#ifdef SQLITE_ENABLE_NULL_TRIM +SQLITE_PRIVATE void sqlite3SetMakeRecordP5(Vdbe*,Table*); +#else +# define sqlite3SetMakeRecordP5(A,B) +#endif +SQLITE_PRIVATE void sqlite3CompleteInsertion(Parse*,Table*,int,int,int,int*,int,int,int); +SQLITE_PRIVATE int sqlite3OpenTableAndIndices(Parse*, Table*, int, u8, int, u8*, int*, int*); +SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse*, int, int); +SQLITE_PRIVATE void sqlite3MultiWrite(Parse*); +SQLITE_PRIVATE void sqlite3MayAbort(Parse*); +SQLITE_PRIVATE void sqlite3HaltConstraint(Parse*, int, int, char*, i8, u8); +SQLITE_PRIVATE void sqlite3UniqueConstraint(Parse*, int, Index*); +SQLITE_PRIVATE void sqlite3RowidConstraint(Parse*, int, Table*); +SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3*,Expr*,int); +SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3*,ExprList*,int); +SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3*,SrcList*,int); +SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3*,IdList*); +SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3*,Select*,int); +SQLITE_PRIVATE FuncDef *sqlite3FunctionSearch(int,const char*); +SQLITE_PRIVATE void sqlite3InsertBuiltinFuncs(FuncDef*,int); +SQLITE_PRIVATE FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,u8,u8); +SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void); +SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void); +SQLITE_PRIVATE void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3*); +SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3*); +SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3*); +SQLITE_PRIVATE void sqlite3ChangeCookie(Parse*, int); + +#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) +SQLITE_PRIVATE void sqlite3MaterializeView(Parse*, Table*, Expr*, ExprList*,Expr*,int); +#endif + +#ifndef SQLITE_OMIT_TRIGGER +SQLITE_PRIVATE void sqlite3BeginTrigger(Parse*, Token*,Token*,int,int,IdList*,SrcList*, + Expr*,int, int); +SQLITE_PRIVATE void sqlite3FinishTrigger(Parse*, TriggerStep*, Token*); +SQLITE_PRIVATE void sqlite3DropTrigger(Parse*, SrcList*, int); +SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse*, Trigger*); +SQLITE_PRIVATE Trigger *sqlite3TriggersExist(Parse *, Table*, int, ExprList*, int *pMask); +SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *, Table *); +SQLITE_PRIVATE void sqlite3CodeRowTrigger(Parse*, Trigger *, int, ExprList*, int, Table *, + int, int, int); +SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect(Parse *, Trigger *, Table *, int, int, int); + void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*); +SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3*, TriggerStep*); +SQLITE_PRIVATE TriggerStep *sqlite3TriggerSelectStep(sqlite3*,Select*, + const char*,const char*); +SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep(Parse*,Token*, IdList*, + Select*,u8,Upsert*, + const char*,const char*); +SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(Parse*,Token*,SrcList*,ExprList*, + Expr*, u8, const char*,const char*); +SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep(Parse*,Token*, Expr*, + const char*,const char*); +SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3*, Trigger*); +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3*,int,const char*); +SQLITE_PRIVATE u32 sqlite3TriggerColmask(Parse*,Trigger*,ExprList*,int,int,Table*,int); +SQLITE_PRIVATE SrcList *sqlite3TriggerStepSrc(Parse*, TriggerStep*); +# define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p)) +# define sqlite3IsToplevel(p) ((p)->pToplevel==0) +#else +# define sqlite3TriggersExist(B,C,D,E,F) 0 +# define sqlite3DeleteTrigger(A,B) +# define sqlite3DropTriggerPtr(A,B) +# define sqlite3UnlinkAndDeleteTrigger(A,B,C) +# define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I) +# define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F) +# define sqlite3TriggerList(X, Y) 0 +# define sqlite3ParseToplevel(p) p +# define sqlite3IsToplevel(p) 1 +# define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0 +# define sqlite3TriggerStepSrc(A,B) 0 +#endif + +SQLITE_PRIVATE int sqlite3JoinType(Parse*, Token*, Token*, Token*); +SQLITE_PRIVATE void sqlite3SetJoinExpr(Expr*,int); +SQLITE_PRIVATE void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int); +SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse*, int); +#ifndef SQLITE_OMIT_AUTHORIZATION +SQLITE_PRIVATE void sqlite3AuthRead(Parse*,Expr*,Schema*,SrcList*); +SQLITE_PRIVATE int sqlite3AuthCheck(Parse*,int, const char*, const char*, const char*); +SQLITE_PRIVATE void sqlite3AuthContextPush(Parse*, AuthContext*, const char*); +SQLITE_PRIVATE void sqlite3AuthContextPop(AuthContext*); +SQLITE_PRIVATE int sqlite3AuthReadCol(Parse*, const char *, const char *, int); +#else +# define sqlite3AuthRead(a,b,c,d) +# define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK +# define sqlite3AuthContextPush(a,b,c) +# define sqlite3AuthContextPop(a) ((void)(a)) +#endif +SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName); +SQLITE_PRIVATE void sqlite3Attach(Parse*, Expr*, Expr*, Expr*); +SQLITE_PRIVATE void sqlite3Detach(Parse*, Expr*); +SQLITE_PRIVATE void sqlite3FixInit(DbFixer*, Parse*, int, const char*, const Token*); +SQLITE_PRIVATE int sqlite3FixSrcList(DbFixer*, SrcList*); +SQLITE_PRIVATE int sqlite3FixSelect(DbFixer*, Select*); +SQLITE_PRIVATE int sqlite3FixExpr(DbFixer*, Expr*); +SQLITE_PRIVATE int sqlite3FixExprList(DbFixer*, ExprList*); +SQLITE_PRIVATE int sqlite3FixTriggerStep(DbFixer*, TriggerStep*); +SQLITE_PRIVATE int sqlite3RealSameAsInt(double,sqlite3_int64); +SQLITE_PRIVATE void sqlite3Int64ToText(i64,char*); +SQLITE_PRIVATE int sqlite3AtoF(const char *z, double*, int, u8); +SQLITE_PRIVATE int sqlite3GetInt32(const char *, int*); +SQLITE_PRIVATE int sqlite3GetUInt32(const char*, u32*); +SQLITE_PRIVATE int sqlite3Atoi(const char*); +#ifndef SQLITE_OMIT_UTF16 +SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *pData, int nChar); +#endif +SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *pData, int nByte); +SQLITE_PRIVATE u32 sqlite3Utf8Read(const u8**); +SQLITE_PRIVATE LogEst sqlite3LogEst(u64); +SQLITE_PRIVATE LogEst sqlite3LogEstAdd(LogEst,LogEst); +#ifndef SQLITE_OMIT_VIRTUALTABLE +SQLITE_PRIVATE LogEst sqlite3LogEstFromDouble(double); +#endif +#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \ + defined(SQLITE_ENABLE_STAT4) || \ + defined(SQLITE_EXPLAIN_ESTIMATED_ROWS) +SQLITE_PRIVATE u64 sqlite3LogEstToInt(LogEst); +#endif +SQLITE_PRIVATE VList *sqlite3VListAdd(sqlite3*,VList*,const char*,int,int); +SQLITE_PRIVATE const char *sqlite3VListNumToName(VList*,int); +SQLITE_PRIVATE int sqlite3VListNameToNum(VList*,const char*,int); + +/* +** Routines to read and write variable-length integers. These used to +** be defined locally, but now we use the varint routines in the util.c +** file. +*/ +SQLITE_PRIVATE int sqlite3PutVarint(unsigned char*, u64); +SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *, u64 *); +SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *, u32 *); +SQLITE_PRIVATE int sqlite3VarintLen(u64 v); + +/* +** The common case is for a varint to be a single byte. They following +** macros handle the common case without a procedure call, but then call +** the procedure for larger varints. +*/ +#define getVarint32(A,B) \ + (u8)((*(A)<(u8)0x80)?((B)=(u32)*(A)),1:sqlite3GetVarint32((A),(u32 *)&(B))) +#define getVarint32NR(A,B) \ + B=(u32)*(A);if(B>=0x80)sqlite3GetVarint32((A),(u32*)&(B)) +#define putVarint32(A,B) \ + (u8)(((u32)(B)<(u32)0x80)?(*(A)=(unsigned char)(B)),1:\ + sqlite3PutVarint((A),(B))) +#define getVarint sqlite3GetVarint +#define putVarint sqlite3PutVarint + + +SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3*, Index*); +SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe*, Table*, int); +SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2); +SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity); +SQLITE_PRIVATE char sqlite3TableColumnAffinity(Table*,int); +SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr); +SQLITE_PRIVATE int sqlite3Atoi64(const char*, i64*, int, u8); +SQLITE_PRIVATE int sqlite3DecOrHexToI64(const char*, i64*); +SQLITE_PRIVATE void sqlite3ErrorWithMsg(sqlite3*, int, const char*,...); +SQLITE_PRIVATE void sqlite3Error(sqlite3*,int); +SQLITE_PRIVATE void sqlite3SystemError(sqlite3*,int); +SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3*, const char *z, int n); +SQLITE_PRIVATE u8 sqlite3HexToInt(int h); +SQLITE_PRIVATE int sqlite3TwoPartName(Parse *, Token *, Token *, Token **); + +#if defined(SQLITE_NEED_ERR_NAME) +SQLITE_PRIVATE const char *sqlite3ErrName(int); +#endif + +#ifdef SQLITE_ENABLE_DESERIALIZE +SQLITE_PRIVATE int sqlite3MemdbInit(void); +#endif + +SQLITE_PRIVATE const char *sqlite3ErrStr(int); +SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse); +SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char*,int); +SQLITE_PRIVATE int sqlite3IsBinary(const CollSeq*); +SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName); +SQLITE_PRIVATE void sqlite3SetTextEncoding(sqlite3 *db, u8); +SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr); +SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr); +SQLITE_PRIVATE int sqlite3ExprCollSeqMatch(Parse*,const Expr*,const Expr*); +SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(Parse *pParse, Expr*, const Token*, int); +SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse*,Expr*,const char*); +SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr*); +SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr*); +SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *, CollSeq *); +SQLITE_PRIVATE int sqlite3WritableSchema(sqlite3*); +SQLITE_PRIVATE int sqlite3CheckObjectName(Parse*, const char*,const char*,const char*); +SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *, int); +SQLITE_PRIVATE int sqlite3AddInt64(i64*,i64); +SQLITE_PRIVATE int sqlite3SubInt64(i64*,i64); +SQLITE_PRIVATE int sqlite3MulInt64(i64*,i64); +SQLITE_PRIVATE int sqlite3AbsInt32(int); +#ifdef SQLITE_ENABLE_8_3_NAMES +SQLITE_PRIVATE void sqlite3FileSuffix3(const char*, char*); +#else +# define sqlite3FileSuffix3(X,Y) +#endif +SQLITE_PRIVATE u8 sqlite3GetBoolean(const char *z,u8); + +SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value*, u8); +SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value*, u8); +SQLITE_PRIVATE void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8, + void(*)(void*)); +SQLITE_PRIVATE void sqlite3ValueSetNull(sqlite3_value*); +SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value*); +#ifndef SQLITE_UNTESTABLE +SQLITE_PRIVATE void sqlite3ResultIntReal(sqlite3_context*); +#endif +SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *); +#ifndef SQLITE_OMIT_UTF16 +SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *, const void*, int, u8); +#endif +SQLITE_PRIVATE int sqlite3ValueFromExpr(sqlite3 *, Expr *, u8, u8, sqlite3_value **); +SQLITE_PRIVATE void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8); +#ifndef SQLITE_AMALGAMATION +SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[]; +SQLITE_PRIVATE const char sqlite3StrBINARY[]; +SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[]; +SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[]; +SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config; +SQLITE_PRIVATE FuncDefHash sqlite3BuiltinFunctions; +SQLITE_API extern u32 sqlite3_unsupported_selecttrace; +#ifndef SQLITE_OMIT_WSD +SQLITE_PRIVATE int sqlite3PendingByte; +#endif +#endif /* SQLITE_AMALGAMATION */ +#ifdef VDBE_PROFILE +SQLITE_PRIVATE sqlite3_uint64 sqlite3NProfileCnt; +#endif +SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3*, int, Pgno, Pgno); +SQLITE_PRIVATE void sqlite3Reindex(Parse*, Token*, Token*); +SQLITE_PRIVATE void sqlite3AlterFunctions(void); +SQLITE_PRIVATE void sqlite3AlterRenameTable(Parse*, SrcList*, Token*); +SQLITE_PRIVATE void sqlite3AlterRenameColumn(Parse*, SrcList*, Token*, Token*); +SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *, int *); +SQLITE_PRIVATE void sqlite3NestedParse(Parse*, const char*, ...); +SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3*, int); +SQLITE_PRIVATE void sqlite3CodeRhsOfIN(Parse*, Expr*, int); +SQLITE_PRIVATE int sqlite3CodeSubselect(Parse*, Expr*); +SQLITE_PRIVATE void sqlite3SelectPrep(Parse*, Select*, NameContext*); +SQLITE_PRIVATE void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p); +SQLITE_PRIVATE int sqlite3MatchEName( + const struct ExprList_item*, + const char*, + const char*, + const char* +); +SQLITE_PRIVATE Bitmask sqlite3ExprColUsed(Expr*); +SQLITE_PRIVATE u8 sqlite3StrIHash(const char*); +SQLITE_PRIVATE int sqlite3ResolveExprNames(NameContext*, Expr*); +SQLITE_PRIVATE int sqlite3ResolveExprListNames(NameContext*, ExprList*); +SQLITE_PRIVATE void sqlite3ResolveSelectNames(Parse*, Select*, NameContext*); +SQLITE_PRIVATE int sqlite3ResolveSelfReference(Parse*,Table*,int,Expr*,ExprList*); +SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy(Parse*, Select*, ExprList*, const char*); +SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *, Table *, int, int); +SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *, Token *); +SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *, SrcList *); +SQLITE_PRIVATE void *sqlite3RenameTokenMap(Parse*, void*, Token*); +SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse*, void *pTo, void *pFrom); +SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse*, Expr*); +SQLITE_PRIVATE void sqlite3RenameExprlistUnmap(Parse*, ExprList*); +SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq(Parse*, u8, CollSeq *, const char*); +SQLITE_PRIVATE char sqlite3AffinityType(const char*, Column*); +SQLITE_PRIVATE void sqlite3Analyze(Parse*, Token*, Token*); +SQLITE_PRIVATE int sqlite3InvokeBusyHandler(BusyHandler*); +SQLITE_PRIVATE int sqlite3FindDb(sqlite3*, Token*); +SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *, const char *); +SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3*,int iDB); +SQLITE_PRIVATE void sqlite3DeleteIndexSamples(sqlite3*,Index*); +SQLITE_PRIVATE void sqlite3DefaultRowEst(Index*); +SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3*, int); +SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3*,Expr*,int*,char*); +SQLITE_PRIVATE void sqlite3SchemaClear(void *); +SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *, Btree *); +SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *); +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3*,int,int); +SQLITE_PRIVATE void sqlite3KeyInfoUnref(KeyInfo*); +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoRef(KeyInfo*); +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse*, Index*); +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoFromExprList(Parse*, ExprList*, int, int); +SQLITE_PRIVATE int sqlite3HasExplicitNulls(Parse*, ExprList*); + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3KeyInfoIsWriteable(KeyInfo*); +#endif +SQLITE_PRIVATE int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *, + void (*)(sqlite3_context*,int,sqlite3_value **), + void (*)(sqlite3_context*,int,sqlite3_value **), + void (*)(sqlite3_context*), + void (*)(sqlite3_context*), + void (*)(sqlite3_context*,int,sqlite3_value **), + FuncDestructor *pDestructor +); +SQLITE_PRIVATE void sqlite3NoopDestructor(void*); +SQLITE_PRIVATE void sqlite3OomFault(sqlite3*); +SQLITE_PRIVATE void sqlite3OomClear(sqlite3*); +SQLITE_PRIVATE int sqlite3ApiExit(sqlite3 *db, int); +SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *); + +SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum*, sqlite3*, char*, int, int); +SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum*); +SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest*,int,int); +SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *, SrcList *, int, int); + +SQLITE_PRIVATE void sqlite3BackupRestart(sqlite3_backup *); +SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *); + +#ifndef SQLITE_OMIT_SUBQUERY +SQLITE_PRIVATE int sqlite3ExprCheckIN(Parse*, Expr*); +#else +# define sqlite3ExprCheckIN(x,y) SQLITE_OK +#endif + +#ifdef SQLITE_ENABLE_STAT4 +SQLITE_PRIVATE int sqlite3Stat4ProbeSetValue( + Parse*,Index*,UnpackedRecord**,Expr*,int,int,int*); +SQLITE_PRIVATE int sqlite3Stat4ValueFromExpr(Parse*, Expr*, u8, sqlite3_value**); +SQLITE_PRIVATE void sqlite3Stat4ProbeFree(UnpackedRecord*); +SQLITE_PRIVATE int sqlite3Stat4Column(sqlite3*, const void*, int, int, sqlite3_value**); +SQLITE_PRIVATE char sqlite3IndexColumnAffinity(sqlite3*, Index*, int); +#endif + +/* +** The interface to the LEMON-generated parser +*/ +#ifndef SQLITE_AMALGAMATION +SQLITE_PRIVATE void *sqlite3ParserAlloc(void*(*)(u64), Parse*); +SQLITE_PRIVATE void sqlite3ParserFree(void*, void(*)(void*)); +#endif +SQLITE_PRIVATE void sqlite3Parser(void*, int, Token); +SQLITE_PRIVATE int sqlite3ParserFallback(int); +#ifdef YYTRACKMAXSTACKDEPTH +SQLITE_PRIVATE int sqlite3ParserStackPeak(void*); +#endif + +SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3*); +#ifndef SQLITE_OMIT_LOAD_EXTENSION +SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3*); +#else +# define sqlite3CloseExtensions(X) +#endif + +#ifndef SQLITE_OMIT_SHARED_CACHE +SQLITE_PRIVATE void sqlite3TableLock(Parse *, int, Pgno, u8, const char *); +#else + #define sqlite3TableLock(v,w,x,y,z) +#endif + +#ifdef SQLITE_TEST +SQLITE_PRIVATE int sqlite3Utf8To8(unsigned char*); +#endif + +#ifdef SQLITE_OMIT_VIRTUALTABLE +# define sqlite3VtabClear(Y) +# define sqlite3VtabSync(X,Y) SQLITE_OK +# define sqlite3VtabRollback(X) +# define sqlite3VtabCommit(X) +# define sqlite3VtabInSync(db) 0 +# define sqlite3VtabLock(X) +# define sqlite3VtabUnlock(X) +# define sqlite3VtabModuleUnref(D,X) +# define sqlite3VtabUnlockList(X) +# define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK +# define sqlite3GetVTable(X,Y) ((VTable*)0) +#else +SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table*); +SQLITE_PRIVATE void sqlite3VtabDisconnect(sqlite3 *db, Table *p); +SQLITE_PRIVATE int sqlite3VtabSync(sqlite3 *db, Vdbe*); +SQLITE_PRIVATE int sqlite3VtabRollback(sqlite3 *db); +SQLITE_PRIVATE int sqlite3VtabCommit(sqlite3 *db); +SQLITE_PRIVATE void sqlite3VtabLock(VTable *); +SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *); +SQLITE_PRIVATE void sqlite3VtabModuleUnref(sqlite3*,Module*); +SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3*); +SQLITE_PRIVATE int sqlite3VtabSavepoint(sqlite3 *, int, int); +SQLITE_PRIVATE void sqlite3VtabImportErrmsg(Vdbe*, sqlite3_vtab*); +SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3*, Table*); +SQLITE_PRIVATE Module *sqlite3VtabCreateModule( + sqlite3*, + const char*, + const sqlite3_module*, + void*, + void(*)(void*) + ); +# define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0) +#endif +SQLITE_PRIVATE int sqlite3ReadOnlyShadowTables(sqlite3 *db); +#ifndef SQLITE_OMIT_VIRTUALTABLE +SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName); +SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3*,Table*,const char*); +#else +# define sqlite3ShadowTableName(A,B) 0 +# define sqlite3IsShadowTableOf(A,B,C) 0 +#endif +SQLITE_PRIVATE int sqlite3VtabEponymousTableInit(Parse*,Module*); +SQLITE_PRIVATE void sqlite3VtabEponymousTableClear(sqlite3*,Module*); +SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse*,Table*); +SQLITE_PRIVATE void sqlite3VtabBeginParse(Parse*, Token*, Token*, Token*, int); +SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse*, Token*); +SQLITE_PRIVATE void sqlite3VtabArgInit(Parse*); +SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse*, Token*); +SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3*, int, const char *, char **); +SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse*, Table*); +SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3*, int, const char *); +SQLITE_PRIVATE int sqlite3VtabBegin(sqlite3 *, VTable *); +SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction(sqlite3 *,FuncDef*, int nArg, Expr*); +SQLITE_PRIVATE sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context*); +SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe*, const char*, int); +SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *, sqlite3_stmt *); +SQLITE_PRIVATE void sqlite3ParserReset(Parse*); +#ifdef SQLITE_ENABLE_NORMALIZE +SQLITE_PRIVATE char *sqlite3Normalize(Vdbe*, const char*); +#endif +SQLITE_PRIVATE int sqlite3Reprepare(Vdbe*); +SQLITE_PRIVATE void sqlite3ExprListCheckLength(Parse*, ExprList*, const char*); +SQLITE_PRIVATE CollSeq *sqlite3ExprCompareCollSeq(Parse*,const Expr*); +SQLITE_PRIVATE CollSeq *sqlite3BinaryCompareCollSeq(Parse *, const Expr*, const Expr*); +SQLITE_PRIVATE int sqlite3TempInMemory(const sqlite3*); +SQLITE_PRIVATE const char *sqlite3JournalModename(int); +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3*, int, int, int*, int*); +SQLITE_PRIVATE int sqlite3WalDefaultHook(void*,sqlite3*,const char*,int); +#endif +#ifndef SQLITE_OMIT_CTE +SQLITE_PRIVATE With *sqlite3WithAdd(Parse*,With*,Token*,ExprList*,Select*); +SQLITE_PRIVATE void sqlite3WithDelete(sqlite3*,With*); +SQLITE_PRIVATE void sqlite3WithPush(Parse*, With*, u8); +#else +#define sqlite3WithPush(x,y,z) +#define sqlite3WithDelete(x,y) +#endif +#ifndef SQLITE_OMIT_UPSERT +SQLITE_PRIVATE Upsert *sqlite3UpsertNew(sqlite3*,ExprList*,Expr*,ExprList*,Expr*); +SQLITE_PRIVATE void sqlite3UpsertDelete(sqlite3*,Upsert*); +SQLITE_PRIVATE Upsert *sqlite3UpsertDup(sqlite3*,Upsert*); +SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget(Parse*,SrcList*,Upsert*); +SQLITE_PRIVATE void sqlite3UpsertDoUpdate(Parse*,Upsert*,Table*,Index*,int); +#else +#define sqlite3UpsertNew(v,w,x,y,z) ((Upsert*)0) +#define sqlite3UpsertDelete(x,y) +#define sqlite3UpsertDup(x,y) ((Upsert*)0) +#endif + + +/* Declarations for functions in fkey.c. All of these are replaced by +** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign +** key functionality is available. If OMIT_TRIGGER is defined but +** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In +** this case foreign keys are parsed, but no other functionality is +** provided (enforcement of FK constraints requires the triggers sub-system). +*/ +#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) +SQLITE_PRIVATE void sqlite3FkCheck(Parse*, Table*, int, int, int*, int); +SQLITE_PRIVATE void sqlite3FkDropTable(Parse*, SrcList *, Table*); +SQLITE_PRIVATE void sqlite3FkActions(Parse*, Table*, ExprList*, int, int*, int); +SQLITE_PRIVATE int sqlite3FkRequired(Parse*, Table*, int*, int); +SQLITE_PRIVATE u32 sqlite3FkOldmask(Parse*, Table*); +SQLITE_PRIVATE FKey *sqlite3FkReferences(Table *); +#else + #define sqlite3FkActions(a,b,c,d,e,f) + #define sqlite3FkCheck(a,b,c,d,e,f) + #define sqlite3FkDropTable(a,b,c) + #define sqlite3FkOldmask(a,b) 0 + #define sqlite3FkRequired(a,b,c,d) 0 + #define sqlite3FkReferences(a) 0 +#endif +#ifndef SQLITE_OMIT_FOREIGN_KEY +SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *, Table*); +SQLITE_PRIVATE int sqlite3FkLocateIndex(Parse*,Table*,FKey*,Index**,int**); +#else + #define sqlite3FkDelete(a,b) + #define sqlite3FkLocateIndex(a,b,c,d,e) +#endif + + +/* +** Available fault injectors. Should be numbered beginning with 0. +*/ +#define SQLITE_FAULTINJECTOR_MALLOC 0 +#define SQLITE_FAULTINJECTOR_COUNT 1 + +/* +** The interface to the code in fault.c used for identifying "benign" +** malloc failures. This is only present if SQLITE_UNTESTABLE +** is not defined. +*/ +#ifndef SQLITE_UNTESTABLE +SQLITE_PRIVATE void sqlite3BeginBenignMalloc(void); +SQLITE_PRIVATE void sqlite3EndBenignMalloc(void); +#else + #define sqlite3BeginBenignMalloc() + #define sqlite3EndBenignMalloc() +#endif + +/* +** Allowed return values from sqlite3FindInIndex() +*/ +#define IN_INDEX_ROWID 1 /* Search the rowid of the table */ +#define IN_INDEX_EPH 2 /* Search an ephemeral b-tree */ +#define IN_INDEX_INDEX_ASC 3 /* Existing index ASCENDING */ +#define IN_INDEX_INDEX_DESC 4 /* Existing index DESCENDING */ +#define IN_INDEX_NOOP 5 /* No table available. Use comparisons */ +/* +** Allowed flags for the 3rd parameter to sqlite3FindInIndex(). +*/ +#define IN_INDEX_NOOP_OK 0x0001 /* OK to return IN_INDEX_NOOP */ +#define IN_INDEX_MEMBERSHIP 0x0002 /* IN operator used for membership test */ +#define IN_INDEX_LOOP 0x0004 /* IN operator used as a loop */ +SQLITE_PRIVATE int sqlite3FindInIndex(Parse *, Expr *, u32, int*, int*, int*); + +SQLITE_PRIVATE int sqlite3JournalOpen(sqlite3_vfs *, const char *, sqlite3_file *, int, int); +SQLITE_PRIVATE int sqlite3JournalSize(sqlite3_vfs *); +#if defined(SQLITE_ENABLE_ATOMIC_WRITE) \ + || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE) +SQLITE_PRIVATE int sqlite3JournalCreate(sqlite3_file *); +#endif + +SQLITE_PRIVATE int sqlite3JournalIsInMemory(sqlite3_file *p); +SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *); + +SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p); +#if SQLITE_MAX_EXPR_DEPTH>0 +SQLITE_PRIVATE int sqlite3SelectExprHeight(Select *); +SQLITE_PRIVATE int sqlite3ExprCheckHeight(Parse*, int); +#else + #define sqlite3SelectExprHeight(x) 0 + #define sqlite3ExprCheckHeight(x,y) +#endif + +SQLITE_PRIVATE u32 sqlite3Get4byte(const u8*); +SQLITE_PRIVATE void sqlite3Put4byte(u8*, u32); + +#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY +SQLITE_PRIVATE void sqlite3ConnectionBlocked(sqlite3 *, sqlite3 *); +SQLITE_PRIVATE void sqlite3ConnectionUnlocked(sqlite3 *db); +SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db); +#else + #define sqlite3ConnectionBlocked(x,y) + #define sqlite3ConnectionUnlocked(x) + #define sqlite3ConnectionClosed(x) +#endif + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE void sqlite3ParserTrace(FILE*, char *); +#endif +#if defined(YYCOVERAGE) +SQLITE_PRIVATE int sqlite3ParserCoverage(FILE*); +#endif + +/* +** If the SQLITE_ENABLE IOTRACE exists then the global variable +** sqlite3IoTrace is a pointer to a printf-like routine used to +** print I/O tracing messages. +*/ +#ifdef SQLITE_ENABLE_IOTRACE +# define IOTRACE(A) if( sqlite3IoTrace ){ sqlite3IoTrace A; } +SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe*); +SQLITE_API SQLITE_EXTERN void (SQLITE_CDECL *sqlite3IoTrace)(const char*,...); +#else +# define IOTRACE(A) +# define sqlite3VdbeIOTraceSql(X) +#endif + +/* +** These routines are available for the mem2.c debugging memory allocator +** only. They are used to verify that different "types" of memory +** allocations are properly tracked by the system. +** +** sqlite3MemdebugSetType() sets the "type" of an allocation to one of +** the MEMTYPE_* macros defined below. The type must be a bitmask with +** a single bit set. +** +** sqlite3MemdebugHasType() returns true if any of the bits in its second +** argument match the type set by the previous sqlite3MemdebugSetType(). +** sqlite3MemdebugHasType() is intended for use inside assert() statements. +** +** sqlite3MemdebugNoType() returns true if none of the bits in its second +** argument match the type set by the previous sqlite3MemdebugSetType(). +** +** Perhaps the most important point is the difference between MEMTYPE_HEAP +** and MEMTYPE_LOOKASIDE. If an allocation is MEMTYPE_LOOKASIDE, that means +** it might have been allocated by lookaside, except the allocation was +** too large or lookaside was already full. It is important to verify +** that allocations that might have been satisfied by lookaside are not +** passed back to non-lookaside free() routines. Asserts such as the +** example above are placed on the non-lookaside free() routines to verify +** this constraint. +** +** All of this is no-op for a production build. It only comes into +** play when the SQLITE_MEMDEBUG compile-time option is used. +*/ +#ifdef SQLITE_MEMDEBUG +SQLITE_PRIVATE void sqlite3MemdebugSetType(void*,u8); +SQLITE_PRIVATE int sqlite3MemdebugHasType(void*,u8); +SQLITE_PRIVATE int sqlite3MemdebugNoType(void*,u8); +#else +# define sqlite3MemdebugSetType(X,Y) /* no-op */ +# define sqlite3MemdebugHasType(X,Y) 1 +# define sqlite3MemdebugNoType(X,Y) 1 +#endif +#define MEMTYPE_HEAP 0x01 /* General heap allocations */ +#define MEMTYPE_LOOKASIDE 0x02 /* Heap that might have been lookaside */ +#define MEMTYPE_PCACHE 0x04 /* Page cache allocations */ + +/* +** Threading interface +*/ +#if SQLITE_MAX_WORKER_THREADS>0 +SQLITE_PRIVATE int sqlite3ThreadCreate(SQLiteThread**,void*(*)(void*),void*); +SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread*, void**); +#endif + +#if defined(SQLITE_ENABLE_DBPAGE_VTAB) || defined(SQLITE_TEST) +SQLITE_PRIVATE int sqlite3DbpageRegister(sqlite3*); +#endif +#if defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST) +SQLITE_PRIVATE int sqlite3DbstatRegister(sqlite3*); +#endif + +SQLITE_PRIVATE int sqlite3ExprVectorSize(Expr *pExpr); +SQLITE_PRIVATE int sqlite3ExprIsVector(Expr *pExpr); +SQLITE_PRIVATE Expr *sqlite3VectorFieldSubexpr(Expr*, int); +SQLITE_PRIVATE Expr *sqlite3ExprForVectorField(Parse*,Expr*,int); +SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse*, Expr*); + +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +SQLITE_PRIVATE const char **sqlite3CompileOptions(int *pnOpt); +#endif + +#endif /* SQLITEINT_H */ + +/************** End of sqliteInt.h *******************************************/ +/************** Begin file global.c ******************************************/ +/* +** 2008 June 13 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains definitions of global variables and constants. +*/ +/* #include "sqliteInt.h" */ + +/* An array to map all upper-case characters into their corresponding +** lower-case character. +** +** SQLite only considers US-ASCII (or EBCDIC) characters. We do not +** handle case conversions for the UTF character set since the tables +** involved are nearly as big or bigger than SQLite itself. +*/ +SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[] = { +#ifdef SQLITE_ASCII + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103, + 104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121, + 122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107, + 108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125, + 126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, + 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161, + 162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179, + 180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197, + 198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215, + 216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233, + 234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251, + 252,253,254,255 +#endif +#ifdef SQLITE_EBCDIC + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 0x */ + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */ + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */ + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */ + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */ + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */ + 96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111, /* 6x */ + 112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127, /* 7x */ + 128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */ + 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159, /* 9x */ + 160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */ + 176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */ + 192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */ + 208,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223, /* Dx */ + 224,225,162,163,164,165,166,167,168,169,234,235,236,237,238,239, /* Ex */ + 240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255, /* Fx */ +#endif +}; + +/* +** The following 256 byte lookup table is used to support SQLites built-in +** equivalents to the following standard library functions: +** +** isspace() 0x01 +** isalpha() 0x02 +** isdigit() 0x04 +** isalnum() 0x06 +** isxdigit() 0x08 +** toupper() 0x20 +** SQLite identifier character 0x40 +** Quote character 0x80 +** +** Bit 0x20 is set if the mapped character requires translation to upper +** case. i.e. if the character is a lower-case ASCII character. +** If x is a lower-case ASCII character, then its upper-case equivalent +** is (x - 0x20). Therefore toupper() can be implemented as: +** +** (x & ~(map[x]&0x20)) +** +** The equivalent of tolower() is implemented using the sqlite3UpperToLower[] +** array. tolower() is used more often than toupper() by SQLite. +** +** Bit 0x40 is set if the character is non-alphanumeric and can be used in an +** SQLite identifier. Identifiers are alphanumerics, "_", "$", and any +** non-ASCII UTF character. Hence the test for whether or not a character is +** part of an identifier is 0x46. +*/ +SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[256] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 00..07 ........ */ + 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, /* 08..0f ........ */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 10..17 ........ */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 18..1f ........ */ + 0x01, 0x00, 0x80, 0x00, 0x40, 0x00, 0x00, 0x80, /* 20..27 !"#$%&' */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 28..2f ()*+,-./ */ + 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, /* 30..37 01234567 */ + 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 38..3f 89:;<=>? */ + + 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x02, /* 40..47 @ABCDEFG */ + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* 48..4f HIJKLMNO */ + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* 50..57 PQRSTUVW */ + 0x02, 0x02, 0x02, 0x80, 0x00, 0x00, 0x00, 0x40, /* 58..5f XYZ[\]^_ */ + 0x80, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x22, /* 60..67 `abcdefg */ + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, /* 68..6f hijklmno */ + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, /* 70..77 pqrstuvw */ + 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, /* 78..7f xyz{|}~. */ + + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 80..87 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 88..8f ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 90..97 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 98..9f ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* a0..a7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* a8..af ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* b0..b7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* b8..bf ........ */ + + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* c0..c7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* c8..cf ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* d0..d7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* d8..df ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* e0..e7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* e8..ef ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* f0..f7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40 /* f8..ff ........ */ +}; + +/* EVIDENCE-OF: R-02982-34736 In order to maintain full backwards +** compatibility for legacy applications, the URI filename capability is +** disabled by default. +** +** EVIDENCE-OF: R-38799-08373 URI filenames can be enabled or disabled +** using the SQLITE_USE_URI=1 or SQLITE_USE_URI=0 compile-time options. +** +** EVIDENCE-OF: R-43642-56306 By default, URI handling is globally +** disabled. The default value may be changed by compiling with the +** SQLITE_USE_URI symbol defined. +*/ +#ifndef SQLITE_USE_URI +# define SQLITE_USE_URI 0 +#endif + +/* EVIDENCE-OF: R-38720-18127 The default setting is determined by the +** SQLITE_ALLOW_COVERING_INDEX_SCAN compile-time option, or is "on" if +** that compile-time option is omitted. +*/ +#if !defined(SQLITE_ALLOW_COVERING_INDEX_SCAN) +# define SQLITE_ALLOW_COVERING_INDEX_SCAN 1 +#else +# if !SQLITE_ALLOW_COVERING_INDEX_SCAN +# error "Compile-time disabling of covering index scan using the\ + -DSQLITE_ALLOW_COVERING_INDEX_SCAN=0 option is deprecated.\ + Contact SQLite developers if this is a problem for you, and\ + delete this #error macro to continue with your build." +# endif +#endif + +/* The minimum PMA size is set to this value multiplied by the database +** page size in bytes. +*/ +#ifndef SQLITE_SORTER_PMASZ +# define SQLITE_SORTER_PMASZ 250 +#endif + +/* Statement journals spill to disk when their size exceeds the following +** threshold (in bytes). 0 means that statement journals are created and +** written to disk immediately (the default behavior for SQLite versions +** before 3.12.0). -1 means always keep the entire statement journal in +** memory. (The statement journal is also always held entirely in memory +** if journal_mode=MEMORY or if temp_store=MEMORY, regardless of this +** setting.) +*/ +#ifndef SQLITE_STMTJRNL_SPILL +# define SQLITE_STMTJRNL_SPILL (64*1024) +#endif + +/* +** The default lookaside-configuration, the format "SZ,N". SZ is the +** number of bytes in each lookaside slot (should be a multiple of 8) +** and N is the number of slots. The lookaside-configuration can be +** changed as start-time using sqlite3_config(SQLITE_CONFIG_LOOKASIDE) +** or at run-time for an individual database connection using +** sqlite3_db_config(db, SQLITE_DBCONFIG_LOOKASIDE); +** +** With the two-size-lookaside enhancement, less lookaside is required. +** The default configuration of 1200,40 actually provides 30 1200-byte slots +** and 93 128-byte slots, which is more lookaside than is available +** using the older 1200,100 configuration without two-size-lookaside. +*/ +#ifndef SQLITE_DEFAULT_LOOKASIDE +# ifdef SQLITE_OMIT_TWOSIZE_LOOKASIDE +# define SQLITE_DEFAULT_LOOKASIDE 1200,100 /* 120KB of memory */ +# else +# define SQLITE_DEFAULT_LOOKASIDE 1200,40 /* 48KB of memory */ +# endif +#endif + + +/* The default maximum size of an in-memory database created using +** sqlite3_deserialize() +*/ +#ifndef SQLITE_MEMDB_DEFAULT_MAXSIZE +# define SQLITE_MEMDB_DEFAULT_MAXSIZE 1073741824 +#endif + +/* +** The following singleton contains the global configuration for +** the SQLite library. +*/ +SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config = { + SQLITE_DEFAULT_MEMSTATUS, /* bMemstat */ + 1, /* bCoreMutex */ + SQLITE_THREADSAFE==1, /* bFullMutex */ + SQLITE_USE_URI, /* bOpenUri */ + SQLITE_ALLOW_COVERING_INDEX_SCAN, /* bUseCis */ + 0, /* bSmallMalloc */ + 1, /* bExtraSchemaChecks */ + 0x7ffffffe, /* mxStrlen */ + 0, /* neverCorrupt */ + SQLITE_DEFAULT_LOOKASIDE, /* szLookaside, nLookaside */ + SQLITE_STMTJRNL_SPILL, /* nStmtSpill */ + {0,0,0,0,0,0,0,0}, /* m */ + {0,0,0,0,0,0,0,0,0}, /* mutex */ + {0,0,0,0,0,0,0,0,0,0,0,0,0},/* pcache2 */ + (void*)0, /* pHeap */ + 0, /* nHeap */ + 0, 0, /* mnHeap, mxHeap */ + SQLITE_DEFAULT_MMAP_SIZE, /* szMmap */ + SQLITE_MAX_MMAP_SIZE, /* mxMmap */ + (void*)0, /* pPage */ + 0, /* szPage */ + SQLITE_DEFAULT_PCACHE_INITSZ, /* nPage */ + 0, /* mxParserStack */ + 0, /* sharedCacheEnabled */ + SQLITE_SORTER_PMASZ, /* szPma */ + /* All the rest should always be initialized to zero */ + 0, /* isInit */ + 0, /* inProgress */ + 0, /* isMutexInit */ + 0, /* isMallocInit */ + 0, /* isPCacheInit */ + 0, /* nRefInitMutex */ + 0, /* pInitMutex */ + 0, /* xLog */ + 0, /* pLogArg */ +#ifdef SQLITE_ENABLE_SQLLOG + 0, /* xSqllog */ + 0, /* pSqllogArg */ +#endif +#ifdef SQLITE_VDBE_COVERAGE + 0, /* xVdbeBranch */ + 0, /* pVbeBranchArg */ +#endif +#ifdef SQLITE_ENABLE_DESERIALIZE + SQLITE_MEMDB_DEFAULT_MAXSIZE, /* mxMemdbSize */ +#endif +#ifndef SQLITE_UNTESTABLE + 0, /* xTestCallback */ +#endif + 0, /* bLocaltimeFault */ + 0x7ffffffe, /* iOnceResetThreshold */ + SQLITE_DEFAULT_SORTERREF_SIZE, /* szSorterRef */ + 0, /* iPrngSeed */ +}; + +/* +** Hash table for global functions - functions common to all +** database connections. After initialization, this table is +** read-only. +*/ +SQLITE_PRIVATE FuncDefHash sqlite3BuiltinFunctions; + +#ifdef VDBE_PROFILE +/* +** The following performance counter can be used in place of +** sqlite3Hwtime() for profiling. This is a no-op on standard builds. +*/ +SQLITE_PRIVATE sqlite3_uint64 sqlite3NProfileCnt = 0; +#endif + +/* +** The value of the "pending" byte must be 0x40000000 (1 byte past the +** 1-gibabyte boundary) in a compatible database. SQLite never uses +** the database page that contains the pending byte. It never attempts +** to read or write that page. The pending byte page is set aside +** for use by the VFS layers as space for managing file locks. +** +** During testing, it is often desirable to move the pending byte to +** a different position in the file. This allows code that has to +** deal with the pending byte to run on files that are much smaller +** than 1 GiB. The sqlite3_test_control() interface can be used to +** move the pending byte. +** +** IMPORTANT: Changing the pending byte to any value other than +** 0x40000000 results in an incompatible database file format! +** Changing the pending byte during operation will result in undefined +** and incorrect behavior. +*/ +#ifndef SQLITE_OMIT_WSD +SQLITE_PRIVATE int sqlite3PendingByte = 0x40000000; +#endif + +/* +** Flags for select tracing and the ".selecttrace" macro of the CLI +*/ +SQLITE_API u32 sqlite3_unsupported_selecttrace = 0; + +/* #include "opcodes.h" */ +/* +** Properties of opcodes. The OPFLG_INITIALIZER macro is +** created by mkopcodeh.awk during compilation. Data is obtained +** from the comments following the "case OP_xxxx:" statements in +** the vdbe.c file. +*/ +SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[] = OPFLG_INITIALIZER; + +/* +** Name of the default collating sequence +*/ +SQLITE_PRIVATE const char sqlite3StrBINARY[] = "BINARY"; + +/************** End of global.c **********************************************/ +/************** Begin file status.c ******************************************/ +/* +** 2008 June 18 +** +** 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 module implements the sqlite3_status() interface and related +** functionality. +*/ +/* #include "sqliteInt.h" */ +/************** Include vdbeInt.h in the middle of status.c ******************/ +/************** Begin file vdbeInt.h *****************************************/ +/* +** 2003 September 6 +** +** 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 is the header file for information that is private to the +** VDBE. This information used to all be at the top of the single +** source code file "vdbe.c". When that file became too big (over +** 6000 lines long) it was split up into several smaller files and +** this header information was factored out. +*/ +#ifndef SQLITE_VDBEINT_H +#define SQLITE_VDBEINT_H + +/* +** The maximum number of times that a statement will try to reparse +** itself before giving up and returning SQLITE_SCHEMA. +*/ +#ifndef SQLITE_MAX_SCHEMA_RETRY +# define SQLITE_MAX_SCHEMA_RETRY 50 +#endif + +/* +** VDBE_DISPLAY_P4 is true or false depending on whether or not the +** "explain" P4 display logic is enabled. +*/ +#if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) \ + || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) \ + || defined(SQLITE_ENABLE_BYTECODE_VTAB) +# define VDBE_DISPLAY_P4 1 +#else +# define VDBE_DISPLAY_P4 0 +#endif + +/* +** SQL is translated into a sequence of instructions to be +** executed by a virtual machine. Each instruction is an instance +** of the following structure. +*/ +typedef struct VdbeOp Op; + +/* +** Boolean values +*/ +typedef unsigned Bool; + +/* Opaque type used by code in vdbesort.c */ +typedef struct VdbeSorter VdbeSorter; + +/* Elements of the linked list at Vdbe.pAuxData */ +typedef struct AuxData AuxData; + +/* Types of VDBE cursors */ +#define CURTYPE_BTREE 0 +#define CURTYPE_SORTER 1 +#define CURTYPE_VTAB 2 +#define CURTYPE_PSEUDO 3 + +/* +** A VdbeCursor is an superclass (a wrapper) for various cursor objects: +** +** * A b-tree cursor +** - In the main database or in an ephemeral database +** - On either an index or a table +** * A sorter +** * A virtual table +** * A one-row "pseudotable" stored in a single register +*/ +typedef struct VdbeCursor VdbeCursor; +struct VdbeCursor { + u8 eCurType; /* One of the CURTYPE_* values above */ + i8 iDb; /* Index of cursor database in db->aDb[] (or -1) */ + u8 nullRow; /* True if pointing to a row with no data */ + u8 deferredMoveto; /* A call to sqlite3BtreeMoveto() is needed */ + u8 isTable; /* True for rowid tables. False for indexes */ +#ifdef SQLITE_DEBUG + u8 seekOp; /* Most recent seek operation on this cursor */ + u8 wrFlag; /* The wrFlag argument to sqlite3BtreeCursor() */ +#endif + Bool isEphemeral:1; /* True for an ephemeral table */ + Bool useRandomRowid:1; /* Generate new record numbers semi-randomly */ + Bool isOrdered:1; /* True if the table is not BTREE_UNORDERED */ + u16 seekHit; /* See the OP_SeekHit and OP_IfNoHope opcodes */ + Btree *pBtx; /* Separate file holding temporary table */ + i64 seqCount; /* Sequence counter */ + u32 *aAltMap; /* Mapping from table to index column numbers */ + + /* Cached OP_Column parse information is only valid if cacheStatus matches + ** Vdbe.cacheCtr. Vdbe.cacheCtr will never take on the value of + ** CACHE_STALE (0) and so setting cacheStatus=CACHE_STALE guarantees that + ** the cache is out of date. */ + u32 cacheStatus; /* Cache is valid if this matches Vdbe.cacheCtr */ + int seekResult; /* Result of previous sqlite3BtreeMoveto() or 0 + ** if there have been no prior seeks on the cursor. */ + /* seekResult does not distinguish between "no seeks have ever occurred + ** on this cursor" and "the most recent seek was an exact match". + ** For CURTYPE_PSEUDO, seekResult is the register holding the record */ + + /* When a new VdbeCursor is allocated, only the fields above are zeroed. + ** The fields that follow are uninitialized, and must be individually + ** initialized prior to first use. */ + VdbeCursor *pAltCursor; /* Associated index cursor from which to read */ + union { + BtCursor *pCursor; /* CURTYPE_BTREE or _PSEUDO. Btree cursor */ + sqlite3_vtab_cursor *pVCur; /* CURTYPE_VTAB. Vtab cursor */ + VdbeSorter *pSorter; /* CURTYPE_SORTER. Sorter object */ + } uc; + KeyInfo *pKeyInfo; /* Info about index keys needed by index cursors */ + u32 iHdrOffset; /* Offset to next unparsed byte of the header */ + Pgno pgnoRoot; /* Root page of the open btree cursor */ + i16 nField; /* Number of fields in the header */ + u16 nHdrParsed; /* Number of header fields parsed so far */ + i64 movetoTarget; /* Argument to the deferred sqlite3BtreeMoveto() */ + u32 *aOffset; /* Pointer to aType[nField] */ + const u8 *aRow; /* Data for the current row, if all on one page */ + u32 payloadSize; /* Total number of bytes in the record */ + u32 szRow; /* Byte available in aRow */ +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK + u64 maskUsed; /* Mask of columns used by this cursor */ +#endif + + /* 2*nField extra array elements allocated for aType[], beyond the one + ** static element declared in the structure. nField total array slots for + ** aType[] and nField+1 array slots for aOffset[] */ + u32 aType[1]; /* Type values record decode. MUST BE LAST */ +}; + + +/* +** A value for VdbeCursor.cacheStatus that means the cache is always invalid. +*/ +#define CACHE_STALE 0 + +/* +** When a sub-program is executed (OP_Program), a structure of this type +** is allocated to store the current value of the program counter, as +** well as the current memory cell array and various other frame specific +** values stored in the Vdbe struct. When the sub-program is finished, +** these values are copied back to the Vdbe from the VdbeFrame structure, +** restoring the state of the VM to as it was before the sub-program +** began executing. +** +** The memory for a VdbeFrame object is allocated and managed by a memory +** cell in the parent (calling) frame. When the memory cell is deleted or +** overwritten, the VdbeFrame object is not freed immediately. Instead, it +** is linked into the Vdbe.pDelFrame list. The contents of the Vdbe.pDelFrame +** list is deleted when the VM is reset in VdbeHalt(). The reason for doing +** this instead of deleting the VdbeFrame immediately is to avoid recursive +** calls to sqlite3VdbeMemRelease() when the memory cells belonging to the +** child frame are released. +** +** The currently executing frame is stored in Vdbe.pFrame. Vdbe.pFrame is +** set to NULL if the currently executing frame is the main program. +*/ +typedef struct VdbeFrame VdbeFrame; +struct VdbeFrame { + Vdbe *v; /* VM this frame belongs to */ + 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 */ + 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 */ + void *token; /* Copy of SubProgram.token */ + i64 lastRowid; /* Last insert rowid (sqlite3.lastRowid) */ + AuxData *pAuxData; /* Linked list of auxdata allocations */ +#if SQLITE_DEBUG + u32 iFrameMagic; /* magic number for sanity checking */ +#endif + int nCursor; /* Number of entries in apCsr */ + int pc; /* Program Counter in parent (calling) frame */ + int nOp; /* Size of aOp array */ + int nMem; /* Number of entries in aMem */ + int nChildMem; /* Number of memory cells for child frame */ + int nChildCsr; /* Number of cursors for child frame */ + int nChange; /* Statement changes (Vdbe.nChange) */ + int nDbChange; /* Value of db->nChange */ +}; + +/* Magic number for sanity checking on VdbeFrame objects */ +#define SQLITE_FRAME_MAGIC 0x879fb71e + +/* +** Return a pointer to the array of registers allocated for use +** by a VdbeFrame. +*/ +#define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))]) + +/* +** Internally, the vdbe manipulates nearly all SQL values as Mem +** structures. Each Mem struct may cache multiple representations (string, +** integer etc.) of the same value. +*/ +struct sqlite3_value { + union MemValue { + double r; /* Real value used when MEM_Real is set in flags */ + i64 i; /* Integer value used when MEM_Int is set in flags */ + int nZero; /* Extra zero bytes when MEM_Zero and MEM_Blob set */ + const char *zPType; /* Pointer type when MEM_Term|MEM_Subtype|MEM_Null */ + FuncDef *pDef; /* Used only when flags==MEM_Agg */ + } u; + u16 flags; /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */ + u8 enc; /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */ + u8 eSubtype; /* Subtype for this value */ + int n; /* Number of characters in string value, excluding '\0' */ + char *z; /* String or BLOB value */ + /* ShallowCopy only needs to copy the information above */ + char *zMalloc; /* Space to hold MEM_Str or MEM_Blob if szMalloc>0 */ + int szMalloc; /* Size of the zMalloc allocation */ + u32 uTemp; /* Transient storage for serial_type in OP_MakeRecord */ + sqlite3 *db; /* The associated database connection */ + void (*xDel)(void*);/* Destructor for Mem.z - only valid if MEM_Dyn */ +#ifdef SQLITE_DEBUG + Mem *pScopyFrom; /* This Mem is a shallow copy of pScopyFrom */ + u16 mScopyFlags; /* flags value immediately after the shallow copy */ +#endif +}; + +/* +** Size of struct Mem not including the Mem.zMalloc member or anything that +** follows. +*/ +#define MEMCELLSIZE offsetof(Mem,zMalloc) + +/* One or more of the following flags are set to indicate the validOK +** representations of the value stored in the Mem struct. +** +** If the MEM_Null flag is set, then the value is an SQL NULL value. +** For a pointer type created using sqlite3_bind_pointer() or +** sqlite3_result_pointer() the MEM_Term and MEM_Subtype flags are also set. +** +** If the MEM_Str flag is set then Mem.z points at a string representation. +** Usually this is encoded in the same unicode encoding as the main +** database (see below for exceptions). If the MEM_Term flag is also +** set, then the string is nul terminated. The MEM_Int and MEM_Real +** flags may coexist with the MEM_Str flag. +*/ +#define MEM_Null 0x0001 /* Value is NULL (or a pointer) */ +#define MEM_Str 0x0002 /* Value is a string */ +#define MEM_Int 0x0004 /* Value is an integer */ +#define MEM_Real 0x0008 /* Value is a real number */ +#define MEM_Blob 0x0010 /* Value is a BLOB */ +#define MEM_IntReal 0x0020 /* MEM_Int that stringifies like MEM_Real */ +#define MEM_AffMask 0x003f /* Mask of affinity bits */ +#define MEM_FromBind 0x0040 /* Value originates from sqlite3_bind() */ +#define MEM_Undefined 0x0080 /* Value is undefined */ +#define MEM_Cleared 0x0100 /* NULL set by OP_Null, not from data */ +#define MEM_TypeMask 0xc1bf /* Mask of type bits */ + + +/* Whenever Mem contains a valid string or blob representation, one of +** the following flags must be set to determine the memory management +** policy for Mem.z. The MEM_Term flag tells us whether or not the +** string is \000 or \u0000 terminated +*/ +#define MEM_Term 0x0200 /* String in Mem.z is zero terminated */ +#define MEM_Dyn 0x0400 /* Need to call Mem.xDel() on Mem.z */ +#define MEM_Static 0x0800 /* Mem.z points to a static string */ +#define MEM_Ephem 0x1000 /* Mem.z points to an ephemeral string */ +#define MEM_Agg 0x2000 /* Mem.z points to an agg function context */ +#define MEM_Zero 0x4000 /* Mem.i contains count of 0s appended to blob */ +#define MEM_Subtype 0x8000 /* Mem.eSubtype is valid */ +#ifdef SQLITE_OMIT_INCRBLOB + #undef MEM_Zero + #define MEM_Zero 0x0000 +#endif + +/* Return TRUE if Mem X contains dynamically allocated content - anything +** that needs to be deallocated to avoid a leak. +*/ +#define VdbeMemDynamic(X) \ + (((X)->flags&(MEM_Agg|MEM_Dyn))!=0) + +/* +** Clear any existing type flags from a Mem and replace them with f +*/ +#define MemSetTypeFlag(p, f) \ + ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f) + +/* +** True if Mem X is a NULL-nochng type. +*/ +#define MemNullNochng(X) \ + (((X)->flags&MEM_TypeMask)==(MEM_Null|MEM_Zero) \ + && (X)->n==0 && (X)->u.nZero==0) + +/* +** Return true if a memory cell is not marked as invalid. This macro +** is for use inside assert() statements only. +*/ +#ifdef SQLITE_DEBUG +#define memIsValid(M) ((M)->flags & MEM_Undefined)==0 +#endif + +/* +** Each auxiliary data pointer stored by a user defined function +** implementation calling sqlite3_set_auxdata() is stored in an instance +** of this structure. All such structures associated with a single VM +** are stored in a linked list headed at Vdbe.pAuxData. All are destroyed +** when the VM is halted (if not before). +*/ +struct AuxData { + int iAuxOp; /* Instruction number of OP_Function opcode */ + int iAuxArg; /* Index of function argument. */ + void *pAux; /* Aux data pointer */ + void (*xDeleteAux)(void*); /* Destructor for the aux data */ + AuxData *pNextAux; /* Next element in list */ +}; + +/* +** The "context" argument for an installable function. A pointer to an +** instance of this structure is the first argument to the routines used +** implement the SQL functions. +** +** There is a typedef for this structure in sqlite.h. So all routines, +** even the public interface to SQLite, can use a pointer to this structure. +** But this file is the only place where the internal details of this +** structure are known. +** +** This structure is defined inside of vdbeInt.h because it uses substructures +** (Mem) which are only defined there. +*/ +struct sqlite3_context { + Mem *pOut; /* The return value is stored here */ + FuncDef *pFunc; /* Pointer to function information */ + Mem *pMem; /* Memory cell used to store aggregate context */ + Vdbe *pVdbe; /* The VM that owns this context */ + int iOp; /* Instruction number of OP_Function */ + int isError; /* Error code returned by the function. */ + u8 skipFlag; /* Skip accumulator loading if true */ + u8 argc; /* Number of arguments */ + sqlite3_value *argv[1]; /* Argument set */ +}; + +/* A bitfield type for use inside of structures. Always follow with :N where +** N is the number of bits. +*/ +typedef unsigned bft; /* Bit Field Type */ + +/* The ScanStatus object holds a single value for the +** sqlite3_stmt_scanstatus() interface. +*/ +typedef struct ScanStatus ScanStatus; +struct ScanStatus { + int addrExplain; /* OP_Explain for loop */ + int addrLoop; /* Address of "loops" counter */ + int addrVisit; /* Address of "rows visited" counter */ + int iSelectID; /* The "Select-ID" for this loop */ + LogEst nEst; /* Estimated output rows per loop */ + char *zName; /* Name of table or index */ +}; + +/* The DblquoteStr object holds the text of a double-quoted +** string for a prepared statement. A linked list of these objects +** is constructed during statement parsing and is held on Vdbe.pDblStr. +** When computing a normalized SQL statement for an SQL statement, that +** list is consulted for each double-quoted identifier to see if the +** identifier should really be a string literal. +*/ +typedef struct DblquoteStr DblquoteStr; +struct DblquoteStr { + DblquoteStr *pNextStr; /* Next string literal in the list */ + char z[8]; /* Dequoted value for the string */ +}; + +/* +** An instance of the virtual machine. This structure contains the complete +** state of the virtual machine. +** +** The "sqlite3_stmt" structure pointer that is returned by sqlite3_prepare() +** is really a pointer to an instance of this structure. +*/ +struct Vdbe { + sqlite3 *db; /* The database connection that owns this statement */ + Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */ + Parse *pParse; /* Parsing context used to create this Vdbe */ + ynVar nVar; /* Number of entries in aVar[] */ + u32 magic; /* Magic number for sanity checking */ + int nMem; /* Number of memory locations currently allocated */ + int nCursor; /* Number of slots in apCsr[] */ + u32 cacheCtr; /* VdbeCursor row cache generation counter */ + int pc; /* The program counter */ + int rc; /* Value to return */ + int nChange; /* Number of db changes made since last reset */ + int iStatement; /* Statement number (or 0 if has no opened stmt) */ + i64 iCurrentTime; /* Value of julianday('now') for this statement */ + i64 nFkConstraint; /* Number of imm. FK constraints this VM */ + i64 nStmtDefCons; /* Number of def. constraints when stmt started */ + i64 nStmtDefImmCons; /* Number of def. imm constraints when stmt started */ + Mem *aMem; /* The memory locations */ + Mem **apArg; /* Arguments to currently executing user function */ + VdbeCursor **apCsr; /* One element of this array for each open cursor */ + Mem *aVar; /* Values for the OP_Variable opcode. */ + + /* When allocating a new Vdbe object, all of the fields below should be + ** initialized to zero or NULL */ + + Op *aOp; /* Space to hold the virtual machine's program */ + int nOp; /* Number of instructions in the program */ + int nOpAlloc; /* Slots allocated for aOp[] */ + Mem *aColName; /* Column names to return */ + Mem *pResultSet; /* Pointer to an array of results */ + char *zErrMsg; /* Error message written here */ + VList *pVList; /* Name of variables */ +#ifndef SQLITE_OMIT_TRACE + i64 startTime; /* Time when query started - used for profiling */ +#endif +#ifdef SQLITE_DEBUG + int rcApp; /* errcode set by sqlite3_result_error_code() */ + u32 nWrite; /* Number of write operations that have occurred */ +#endif + u16 nResColumn; /* Number of columns in one row of the result set */ + u8 errorAction; /* Recovery action to do in case of an error */ + u8 minWriteFileFormat; /* Minimum file format for writable database files */ + u8 prepFlags; /* SQLITE_PREPARE_* flags */ + u8 doingRerun; /* True if rerunning after an auto-reprepare */ + bft expired:2; /* 1: recompile VM immediately 2: when convenient */ + bft explain:2; /* True if EXPLAIN present on SQL command */ + bft changeCntOn:1; /* True to update the change-counter */ + bft runOnlyOnce:1; /* Automatically expire on reset */ + bft usesStmtJournal:1; /* True if uses a statement journal */ + bft readOnly:1; /* True for statements that do not write */ + bft bIsReader:1; /* True for statements that read */ + yDbMask btreeMask; /* Bitmask of db->aDb[] entries referenced */ + yDbMask lockMask; /* Subset of btreeMask that requires a lock */ + u32 aCounter[7]; /* Counters used by sqlite3_stmt_status() */ + char *zSql; /* Text of the SQL statement that generated this */ +#ifdef SQLITE_ENABLE_NORMALIZE + char *zNormSql; /* Normalization of the associated SQL statement */ + DblquoteStr *pDblStr; /* List of double-quoted string literals */ +#endif + void *pFree; /* Free this when deleting the vdbe */ + VdbeFrame *pFrame; /* Parent frame */ + VdbeFrame *pDelFrame; /* List of frame objects to free on VM reset */ + int nFrame; /* Number of frames in pFrame list */ + 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 + i64 *anExec; /* Number of times each op has been executed */ + int nScan; /* Entries in aScan[] */ + ScanStatus *aScan; /* Scan definitions for sqlite3_stmt_scanstatus() */ +#endif +}; + +/* +** The following are allowed values for Vdbe.magic +*/ +#define VDBE_MAGIC_INIT 0x16bceaa5 /* Building a VDBE program */ +#define VDBE_MAGIC_RUN 0x2df20da3 /* VDBE is ready to execute */ +#define VDBE_MAGIC_HALT 0x319c2973 /* VDBE has completed execution */ +#define VDBE_MAGIC_RESET 0x48fa9f76 /* Reset and ready to run again */ +#define VDBE_MAGIC_DEAD 0x5606c3c8 /* The VDBE has been deallocated */ + +/* +** Structure used to store the context required by the +** sqlite3_preupdate_*() API functions. +*/ +struct PreUpdate { + Vdbe *v; + VdbeCursor *pCsr; /* Cursor to read old values from */ + int op; /* One of SQLITE_INSERT, UPDATE, DELETE */ + u8 *aRecord; /* old.* database record */ + KeyInfo keyinfo; + UnpackedRecord *pUnpacked; /* Unpacked version of aRecord[] */ + UnpackedRecord *pNewUnpacked; /* Unpacked version of new.* record */ + int iNewReg; /* Register for new.* values */ + i64 iKey1; /* First key value passed to hook */ + i64 iKey2; /* Second key value passed to hook */ + Mem *aNew; /* Array of new.* values */ + Table *pTab; /* Schema object being upated */ + Index *pPk; /* PK index if pTab is WITHOUT ROWID */ +}; + +/* +** Function prototypes +*/ +SQLITE_PRIVATE void sqlite3VdbeError(Vdbe*, const char *, ...); +SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *, VdbeCursor*); +void sqliteVdbePopStack(Vdbe*,int); +SQLITE_PRIVATE int SQLITE_NOINLINE sqlite3VdbeFinishMoveto(VdbeCursor*); +SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor**, u32*); +SQLITE_PRIVATE int sqlite3VdbeCursorRestore(VdbeCursor*); +SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32); +SQLITE_PRIVATE u8 sqlite3VdbeOneByteSerialTypeLen(u8); +SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(unsigned char*, Mem*, u32); +SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*); +SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(sqlite3*, AuxData**, int, int); + +int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *); +SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(sqlite3*,VdbeCursor*,UnpackedRecord*,int*); +SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3*, BtCursor*, i64*); +SQLITE_PRIVATE int sqlite3VdbeExec(Vdbe*); +#if !defined(SQLITE_OMIT_EXPLAIN) || defined(SQLITE_ENABLE_BYTECODE_VTAB) +SQLITE_PRIVATE int sqlite3VdbeNextOpcode(Vdbe*,Mem*,int,int*,int*,Op**); +SQLITE_PRIVATE char *sqlite3VdbeDisplayP4(sqlite3*,Op*); +#endif +#if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) +SQLITE_PRIVATE char *sqlite3VdbeDisplayComment(sqlite3*,const Op*,const char*); +#endif +#if !defined(SQLITE_OMIT_EXPLAIN) +SQLITE_PRIVATE int sqlite3VdbeList(Vdbe*); +#endif +SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe*); +SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *, int); +SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem*, const Mem*); +SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int); +SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem*, Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*)); +SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem*, i64); +#ifdef SQLITE_OMIT_FLOATING_POINT +# define sqlite3VdbeMemSetDouble sqlite3VdbeMemSetInt64 +#else +SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem*, double); +#endif +SQLITE_PRIVATE void sqlite3VdbeMemSetPointer(Mem*, void*, const char*, void(*)(void*)); +SQLITE_PRIVATE void sqlite3VdbeMemInit(Mem*,sqlite3*,u16); +SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem*); +SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem*,int); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3VdbeMemIsRowSet(const Mem*); +#endif +SQLITE_PRIVATE int sqlite3VdbeMemSetRowSet(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem*, u8, u8); +SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem*); +SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem*); +SQLITE_PRIVATE int sqlite3VdbeBooleanValue(Mem*, int ifNull); +SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemCast(Mem*,u8,u8); +SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,u32,u32,Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemFromBtreeZeroOffset(BtCursor*,u32,Mem*); +SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p); +SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem*, FuncDef*); +#ifndef SQLITE_OMIT_WINDOWFUNC +SQLITE_PRIVATE int sqlite3VdbeMemAggValue(Mem*, Mem*, FuncDef*); +#endif +#if !defined(SQLITE_OMIT_EXPLAIN) || defined(SQLITE_ENABLE_BYTECODE_VTAB) +SQLITE_PRIVATE const char *sqlite3OpcodeName(int); +#endif +SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve); +SQLITE_PRIVATE int sqlite3VdbeMemClearAndResize(Mem *pMem, int n); +SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *, int); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3VdbeFrameIsValid(VdbeFrame*); +#endif +SQLITE_PRIVATE void sqlite3VdbeFrameMemDel(void*); /* Destructor on Mem */ +SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame*); /* Actually deletes the Frame */ +SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *); +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +SQLITE_PRIVATE void sqlite3VdbePreUpdateHook(Vdbe*,VdbeCursor*,int,const char*,Table*,i64,int); +#endif +SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p); + +SQLITE_PRIVATE int sqlite3VdbeSorterInit(sqlite3 *, int, VdbeCursor *); +SQLITE_PRIVATE void sqlite3VdbeSorterReset(sqlite3 *, VdbeSorter *); +SQLITE_PRIVATE void sqlite3VdbeSorterClose(sqlite3 *, VdbeCursor *); +SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *, Mem *); +SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *, const VdbeCursor *); +SQLITE_PRIVATE int sqlite3VdbeSorterRewind(const VdbeCursor *, int *); +SQLITE_PRIVATE int sqlite3VdbeSorterWrite(const VdbeCursor *, Mem *); +SQLITE_PRIVATE int sqlite3VdbeSorterCompare(const VdbeCursor *, Mem *, int, int *); + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE void sqlite3VdbeIncrWriteCounter(Vdbe*, VdbeCursor*); +SQLITE_PRIVATE void sqlite3VdbeAssertAbortable(Vdbe*); +#else +# define sqlite3VdbeIncrWriteCounter(V,C) +# define sqlite3VdbeAssertAbortable(V) +#endif + +#if !defined(SQLITE_OMIT_SHARED_CACHE) +SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe*); +#else +# define sqlite3VdbeEnter(X) +#endif + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0 +SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe*); +#else +# define sqlite3VdbeLeave(X) +#endif + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe*,Mem*); +SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem*); +#endif + +#ifndef SQLITE_OMIT_FOREIGN_KEY +SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *, int); +#else +# define sqlite3VdbeCheckFk(p,i) 0 +#endif + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, StrAccum *pStr); +#endif +#ifndef SQLITE_OMIT_UTF16 +SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem*, u8); +SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem); +#endif + +#ifndef SQLITE_OMIT_INCRBLOB +SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *); + #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0) +#else + #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK + #define ExpandBlob(P) SQLITE_OK +#endif + +#endif /* !defined(SQLITE_VDBEINT_H) */ + +/************** End of vdbeInt.h *********************************************/ +/************** Continuing where we left off in status.c *********************/ + +/* +** Variables in which to record status information. +*/ +#if SQLITE_PTRSIZE>4 +typedef sqlite3_int64 sqlite3StatValueType; +#else +typedef u32 sqlite3StatValueType; +#endif +typedef struct sqlite3StatType sqlite3StatType; +static SQLITE_WSD struct sqlite3StatType { + sqlite3StatValueType nowValue[10]; /* Current value */ + sqlite3StatValueType mxValue[10]; /* Maximum value */ +} sqlite3Stat = { {0,}, {0,} }; + +/* +** Elements of sqlite3Stat[] are protected by either the memory allocator +** mutex, or by the pcache1 mutex. The following array determines which. +*/ +static const char statMutex[] = { + 0, /* SQLITE_STATUS_MEMORY_USED */ + 1, /* SQLITE_STATUS_PAGECACHE_USED */ + 1, /* SQLITE_STATUS_PAGECACHE_OVERFLOW */ + 0, /* SQLITE_STATUS_SCRATCH_USED */ + 0, /* SQLITE_STATUS_SCRATCH_OVERFLOW */ + 0, /* SQLITE_STATUS_MALLOC_SIZE */ + 0, /* SQLITE_STATUS_PARSER_STACK */ + 1, /* SQLITE_STATUS_PAGECACHE_SIZE */ + 0, /* SQLITE_STATUS_SCRATCH_SIZE */ + 0, /* SQLITE_STATUS_MALLOC_COUNT */ +}; + + +/* The "wsdStat" macro will resolve to the status information +** state vector. If writable static data is unsupported on the target, +** we have to locate the state vector at run-time. In the more common +** case where writable static data is supported, wsdStat can refer directly +** to the "sqlite3Stat" state vector declared above. +*/ +#ifdef SQLITE_OMIT_WSD +# define wsdStatInit sqlite3StatType *x = &GLOBAL(sqlite3StatType,sqlite3Stat) +# define wsdStat x[0] +#else +# define wsdStatInit +# define wsdStat sqlite3Stat +#endif + +/* +** Return the current value of a status parameter. The caller must +** be holding the appropriate mutex. +*/ +SQLITE_PRIVATE sqlite3_int64 sqlite3StatusValue(int op){ + wsdStatInit; + assert( op>=0 && op=0 && op=0 && op=0 && opwsdStat.mxValue[op] ){ + wsdStat.mxValue[op] = wsdStat.nowValue[op]; + } +} +SQLITE_PRIVATE void sqlite3StatusDown(int op, int N){ + wsdStatInit; + assert( N>=0 ); + assert( op>=0 && op=0 && op=0 ); + newValue = (sqlite3StatValueType)X; + assert( op>=0 && op=0 && opwsdStat.mxValue[op] ){ + wsdStat.mxValue[op] = newValue; + } +} + +/* +** Query status information. +*/ +SQLITE_API int sqlite3_status64( + int op, + sqlite3_int64 *pCurrent, + sqlite3_int64 *pHighwater, + int resetFlag +){ + sqlite3_mutex *pMutex; + wsdStatInit; + if( op<0 || op>=ArraySize(wsdStat.nowValue) ){ + return SQLITE_MISUSE_BKPT; + } +#ifdef SQLITE_ENABLE_API_ARMOR + if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT; +#endif + pMutex = statMutex[op] ? sqlite3Pcache1Mutex() : sqlite3MallocMutex(); + sqlite3_mutex_enter(pMutex); + *pCurrent = wsdStat.nowValue[op]; + *pHighwater = wsdStat.mxValue[op]; + if( resetFlag ){ + wsdStat.mxValue[op] = wsdStat.nowValue[op]; + } + sqlite3_mutex_leave(pMutex); + (void)pMutex; /* Prevent warning when SQLITE_THREADSAFE=0 */ + return SQLITE_OK; +} +SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){ + sqlite3_int64 iCur = 0, iHwtr = 0; + int rc; +#ifdef SQLITE_ENABLE_API_ARMOR + if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT; +#endif + rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag); + if( rc==0 ){ + *pCurrent = (int)iCur; + *pHighwater = (int)iHwtr; + } + return rc; +} + +/* +** Return the number of LookasideSlot elements on the linked list +*/ +static u32 countLookasideSlots(LookasideSlot *p){ + u32 cnt = 0; + while( p ){ + p = p->pNext; + cnt++; + } + return cnt; +} + +/* +** Count the number of slots of lookaside memory that are outstanding +*/ +SQLITE_PRIVATE int sqlite3LookasideUsed(sqlite3 *db, int *pHighwater){ + u32 nInit = countLookasideSlots(db->lookaside.pInit); + u32 nFree = countLookasideSlots(db->lookaside.pFree); +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + nInit += countLookasideSlots(db->lookaside.pSmallInit); + nFree += countLookasideSlots(db->lookaside.pSmallFree); +#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */ + if( pHighwater ) *pHighwater = db->lookaside.nSlot - nInit; + return db->lookaside.nSlot - (nInit+nFree); +} + +/* +** Query status information for a single database connection +*/ +SQLITE_API int sqlite3_db_status( + sqlite3 *db, /* The database connection whose status is desired */ + int op, /* Status verb */ + int *pCurrent, /* Write current value here */ + int *pHighwater, /* Write high-water mark here */ + int resetFlag /* Reset high-water mark if true */ +){ + int rc = SQLITE_OK; /* Return code */ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || pCurrent==0|| pHighwater==0 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + switch( op ){ + case SQLITE_DBSTATUS_LOOKASIDE_USED: { + *pCurrent = sqlite3LookasideUsed(db, pHighwater); + if( resetFlag ){ + LookasideSlot *p = db->lookaside.pFree; + if( p ){ + while( p->pNext ) p = p->pNext; + p->pNext = db->lookaside.pInit; + db->lookaside.pInit = db->lookaside.pFree; + db->lookaside.pFree = 0; + } +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + p = db->lookaside.pSmallFree; + if( p ){ + while( p->pNext ) p = p->pNext; + p->pNext = db->lookaside.pSmallInit; + db->lookaside.pSmallInit = db->lookaside.pSmallFree; + db->lookaside.pSmallFree = 0; + } +#endif + } + break; + } + + case SQLITE_DBSTATUS_LOOKASIDE_HIT: + case SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: + case SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: { + testcase( op==SQLITE_DBSTATUS_LOOKASIDE_HIT ); + testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE ); + testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL ); + assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)>=0 ); + assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)<3 ); + *pCurrent = 0; + *pHighwater = db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT]; + if( resetFlag ){ + db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT] = 0; + } + break; + } + + /* + ** Return an approximation for the amount of memory currently used + ** by all pagers associated with the given database connection. The + ** highwater mark is meaningless and is returned as zero. + */ + case SQLITE_DBSTATUS_CACHE_USED_SHARED: + case SQLITE_DBSTATUS_CACHE_USED: { + int totalUsed = 0; + int i; + sqlite3BtreeEnterAll(db); + for(i=0; inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + Pager *pPager = sqlite3BtreePager(pBt); + int nByte = sqlite3PagerMemUsed(pPager); + if( op==SQLITE_DBSTATUS_CACHE_USED_SHARED ){ + nByte = nByte / sqlite3BtreeConnectionCount(pBt); + } + totalUsed += nByte; + } + } + sqlite3BtreeLeaveAll(db); + *pCurrent = totalUsed; + *pHighwater = 0; + break; + } + + /* + ** *pCurrent gets an accurate estimate of the amount of memory used + ** to store the schema for all databases (main, temp, and any ATTACHed + ** databases. *pHighwater is set to zero. + */ + case SQLITE_DBSTATUS_SCHEMA_USED: { + int i; /* Used to iterate through schemas */ + int nByte = 0; /* Used to accumulate return value */ + + sqlite3BtreeEnterAll(db); + db->pnBytesFreed = &nByte; + for(i=0; inDb; i++){ + Schema *pSchema = db->aDb[i].pSchema; + if( ALWAYS(pSchema!=0) ){ + HashElem *p; + + nByte += sqlite3GlobalConfig.m.xRoundup(sizeof(HashElem)) * ( + pSchema->tblHash.count + + pSchema->trigHash.count + + pSchema->idxHash.count + + pSchema->fkeyHash.count + ); + nByte += sqlite3_msize(pSchema->tblHash.ht); + nByte += sqlite3_msize(pSchema->trigHash.ht); + nByte += sqlite3_msize(pSchema->idxHash.ht); + nByte += sqlite3_msize(pSchema->fkeyHash.ht); + + for(p=sqliteHashFirst(&pSchema->trigHash); p; p=sqliteHashNext(p)){ + sqlite3DeleteTrigger(db, (Trigger*)sqliteHashData(p)); + } + for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){ + sqlite3DeleteTable(db, (Table *)sqliteHashData(p)); + } + } + } + db->pnBytesFreed = 0; + sqlite3BtreeLeaveAll(db); + + *pHighwater = 0; + *pCurrent = nByte; + break; + } + + /* + ** *pCurrent gets an accurate estimate of the amount of memory used + ** to store all prepared statements. + ** *pHighwater is set to zero. + */ + case SQLITE_DBSTATUS_STMT_USED: { + struct Vdbe *pVdbe; /* Used to iterate through VMs */ + int nByte = 0; /* Used to accumulate return value */ + + db->pnBytesFreed = &nByte; + for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pNext){ + sqlite3VdbeClearObject(db, pVdbe); + sqlite3DbFree(db, pVdbe); + } + db->pnBytesFreed = 0; + + *pHighwater = 0; /* IMP: R-64479-57858 */ + *pCurrent = nByte; + + break; + } + + /* + ** Set *pCurrent to the total cache hits or misses encountered by all + ** pagers the database handle is connected to. *pHighwater is always set + ** to zero. + */ + case SQLITE_DBSTATUS_CACHE_SPILL: + op = SQLITE_DBSTATUS_CACHE_WRITE+1; + /* no break */ deliberate_fall_through + case SQLITE_DBSTATUS_CACHE_HIT: + case SQLITE_DBSTATUS_CACHE_MISS: + case SQLITE_DBSTATUS_CACHE_WRITE:{ + int i; + int nRet = 0; + assert( SQLITE_DBSTATUS_CACHE_MISS==SQLITE_DBSTATUS_CACHE_HIT+1 ); + assert( SQLITE_DBSTATUS_CACHE_WRITE==SQLITE_DBSTATUS_CACHE_HIT+2 ); + + for(i=0; inDb; i++){ + if( db->aDb[i].pBt ){ + Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt); + sqlite3PagerCacheStat(pPager, op, resetFlag, &nRet); + } + } + *pHighwater = 0; /* IMP: R-42420-56072 */ + /* IMP: R-54100-20147 */ + /* IMP: R-29431-39229 */ + *pCurrent = nRet; + break; + } + + /* Set *pCurrent to non-zero if there are unresolved deferred foreign + ** key constraints. Set *pCurrent to zero if all foreign key constraints + ** have been satisfied. The *pHighwater is always set to zero. + */ + case SQLITE_DBSTATUS_DEFERRED_FKS: { + *pHighwater = 0; /* IMP: R-11967-56545 */ + *pCurrent = db->nDeferredImmCons>0 || db->nDeferredCons>0; + break; + } + + default: { + rc = SQLITE_ERROR; + } + } + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/************** End of status.c **********************************************/ +/************** Begin file date.c ********************************************/ +/* +** 2003 October 31 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement date and time +** functions for SQLite. +** +** There is only one exported symbol in this file - the function +** sqlite3RegisterDateTimeFunctions() found at the bottom of the file. +** All other code has file scope. +** +** SQLite processes all times and dates as julian day numbers. The +** dates and times are stored as the number of days since noon +** in Greenwich on November 24, 4714 B.C. according to the Gregorian +** calendar system. +** +** 1970-01-01 00:00:00 is JD 2440587.5 +** 2000-01-01 00:00:00 is JD 2451544.5 +** +** This implementation requires years to be expressed as a 4-digit number +** which means that only dates between 0000-01-01 and 9999-12-31 can +** be represented, even though julian day numbers allow a much wider +** range of dates. +** +** The Gregorian calendar system is used for all dates and times, +** even those that predate the Gregorian calendar. Historians usually +** use the julian calendar for dates prior to 1582-10-15 and for some +** dates afterwards, depending on locale. Beware of this difference. +** +** The conversion algorithms are implemented based on descriptions +** in the following text: +** +** Jean Meeus +** Astronomical Algorithms, 2nd Edition, 1998 +** ISBN 0-943396-61-1 +** Willmann-Bell, Inc +** Richmond, Virginia (USA) +*/ +/* #include "sqliteInt.h" */ +/* #include */ +/* #include */ +#include + +#ifndef SQLITE_OMIT_DATETIME_FUNCS + +/* +** The MSVC CRT on Windows CE may not have a localtime() function. +** So declare a substitute. The substitute function itself is +** defined in "os_win.c". +*/ +#if !defined(SQLITE_OMIT_LOCALTIME) && defined(_WIN32_WCE) && \ + (!defined(SQLITE_MSVC_LOCALTIME_API) || !SQLITE_MSVC_LOCALTIME_API) +struct tm *__cdecl localtime(const time_t *); +#endif + +/* +** A structure for holding a single date and time. +*/ +typedef struct DateTime DateTime; +struct DateTime { + sqlite3_int64 iJD; /* The julian day number times 86400000 */ + int Y, M, D; /* Year, month, and day */ + int h, m; /* Hour and minutes */ + int tz; /* Timezone offset in minutes */ + double s; /* Seconds */ + char validJD; /* True (1) if iJD is valid */ + char rawS; /* Raw numeric value stored in s */ + char validYMD; /* True (1) if Y,M,D are valid */ + char validHMS; /* True (1) if h,m,s are valid */ + char validTZ; /* True (1) if tz is valid */ + char tzSet; /* Timezone was set explicitly */ + char isError; /* An overflow has occurred */ +}; + + +/* +** Convert zDate into one or more integers according to the conversion +** specifier zFormat. +** +** zFormat[] contains 4 characters for each integer converted, except for +** the last integer which is specified by three characters. The meaning +** of a four-character format specifiers ABCD is: +** +** A: number of digits to convert. Always "2" or "4". +** B: minimum value. Always "0" or "1". +** C: maximum value, decoded as: +** a: 12 +** b: 14 +** c: 24 +** d: 31 +** e: 59 +** f: 9999 +** D: the separator character, or \000 to indicate this is the +** last number to convert. +** +** Example: To translate an ISO-8601 date YYYY-MM-DD, the format would +** be "40f-21a-20c". The "40f-" indicates the 4-digit year followed by "-". +** The "21a-" indicates the 2-digit month followed by "-". The "20c" indicates +** the 2-digit day which is the last integer in the set. +** +** The function returns the number of successful conversions. +*/ +static int getDigits(const char *zDate, const char *zFormat, ...){ + /* The aMx[] array translates the 3rd character of each format + ** spec into a max size: a b c d e f */ + static const u16 aMx[] = { 12, 14, 24, 31, 59, 9999 }; + va_list ap; + int cnt = 0; + char nextC; + va_start(ap, zFormat); + do{ + char N = zFormat[0] - '0'; + char min = zFormat[1] - '0'; + int val = 0; + u16 max; + + assert( zFormat[2]>='a' && zFormat[2]<='f' ); + max = aMx[zFormat[2] - 'a']; + nextC = zFormat[3]; + val = 0; + while( N-- ){ + if( !sqlite3Isdigit(*zDate) ){ + goto end_getDigits; + } + val = val*10 + *zDate - '0'; + zDate++; + } + if( val<(int)min || val>(int)max || (nextC!=0 && nextC!=*zDate) ){ + goto end_getDigits; + } + *va_arg(ap,int*) = val; + zDate++; + cnt++; + zFormat += 4; + }while( nextC ); +end_getDigits: + va_end(ap); + return cnt; +} + +/* +** Parse a timezone extension on the end of a date-time. +** The extension is of the form: +** +** (+/-)HH:MM +** +** Or the "zulu" notation: +** +** Z +** +** If the parse is successful, write the number of minutes +** of change in p->tz and return 0. If a parser error occurs, +** return non-zero. +** +** A missing specifier is not considered an error. +*/ +static int parseTimezone(const char *zDate, DateTime *p){ + int sgn = 0; + int nHr, nMn; + int c; + while( sqlite3Isspace(*zDate) ){ zDate++; } + p->tz = 0; + c = *zDate; + if( c=='-' ){ + sgn = -1; + }else if( c=='+' ){ + sgn = +1; + }else if( c=='Z' || c=='z' ){ + zDate++; + goto zulu_time; + }else{ + return c!=0; + } + zDate++; + if( getDigits(zDate, "20b:20e", &nHr, &nMn)!=2 ){ + return 1; + } + zDate += 5; + p->tz = sgn*(nMn + nHr*60); +zulu_time: + while( sqlite3Isspace(*zDate) ){ zDate++; } + p->tzSet = 1; + return *zDate!=0; +} + +/* +** Parse times of the form HH:MM or HH:MM:SS or HH:MM:SS.FFFF. +** The HH, MM, and SS must each be exactly 2 digits. The +** fractional seconds FFFF can be one or more digits. +** +** Return 1 if there is a parsing error and 0 on success. +*/ +static int parseHhMmSs(const char *zDate, DateTime *p){ + int h, m, s; + double ms = 0.0; + if( getDigits(zDate, "20c:20e", &h, &m)!=2 ){ + return 1; + } + zDate += 5; + if( *zDate==':' ){ + zDate++; + if( getDigits(zDate, "20e", &s)!=1 ){ + return 1; + } + zDate += 2; + if( *zDate=='.' && sqlite3Isdigit(zDate[1]) ){ + double rScale = 1.0; + zDate++; + while( sqlite3Isdigit(*zDate) ){ + ms = ms*10.0 + *zDate - '0'; + rScale *= 10.0; + zDate++; + } + ms /= rScale; + } + }else{ + s = 0; + } + p->validJD = 0; + p->rawS = 0; + p->validHMS = 1; + p->h = h; + p->m = m; + p->s = s + ms; + if( parseTimezone(zDate, p) ) return 1; + p->validTZ = (p->tz!=0)?1:0; + return 0; +} + +/* +** Put the DateTime object into its error state. +*/ +static void datetimeError(DateTime *p){ + memset(p, 0, sizeof(*p)); + p->isError = 1; +} + +/* +** Convert from YYYY-MM-DD HH:MM:SS to julian day. We always assume +** that the YYYY-MM-DD is according to the Gregorian calendar. +** +** Reference: Meeus page 61 +*/ +static void computeJD(DateTime *p){ + int Y, M, D, A, B, X1, X2; + + if( p->validJD ) return; + if( p->validYMD ){ + Y = p->Y; + M = p->M; + D = p->D; + }else{ + Y = 2000; /* If no YMD specified, assume 2000-Jan-01 */ + M = 1; + D = 1; + } + if( Y<-4713 || Y>9999 || p->rawS ){ + datetimeError(p); + return; + } + if( M<=2 ){ + Y--; + M += 12; + } + A = Y/100; + B = 2 - A + (A/4); + X1 = 36525*(Y+4716)/100; + X2 = 306001*(M+1)/10000; + p->iJD = (sqlite3_int64)((X1 + X2 + D + B - 1524.5 ) * 86400000); + p->validJD = 1; + if( p->validHMS ){ + p->iJD += p->h*3600000 + p->m*60000 + (sqlite3_int64)(p->s*1000); + if( p->validTZ ){ + p->iJD -= p->tz*60000; + p->validYMD = 0; + p->validHMS = 0; + p->validTZ = 0; + } + } +} + +/* +** Parse dates of the form +** +** YYYY-MM-DD HH:MM:SS.FFF +** YYYY-MM-DD HH:MM:SS +** YYYY-MM-DD HH:MM +** YYYY-MM-DD +** +** Write the result into the DateTime structure and return 0 +** on success and 1 if the input string is not a well-formed +** date. +*/ +static int parseYyyyMmDd(const char *zDate, DateTime *p){ + int Y, M, D, neg; + + if( zDate[0]=='-' ){ + zDate++; + neg = 1; + }else{ + neg = 0; + } + if( getDigits(zDate, "40f-21a-21d", &Y, &M, &D)!=3 ){ + return 1; + } + zDate += 10; + while( sqlite3Isspace(*zDate) || 'T'==*(u8*)zDate ){ zDate++; } + if( parseHhMmSs(zDate, p)==0 ){ + /* We got the time */ + }else if( *zDate==0 ){ + p->validHMS = 0; + }else{ + return 1; + } + p->validJD = 0; + p->validYMD = 1; + p->Y = neg ? -Y : Y; + p->M = M; + p->D = D; + if( p->validTZ ){ + computeJD(p); + } + return 0; +} + +/* +** Set the time to the current time reported by the VFS. +** +** Return the number of errors. +*/ +static int setDateTimeToCurrent(sqlite3_context *context, DateTime *p){ + p->iJD = sqlite3StmtCurrentTime(context); + if( p->iJD>0 ){ + p->validJD = 1; + return 0; + }else{ + return 1; + } +} + +/* +** Input "r" is a numeric quantity which might be a julian day number, +** or the number of seconds since 1970. If the value if r is within +** range of a julian day number, install it as such and set validJD. +** If the value is a valid unix timestamp, put it in p->s and set p->rawS. +*/ +static void setRawDateNumber(DateTime *p, double r){ + p->s = r; + p->rawS = 1; + if( r>=0.0 && r<5373484.5 ){ + p->iJD = (sqlite3_int64)(r*86400000.0 + 0.5); + p->validJD = 1; + } +} + +/* +** Attempt to parse the given string into a julian day number. Return +** the number of errors. +** +** The following are acceptable forms for the input string: +** +** YYYY-MM-DD HH:MM:SS.FFF +/-HH:MM +** DDDD.DD +** now +** +** In the first form, the +/-HH:MM is always optional. The fractional +** seconds extension (the ".FFF") is optional. The seconds portion +** (":SS.FFF") is option. The year and date can be omitted as long +** as there is a time string. The time string can be omitted as long +** as there is a year and date. +*/ +static int parseDateOrTime( + sqlite3_context *context, + const char *zDate, + DateTime *p +){ + double r; + if( parseYyyyMmDd(zDate,p)==0 ){ + return 0; + }else if( parseHhMmSs(zDate, p)==0 ){ + return 0; + }else if( sqlite3StrICmp(zDate,"now")==0 && sqlite3NotPureFunc(context) ){ + return setDateTimeToCurrent(context, p); + }else if( sqlite3AtoF(zDate, &r, sqlite3Strlen30(zDate), SQLITE_UTF8)>0 ){ + setRawDateNumber(p, r); + return 0; + } + return 1; +} + +/* The julian day number for 9999-12-31 23:59:59.999 is 5373484.4999999. +** Multiplying this by 86400000 gives 464269060799999 as the maximum value +** for DateTime.iJD. +** +** But some older compilers (ex: gcc 4.2.1 on older Macs) cannot deal with +** such a large integer literal, so we have to encode it. +*/ +#define INT_464269060799999 ((((i64)0x1a640)<<32)|0x1072fdff) + +/* +** Return TRUE if the given julian day number is within range. +** +** The input is the JulianDay times 86400000. +*/ +static int validJulianDay(sqlite3_int64 iJD){ + return iJD>=0 && iJD<=INT_464269060799999; +} + +/* +** Compute the Year, Month, and Day from the julian day number. +*/ +static void computeYMD(DateTime *p){ + int Z, A, B, C, D, E, X1; + if( p->validYMD ) return; + if( !p->validJD ){ + p->Y = 2000; + p->M = 1; + p->D = 1; + }else if( !validJulianDay(p->iJD) ){ + datetimeError(p); + return; + }else{ + Z = (int)((p->iJD + 43200000)/86400000); + A = (int)((Z - 1867216.25)/36524.25); + A = Z + 1 + A - (A/4); + B = A + 1524; + C = (int)((B - 122.1)/365.25); + D = (36525*(C&32767))/100; + E = (int)((B-D)/30.6001); + X1 = (int)(30.6001*E); + p->D = B - D - X1; + p->M = E<14 ? E-1 : E-13; + p->Y = p->M>2 ? C - 4716 : C - 4715; + } + p->validYMD = 1; +} + +/* +** Compute the Hour, Minute, and Seconds from the julian day number. +*/ +static void computeHMS(DateTime *p){ + int s; + if( p->validHMS ) return; + computeJD(p); + s = (int)((p->iJD + 43200000) % 86400000); + p->s = s/1000.0; + s = (int)p->s; + p->s -= s; + p->h = s/3600; + s -= p->h*3600; + p->m = s/60; + p->s += s - p->m*60; + p->rawS = 0; + p->validHMS = 1; +} + +/* +** Compute both YMD and HMS +*/ +static void computeYMD_HMS(DateTime *p){ + computeYMD(p); + computeHMS(p); +} + +/* +** Clear the YMD and HMS and the TZ +*/ +static void clearYMD_HMS_TZ(DateTime *p){ + p->validYMD = 0; + p->validHMS = 0; + p->validTZ = 0; +} + +#ifndef SQLITE_OMIT_LOCALTIME +/* +** On recent Windows platforms, the localtime_s() function is available +** as part of the "Secure CRT". It is essentially equivalent to +** localtime_r() available under most POSIX platforms, except that the +** order of the parameters is reversed. +** +** See http://msdn.microsoft.com/en-us/library/a442x3ye(VS.80).aspx. +** +** If the user has not indicated to use localtime_r() or localtime_s() +** already, check for an MSVC build environment that provides +** localtime_s(). +*/ +#if !HAVE_LOCALTIME_R && !HAVE_LOCALTIME_S \ + && defined(_MSC_VER) && defined(_CRT_INSECURE_DEPRECATE) +#undef HAVE_LOCALTIME_S +#define HAVE_LOCALTIME_S 1 +#endif + +/* +** The following routine implements the rough equivalent of localtime_r() +** using whatever operating-system specific localtime facility that +** is available. This routine returns 0 on success and +** non-zero on any kind of error. +** +** If the sqlite3GlobalConfig.bLocaltimeFault variable is true then this +** routine will always fail. +** +** EVIDENCE-OF: R-62172-00036 In this implementation, the standard C +** library function localtime_r() is used to assist in the calculation of +** local time. +*/ +static int osLocaltime(time_t *t, struct tm *pTm){ + int rc; +#if !HAVE_LOCALTIME_R && !HAVE_LOCALTIME_S + struct tm *pX; +#if SQLITE_THREADSAFE>0 + sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); +#endif + sqlite3_mutex_enter(mutex); + pX = localtime(t); +#ifndef SQLITE_UNTESTABLE + if( sqlite3GlobalConfig.bLocaltimeFault ) pX = 0; +#endif + if( pX ) *pTm = *pX; + sqlite3_mutex_leave(mutex); + rc = pX==0; +#else +#ifndef SQLITE_UNTESTABLE + if( sqlite3GlobalConfig.bLocaltimeFault ) return 1; +#endif +#if HAVE_LOCALTIME_R + rc = localtime_r(t, pTm)==0; +#else + rc = localtime_s(pTm, t); +#endif /* HAVE_LOCALTIME_R */ +#endif /* HAVE_LOCALTIME_R || HAVE_LOCALTIME_S */ + return rc; +} +#endif /* SQLITE_OMIT_LOCALTIME */ + + +#ifndef SQLITE_OMIT_LOCALTIME +/* +** Compute the difference (in milliseconds) between localtime and UTC +** (a.k.a. GMT) for the time value p where p is in UTC. If no error occurs, +** return this value and set *pRc to SQLITE_OK. +** +** Or, if an error does occur, set *pRc to SQLITE_ERROR. The returned value +** is undefined in this case. +*/ +static sqlite3_int64 localtimeOffset( + DateTime *p, /* Date at which to calculate offset */ + sqlite3_context *pCtx, /* Write error here if one occurs */ + int *pRc /* OUT: Error code. SQLITE_OK or ERROR */ +){ + DateTime x, y; + time_t t; + struct tm sLocal; + + /* Initialize the contents of sLocal to avoid a compiler warning. */ + memset(&sLocal, 0, sizeof(sLocal)); + + x = *p; + computeYMD_HMS(&x); + if( x.Y<1971 || x.Y>=2038 ){ + /* EVIDENCE-OF: R-55269-29598 The localtime_r() C function normally only + ** works for years between 1970 and 2037. For dates outside this range, + ** SQLite attempts to map the year into an equivalent year within this + ** range, do the calculation, then map the year back. + */ + x.Y = 2000; + x.M = 1; + x.D = 1; + x.h = 0; + x.m = 0; + x.s = 0.0; + } else { + int s = (int)(x.s + 0.5); + x.s = s; + } + x.tz = 0; + x.validJD = 0; + computeJD(&x); + t = (time_t)(x.iJD/1000 - 21086676*(i64)10000); + if( osLocaltime(&t, &sLocal) ){ + sqlite3_result_error(pCtx, "local time unavailable", -1); + *pRc = SQLITE_ERROR; + return 0; + } + y.Y = sLocal.tm_year + 1900; + y.M = sLocal.tm_mon + 1; + y.D = sLocal.tm_mday; + y.h = sLocal.tm_hour; + y.m = sLocal.tm_min; + y.s = sLocal.tm_sec; + y.validYMD = 1; + y.validHMS = 1; + y.validJD = 0; + y.rawS = 0; + y.validTZ = 0; + y.isError = 0; + computeJD(&y); + *pRc = SQLITE_OK; + return y.iJD - x.iJD; +} +#endif /* SQLITE_OMIT_LOCALTIME */ + +/* +** The following table defines various date transformations of the form +** +** 'NNN days' +** +** Where NNN is an arbitrary floating-point number and "days" can be one +** of several units of time. +*/ +static const struct { + u8 eType; /* Transformation type code */ + u8 nName; /* Length of th name */ + char *zName; /* Name of the transformation */ + double rLimit; /* Maximum NNN value for this transform */ + double rXform; /* Constant used for this transform */ +} aXformType[] = { + { 0, 6, "second", 464269060800.0, 1000.0 }, + { 0, 6, "minute", 7737817680.0, 60000.0 }, + { 0, 4, "hour", 128963628.0, 3600000.0 }, + { 0, 3, "day", 5373485.0, 86400000.0 }, + { 1, 5, "month", 176546.0, 2592000000.0 }, + { 2, 4, "year", 14713.0, 31536000000.0 }, +}; + +/* +** Process a modifier to a date-time stamp. The modifiers are +** as follows: +** +** NNN days +** NNN hours +** NNN minutes +** NNN.NNNN seconds +** NNN months +** NNN years +** start of month +** start of year +** start of week +** start of day +** weekday N +** unixepoch +** localtime +** utc +** +** Return 0 on success and 1 if there is any kind of error. If the error +** is in a system call (i.e. localtime()), then an error message is written +** to context pCtx. If the error is an unrecognized modifier, no error is +** written to pCtx. +*/ +static int parseModifier( + sqlite3_context *pCtx, /* Function context */ + const char *z, /* The text of the modifier */ + int n, /* Length of zMod in bytes */ + DateTime *p /* The date/time value to be modified */ +){ + int rc = 1; + double r; + switch(sqlite3UpperToLower[(u8)z[0]] ){ +#ifndef SQLITE_OMIT_LOCALTIME + case 'l': { + /* localtime + ** + ** Assuming the current time value is UTC (a.k.a. GMT), shift it to + ** show local time. + */ + if( sqlite3_stricmp(z, "localtime")==0 && sqlite3NotPureFunc(pCtx) ){ + computeJD(p); + p->iJD += localtimeOffset(p, pCtx, &rc); + clearYMD_HMS_TZ(p); + } + break; + } +#endif + case 'u': { + /* + ** unixepoch + ** + ** Treat the current value of p->s as the number of + ** seconds since 1970. Convert to a real julian day number. + */ + if( sqlite3_stricmp(z, "unixepoch")==0 && p->rawS ){ + r = p->s*1000.0 + 210866760000000.0; + if( r>=0.0 && r<464269060800000.0 ){ + clearYMD_HMS_TZ(p); + p->iJD = (sqlite3_int64)(r + 0.5); + p->validJD = 1; + p->rawS = 0; + rc = 0; + } + } +#ifndef SQLITE_OMIT_LOCALTIME + else if( sqlite3_stricmp(z, "utc")==0 && sqlite3NotPureFunc(pCtx) ){ + if( p->tzSet==0 ){ + sqlite3_int64 c1; + computeJD(p); + c1 = localtimeOffset(p, pCtx, &rc); + if( rc==SQLITE_OK ){ + p->iJD -= c1; + clearYMD_HMS_TZ(p); + p->iJD += c1 - localtimeOffset(p, pCtx, &rc); + } + p->tzSet = 1; + }else{ + rc = SQLITE_OK; + } + } +#endif + break; + } + case 'w': { + /* + ** weekday N + ** + ** Move the date to the same time on the next occurrence of + ** weekday N where 0==Sunday, 1==Monday, and so forth. If the + ** date is already on the appropriate weekday, this is a no-op. + */ + if( sqlite3_strnicmp(z, "weekday ", 8)==0 + && sqlite3AtoF(&z[8], &r, sqlite3Strlen30(&z[8]), SQLITE_UTF8)>0 + && (n=(int)r)==r && n>=0 && r<7 ){ + sqlite3_int64 Z; + computeYMD_HMS(p); + p->validTZ = 0; + p->validJD = 0; + computeJD(p); + Z = ((p->iJD + 129600000)/86400000) % 7; + if( Z>n ) Z -= 7; + p->iJD += (n - Z)*86400000; + clearYMD_HMS_TZ(p); + rc = 0; + } + break; + } + case 's': { + /* + ** start of TTTTT + ** + ** Move the date backwards to the beginning of the current day, + ** or month or year. + */ + if( sqlite3_strnicmp(z, "start of ", 9)!=0 ) break; + if( !p->validJD && !p->validYMD && !p->validHMS ) break; + z += 9; + computeYMD(p); + p->validHMS = 1; + p->h = p->m = 0; + p->s = 0.0; + p->rawS = 0; + p->validTZ = 0; + p->validJD = 0; + if( sqlite3_stricmp(z,"month")==0 ){ + p->D = 1; + rc = 0; + }else if( sqlite3_stricmp(z,"year")==0 ){ + p->M = 1; + p->D = 1; + rc = 0; + }else if( sqlite3_stricmp(z,"day")==0 ){ + rc = 0; + } + break; + } + case '+': + case '-': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': { + double rRounder; + int i; + for(n=1; z[n] && z[n]!=':' && !sqlite3Isspace(z[n]); n++){} + if( sqlite3AtoF(z, &r, n, SQLITE_UTF8)<=0 ){ + rc = 1; + break; + } + if( z[n]==':' ){ + /* A modifier of the form (+|-)HH:MM:SS.FFF adds (or subtracts) the + ** specified number of hours, minutes, seconds, and fractional seconds + ** to the time. The ".FFF" may be omitted. The ":SS.FFF" may be + ** omitted. + */ + const char *z2 = z; + DateTime tx; + sqlite3_int64 day; + if( !sqlite3Isdigit(*z2) ) z2++; + memset(&tx, 0, sizeof(tx)); + if( parseHhMmSs(z2, &tx) ) break; + computeJD(&tx); + tx.iJD -= 43200000; + day = tx.iJD/86400000; + tx.iJD -= day*86400000; + if( z[0]=='-' ) tx.iJD = -tx.iJD; + computeJD(p); + clearYMD_HMS_TZ(p); + p->iJD += tx.iJD; + rc = 0; + break; + } + + /* If control reaches this point, it means the transformation is + ** one of the forms like "+NNN days". */ + z += n; + while( sqlite3Isspace(*z) ) z++; + n = sqlite3Strlen30(z); + if( n>10 || n<3 ) break; + if( sqlite3UpperToLower[(u8)z[n-1]]=='s' ) n--; + computeJD(p); + rc = 1; + rRounder = r<0 ? -0.5 : +0.5; + for(i=0; i-aXformType[i].rLimit && rM += (int)r; + x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12; + p->Y += x; + p->M -= x*12; + p->validJD = 0; + r -= (int)r; + break; + } + case 2: { /* Special processing to add years */ + int y = (int)r; + computeYMD_HMS(p); + p->Y += y; + p->validJD = 0; + r -= (int)r; + break; + } + } + computeJD(p); + p->iJD += (sqlite3_int64)(r*aXformType[i].rXform + rRounder); + rc = 0; + break; + } + } + clearYMD_HMS_TZ(p); + break; + } + default: { + break; + } + } + return rc; +} + +/* +** Process time function arguments. argv[0] is a date-time stamp. +** argv[1] and following are modifiers. Parse them all and write +** the resulting time into the DateTime structure p. Return 0 +** on success and 1 if there are any errors. +** +** If there are zero parameters (if even argv[0] is undefined) +** then assume a default value of "now" for argv[0]. +*/ +static int isDate( + sqlite3_context *context, + int argc, + sqlite3_value **argv, + DateTime *p +){ + int i, n; + const unsigned char *z; + int eType; + memset(p, 0, sizeof(*p)); + if( argc==0 ){ + return setDateTimeToCurrent(context, p); + } + if( (eType = sqlite3_value_type(argv[0]))==SQLITE_FLOAT + || eType==SQLITE_INTEGER ){ + setRawDateNumber(p, sqlite3_value_double(argv[0])); + }else{ + z = sqlite3_value_text(argv[0]); + if( !z || parseDateOrTime(context, (char*)z, p) ){ + return 1; + } + } + for(i=1; iisError || !validJulianDay(p->iJD) ) return 1; + return 0; +} + + +/* +** The following routines implement the various date and time functions +** of SQLite. +*/ + +/* +** julianday( TIMESTRING, MOD, MOD, ...) +** +** Return the julian day number of the date specified in the arguments +*/ +static void juliandayFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + DateTime x; + if( isDate(context, argc, argv, &x)==0 ){ + computeJD(&x); + sqlite3_result_double(context, x.iJD/86400000.0); + } +} + +/* +** datetime( TIMESTRING, MOD, MOD, ...) +** +** Return YYYY-MM-DD HH:MM:SS +*/ +static void datetimeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + DateTime x; + if( isDate(context, argc, argv, &x)==0 ){ + char zBuf[100]; + computeYMD_HMS(&x); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d %02d:%02d:%02d", + x.Y, x.M, x.D, x.h, x.m, (int)(x.s)); + sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT); + } +} + +/* +** time( TIMESTRING, MOD, MOD, ...) +** +** Return HH:MM:SS +*/ +static void timeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + DateTime x; + if( isDate(context, argc, argv, &x)==0 ){ + char zBuf[100]; + computeHMS(&x); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s); + sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT); + } +} + +/* +** date( TIMESTRING, MOD, MOD, ...) +** +** Return YYYY-MM-DD +*/ +static void dateFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + DateTime x; + if( isDate(context, argc, argv, &x)==0 ){ + char zBuf[100]; + computeYMD(&x); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D); + sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT); + } +} + +/* +** strftime( FORMAT, TIMESTRING, MOD, MOD, ...) +** +** Return a string described by FORMAT. Conversions as follows: +** +** %d day of month +** %f ** fractional seconds SS.SSS +** %H hour 00-24 +** %j day of year 000-366 +** %J ** julian day number +** %m month 01-12 +** %M minute 00-59 +** %s seconds since 1970-01-01 +** %S seconds 00-59 +** %w day of week 0-6 sunday==0 +** %W week of year 00-53 +** %Y year 0000-9999 +** %% % +*/ +static void strftimeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + DateTime x; + u64 n; + size_t i,j; + char *z; + sqlite3 *db; + const char *zFmt; + char zBuf[100]; + if( argc==0 ) return; + zFmt = (const char*)sqlite3_value_text(argv[0]); + if( zFmt==0 || isDate(context, argc-1, argv+1, &x) ) return; + db = sqlite3_context_db_handle(context); + for(i=0, n=1; zFmt[i]; i++, n++){ + if( zFmt[i]=='%' ){ + switch( zFmt[i+1] ){ + case 'd': + case 'H': + case 'm': + case 'M': + case 'S': + case 'W': + n++; + /* fall thru */ + case 'w': + case '%': + break; + case 'f': + n += 8; + break; + case 'j': + n += 3; + break; + case 'Y': + n += 8; + break; + case 's': + case 'J': + n += 50; + break; + default: + return; /* ERROR. return a NULL */ + } + i++; + } + } + testcase( n==sizeof(zBuf)-1 ); + testcase( n==sizeof(zBuf) ); + testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH]+1 ); + testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH] ); + if( n(u64)db->aLimit[SQLITE_LIMIT_LENGTH] ){ + sqlite3_result_error_toobig(context); + return; + }else{ + z = sqlite3DbMallocRawNN(db, (int)n); + if( z==0 ){ + sqlite3_result_error_nomem(context); + return; + } + } + computeJD(&x); + computeYMD_HMS(&x); + for(i=j=0; zFmt[i]; i++){ + if( zFmt[i]!='%' ){ + z[j++] = zFmt[i]; + }else{ + i++; + switch( zFmt[i] ){ + case 'd': sqlite3_snprintf(3, &z[j],"%02d",x.D); j+=2; break; + case 'f': { + double s = x.s; + if( s>59.999 ) s = 59.999; + sqlite3_snprintf(7, &z[j],"%06.3f", s); + j += sqlite3Strlen30(&z[j]); + break; + } + case 'H': sqlite3_snprintf(3, &z[j],"%02d",x.h); j+=2; break; + case 'W': /* Fall thru */ + case 'j': { + int nDay; /* Number of days since 1st day of year */ + DateTime y = x; + y.validJD = 0; + y.M = 1; + y.D = 1; + computeJD(&y); + nDay = (int)((x.iJD-y.iJD+43200000)/86400000); + if( zFmt[i]=='W' ){ + int wd; /* 0=Monday, 1=Tuesday, ... 6=Sunday */ + wd = (int)(((x.iJD+43200000)/86400000)%7); + sqlite3_snprintf(3, &z[j],"%02d",(nDay+7-wd)/7); + j += 2; + }else{ + sqlite3_snprintf(4, &z[j],"%03d",nDay+1); + j += 3; + } + break; + } + case 'J': { + sqlite3_snprintf(20, &z[j],"%.16g",x.iJD/86400000.0); + j+=sqlite3Strlen30(&z[j]); + break; + } + case 'm': sqlite3_snprintf(3, &z[j],"%02d",x.M); j+=2; break; + case 'M': sqlite3_snprintf(3, &z[j],"%02d",x.m); j+=2; break; + case 's': { + i64 iS = (i64)(x.iJD/1000 - 21086676*(i64)10000); + sqlite3Int64ToText(iS, &z[j]); + j += sqlite3Strlen30(&z[j]); + break; + } + case 'S': sqlite3_snprintf(3,&z[j],"%02d",(int)x.s); j+=2; break; + case 'w': { + z[j++] = (char)(((x.iJD+129600000)/86400000) % 7) + '0'; + break; + } + case 'Y': { + sqlite3_snprintf(5,&z[j],"%04d",x.Y); j+=sqlite3Strlen30(&z[j]); + break; + } + default: z[j++] = '%'; break; + } + } + } + z[j] = 0; + sqlite3_result_text(context, z, -1, + z==zBuf ? SQLITE_TRANSIENT : SQLITE_DYNAMIC); +} + +/* +** current_time() +** +** This function returns the same value as time('now'). +*/ +static void ctimeFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **NotUsed2 +){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + timeFunc(context, 0, 0); +} + +/* +** current_date() +** +** This function returns the same value as date('now'). +*/ +static void cdateFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **NotUsed2 +){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + dateFunc(context, 0, 0); +} + +/* +** current_timestamp() +** +** This function returns the same value as datetime('now'). +*/ +static void ctimestampFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **NotUsed2 +){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + datetimeFunc(context, 0, 0); +} +#endif /* !defined(SQLITE_OMIT_DATETIME_FUNCS) */ + +#ifdef SQLITE_OMIT_DATETIME_FUNCS +/* +** If the library is compiled to omit the full-scale date and time +** handling (to get a smaller binary), the following minimal version +** of the functions current_time(), current_date() and current_timestamp() +** are included instead. This is to support column declarations that +** include "DEFAULT CURRENT_TIME" etc. +** +** This function uses the C-library functions time(), gmtime() +** and strftime(). The format string to pass to strftime() is supplied +** as the user-data for the function. +*/ +static void currentTimeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + time_t t; + char *zFormat = (char *)sqlite3_user_data(context); + sqlite3_int64 iT; + struct tm *pTm; + struct tm sNow; + char zBuf[20]; + + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(argv); + + iT = sqlite3StmtCurrentTime(context); + if( iT<=0 ) return; + t = iT/1000 - 10000*(sqlite3_int64)21086676; +#if HAVE_GMTIME_R + pTm = gmtime_r(&t, &sNow); +#else + sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN)); + pTm = gmtime(&t); + if( pTm ) memcpy(&sNow, pTm, sizeof(sNow)); + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN)); +#endif + if( pTm ){ + strftime(zBuf, 20, zFormat, &sNow); + sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT); + } +} +#endif + +/* +** This function registered all of the above C functions as SQL +** functions. This should be the only routine in this file with +** external linkage. +*/ +SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void){ + static FuncDef aDateTimeFuncs[] = { +#ifndef SQLITE_OMIT_DATETIME_FUNCS + PURE_DATE(julianday, -1, 0, 0, juliandayFunc ), + PURE_DATE(date, -1, 0, 0, dateFunc ), + PURE_DATE(time, -1, 0, 0, timeFunc ), + PURE_DATE(datetime, -1, 0, 0, datetimeFunc ), + PURE_DATE(strftime, -1, 0, 0, strftimeFunc ), + DFUNCTION(current_time, 0, 0, 0, ctimeFunc ), + DFUNCTION(current_timestamp, 0, 0, 0, ctimestampFunc), + DFUNCTION(current_date, 0, 0, 0, cdateFunc ), +#else + STR_FUNCTION(current_time, 0, "%H:%M:%S", 0, currentTimeFunc), + STR_FUNCTION(current_date, 0, "%Y-%m-%d", 0, currentTimeFunc), + STR_FUNCTION(current_timestamp, 0, "%Y-%m-%d %H:%M:%S", 0, currentTimeFunc), +#endif + }; + sqlite3InsertBuiltinFuncs(aDateTimeFuncs, ArraySize(aDateTimeFuncs)); +} + +/************** End of date.c ************************************************/ +/************** Begin file os.c **********************************************/ +/* +** 2005 November 29 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains OS interface code that is common to all +** architectures. +*/ +/* #include "sqliteInt.h" */ + +/* +** If we compile with the SQLITE_TEST macro set, then the following block +** of code will give us the ability to simulate a disk I/O error. This +** is used for testing the I/O recovery logic. +*/ +#if defined(SQLITE_TEST) +SQLITE_API int sqlite3_io_error_hit = 0; /* Total number of I/O Errors */ +SQLITE_API int sqlite3_io_error_hardhit = 0; /* Number of non-benign errors */ +SQLITE_API int sqlite3_io_error_pending = 0; /* Count down to first I/O error */ +SQLITE_API int sqlite3_io_error_persist = 0; /* True if I/O errors persist */ +SQLITE_API int sqlite3_io_error_benign = 0; /* True if errors are benign */ +SQLITE_API int sqlite3_diskfull_pending = 0; +SQLITE_API int sqlite3_diskfull = 0; +#endif /* defined(SQLITE_TEST) */ + +/* +** When testing, also keep a count of the number of open files. +*/ +#if defined(SQLITE_TEST) +SQLITE_API int sqlite3_open_file_count = 0; +#endif /* defined(SQLITE_TEST) */ + +/* +** The default SQLite sqlite3_vfs implementations do not allocate +** memory (actually, os_unix.c allocates a small amount of memory +** from within OsOpen()), but some third-party implementations may. +** So we test the effects of a malloc() failing and the sqlite3OsXXX() +** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro. +** +** The following functions are instrumented for malloc() failure +** testing: +** +** sqlite3OsRead() +** sqlite3OsWrite() +** sqlite3OsSync() +** sqlite3OsFileSize() +** sqlite3OsLock() +** sqlite3OsCheckReservedLock() +** sqlite3OsFileControl() +** sqlite3OsShmMap() +** sqlite3OsOpen() +** sqlite3OsDelete() +** sqlite3OsAccess() +** sqlite3OsFullPathname() +** +*/ +#if defined(SQLITE_TEST) +SQLITE_API int sqlite3_memdebug_vfs_oom_test = 1; + #define DO_OS_MALLOC_TEST(x) \ + if (sqlite3_memdebug_vfs_oom_test && (!x || !sqlite3JournalIsInMemory(x))) { \ + void *pTstAlloc = sqlite3Malloc(10); \ + if (!pTstAlloc) return SQLITE_IOERR_NOMEM_BKPT; \ + sqlite3_free(pTstAlloc); \ + } +#else + #define DO_OS_MALLOC_TEST(x) +#endif + +/* +** The following routines are convenience wrappers around methods +** of the sqlite3_file object. This is mostly just syntactic sugar. All +** of this would be completely automatic if SQLite were coded using +** C++ instead of plain old C. +*/ +SQLITE_PRIVATE void sqlite3OsClose(sqlite3_file *pId){ + if( pId->pMethods ){ + pId->pMethods->xClose(pId); + pId->pMethods = 0; + } +} +SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xRead(id, pBuf, amt, offset); +} +SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xWrite(id, pBuf, amt, offset); +} +SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file *id, i64 size){ + return id->pMethods->xTruncate(id, size); +} +SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file *id, int flags){ + DO_OS_MALLOC_TEST(id); + return flags ? id->pMethods->xSync(id, flags) : SQLITE_OK; +} +SQLITE_PRIVATE int sqlite3OsFileSize(sqlite3_file *id, i64 *pSize){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xFileSize(id, pSize); +} +SQLITE_PRIVATE int sqlite3OsLock(sqlite3_file *id, int lockType){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xLock(id, lockType); +} +SQLITE_PRIVATE int sqlite3OsUnlock(sqlite3_file *id, int lockType){ + return id->pMethods->xUnlock(id, lockType); +} +SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xCheckReservedLock(id, pResOut); +} + +/* +** Use sqlite3OsFileControl() when we are doing something that might fail +** and we need to know about the failures. Use sqlite3OsFileControlHint() +** when simply tossing information over the wall to the VFS and we do not +** really care if the VFS receives and understands the information since it +** is only a hint and can be safely ignored. The sqlite3OsFileControlHint() +** routine has no return value since the return value would be meaningless. +*/ +SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){ + if( id->pMethods==0 ) return SQLITE_NOTFOUND; +#ifdef SQLITE_TEST + if( op!=SQLITE_FCNTL_COMMIT_PHASETWO + && op!=SQLITE_FCNTL_LOCK_TIMEOUT + ){ + /* Faults are not injected into COMMIT_PHASETWO because, assuming SQLite + ** is using a regular VFS, it is called after the corresponding + ** transaction has been committed. Injecting a fault at this point + ** confuses the test scripts - the COMMIT comand returns SQLITE_NOMEM + ** but the transaction is committed anyway. + ** + ** The core must call OsFileControl() though, not OsFileControlHint(), + ** as if a custom VFS (e.g. zipvfs) returns an error here, it probably + ** means the commit really has failed and an error should be returned + ** to the user. */ + DO_OS_MALLOC_TEST(id); + } +#endif + return id->pMethods->xFileControl(id, op, pArg); +} +SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file *id, int op, void *pArg){ + if( id->pMethods ) (void)id->pMethods->xFileControl(id, op, pArg); +} + +SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id){ + int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize; + return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE); +} +SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id){ + return id->pMethods->xDeviceCharacteristics(id); +} +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int offset, int n, int flags){ + return id->pMethods->xShmLock(id, offset, n, flags); +} +SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id){ + id->pMethods->xShmBarrier(id); +} +SQLITE_PRIVATE int sqlite3OsShmUnmap(sqlite3_file *id, int deleteFlag){ + return id->pMethods->xShmUnmap(id, deleteFlag); +} +SQLITE_PRIVATE int sqlite3OsShmMap( + sqlite3_file *id, /* Database file handle */ + int iPage, + int pgsz, + int bExtend, /* True to extend file if necessary */ + void volatile **pp /* OUT: Pointer to mapping */ +){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xShmMap(id, iPage, pgsz, bExtend, pp); +} +#endif /* SQLITE_OMIT_WAL */ + +#if SQLITE_MAX_MMAP_SIZE>0 +/* The real implementation of xFetch and xUnfetch */ +SQLITE_PRIVATE int sqlite3OsFetch(sqlite3_file *id, i64 iOff, int iAmt, void **pp){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xFetch(id, iOff, iAmt, pp); +} +SQLITE_PRIVATE int sqlite3OsUnfetch(sqlite3_file *id, i64 iOff, void *p){ + return id->pMethods->xUnfetch(id, iOff, p); +} +#else +/* No-op stubs to use when memory-mapped I/O is disabled */ +SQLITE_PRIVATE int sqlite3OsFetch(sqlite3_file *id, i64 iOff, int iAmt, void **pp){ + *pp = 0; + return SQLITE_OK; +} +SQLITE_PRIVATE int sqlite3OsUnfetch(sqlite3_file *id, i64 iOff, void *p){ + return SQLITE_OK; +} +#endif + +/* +** The next group of routines are convenience wrappers around the +** VFS methods. +*/ +SQLITE_PRIVATE int sqlite3OsOpen( + sqlite3_vfs *pVfs, + const char *zPath, + sqlite3_file *pFile, + int flags, + int *pFlagsOut +){ + int rc; + DO_OS_MALLOC_TEST(0); + /* 0x87f7f is a mask of SQLITE_OPEN_ flags that are valid to be passed + ** down into the VFS layer. Some SQLITE_OPEN_ flags (for example, + ** SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before + ** reaching the VFS. */ + rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x1087f7f, pFlagsOut); + assert( rc==SQLITE_OK || pFile->pMethods==0 ); + return rc; +} +SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ + DO_OS_MALLOC_TEST(0); + assert( dirSync==0 || dirSync==1 ); + return pVfs->xDelete(pVfs, zPath, dirSync); +} +SQLITE_PRIVATE int sqlite3OsAccess( + sqlite3_vfs *pVfs, + const char *zPath, + int flags, + int *pResOut +){ + DO_OS_MALLOC_TEST(0); + return pVfs->xAccess(pVfs, zPath, flags, pResOut); +} +SQLITE_PRIVATE int sqlite3OsFullPathname( + sqlite3_vfs *pVfs, + const char *zPath, + int nPathOut, + char *zPathOut +){ + DO_OS_MALLOC_TEST(0); + zPathOut[0] = 0; + return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut); +} +#ifndef SQLITE_OMIT_LOAD_EXTENSION +SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){ + return pVfs->xDlOpen(pVfs, zPath); +} +SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ + pVfs->xDlError(pVfs, nByte, zBufOut); +} +SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHdle, const char *zSym))(void){ + return pVfs->xDlSym(pVfs, pHdle, zSym); +} +SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){ + pVfs->xDlClose(pVfs, pHandle); +} +#endif /* SQLITE_OMIT_LOAD_EXTENSION */ +SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ + if( sqlite3Config.iPrngSeed ){ + memset(zBufOut, 0, nByte); + if( ALWAYS(nByte>(signed)sizeof(unsigned)) ) nByte = sizeof(unsigned int); + memcpy(zBufOut, &sqlite3Config.iPrngSeed, nByte); + return SQLITE_OK; + }else{ + return pVfs->xRandomness(pVfs, nByte, zBufOut); + } + +} +SQLITE_PRIVATE int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){ + return pVfs->xSleep(pVfs, nMicro); +} +SQLITE_PRIVATE int sqlite3OsGetLastError(sqlite3_vfs *pVfs){ + return pVfs->xGetLastError ? pVfs->xGetLastError(pVfs, 0, 0) : 0; +} +SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){ + int rc; + /* IMPLEMENTATION-OF: R-49045-42493 SQLite will use the xCurrentTimeInt64() + ** method to get the current date and time if that method is available + ** (if iVersion is 2 or greater and the function pointer is not NULL) and + ** will fall back to xCurrentTime() if xCurrentTimeInt64() is + ** unavailable. + */ + if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){ + rc = pVfs->xCurrentTimeInt64(pVfs, pTimeOut); + }else{ + double r; + rc = pVfs->xCurrentTime(pVfs, &r); + *pTimeOut = (sqlite3_int64)(r*86400000.0); + } + return rc; +} + +SQLITE_PRIVATE int sqlite3OsOpenMalloc( + sqlite3_vfs *pVfs, + const char *zFile, + sqlite3_file **ppFile, + int flags, + int *pOutFlags +){ + int rc; + sqlite3_file *pFile; + pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile); + if( pFile ){ + rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags); + if( rc!=SQLITE_OK ){ + sqlite3_free(pFile); + }else{ + *ppFile = pFile; + } + }else{ + rc = SQLITE_NOMEM_BKPT; + } + return rc; +} +SQLITE_PRIVATE void sqlite3OsCloseFree(sqlite3_file *pFile){ + assert( pFile ); + sqlite3OsClose(pFile); + sqlite3_free(pFile); +} + +/* +** This function is a wrapper around the OS specific implementation of +** sqlite3_os_init(). The purpose of the wrapper is to provide the +** ability to simulate a malloc failure, so that the handling of an +** error in sqlite3_os_init() by the upper layers can be tested. +*/ +SQLITE_PRIVATE int sqlite3OsInit(void){ + void *p = sqlite3_malloc(10); + if( p==0 ) return SQLITE_NOMEM_BKPT; + sqlite3_free(p); + return sqlite3_os_init(); +} + +/* +** The list of all registered VFS implementations. +*/ +static sqlite3_vfs * SQLITE_WSD vfsList = 0; +#define vfsList GLOBAL(sqlite3_vfs *, vfsList) + +/* +** Locate a VFS by name. If no name is given, simply return the +** first VFS on the list. +*/ +SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){ + sqlite3_vfs *pVfs = 0; +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex; +#endif +#ifndef SQLITE_OMIT_AUTOINIT + int rc = sqlite3_initialize(); + if( rc ) return 0; +#endif +#if SQLITE_THREADSAFE + mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); +#endif + sqlite3_mutex_enter(mutex); + for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){ + if( zVfs==0 ) break; + if( strcmp(zVfs, pVfs->zName)==0 ) break; + } + sqlite3_mutex_leave(mutex); + return pVfs; +} + +/* +** Unlink a VFS from the linked list +*/ +static void vfsUnlink(sqlite3_vfs *pVfs){ + assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN)) ); + if( pVfs==0 ){ + /* No-op */ + }else if( vfsList==pVfs ){ + vfsList = pVfs->pNext; + }else if( vfsList ){ + sqlite3_vfs *p = vfsList; + while( p->pNext && p->pNext!=pVfs ){ + p = p->pNext; + } + if( p->pNext==pVfs ){ + p->pNext = pVfs->pNext; + } + } +} + +/* +** Register a VFS with the system. It is harmless to register the same +** VFS multiple times. The new VFS becomes the default if makeDflt is +** true. +*/ +SQLITE_API int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){ + MUTEX_LOGIC(sqlite3_mutex *mutex;) +#ifndef SQLITE_OMIT_AUTOINIT + int rc = sqlite3_initialize(); + if( rc ) return rc; +#endif +#ifdef SQLITE_ENABLE_API_ARMOR + if( pVfs==0 ) return SQLITE_MISUSE_BKPT; +#endif + + MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); ) + sqlite3_mutex_enter(mutex); + vfsUnlink(pVfs); + if( makeDflt || vfsList==0 ){ + pVfs->pNext = vfsList; + vfsList = pVfs; + }else{ + pVfs->pNext = vfsList->pNext; + vfsList->pNext = pVfs; + } + assert(vfsList); + sqlite3_mutex_leave(mutex); + return SQLITE_OK; +} + +/* +** Unregister a VFS so that it is no longer accessible. +*/ +SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){ + MUTEX_LOGIC(sqlite3_mutex *mutex;) +#ifndef SQLITE_OMIT_AUTOINIT + int rc = sqlite3_initialize(); + if( rc ) return rc; +#endif + MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); ) + sqlite3_mutex_enter(mutex); + vfsUnlink(pVfs); + sqlite3_mutex_leave(mutex); + return SQLITE_OK; +} + +/************** End of os.c **************************************************/ +/************** Begin file fault.c *******************************************/ +/* +** 2008 Jan 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code to support the concept of "benign" +** malloc failures (when the xMalloc() or xRealloc() method of the +** sqlite3_mem_methods structure fails to allocate a block of memory +** and returns 0). +** +** Most malloc failures are non-benign. After they occur, SQLite +** abandons the current operation and returns an error code (usually +** SQLITE_NOMEM) to the user. However, sometimes a fault is not necessarily +** fatal. For example, if a malloc fails while resizing a hash table, this +** is completely recoverable simply by not carrying out the resize. The +** hash table will continue to function normally. So a malloc failure +** during a hash table resize is a benign fault. +*/ + +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_UNTESTABLE + +/* +** Global variables. +*/ +typedef struct BenignMallocHooks BenignMallocHooks; +static SQLITE_WSD struct BenignMallocHooks { + void (*xBenignBegin)(void); + void (*xBenignEnd)(void); +} sqlite3Hooks = { 0, 0 }; + +/* The "wsdHooks" macro will resolve to the appropriate BenignMallocHooks +** structure. If writable static data is unsupported on the target, +** we have to locate the state vector at run-time. In the more common +** case where writable static data is supported, wsdHooks can refer directly +** to the "sqlite3Hooks" state vector declared above. +*/ +#ifdef SQLITE_OMIT_WSD +# define wsdHooksInit \ + BenignMallocHooks *x = &GLOBAL(BenignMallocHooks,sqlite3Hooks) +# define wsdHooks x[0] +#else +# define wsdHooksInit +# define wsdHooks sqlite3Hooks +#endif + + +/* +** Register hooks to call when sqlite3BeginBenignMalloc() and +** sqlite3EndBenignMalloc() are called, respectively. +*/ +SQLITE_PRIVATE void sqlite3BenignMallocHooks( + void (*xBenignBegin)(void), + void (*xBenignEnd)(void) +){ + wsdHooksInit; + wsdHooks.xBenignBegin = xBenignBegin; + wsdHooks.xBenignEnd = xBenignEnd; +} + +/* +** This (sqlite3EndBenignMalloc()) is called by SQLite code to indicate that +** subsequent malloc failures are benign. A call to sqlite3EndBenignMalloc() +** indicates that subsequent malloc failures are non-benign. +*/ +SQLITE_PRIVATE void sqlite3BeginBenignMalloc(void){ + wsdHooksInit; + if( wsdHooks.xBenignBegin ){ + wsdHooks.xBenignBegin(); + } +} +SQLITE_PRIVATE void sqlite3EndBenignMalloc(void){ + wsdHooksInit; + if( wsdHooks.xBenignEnd ){ + wsdHooks.xBenignEnd(); + } +} + +#endif /* #ifndef SQLITE_UNTESTABLE */ + +/************** End of fault.c ***********************************************/ +/************** Begin file mem0.c ********************************************/ +/* +** 2008 October 28 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains a no-op memory allocation drivers for use when +** SQLITE_ZERO_MALLOC is defined. The allocation drivers implemented +** here always fail. SQLite will not operate with these drivers. These +** are merely placeholders. Real drivers must be substituted using +** sqlite3_config() before SQLite will operate. +*/ +/* #include "sqliteInt.h" */ + +/* +** This version of the memory allocator is the default. It is +** used when no other memory allocator is specified using compile-time +** macros. +*/ +#ifdef SQLITE_ZERO_MALLOC + +/* +** No-op versions of all memory allocation routines +*/ +static void *sqlite3MemMalloc(int nByte){ return 0; } +static void sqlite3MemFree(void *pPrior){ return; } +static void *sqlite3MemRealloc(void *pPrior, int nByte){ return 0; } +static int sqlite3MemSize(void *pPrior){ return 0; } +static int sqlite3MemRoundup(int n){ return n; } +static int sqlite3MemInit(void *NotUsed){ return SQLITE_OK; } +static void sqlite3MemShutdown(void *NotUsed){ return; } + +/* +** This routine is the only routine in this file with external linkage. +** +** Populate the low-level memory allocation function pointers in +** sqlite3GlobalConfig.m with pointers to the routines in this file. +*/ +SQLITE_PRIVATE void sqlite3MemSetDefault(void){ + static const sqlite3_mem_methods defaultMethods = { + sqlite3MemMalloc, + sqlite3MemFree, + sqlite3MemRealloc, + sqlite3MemSize, + sqlite3MemRoundup, + sqlite3MemInit, + sqlite3MemShutdown, + 0 + }; + sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods); +} + +#endif /* SQLITE_ZERO_MALLOC */ + +/************** End of mem0.c ************************************************/ +/************** Begin file mem1.c ********************************************/ +/* +** 2007 August 14 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains low-level memory allocation drivers for when +** SQLite will use the standard C-library malloc/realloc/free interface +** to obtain the memory it needs. +** +** This file contains implementations of the low-level memory allocation +** routines specified in the sqlite3_mem_methods object. The content of +** this file is only used if SQLITE_SYSTEM_MALLOC is defined. The +** SQLITE_SYSTEM_MALLOC macro is defined automatically if neither the +** SQLITE_MEMDEBUG nor the SQLITE_WIN32_MALLOC macros are defined. The +** default configuration is to use memory allocation routines in this +** file. +** +** C-preprocessor macro summary: +** +** HAVE_MALLOC_USABLE_SIZE The configure script sets this symbol if +** the malloc_usable_size() interface exists +** on the target platform. Or, this symbol +** can be set manually, if desired. +** If an equivalent interface exists by +** a different name, using a separate -D +** option to rename it. +** +** SQLITE_WITHOUT_ZONEMALLOC Some older macs lack support for the zone +** memory allocator. Set this symbol to enable +** building on older macs. +** +** SQLITE_WITHOUT_MSIZE Set this symbol to disable the use of +** _msize() on windows systems. This might +** be necessary when compiling for Delphi, +** for example. +*/ +/* #include "sqliteInt.h" */ + +/* +** This version of the memory allocator is the default. It is +** used when no other memory allocator is specified using compile-time +** macros. +*/ +#ifdef SQLITE_SYSTEM_MALLOC +#if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC) + +/* +** Use the zone allocator available on apple products unless the +** SQLITE_WITHOUT_ZONEMALLOC symbol is defined. +*/ +#include +#include +#ifdef SQLITE_MIGHT_BE_SINGLE_CORE +#include +#endif /* SQLITE_MIGHT_BE_SINGLE_CORE */ +static malloc_zone_t* _sqliteZone_; +#define SQLITE_MALLOC(x) malloc_zone_malloc(_sqliteZone_, (x)) +#define SQLITE_FREE(x) malloc_zone_free(_sqliteZone_, (x)); +#define SQLITE_REALLOC(x,y) malloc_zone_realloc(_sqliteZone_, (x), (y)) +#define SQLITE_MALLOCSIZE(x) \ + (_sqliteZone_ ? _sqliteZone_->size(_sqliteZone_,x) : malloc_size(x)) + +#else /* if not __APPLE__ */ + +/* +** Use standard C library malloc and free on non-Apple systems. +** Also used by Apple systems if SQLITE_WITHOUT_ZONEMALLOC is defined. +*/ +#define SQLITE_MALLOC(x) malloc(x) +#define SQLITE_FREE(x) free(x) +#define SQLITE_REALLOC(x,y) realloc((x),(y)) + +/* +** The malloc.h header file is needed for malloc_usable_size() function +** on some systems (e.g. Linux). +*/ +#if HAVE_MALLOC_H && HAVE_MALLOC_USABLE_SIZE +# define SQLITE_USE_MALLOC_H 1 +# define SQLITE_USE_MALLOC_USABLE_SIZE 1 +/* +** The MSVCRT has malloc_usable_size(), but it is called _msize(). The +** use of _msize() is automatic, but can be disabled by compiling with +** -DSQLITE_WITHOUT_MSIZE. Using the _msize() function also requires +** the malloc.h header file. +*/ +#elif defined(_MSC_VER) && !defined(SQLITE_WITHOUT_MSIZE) +# define SQLITE_USE_MALLOC_H +# define SQLITE_USE_MSIZE +#endif + +/* +** Include the malloc.h header file, if necessary. Also set define macro +** SQLITE_MALLOCSIZE to the appropriate function name, which is _msize() +** for MSVC and malloc_usable_size() for most other systems (e.g. Linux). +** The memory size function can always be overridden manually by defining +** the macro SQLITE_MALLOCSIZE to the desired function name. +*/ +#if defined(SQLITE_USE_MALLOC_H) +# include +# if defined(SQLITE_USE_MALLOC_USABLE_SIZE) +# if !defined(SQLITE_MALLOCSIZE) +# define SQLITE_MALLOCSIZE(x) malloc_usable_size(x) +# endif +# elif defined(SQLITE_USE_MSIZE) +# if !defined(SQLITE_MALLOCSIZE) +# define SQLITE_MALLOCSIZE _msize +# endif +# endif +#endif /* defined(SQLITE_USE_MALLOC_H) */ + +#endif /* __APPLE__ or not __APPLE__ */ + +/* +** Like malloc(), but remember the size of the allocation +** so that we can find it later using sqlite3MemSize(). +** +** For this low-level routine, we are guaranteed that nByte>0 because +** cases of nByte<=0 will be intercepted and dealt with by higher level +** routines. +*/ +static void *sqlite3MemMalloc(int nByte){ +#ifdef SQLITE_MALLOCSIZE + void *p; + testcase( ROUND8(nByte)==nByte ); + p = SQLITE_MALLOC( nByte ); + if( p==0 ){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte); + } + return p; +#else + sqlite3_int64 *p; + assert( nByte>0 ); + testcase( ROUND8(nByte)!=nByte ); + p = SQLITE_MALLOC( nByte+8 ); + if( p ){ + p[0] = nByte; + p++; + }else{ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte); + } + return (void *)p; +#endif +} + +/* +** Like free() but works for allocations obtained from sqlite3MemMalloc() +** or sqlite3MemRealloc(). +** +** For this low-level routine, we already know that pPrior!=0 since +** cases where pPrior==0 will have been intecepted and dealt with +** by higher-level routines. +*/ +static void sqlite3MemFree(void *pPrior){ +#ifdef SQLITE_MALLOCSIZE + SQLITE_FREE(pPrior); +#else + sqlite3_int64 *p = (sqlite3_int64*)pPrior; + assert( pPrior!=0 ); + p--; + SQLITE_FREE(p); +#endif +} + +/* +** Report the allocated size of a prior return from xMalloc() +** or xRealloc(). +*/ +static int sqlite3MemSize(void *pPrior){ +#ifdef SQLITE_MALLOCSIZE + assert( pPrior!=0 ); + return (int)SQLITE_MALLOCSIZE(pPrior); +#else + sqlite3_int64 *p; + assert( pPrior!=0 ); + p = (sqlite3_int64*)pPrior; + p--; + return (int)p[0]; +#endif +} + +/* +** Like realloc(). Resize an allocation previously obtained from +** sqlite3MemMalloc(). +** +** For this low-level interface, we know that pPrior!=0. Cases where +** pPrior==0 while have been intercepted by higher-level routine and +** redirected to xMalloc. Similarly, we know that nByte>0 because +** cases where nByte<=0 will have been intercepted by higher-level +** routines and redirected to xFree. +*/ +static void *sqlite3MemRealloc(void *pPrior, int nByte){ +#ifdef SQLITE_MALLOCSIZE + void *p = SQLITE_REALLOC(pPrior, nByte); + if( p==0 ){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_NOMEM, + "failed memory resize %u to %u bytes", + SQLITE_MALLOCSIZE(pPrior), nByte); + } + return p; +#else + sqlite3_int64 *p = (sqlite3_int64*)pPrior; + assert( pPrior!=0 && nByte>0 ); + assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */ + p--; + p = SQLITE_REALLOC(p, nByte+8 ); + if( p ){ + p[0] = nByte; + p++; + }else{ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_NOMEM, + "failed memory resize %u to %u bytes", + sqlite3MemSize(pPrior), nByte); + } + return (void*)p; +#endif +} + +/* +** Round up a request size to the next valid allocation size. +*/ +static int sqlite3MemRoundup(int n){ + return ROUND8(n); +} + +/* +** Initialize this module. +*/ +static int sqlite3MemInit(void *NotUsed){ +#if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC) + int cpuCount; + size_t len; + if( _sqliteZone_ ){ + return SQLITE_OK; + } + len = sizeof(cpuCount); + /* One usually wants to use hw.acctivecpu for MT decisions, but not here */ + sysctlbyname("hw.ncpu", &cpuCount, &len, NULL, 0); + if( cpuCount>1 ){ + /* defer MT decisions to system malloc */ + _sqliteZone_ = malloc_default_zone(); + }else{ + /* only 1 core, use our own zone to contention over global locks, + ** e.g. we have our own dedicated locks */ + _sqliteZone_ = malloc_create_zone(4096, 0); + malloc_set_zone_name(_sqliteZone_, "Sqlite_Heap"); + } +#endif /* defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC) */ + UNUSED_PARAMETER(NotUsed); + return SQLITE_OK; +} + +/* +** Deinitialize this module. +*/ +static void sqlite3MemShutdown(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + return; +} + +/* +** This routine is the only routine in this file with external linkage. +** +** Populate the low-level memory allocation function pointers in +** sqlite3GlobalConfig.m with pointers to the routines in this file. +*/ +SQLITE_PRIVATE void sqlite3MemSetDefault(void){ + static const sqlite3_mem_methods defaultMethods = { + sqlite3MemMalloc, + sqlite3MemFree, + sqlite3MemRealloc, + sqlite3MemSize, + sqlite3MemRoundup, + sqlite3MemInit, + sqlite3MemShutdown, + 0 + }; + sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods); +} + +#endif /* SQLITE_SYSTEM_MALLOC */ + +/************** End of mem1.c ************************************************/ +/************** Begin file mem2.c ********************************************/ +/* +** 2007 August 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains low-level memory allocation drivers for when +** SQLite will use the standard C-library malloc/realloc/free interface +** to obtain the memory it needs while adding lots of additional debugging +** information to each allocation in order to help detect and fix memory +** leaks and memory usage errors. +** +** This file contains implementations of the low-level memory allocation +** routines specified in the sqlite3_mem_methods object. +*/ +/* #include "sqliteInt.h" */ + +/* +** This version of the memory allocator is used only if the +** SQLITE_MEMDEBUG macro is defined +*/ +#ifdef SQLITE_MEMDEBUG + +/* +** The backtrace functionality is only available with GLIBC +*/ +#ifdef __GLIBC__ + extern int backtrace(void**,int); + extern void backtrace_symbols_fd(void*const*,int,int); +#else +# define backtrace(A,B) 1 +# define backtrace_symbols_fd(A,B,C) +#endif +/* #include */ + +/* +** Each memory allocation looks like this: +** +** ------------------------------------------------------------------------ +** | Title | backtrace pointers | MemBlockHdr | allocation | EndGuard | +** ------------------------------------------------------------------------ +** +** The application code sees only a pointer to the allocation. We have +** to back up from the allocation pointer to find the MemBlockHdr. The +** MemBlockHdr tells us the size of the allocation and the number of +** backtrace pointers. There is also a guard word at the end of the +** MemBlockHdr. +*/ +struct MemBlockHdr { + i64 iSize; /* Size of this allocation */ + struct MemBlockHdr *pNext, *pPrev; /* Linked list of all unfreed memory */ + char nBacktrace; /* Number of backtraces on this alloc */ + char nBacktraceSlots; /* Available backtrace slots */ + u8 nTitle; /* Bytes of title; includes '\0' */ + u8 eType; /* Allocation type code */ + int iForeGuard; /* Guard word for sanity */ +}; + +/* +** Guard words +*/ +#define FOREGUARD 0x80F5E153 +#define REARGUARD 0xE4676B53 + +/* +** Number of malloc size increments to track. +*/ +#define NCSIZE 1000 + +/* +** All of the static variables used by this module are collected +** into a single structure named "mem". This is to keep the +** static variables organized and to reduce namespace pollution +** when this module is combined with other in the amalgamation. +*/ +static struct { + + /* + ** Mutex to control access to the memory allocation subsystem. + */ + sqlite3_mutex *mutex; + + /* + ** Head and tail of a linked list of all outstanding allocations + */ + struct MemBlockHdr *pFirst; + struct MemBlockHdr *pLast; + + /* + ** The number of levels of backtrace to save in new allocations. + */ + int nBacktrace; + void (*xBacktrace)(int, int, void **); + + /* + ** Title text to insert in front of each block + */ + int nTitle; /* Bytes of zTitle to save. Includes '\0' and padding */ + char zTitle[100]; /* The title text */ + + /* + ** sqlite3MallocDisallow() increments the following counter. + ** sqlite3MallocAllow() decrements it. + */ + int disallow; /* Do not allow memory allocation */ + + /* + ** Gather statistics on the sizes of memory allocations. + ** nAlloc[i] is the number of allocation attempts of i*8 + ** bytes. i==NCSIZE is the number of allocation attempts for + ** sizes more than NCSIZE*8 bytes. + */ + int nAlloc[NCSIZE]; /* Total number of allocations */ + int nCurrent[NCSIZE]; /* Current number of allocations */ + int mxCurrent[NCSIZE]; /* Highwater mark for nCurrent */ + +} mem; + + +/* +** Adjust memory usage statistics +*/ +static void adjustStats(int iSize, int increment){ + int i = ROUND8(iSize)/8; + if( i>NCSIZE-1 ){ + i = NCSIZE - 1; + } + if( increment>0 ){ + mem.nAlloc[i]++; + mem.nCurrent[i]++; + if( mem.nCurrent[i]>mem.mxCurrent[i] ){ + mem.mxCurrent[i] = mem.nCurrent[i]; + } + }else{ + mem.nCurrent[i]--; + assert( mem.nCurrent[i]>=0 ); + } +} + +/* +** Given an allocation, find the MemBlockHdr for that allocation. +** +** This routine checks the guards at either end of the allocation and +** if they are incorrect it asserts. +*/ +static struct MemBlockHdr *sqlite3MemsysGetHeader(void *pAllocation){ + struct MemBlockHdr *p; + int *pInt; + u8 *pU8; + int nReserve; + + p = (struct MemBlockHdr*)pAllocation; + p--; + assert( p->iForeGuard==(int)FOREGUARD ); + nReserve = ROUND8(p->iSize); + pInt = (int*)pAllocation; + pU8 = (u8*)pAllocation; + assert( pInt[nReserve/sizeof(int)]==(int)REARGUARD ); + /* This checks any of the "extra" bytes allocated due + ** to rounding up to an 8 byte boundary to ensure + ** they haven't been overwritten. + */ + while( nReserve-- > p->iSize ) assert( pU8[nReserve]==0x65 ); + return p; +} + +/* +** Return the number of bytes currently allocated at address p. +*/ +static int sqlite3MemSize(void *p){ + struct MemBlockHdr *pHdr; + if( !p ){ + return 0; + } + pHdr = sqlite3MemsysGetHeader(p); + return (int)pHdr->iSize; +} + +/* +** Initialize the memory allocation subsystem. +*/ +static int sqlite3MemInit(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + assert( (sizeof(struct MemBlockHdr)&7) == 0 ); + if( !sqlite3GlobalConfig.bMemstat ){ + /* If memory status is enabled, then the malloc.c wrapper will already + ** hold the STATIC_MEM mutex when the routines here are invoked. */ + mem.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); + } + return SQLITE_OK; +} + +/* +** Deinitialize the memory allocation subsystem. +*/ +static void sqlite3MemShutdown(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + mem.mutex = 0; +} + +/* +** Round up a request size to the next valid allocation size. +*/ +static int sqlite3MemRoundup(int n){ + return ROUND8(n); +} + +/* +** Fill a buffer with pseudo-random bytes. This is used to preset +** the content of a new memory allocation to unpredictable values and +** to clear the content of a freed allocation to unpredictable values. +*/ +static void randomFill(char *pBuf, int nByte){ + unsigned int x, y, r; + x = SQLITE_PTR_TO_INT(pBuf); + y = nByte | 1; + while( nByte >= 4 ){ + x = (x>>1) ^ (-(int)(x&1) & 0xd0000001); + y = y*1103515245 + 12345; + r = x ^ y; + *(int*)pBuf = r; + pBuf += 4; + nByte -= 4; + } + while( nByte-- > 0 ){ + x = (x>>1) ^ (-(int)(x&1) & 0xd0000001); + y = y*1103515245 + 12345; + r = x ^ y; + *(pBuf++) = r & 0xff; + } +} + +/* +** Allocate nByte bytes of memory. +*/ +static void *sqlite3MemMalloc(int nByte){ + struct MemBlockHdr *pHdr; + void **pBt; + char *z; + int *pInt; + void *p = 0; + int totalSize; + int nReserve; + sqlite3_mutex_enter(mem.mutex); + assert( mem.disallow==0 ); + nReserve = ROUND8(nByte); + totalSize = nReserve + sizeof(*pHdr) + sizeof(int) + + mem.nBacktrace*sizeof(void*) + mem.nTitle; + p = malloc(totalSize); + if( p ){ + z = p; + pBt = (void**)&z[mem.nTitle]; + pHdr = (struct MemBlockHdr*)&pBt[mem.nBacktrace]; + pHdr->pNext = 0; + pHdr->pPrev = mem.pLast; + if( mem.pLast ){ + mem.pLast->pNext = pHdr; + }else{ + mem.pFirst = pHdr; + } + mem.pLast = pHdr; + pHdr->iForeGuard = FOREGUARD; + pHdr->eType = MEMTYPE_HEAP; + pHdr->nBacktraceSlots = mem.nBacktrace; + pHdr->nTitle = mem.nTitle; + if( mem.nBacktrace ){ + void *aAddr[40]; + pHdr->nBacktrace = backtrace(aAddr, mem.nBacktrace+1)-1; + memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*)); + assert(pBt[0]); + if( mem.xBacktrace ){ + mem.xBacktrace(nByte, pHdr->nBacktrace-1, &aAddr[1]); + } + }else{ + pHdr->nBacktrace = 0; + } + if( mem.nTitle ){ + memcpy(z, mem.zTitle, mem.nTitle); + } + pHdr->iSize = nByte; + adjustStats(nByte, +1); + pInt = (int*)&pHdr[1]; + pInt[nReserve/sizeof(int)] = REARGUARD; + randomFill((char*)pInt, nByte); + memset(((char*)pInt)+nByte, 0x65, nReserve-nByte); + p = (void*)pInt; + } + sqlite3_mutex_leave(mem.mutex); + return p; +} + +/* +** Free memory. +*/ +static void sqlite3MemFree(void *pPrior){ + struct MemBlockHdr *pHdr; + void **pBt; + char *z; + assert( sqlite3GlobalConfig.bMemstat || sqlite3GlobalConfig.bCoreMutex==0 + || mem.mutex!=0 ); + pHdr = sqlite3MemsysGetHeader(pPrior); + pBt = (void**)pHdr; + pBt -= pHdr->nBacktraceSlots; + sqlite3_mutex_enter(mem.mutex); + if( pHdr->pPrev ){ + assert( pHdr->pPrev->pNext==pHdr ); + pHdr->pPrev->pNext = pHdr->pNext; + }else{ + assert( mem.pFirst==pHdr ); + mem.pFirst = pHdr->pNext; + } + if( pHdr->pNext ){ + assert( pHdr->pNext->pPrev==pHdr ); + pHdr->pNext->pPrev = pHdr->pPrev; + }else{ + assert( mem.pLast==pHdr ); + mem.pLast = pHdr->pPrev; + } + z = (char*)pBt; + z -= pHdr->nTitle; + adjustStats((int)pHdr->iSize, -1); + randomFill(z, sizeof(void*)*pHdr->nBacktraceSlots + sizeof(*pHdr) + + (int)pHdr->iSize + sizeof(int) + pHdr->nTitle); + free(z); + sqlite3_mutex_leave(mem.mutex); +} + +/* +** Change the size of an existing memory allocation. +** +** For this debugging implementation, we *always* make a copy of the +** allocation into a new place in memory. In this way, if the +** higher level code is using pointer to the old allocation, it is +** much more likely to break and we are much more liking to find +** the error. +*/ +static void *sqlite3MemRealloc(void *pPrior, int nByte){ + struct MemBlockHdr *pOldHdr; + void *pNew; + assert( mem.disallow==0 ); + assert( (nByte & 7)==0 ); /* EV: R-46199-30249 */ + pOldHdr = sqlite3MemsysGetHeader(pPrior); + pNew = sqlite3MemMalloc(nByte); + if( pNew ){ + memcpy(pNew, pPrior, (int)(nByteiSize ? nByte : pOldHdr->iSize)); + if( nByte>pOldHdr->iSize ){ + randomFill(&((char*)pNew)[pOldHdr->iSize], nByte - (int)pOldHdr->iSize); + } + sqlite3MemFree(pPrior); + } + return pNew; +} + +/* +** Populate the low-level memory allocation function pointers in +** sqlite3GlobalConfig.m with pointers to the routines in this file. +*/ +SQLITE_PRIVATE void sqlite3MemSetDefault(void){ + static const sqlite3_mem_methods defaultMethods = { + sqlite3MemMalloc, + sqlite3MemFree, + sqlite3MemRealloc, + sqlite3MemSize, + sqlite3MemRoundup, + sqlite3MemInit, + sqlite3MemShutdown, + 0 + }; + sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods); +} + +/* +** Set the "type" of an allocation. +*/ +SQLITE_PRIVATE void sqlite3MemdebugSetType(void *p, u8 eType){ + if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){ + struct MemBlockHdr *pHdr; + pHdr = sqlite3MemsysGetHeader(p); + assert( pHdr->iForeGuard==FOREGUARD ); + pHdr->eType = eType; + } +} + +/* +** Return TRUE if the mask of type in eType matches the type of the +** allocation p. Also return true if p==NULL. +** +** This routine is designed for use within an assert() statement, to +** verify the type of an allocation. For example: +** +** assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); +*/ +SQLITE_PRIVATE int sqlite3MemdebugHasType(void *p, u8 eType){ + int rc = 1; + if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){ + struct MemBlockHdr *pHdr; + pHdr = sqlite3MemsysGetHeader(p); + assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ + if( (pHdr->eType&eType)==0 ){ + rc = 0; + } + } + return rc; +} + +/* +** Return TRUE if the mask of type in eType matches no bits of the type of the +** allocation p. Also return true if p==NULL. +** +** This routine is designed for use within an assert() statement, to +** verify the type of an allocation. For example: +** +** assert( sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) ); +*/ +SQLITE_PRIVATE int sqlite3MemdebugNoType(void *p, u8 eType){ + int rc = 1; + if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){ + struct MemBlockHdr *pHdr; + pHdr = sqlite3MemsysGetHeader(p); + assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ + if( (pHdr->eType&eType)!=0 ){ + rc = 0; + } + } + return rc; +} + +/* +** Set the number of backtrace levels kept for each allocation. +** A value of zero turns off backtracing. The number is always rounded +** up to a multiple of 2. +*/ +SQLITE_PRIVATE void sqlite3MemdebugBacktrace(int depth){ + if( depth<0 ){ depth = 0; } + if( depth>20 ){ depth = 20; } + depth = (depth+1)&0xfe; + mem.nBacktrace = depth; +} + +SQLITE_PRIVATE void sqlite3MemdebugBacktraceCallback(void (*xBacktrace)(int, int, void **)){ + mem.xBacktrace = xBacktrace; +} + +/* +** Set the title string for subsequent allocations. +*/ +SQLITE_PRIVATE void sqlite3MemdebugSettitle(const char *zTitle){ + unsigned int n = sqlite3Strlen30(zTitle) + 1; + sqlite3_mutex_enter(mem.mutex); + if( n>=sizeof(mem.zTitle) ) n = sizeof(mem.zTitle)-1; + memcpy(mem.zTitle, zTitle, n); + mem.zTitle[n] = 0; + mem.nTitle = ROUND8(n); + sqlite3_mutex_leave(mem.mutex); +} + +SQLITE_PRIVATE void sqlite3MemdebugSync(){ + struct MemBlockHdr *pHdr; + for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){ + void **pBt = (void**)pHdr; + pBt -= pHdr->nBacktraceSlots; + mem.xBacktrace((int)pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]); + } +} + +/* +** Open the file indicated and write a log of all unfreed memory +** allocations into that log. +*/ +SQLITE_PRIVATE void sqlite3MemdebugDump(const char *zFilename){ + FILE *out; + struct MemBlockHdr *pHdr; + void **pBt; + int i; + out = fopen(zFilename, "w"); + if( out==0 ){ + fprintf(stderr, "** Unable to output memory debug output log: %s **\n", + zFilename); + return; + } + for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){ + char *z = (char*)pHdr; + z -= pHdr->nBacktraceSlots*sizeof(void*) + pHdr->nTitle; + fprintf(out, "**** %lld bytes at %p from %s ****\n", + pHdr->iSize, &pHdr[1], pHdr->nTitle ? z : "???"); + if( pHdr->nBacktrace ){ + fflush(out); + pBt = (void**)pHdr; + pBt -= pHdr->nBacktraceSlots; + backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out)); + fprintf(out, "\n"); + } + } + fprintf(out, "COUNTS:\n"); + for(i=0; i=1 ); + size = mem3.aPool[i-1].u.hdr.size4x/4; + assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); + assert( size>=2 ); + if( size <= MX_SMALL ){ + memsys3UnlinkFromList(i, &mem3.aiSmall[size-2]); + }else{ + hash = size % N_HASH; + memsys3UnlinkFromList(i, &mem3.aiHash[hash]); + } +} + +/* +** Link the chunk at mem3.aPool[i] so that is on the list rooted +** at *pRoot. +*/ +static void memsys3LinkIntoList(u32 i, u32 *pRoot){ + assert( sqlite3_mutex_held(mem3.mutex) ); + mem3.aPool[i].u.list.next = *pRoot; + mem3.aPool[i].u.list.prev = 0; + if( *pRoot ){ + mem3.aPool[*pRoot].u.list.prev = i; + } + *pRoot = i; +} + +/* +** Link the chunk at index i into either the appropriate +** small chunk list, or into the large chunk hash table. +*/ +static void memsys3Link(u32 i){ + u32 size, hash; + assert( sqlite3_mutex_held(mem3.mutex) ); + assert( i>=1 ); + assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 ); + size = mem3.aPool[i-1].u.hdr.size4x/4; + assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); + assert( size>=2 ); + if( size <= MX_SMALL ){ + memsys3LinkIntoList(i, &mem3.aiSmall[size-2]); + }else{ + hash = size % N_HASH; + memsys3LinkIntoList(i, &mem3.aiHash[hash]); + } +} + +/* +** If the STATIC_MEM mutex is not already held, obtain it now. The mutex +** will already be held (obtained by code in malloc.c) if +** sqlite3GlobalConfig.bMemStat is true. +*/ +static void memsys3Enter(void){ + if( sqlite3GlobalConfig.bMemstat==0 && mem3.mutex==0 ){ + mem3.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); + } + sqlite3_mutex_enter(mem3.mutex); +} +static void memsys3Leave(void){ + sqlite3_mutex_leave(mem3.mutex); +} + +/* +** Called when we are unable to satisfy an allocation of nBytes. +*/ +static void memsys3OutOfMemory(int nByte){ + if( !mem3.alarmBusy ){ + mem3.alarmBusy = 1; + assert( sqlite3_mutex_held(mem3.mutex) ); + sqlite3_mutex_leave(mem3.mutex); + sqlite3_release_memory(nByte); + sqlite3_mutex_enter(mem3.mutex); + mem3.alarmBusy = 0; + } +} + + +/* +** Chunk i is a free chunk that has been unlinked. Adjust its +** size parameters for check-out and return a pointer to the +** user portion of the chunk. +*/ +static void *memsys3Checkout(u32 i, u32 nBlock){ + u32 x; + assert( sqlite3_mutex_held(mem3.mutex) ); + assert( i>=1 ); + assert( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ); + assert( mem3.aPool[i+nBlock-1].u.hdr.prevSize==nBlock ); + x = mem3.aPool[i-1].u.hdr.size4x; + mem3.aPool[i-1].u.hdr.size4x = nBlock*4 | 1 | (x&2); + mem3.aPool[i+nBlock-1].u.hdr.prevSize = nBlock; + mem3.aPool[i+nBlock-1].u.hdr.size4x |= 2; + return &mem3.aPool[i]; +} + +/* +** Carve a piece off of the end of the mem3.iKeyBlk free chunk. +** Return a pointer to the new allocation. Or, if the key chunk +** is not large enough, return 0. +*/ +static void *memsys3FromKeyBlk(u32 nBlock){ + assert( sqlite3_mutex_held(mem3.mutex) ); + assert( mem3.szKeyBlk>=nBlock ); + if( nBlock>=mem3.szKeyBlk-1 ){ + /* Use the entire key chunk */ + void *p = memsys3Checkout(mem3.iKeyBlk, mem3.szKeyBlk); + mem3.iKeyBlk = 0; + mem3.szKeyBlk = 0; + mem3.mnKeyBlk = 0; + return p; + }else{ + /* Split the key block. Return the tail. */ + u32 newi, x; + newi = mem3.iKeyBlk + mem3.szKeyBlk - nBlock; + assert( newi > mem3.iKeyBlk+1 ); + mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.prevSize = nBlock; + mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.size4x |= 2; + mem3.aPool[newi-1].u.hdr.size4x = nBlock*4 + 1; + mem3.szKeyBlk -= nBlock; + mem3.aPool[newi-1].u.hdr.prevSize = mem3.szKeyBlk; + x = mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x & 2; + mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x = mem3.szKeyBlk*4 | x; + if( mem3.szKeyBlk < mem3.mnKeyBlk ){ + mem3.mnKeyBlk = mem3.szKeyBlk; + } + return (void*)&mem3.aPool[newi]; + } +} + +/* +** *pRoot is the head of a list of free chunks of the same size +** or same size hash. In other words, *pRoot is an entry in either +** mem3.aiSmall[] or mem3.aiHash[]. +** +** This routine examines all entries on the given list and tries +** to coalesce each entries with adjacent free chunks. +** +** If it sees a chunk that is larger than mem3.iKeyBlk, it replaces +** the current mem3.iKeyBlk with the new larger chunk. In order for +** this mem3.iKeyBlk replacement to work, the key chunk must be +** linked into the hash tables. That is not the normal state of +** affairs, of course. The calling routine must link the key +** chunk before invoking this routine, then must unlink the (possibly +** changed) key chunk once this routine has finished. +*/ +static void memsys3Merge(u32 *pRoot){ + u32 iNext, prev, size, i, x; + + assert( sqlite3_mutex_held(mem3.mutex) ); + for(i=*pRoot; i>0; i=iNext){ + iNext = mem3.aPool[i].u.list.next; + size = mem3.aPool[i-1].u.hdr.size4x; + assert( (size&1)==0 ); + if( (size&2)==0 ){ + memsys3UnlinkFromList(i, pRoot); + assert( i > mem3.aPool[i-1].u.hdr.prevSize ); + prev = i - mem3.aPool[i-1].u.hdr.prevSize; + if( prev==iNext ){ + iNext = mem3.aPool[prev].u.list.next; + } + memsys3Unlink(prev); + size = i + size/4 - prev; + x = mem3.aPool[prev-1].u.hdr.size4x & 2; + mem3.aPool[prev-1].u.hdr.size4x = size*4 | x; + mem3.aPool[prev+size-1].u.hdr.prevSize = size; + memsys3Link(prev); + i = prev; + }else{ + size /= 4; + } + if( size>mem3.szKeyBlk ){ + mem3.iKeyBlk = i; + mem3.szKeyBlk = size; + } + } +} + +/* +** Return a block of memory of at least nBytes in size. +** Return NULL if unable. +** +** This function assumes that the necessary mutexes, if any, are +** already held by the caller. Hence "Unsafe". +*/ +static void *memsys3MallocUnsafe(int nByte){ + u32 i; + u32 nBlock; + u32 toFree; + + assert( sqlite3_mutex_held(mem3.mutex) ); + assert( sizeof(Mem3Block)==8 ); + if( nByte<=12 ){ + nBlock = 2; + }else{ + nBlock = (nByte + 11)/8; + } + assert( nBlock>=2 ); + + /* STEP 1: + ** Look for an entry of the correct size in either the small + ** chunk table or in the large chunk hash table. This is + ** successful most of the time (about 9 times out of 10). + */ + if( nBlock <= MX_SMALL ){ + i = mem3.aiSmall[nBlock-2]; + if( i>0 ){ + memsys3UnlinkFromList(i, &mem3.aiSmall[nBlock-2]); + return memsys3Checkout(i, nBlock); + } + }else{ + int hash = nBlock % N_HASH; + for(i=mem3.aiHash[hash]; i>0; i=mem3.aPool[i].u.list.next){ + if( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ){ + memsys3UnlinkFromList(i, &mem3.aiHash[hash]); + return memsys3Checkout(i, nBlock); + } + } + } + + /* STEP 2: + ** Try to satisfy the allocation by carving a piece off of the end + ** of the key chunk. This step usually works if step 1 fails. + */ + if( mem3.szKeyBlk>=nBlock ){ + return memsys3FromKeyBlk(nBlock); + } + + + /* STEP 3: + ** Loop through the entire memory pool. Coalesce adjacent free + ** chunks. Recompute the key chunk as the largest free chunk. + ** Then try again to satisfy the allocation by carving a piece off + ** of the end of the key chunk. This step happens very + ** rarely (we hope!) + */ + for(toFree=nBlock*16; toFree<(mem3.nPool*16); toFree *= 2){ + memsys3OutOfMemory(toFree); + if( mem3.iKeyBlk ){ + memsys3Link(mem3.iKeyBlk); + mem3.iKeyBlk = 0; + mem3.szKeyBlk = 0; + } + for(i=0; i=nBlock ){ + return memsys3FromKeyBlk(nBlock); + } + } + } + + /* If none of the above worked, then we fail. */ + return 0; +} + +/* +** Free an outstanding memory allocation. +** +** This function assumes that the necessary mutexes, if any, are +** already held by the caller. Hence "Unsafe". +*/ +static void memsys3FreeUnsafe(void *pOld){ + Mem3Block *p = (Mem3Block*)pOld; + int i; + u32 size, x; + assert( sqlite3_mutex_held(mem3.mutex) ); + assert( p>mem3.aPool && p<&mem3.aPool[mem3.nPool] ); + i = p - mem3.aPool; + assert( (mem3.aPool[i-1].u.hdr.size4x&1)==1 ); + size = mem3.aPool[i-1].u.hdr.size4x/4; + assert( i+size<=mem3.nPool+1 ); + mem3.aPool[i-1].u.hdr.size4x &= ~1; + mem3.aPool[i+size-1].u.hdr.prevSize = size; + mem3.aPool[i+size-1].u.hdr.size4x &= ~2; + memsys3Link(i); + + /* Try to expand the key using the newly freed chunk */ + if( mem3.iKeyBlk ){ + while( (mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x&2)==0 ){ + size = mem3.aPool[mem3.iKeyBlk-1].u.hdr.prevSize; + mem3.iKeyBlk -= size; + mem3.szKeyBlk += size; + memsys3Unlink(mem3.iKeyBlk); + x = mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x & 2; + mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x = mem3.szKeyBlk*4 | x; + mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.prevSize = mem3.szKeyBlk; + } + x = mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x & 2; + while( (mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.size4x&1)==0 ){ + memsys3Unlink(mem3.iKeyBlk+mem3.szKeyBlk); + mem3.szKeyBlk += mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.size4x/4; + mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x = mem3.szKeyBlk*4 | x; + mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.prevSize = mem3.szKeyBlk; + } + } +} + +/* +** Return the size of an outstanding allocation, in bytes. The +** size returned omits the 8-byte header overhead. This only +** works for chunks that are currently checked out. +*/ +static int memsys3Size(void *p){ + Mem3Block *pBlock; + assert( p!=0 ); + pBlock = (Mem3Block*)p; + assert( (pBlock[-1].u.hdr.size4x&1)!=0 ); + return (pBlock[-1].u.hdr.size4x&~3)*2 - 4; +} + +/* +** Round up a request size to the next valid allocation size. +*/ +static int memsys3Roundup(int n){ + if( n<=12 ){ + return 12; + }else{ + return ((n+11)&~7) - 4; + } +} + +/* +** Allocate nBytes of memory. +*/ +static void *memsys3Malloc(int nBytes){ + sqlite3_int64 *p; + assert( nBytes>0 ); /* malloc.c filters out 0 byte requests */ + memsys3Enter(); + p = memsys3MallocUnsafe(nBytes); + memsys3Leave(); + return (void*)p; +} + +/* +** Free memory. +*/ +static void memsys3Free(void *pPrior){ + assert( pPrior ); + memsys3Enter(); + memsys3FreeUnsafe(pPrior); + memsys3Leave(); +} + +/* +** Change the size of an existing memory allocation +*/ +static void *memsys3Realloc(void *pPrior, int nBytes){ + int nOld; + void *p; + if( pPrior==0 ){ + return sqlite3_malloc(nBytes); + } + if( nBytes<=0 ){ + sqlite3_free(pPrior); + return 0; + } + nOld = memsys3Size(pPrior); + if( nBytes<=nOld && nBytes>=nOld-128 ){ + return pPrior; + } + memsys3Enter(); + p = memsys3MallocUnsafe(nBytes); + if( p ){ + if( nOld>1)!=(size&1) ){ + fprintf(out, "%p tail checkout bit is incorrect\n", &mem3.aPool[i]); + assert( 0 ); + break; + } + if( size&1 ){ + fprintf(out, "%p %6d bytes checked out\n", &mem3.aPool[i], (size/4)*8-8); + }else{ + fprintf(out, "%p %6d bytes free%s\n", &mem3.aPool[i], (size/4)*8-8, + i==mem3.iKeyBlk ? " **key**" : ""); + } + } + for(i=0; i0; j=mem3.aPool[j].u.list.next){ + fprintf(out, " %p(%d)", &mem3.aPool[j], + (mem3.aPool[j-1].u.hdr.size4x/4)*8-8); + } + fprintf(out, "\n"); + } + for(i=0; i0; j=mem3.aPool[j].u.list.next){ + fprintf(out, " %p(%d)", &mem3.aPool[j], + (mem3.aPool[j-1].u.hdr.size4x/4)*8-8); + } + fprintf(out, "\n"); + } + fprintf(out, "key=%d\n", mem3.iKeyBlk); + fprintf(out, "nowUsed=%d\n", mem3.nPool*8 - mem3.szKeyBlk*8); + fprintf(out, "mxUsed=%d\n", mem3.nPool*8 - mem3.mnKeyBlk*8); + sqlite3_mutex_leave(mem3.mutex); + if( out==stdout ){ + fflush(stdout); + }else{ + fclose(out); + } +#else + UNUSED_PARAMETER(zFilename); +#endif +} + +/* +** This routine is the only routine in this file with external +** linkage. +** +** Populate the low-level memory allocation function pointers in +** sqlite3GlobalConfig.m with pointers to the routines in this file. The +** arguments specify the block of memory to manage. +** +** This routine is only called by sqlite3_config(), and therefore +** is not required to be threadsafe (it is not). +*/ +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys3(void){ + static const sqlite3_mem_methods mempoolMethods = { + memsys3Malloc, + memsys3Free, + memsys3Realloc, + memsys3Size, + memsys3Roundup, + memsys3Init, + memsys3Shutdown, + 0 + }; + return &mempoolMethods; +} + +#endif /* SQLITE_ENABLE_MEMSYS3 */ + +/************** End of mem3.c ************************************************/ +/************** Begin file mem5.c ********************************************/ +/* +** 2007 October 14 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement a memory +** allocation subsystem for use by SQLite. +** +** This version of the memory allocation subsystem omits all +** use of malloc(). The application gives SQLite a block of memory +** before calling sqlite3_initialize() from which allocations +** are made and returned by the xMalloc() and xRealloc() +** implementations. Once sqlite3_initialize() has been called, +** the amount of memory available to SQLite is fixed and cannot +** be changed. +** +** This version of the memory allocation subsystem is included +** in the build only if SQLITE_ENABLE_MEMSYS5 is defined. +** +** This memory allocator uses the following algorithm: +** +** 1. All memory allocation sizes are rounded up to a power of 2. +** +** 2. If two adjacent free blocks are the halves of a larger block, +** then the two blocks are coalesced into the single larger block. +** +** 3. New memory is allocated from the first available free block. +** +** This algorithm is described in: J. M. Robson. "Bounds for Some Functions +** Concerning Dynamic Storage Allocation". Journal of the Association for +** Computing Machinery, Volume 21, Number 8, July 1974, pages 491-499. +** +** Let n be the size of the largest allocation divided by the minimum +** allocation size (after rounding all sizes up to a power of 2.) Let M +** be the maximum amount of memory ever outstanding at one time. Let +** N be the total amount of memory available for allocation. Robson +** proved that this memory allocator will never breakdown due to +** fragmentation as long as the following constraint holds: +** +** N >= M*(1 + log2(n)/2) - n + 1 +** +** The sqlite3_status() logic tracks the maximum values of n and M so +** that an application can, at any time, verify this constraint. +*/ +/* #include "sqliteInt.h" */ + +/* +** This version of the memory allocator is used only when +** SQLITE_ENABLE_MEMSYS5 is defined. +*/ +#ifdef SQLITE_ENABLE_MEMSYS5 + +/* +** A minimum allocation is an instance of the following structure. +** Larger allocations are an array of these structures where the +** size of the array is a power of 2. +** +** The size of this object must be a power of two. That fact is +** verified in memsys5Init(). +*/ +typedef struct Mem5Link Mem5Link; +struct Mem5Link { + int next; /* Index of next free chunk */ + int prev; /* Index of previous free chunk */ +}; + +/* +** Maximum size of any allocation is ((1<=0 && i=0 && iLogsize<=LOGMAX ); + assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); + + next = MEM5LINK(i)->next; + prev = MEM5LINK(i)->prev; + if( prev<0 ){ + mem5.aiFreelist[iLogsize] = next; + }else{ + MEM5LINK(prev)->next = next; + } + if( next>=0 ){ + MEM5LINK(next)->prev = prev; + } +} + +/* +** Link the chunk at mem5.aPool[i] so that is on the iLogsize +** free list. +*/ +static void memsys5Link(int i, int iLogsize){ + int x; + assert( sqlite3_mutex_held(mem5.mutex) ); + assert( i>=0 && i=0 && iLogsize<=LOGMAX ); + assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); + + x = MEM5LINK(i)->next = mem5.aiFreelist[iLogsize]; + MEM5LINK(i)->prev = -1; + if( x>=0 ){ + assert( xprev = i; + } + mem5.aiFreelist[iLogsize] = i; +} + +/* +** Obtain or release the mutex needed to access global data structures. +*/ +static void memsys5Enter(void){ + sqlite3_mutex_enter(mem5.mutex); +} +static void memsys5Leave(void){ + sqlite3_mutex_leave(mem5.mutex); +} + +/* +** Return the size of an outstanding allocation, in bytes. +** This only works for chunks that are currently checked out. +*/ +static int memsys5Size(void *p){ + int iSize, i; + assert( p!=0 ); + i = (int)(((u8 *)p-mem5.zPool)/mem5.szAtom); + assert( i>=0 && i0 ); + + /* No more than 1GiB per allocation */ + if( nByte > 0x40000000 ) return 0; + +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + /* Keep track of the maximum allocation request. Even unfulfilled + ** requests are counted */ + if( (u32)nByte>mem5.maxRequest ){ + mem5.maxRequest = nByte; + } +#endif + + + /* Round nByte up to the next valid power of two */ + for(iFullSz=mem5.szAtom,iLogsize=0; iFullSzLOGMAX ){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes", nByte); + return 0; + } + i = mem5.aiFreelist[iBin]; + memsys5Unlink(i, iBin); + while( iBin>iLogsize ){ + int newSize; + + iBin--; + newSize = 1 << iBin; + mem5.aCtrl[i+newSize] = CTRL_FREE | iBin; + memsys5Link(i+newSize, iBin); + } + mem5.aCtrl[i] = iLogsize; + +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + /* Update allocator performance statistics. */ + mem5.nAlloc++; + mem5.totalAlloc += iFullSz; + mem5.totalExcess += iFullSz - nByte; + mem5.currentCount++; + mem5.currentOut += iFullSz; + if( mem5.maxCount=0 && iBlock0 ); + assert( mem5.currentOut>=(size*mem5.szAtom) ); + mem5.currentCount--; + mem5.currentOut -= size*mem5.szAtom; + assert( mem5.currentOut>0 || mem5.currentCount==0 ); + assert( mem5.currentCount>0 || mem5.currentOut==0 ); +#endif + + mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize; + while( ALWAYS(iLogsize>iLogsize) & 1 ){ + iBuddy = iBlock - size; + assert( iBuddy>=0 ); + }else{ + iBuddy = iBlock + size; + if( iBuddy>=mem5.nBlock ) break; + } + if( mem5.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break; + memsys5Unlink(iBuddy, iLogsize); + iLogsize++; + if( iBuddy0 ){ + memsys5Enter(); + p = memsys5MallocUnsafe(nBytes); + memsys5Leave(); + } + return (void*)p; +} + +/* +** Free memory. +** +** The outer layer memory allocator prevents this routine from +** being called with pPrior==0. +*/ +static void memsys5Free(void *pPrior){ + assert( pPrior!=0 ); + memsys5Enter(); + memsys5FreeUnsafe(pPrior); + memsys5Leave(); +} + +/* +** Change the size of an existing memory allocation. +** +** The outer layer memory allocator prevents this routine from +** being called with pPrior==0. +** +** nBytes is always a value obtained from a prior call to +** memsys5Round(). Hence nBytes is always a non-negative power +** of two. If nBytes==0 that means that an oversize allocation +** (an allocation larger than 0x40000000) was requested and this +** routine should return 0 without freeing pPrior. +*/ +static void *memsys5Realloc(void *pPrior, int nBytes){ + int nOld; + void *p; + assert( pPrior!=0 ); + assert( (nBytes&(nBytes-1))==0 ); /* EV: R-46199-30249 */ + assert( nBytes>=0 ); + if( nBytes==0 ){ + return 0; + } + nOld = memsys5Size(pPrior); + if( nBytes<=nOld ){ + return pPrior; + } + p = memsys5Malloc(nBytes); + if( p ){ + memcpy(p, pPrior, nOld); + memsys5Free(pPrior); + } + return p; +} + +/* +** Round up a request size to the next valid allocation size. If +** the allocation is too large to be handled by this allocation system, +** return 0. +** +** All allocations must be a power of two and must be expressed by a +** 32-bit signed integer. Hence the largest allocation is 0x40000000 +** or 1073741824 bytes. +*/ +static int memsys5Roundup(int n){ + int iFullSz; + if( n > 0x40000000 ) return 0; + for(iFullSz=mem5.szAtom; iFullSz 0 +** memsys5Log(2) -> 1 +** memsys5Log(4) -> 2 +** memsys5Log(5) -> 3 +** memsys5Log(8) -> 3 +** memsys5Log(9) -> 4 +*/ +static int memsys5Log(int iValue){ + int iLog; + for(iLog=0; (iLog<(int)((sizeof(int)*8)-1)) && (1<mem5.szAtom ){ + mem5.szAtom = mem5.szAtom << 1; + } + + mem5.nBlock = (nByte / (mem5.szAtom+sizeof(u8))); + mem5.zPool = zByte; + mem5.aCtrl = (u8 *)&mem5.zPool[mem5.nBlock*mem5.szAtom]; + + for(ii=0; ii<=LOGMAX; ii++){ + mem5.aiFreelist[ii] = -1; + } + + iOffset = 0; + for(ii=LOGMAX; ii>=0; ii--){ + int nAlloc = (1<mem5.nBlock); + } + + /* If a mutex is required for normal operation, allocate one */ + if( sqlite3GlobalConfig.bMemstat==0 ){ + mem5.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); + } + + return SQLITE_OK; +} + +/* +** Deinitialize this module. +*/ +static void memsys5Shutdown(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + mem5.mutex = 0; + return; +} + +#ifdef SQLITE_TEST +/* +** Open the file indicated and write a log of all unfreed memory +** allocations into that log. +*/ +SQLITE_PRIVATE void sqlite3Memsys5Dump(const char *zFilename){ + FILE *out; + int i, j, n; + int nMinLog; + + if( zFilename==0 || zFilename[0]==0 ){ + out = stdout; + }else{ + out = fopen(zFilename, "w"); + if( out==0 ){ + fprintf(stderr, "** Unable to output memory debug output log: %s **\n", + zFilename); + return; + } + } + memsys5Enter(); + nMinLog = memsys5Log(mem5.szAtom); + for(i=0; i<=LOGMAX && i+nMinLog<32; i++){ + for(n=0, j=mem5.aiFreelist[i]; j>=0; j = MEM5LINK(j)->next, n++){} + fprintf(out, "freelist items of size %d: %d\n", mem5.szAtom << i, n); + } + fprintf(out, "mem5.nAlloc = %llu\n", mem5.nAlloc); + fprintf(out, "mem5.totalAlloc = %llu\n", mem5.totalAlloc); + fprintf(out, "mem5.totalExcess = %llu\n", mem5.totalExcess); + fprintf(out, "mem5.currentOut = %u\n", mem5.currentOut); + fprintf(out, "mem5.currentCount = %u\n", mem5.currentCount); + fprintf(out, "mem5.maxOut = %u\n", mem5.maxOut); + fprintf(out, "mem5.maxCount = %u\n", mem5.maxCount); + fprintf(out, "mem5.maxRequest = %u\n", mem5.maxRequest); + memsys5Leave(); + if( out==stdout ){ + fflush(stdout); + }else{ + fclose(out); + } +} +#endif + +/* +** This routine is the only routine in this file with external +** linkage. It returns a pointer to a static sqlite3_mem_methods +** struct populated with the memsys5 methods. +*/ +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys5(void){ + static const sqlite3_mem_methods memsys5Methods = { + memsys5Malloc, + memsys5Free, + memsys5Realloc, + memsys5Size, + memsys5Roundup, + memsys5Init, + memsys5Shutdown, + 0 + }; + return &memsys5Methods; +} + +#endif /* SQLITE_ENABLE_MEMSYS5 */ + +/************** End of mem5.c ************************************************/ +/************** Begin file mutex.c *******************************************/ +/* +** 2007 August 14 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement mutexes. +** +** This file contains code that is common across all mutex implementations. +*/ +/* #include "sqliteInt.h" */ + +#if defined(SQLITE_DEBUG) && !defined(SQLITE_MUTEX_OMIT) +/* +** For debugging purposes, record when the mutex subsystem is initialized +** and uninitialized so that we can assert() if there is an attempt to +** allocate a mutex while the system is uninitialized. +*/ +static SQLITE_WSD int mutexIsInit = 0; +#endif /* SQLITE_DEBUG && !defined(SQLITE_MUTEX_OMIT) */ + + +#ifndef SQLITE_MUTEX_OMIT + +#ifdef SQLITE_ENABLE_MULTITHREADED_CHECKS +/* +** This block (enclosed by SQLITE_ENABLE_MULTITHREADED_CHECKS) contains +** the implementation of a wrapper around the system default mutex +** implementation (sqlite3DefaultMutex()). +** +** Most calls are passed directly through to the underlying default +** mutex implementation. Except, if a mutex is configured by calling +** sqlite3MutexWarnOnContention() on it, then if contention is ever +** encountered within xMutexEnter() a warning is emitted via sqlite3_log(). +** +** This type of mutex is used as the database handle mutex when testing +** apps that usually use SQLITE_CONFIG_MULTITHREAD mode. +*/ + +/* +** Type for all mutexes used when SQLITE_ENABLE_MULTITHREADED_CHECKS +** is defined. Variable CheckMutex.mutex is a pointer to the real mutex +** allocated by the system mutex implementation. Variable iType is usually set +** to the type of mutex requested - SQLITE_MUTEX_RECURSIVE, SQLITE_MUTEX_FAST +** or one of the static mutex identifiers. Or, if this is a recursive mutex +** that has been configured using sqlite3MutexWarnOnContention(), it is +** set to SQLITE_MUTEX_WARNONCONTENTION. +*/ +typedef struct CheckMutex CheckMutex; +struct CheckMutex { + int iType; + sqlite3_mutex *mutex; +}; + +#define SQLITE_MUTEX_WARNONCONTENTION (-1) + +/* +** Pointer to real mutex methods object used by the CheckMutex +** implementation. Set by checkMutexInit(). +*/ +static SQLITE_WSD const sqlite3_mutex_methods *pGlobalMutexMethods; + +#ifdef SQLITE_DEBUG +static int checkMutexHeld(sqlite3_mutex *p){ + return pGlobalMutexMethods->xMutexHeld(((CheckMutex*)p)->mutex); +} +static int checkMutexNotheld(sqlite3_mutex *p){ + return pGlobalMutexMethods->xMutexNotheld(((CheckMutex*)p)->mutex); +} +#endif + +/* +** Initialize and deinitialize the mutex subsystem. +*/ +static int checkMutexInit(void){ + pGlobalMutexMethods = sqlite3DefaultMutex(); + return SQLITE_OK; +} +static int checkMutexEnd(void){ + pGlobalMutexMethods = 0; + return SQLITE_OK; +} + +/* +** Allocate a mutex. +*/ +static sqlite3_mutex *checkMutexAlloc(int iType){ + static CheckMutex staticMutexes[] = { + {2, 0}, {3, 0}, {4, 0}, {5, 0}, + {6, 0}, {7, 0}, {8, 0}, {9, 0}, + {10, 0}, {11, 0}, {12, 0}, {13, 0} + }; + CheckMutex *p = 0; + + assert( SQLITE_MUTEX_RECURSIVE==1 && SQLITE_MUTEX_FAST==0 ); + if( iType<2 ){ + p = sqlite3MallocZero(sizeof(CheckMutex)); + if( p==0 ) return 0; + p->iType = iType; + }else{ +#ifdef SQLITE_ENABLE_API_ARMOR + if( iType-2>=ArraySize(staticMutexes) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + p = &staticMutexes[iType-2]; + } + + if( p->mutex==0 ){ + p->mutex = pGlobalMutexMethods->xMutexAlloc(iType); + if( p->mutex==0 ){ + if( iType<2 ){ + sqlite3_free(p); + } + p = 0; + } + } + + return (sqlite3_mutex*)p; +} + +/* +** Free a mutex. +*/ +static void checkMutexFree(sqlite3_mutex *p){ + assert( SQLITE_MUTEX_RECURSIVE<2 ); + assert( SQLITE_MUTEX_FAST<2 ); + assert( SQLITE_MUTEX_WARNONCONTENTION<2 ); + +#if SQLITE_ENABLE_API_ARMOR + if( ((CheckMutex*)p)->iType<2 ) +#endif + { + CheckMutex *pCheck = (CheckMutex*)p; + pGlobalMutexMethods->xMutexFree(pCheck->mutex); + sqlite3_free(pCheck); + } +#ifdef SQLITE_ENABLE_API_ARMOR + else{ + (void)SQLITE_MISUSE_BKPT; + } +#endif +} + +/* +** Enter the mutex. +*/ +static void checkMutexEnter(sqlite3_mutex *p){ + CheckMutex *pCheck = (CheckMutex*)p; + if( pCheck->iType==SQLITE_MUTEX_WARNONCONTENTION ){ + if( SQLITE_OK==pGlobalMutexMethods->xMutexTry(pCheck->mutex) ){ + return; + } + sqlite3_log(SQLITE_MISUSE, + "illegal multi-threaded access to database connection" + ); + } + pGlobalMutexMethods->xMutexEnter(pCheck->mutex); +} + +/* +** Enter the mutex (do not block). +*/ +static int checkMutexTry(sqlite3_mutex *p){ + CheckMutex *pCheck = (CheckMutex*)p; + return pGlobalMutexMethods->xMutexTry(pCheck->mutex); +} + +/* +** Leave the mutex. +*/ +static void checkMutexLeave(sqlite3_mutex *p){ + CheckMutex *pCheck = (CheckMutex*)p; + pGlobalMutexMethods->xMutexLeave(pCheck->mutex); +} + +sqlite3_mutex_methods const *multiThreadedCheckMutex(void){ + static const sqlite3_mutex_methods sMutex = { + checkMutexInit, + checkMutexEnd, + checkMutexAlloc, + checkMutexFree, + checkMutexEnter, + checkMutexTry, + checkMutexLeave, +#ifdef SQLITE_DEBUG + checkMutexHeld, + checkMutexNotheld +#else + 0, + 0 +#endif + }; + return &sMutex; +} + +/* +** Mark the SQLITE_MUTEX_RECURSIVE mutex passed as the only argument as +** one on which there should be no contention. +*/ +SQLITE_PRIVATE void sqlite3MutexWarnOnContention(sqlite3_mutex *p){ + if( sqlite3GlobalConfig.mutex.xMutexAlloc==checkMutexAlloc ){ + CheckMutex *pCheck = (CheckMutex*)p; + assert( pCheck->iType==SQLITE_MUTEX_RECURSIVE ); + pCheck->iType = SQLITE_MUTEX_WARNONCONTENTION; + } +} +#endif /* ifdef SQLITE_ENABLE_MULTITHREADED_CHECKS */ + +/* +** Initialize the mutex system. +*/ +SQLITE_PRIVATE int sqlite3MutexInit(void){ + int rc = SQLITE_OK; + if( !sqlite3GlobalConfig.mutex.xMutexAlloc ){ + /* If the xMutexAlloc method has not been set, then the user did not + ** install a mutex implementation via sqlite3_config() prior to + ** sqlite3_initialize() being called. This block copies pointers to + ** the default implementation into the sqlite3GlobalConfig structure. + */ + sqlite3_mutex_methods const *pFrom; + sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex; + + if( sqlite3GlobalConfig.bCoreMutex ){ +#ifdef SQLITE_ENABLE_MULTITHREADED_CHECKS + pFrom = multiThreadedCheckMutex(); +#else + pFrom = sqlite3DefaultMutex(); +#endif + }else{ + pFrom = sqlite3NoopMutex(); + } + pTo->xMutexInit = pFrom->xMutexInit; + pTo->xMutexEnd = pFrom->xMutexEnd; + pTo->xMutexFree = pFrom->xMutexFree; + pTo->xMutexEnter = pFrom->xMutexEnter; + pTo->xMutexTry = pFrom->xMutexTry; + pTo->xMutexLeave = pFrom->xMutexLeave; + pTo->xMutexHeld = pFrom->xMutexHeld; + pTo->xMutexNotheld = pFrom->xMutexNotheld; + sqlite3MemoryBarrier(); + pTo->xMutexAlloc = pFrom->xMutexAlloc; + } + assert( sqlite3GlobalConfig.mutex.xMutexInit ); + rc = sqlite3GlobalConfig.mutex.xMutexInit(); + +#ifdef SQLITE_DEBUG + GLOBAL(int, mutexIsInit) = 1; +#endif + + sqlite3MemoryBarrier(); + return rc; +} + +/* +** Shutdown the mutex system. This call frees resources allocated by +** sqlite3MutexInit(). +*/ +SQLITE_PRIVATE int sqlite3MutexEnd(void){ + int rc = SQLITE_OK; + if( sqlite3GlobalConfig.mutex.xMutexEnd ){ + rc = sqlite3GlobalConfig.mutex.xMutexEnd(); + } + +#ifdef SQLITE_DEBUG + GLOBAL(int, mutexIsInit) = 0; +#endif + + return rc; +} + +/* +** Retrieve a pointer to a static mutex or allocate a new dynamic one. +*/ +SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int id){ +#ifndef SQLITE_OMIT_AUTOINIT + if( id<=SQLITE_MUTEX_RECURSIVE && sqlite3_initialize() ) return 0; + if( id>SQLITE_MUTEX_RECURSIVE && sqlite3MutexInit() ) return 0; +#endif + assert( sqlite3GlobalConfig.mutex.xMutexAlloc ); + return sqlite3GlobalConfig.mutex.xMutexAlloc(id); +} + +SQLITE_PRIVATE sqlite3_mutex *sqlite3MutexAlloc(int id){ + if( !sqlite3GlobalConfig.bCoreMutex ){ + return 0; + } + assert( GLOBAL(int, mutexIsInit) ); + assert( sqlite3GlobalConfig.mutex.xMutexAlloc ); + return sqlite3GlobalConfig.mutex.xMutexAlloc(id); +} + +/* +** Free a dynamic mutex. +*/ +SQLITE_API void sqlite3_mutex_free(sqlite3_mutex *p){ + if( p ){ + assert( sqlite3GlobalConfig.mutex.xMutexFree ); + sqlite3GlobalConfig.mutex.xMutexFree(p); + } +} + +/* +** Obtain the mutex p. If some other thread already has the mutex, block +** until it can be obtained. +*/ +SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex *p){ + if( p ){ + assert( sqlite3GlobalConfig.mutex.xMutexEnter ); + sqlite3GlobalConfig.mutex.xMutexEnter(p); + } +} + +/* +** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another +** thread holds the mutex and it cannot be obtained, return SQLITE_BUSY. +*/ +SQLITE_API int sqlite3_mutex_try(sqlite3_mutex *p){ + int rc = SQLITE_OK; + if( p ){ + assert( sqlite3GlobalConfig.mutex.xMutexTry ); + return sqlite3GlobalConfig.mutex.xMutexTry(p); + } + return rc; +} + +/* +** The sqlite3_mutex_leave() routine exits a mutex that was previously +** entered by the same thread. The behavior is undefined if the mutex +** is not currently entered. If a NULL pointer is passed as an argument +** this function is a no-op. +*/ +SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex *p){ + if( p ){ + assert( sqlite3GlobalConfig.mutex.xMutexLeave ); + sqlite3GlobalConfig.mutex.xMutexLeave(p); + } +} + +#ifndef NDEBUG +/* +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are +** intended for use inside assert() statements. +*/ +SQLITE_API int sqlite3_mutex_held(sqlite3_mutex *p){ + assert( p==0 || sqlite3GlobalConfig.mutex.xMutexHeld ); + return p==0 || sqlite3GlobalConfig.mutex.xMutexHeld(p); +} +SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex *p){ + assert( p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld ); + return p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld(p); +} +#endif + +#endif /* !defined(SQLITE_MUTEX_OMIT) */ + +/************** End of mutex.c ***********************************************/ +/************** Begin file mutex_noop.c **************************************/ +/* +** 2008 October 07 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement mutexes. +** +** This implementation in this file does not provide any mutual +** exclusion and is thus suitable for use only in applications +** that use SQLite in a single thread. The routines defined +** here are place-holders. Applications can substitute working +** mutex routines at start-time using the +** +** sqlite3_config(SQLITE_CONFIG_MUTEX,...) +** +** interface. +** +** If compiled with SQLITE_DEBUG, then additional logic is inserted +** that does error checking on mutexes to make sure they are being +** called correctly. +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_MUTEX_OMIT + +#ifndef SQLITE_DEBUG +/* +** Stub routines for all mutex methods. +** +** This routines provide no mutual exclusion or error checking. +*/ +static int noopMutexInit(void){ return SQLITE_OK; } +static int noopMutexEnd(void){ return SQLITE_OK; } +static sqlite3_mutex *noopMutexAlloc(int id){ + UNUSED_PARAMETER(id); + return (sqlite3_mutex*)8; +} +static void noopMutexFree(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; } +static void noopMutexEnter(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; } +static int noopMutexTry(sqlite3_mutex *p){ + UNUSED_PARAMETER(p); + return SQLITE_OK; +} +static void noopMutexLeave(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; } + +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void){ + static const sqlite3_mutex_methods sMutex = { + noopMutexInit, + noopMutexEnd, + noopMutexAlloc, + noopMutexFree, + noopMutexEnter, + noopMutexTry, + noopMutexLeave, + + 0, + 0, + }; + + return &sMutex; +} +#endif /* !SQLITE_DEBUG */ + +#ifdef SQLITE_DEBUG +/* +** In this implementation, error checking is provided for testing +** and debugging purposes. The mutexes still do not provide any +** mutual exclusion. +*/ + +/* +** The mutex object +*/ +typedef struct sqlite3_debug_mutex { + int id; /* The mutex type */ + int cnt; /* Number of entries without a matching leave */ +} sqlite3_debug_mutex; + +/* +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are +** intended for use inside assert() statements. +*/ +static int debugMutexHeld(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + return p==0 || p->cnt>0; +} +static int debugMutexNotheld(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + return p==0 || p->cnt==0; +} + +/* +** Initialize and deinitialize the mutex subsystem. +*/ +static int debugMutexInit(void){ return SQLITE_OK; } +static int debugMutexEnd(void){ return SQLITE_OK; } + +/* +** The sqlite3_mutex_alloc() routine allocates a new +** mutex and returns a pointer to it. If it returns NULL +** that means that a mutex could not be allocated. +*/ +static sqlite3_mutex *debugMutexAlloc(int id){ + static sqlite3_debug_mutex aStatic[SQLITE_MUTEX_STATIC_VFS3 - 1]; + sqlite3_debug_mutex *pNew = 0; + switch( id ){ + case SQLITE_MUTEX_FAST: + case SQLITE_MUTEX_RECURSIVE: { + pNew = sqlite3Malloc(sizeof(*pNew)); + if( pNew ){ + pNew->id = id; + pNew->cnt = 0; + } + break; + } + default: { +#ifdef SQLITE_ENABLE_API_ARMOR + if( id-2<0 || id-2>=ArraySize(aStatic) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + pNew = &aStatic[id-2]; + pNew->id = id; + break; + } + } + return (sqlite3_mutex*)pNew; +} + +/* +** This routine deallocates a previously allocated mutex. +*/ +static void debugMutexFree(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + assert( p->cnt==0 ); + if( p->id==SQLITE_MUTEX_RECURSIVE || p->id==SQLITE_MUTEX_FAST ){ + sqlite3_free(p); + }else{ +#ifdef SQLITE_ENABLE_API_ARMOR + (void)SQLITE_MISUSE_BKPT; +#endif + } +} + +/* +** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK +** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can +** be entered multiple times by the same thread. In such cases the, +** mutex must be exited an equal number of times before another thread +** can enter. If the same thread tries to enter any other kind of mutex +** more than once, the behavior is undefined. +*/ +static void debugMutexEnter(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); + p->cnt++; +} +static int debugMutexTry(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); + p->cnt++; + return SQLITE_OK; +} + +/* +** The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. The behavior +** is undefined if the mutex is not currently entered or +** is not currently allocated. SQLite will never do either. +*/ +static void debugMutexLeave(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + assert( debugMutexHeld(pX) ); + p->cnt--; + assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); +} + +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void){ + static const sqlite3_mutex_methods sMutex = { + debugMutexInit, + debugMutexEnd, + debugMutexAlloc, + debugMutexFree, + debugMutexEnter, + debugMutexTry, + debugMutexLeave, + + debugMutexHeld, + debugMutexNotheld + }; + + return &sMutex; +} +#endif /* SQLITE_DEBUG */ + +/* +** If compiled with SQLITE_MUTEX_NOOP, then the no-op mutex implementation +** is used regardless of the run-time threadsafety setting. +*/ +#ifdef SQLITE_MUTEX_NOOP +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){ + return sqlite3NoopMutex(); +} +#endif /* defined(SQLITE_MUTEX_NOOP) */ +#endif /* !defined(SQLITE_MUTEX_OMIT) */ + +/************** End of mutex_noop.c ******************************************/ +/************** Begin file mutex_unix.c **************************************/ +/* +** 2007 August 28 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement mutexes for pthreads +*/ +/* #include "sqliteInt.h" */ + +/* +** The code in this file is only used if we are compiling threadsafe +** under unix with pthreads. +** +** Note that this implementation requires a version of pthreads that +** supports recursive mutexes. +*/ +#ifdef SQLITE_MUTEX_PTHREADS + +#include + +/* +** The sqlite3_mutex.id, sqlite3_mutex.nRef, and sqlite3_mutex.owner fields +** are necessary under two condidtions: (1) Debug builds and (2) using +** home-grown mutexes. Encapsulate these conditions into a single #define. +*/ +#if defined(SQLITE_DEBUG) || defined(SQLITE_HOMEGROWN_RECURSIVE_MUTEX) +# define SQLITE_MUTEX_NREF 1 +#else +# define SQLITE_MUTEX_NREF 0 +#endif + +/* +** Each recursive mutex is an instance of the following structure. +*/ +struct sqlite3_mutex { + pthread_mutex_t mutex; /* Mutex controlling the lock */ +#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR) + int id; /* Mutex type */ +#endif +#if SQLITE_MUTEX_NREF + volatile int nRef; /* Number of entrances */ + volatile pthread_t owner; /* Thread that is within this mutex */ + int trace; /* True to trace changes */ +#endif +}; +#if SQLITE_MUTEX_NREF +# define SQLITE3_MUTEX_INITIALIZER(id) \ + {PTHREAD_MUTEX_INITIALIZER,id,0,(pthread_t)0,0} +#elif defined(SQLITE_ENABLE_API_ARMOR) +# define SQLITE3_MUTEX_INITIALIZER(id) { PTHREAD_MUTEX_INITIALIZER, id } +#else +#define SQLITE3_MUTEX_INITIALIZER(id) { PTHREAD_MUTEX_INITIALIZER } +#endif + +/* +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are +** intended for use only inside assert() statements. On some platforms, +** there might be race conditions that can cause these routines to +** deliver incorrect results. In particular, if pthread_equal() is +** not an atomic operation, then these routines might delivery +** incorrect results. On most platforms, pthread_equal() is a +** comparison of two integers and is therefore atomic. But we are +** told that HPUX is not such a platform. If so, then these routines +** will not always work correctly on HPUX. +** +** On those platforms where pthread_equal() is not atomic, SQLite +** should be compiled without -DSQLITE_DEBUG and with -DNDEBUG to +** make sure no assert() statements are evaluated and hence these +** routines are never called. +*/ +#if !defined(NDEBUG) || defined(SQLITE_DEBUG) +static int pthreadMutexHeld(sqlite3_mutex *p){ + return (p->nRef!=0 && pthread_equal(p->owner, pthread_self())); +} +static int pthreadMutexNotheld(sqlite3_mutex *p){ + return p->nRef==0 || pthread_equal(p->owner, pthread_self())==0; +} +#endif + +/* +** Try to provide a memory barrier operation, needed for initialization +** and also for the implementation of xShmBarrier in the VFS in cases +** where SQLite is compiled without mutexes. +*/ +SQLITE_PRIVATE void sqlite3MemoryBarrier(void){ +#if defined(SQLITE_MEMORY_BARRIER) + SQLITE_MEMORY_BARRIER; +#elif defined(__GNUC__) && GCC_VERSION>=4001000 + __sync_synchronize(); +#endif +} + +/* +** Initialize and deinitialize the mutex subsystem. +*/ +static int pthreadMutexInit(void){ return SQLITE_OK; } +static int pthreadMutexEnd(void){ return SQLITE_OK; } + +/* +** The sqlite3_mutex_alloc() routine allocates a new +** mutex and returns a pointer to it. If it returns NULL +** that means that a mutex could not be allocated. SQLite +** will unwind its stack and return an error. The argument +** to sqlite3_mutex_alloc() is one of these integer constants: +** +**
      +**
    • SQLITE_MUTEX_FAST +**
    • SQLITE_MUTEX_RECURSIVE +**
    • SQLITE_MUTEX_STATIC_MAIN +**
    • SQLITE_MUTEX_STATIC_MEM +**
    • SQLITE_MUTEX_STATIC_OPEN +**
    • SQLITE_MUTEX_STATIC_PRNG +**
    • SQLITE_MUTEX_STATIC_LRU +**
    • SQLITE_MUTEX_STATIC_PMEM +**
    • SQLITE_MUTEX_STATIC_APP1 +**
    • SQLITE_MUTEX_STATIC_APP2 +**
    • SQLITE_MUTEX_STATIC_APP3 +**
    • SQLITE_MUTEX_STATIC_VFS1 +**
    • SQLITE_MUTEX_STATIC_VFS2 +**
    • SQLITE_MUTEX_STATIC_VFS3 +**
    +** +** The first two constants cause sqlite3_mutex_alloc() to create +** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE +** is used but not necessarily so when SQLITE_MUTEX_FAST is used. +** The mutex implementation does not need to make a distinction +** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does +** not want to. But SQLite will only request a recursive mutex in +** cases where it really needs one. If a faster non-recursive mutex +** implementation is available on the host platform, the mutex subsystem +** might return such a mutex in response to SQLITE_MUTEX_FAST. +** +** The other allowed parameters to sqlite3_mutex_alloc() each return +** a pointer to a static preexisting mutex. Six static mutexes are +** used by the current version of SQLite. Future versions of SQLite +** may add additional static mutexes. Static mutexes are for internal +** use by SQLite only. Applications that use SQLite mutexes should +** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or +** SQLITE_MUTEX_RECURSIVE. +** +** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST +** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() +** returns a different mutex on every call. But for the static +** mutex types, the same mutex is returned on every call that has +** the same type number. +*/ +static sqlite3_mutex *pthreadMutexAlloc(int iType){ + static sqlite3_mutex staticMutexes[] = { + SQLITE3_MUTEX_INITIALIZER(2), + SQLITE3_MUTEX_INITIALIZER(3), + SQLITE3_MUTEX_INITIALIZER(4), + SQLITE3_MUTEX_INITIALIZER(5), + SQLITE3_MUTEX_INITIALIZER(6), + SQLITE3_MUTEX_INITIALIZER(7), + SQLITE3_MUTEX_INITIALIZER(8), + SQLITE3_MUTEX_INITIALIZER(9), + SQLITE3_MUTEX_INITIALIZER(10), + SQLITE3_MUTEX_INITIALIZER(11), + SQLITE3_MUTEX_INITIALIZER(12), + SQLITE3_MUTEX_INITIALIZER(13) + }; + sqlite3_mutex *p; + switch( iType ){ + case SQLITE_MUTEX_RECURSIVE: { + p = sqlite3MallocZero( sizeof(*p) ); + if( p ){ +#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX + /* If recursive mutexes are not available, we will have to + ** build our own. See below. */ + pthread_mutex_init(&p->mutex, 0); +#else + /* Use a recursive mutex if it is available */ + pthread_mutexattr_t recursiveAttr; + pthread_mutexattr_init(&recursiveAttr); + pthread_mutexattr_settype(&recursiveAttr, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&p->mutex, &recursiveAttr); + pthread_mutexattr_destroy(&recursiveAttr); +#endif +#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR) + p->id = SQLITE_MUTEX_RECURSIVE; +#endif + } + break; + } + case SQLITE_MUTEX_FAST: { + p = sqlite3MallocZero( sizeof(*p) ); + if( p ){ + pthread_mutex_init(&p->mutex, 0); +#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR) + p->id = SQLITE_MUTEX_FAST; +#endif + } + break; + } + default: { +#ifdef SQLITE_ENABLE_API_ARMOR + if( iType-2<0 || iType-2>=ArraySize(staticMutexes) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + p = &staticMutexes[iType-2]; + break; + } + } +#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR) + assert( p==0 || p->id==iType ); +#endif + return p; +} + + +/* +** This routine deallocates a previously +** allocated mutex. SQLite is careful to deallocate every +** mutex that it allocates. +*/ +static void pthreadMutexFree(sqlite3_mutex *p){ + assert( p->nRef==0 ); +#if SQLITE_ENABLE_API_ARMOR + if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ) +#endif + { + pthread_mutex_destroy(&p->mutex); + sqlite3_free(p); + } +#ifdef SQLITE_ENABLE_API_ARMOR + else{ + (void)SQLITE_MISUSE_BKPT; + } +#endif +} + +/* +** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK +** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can +** be entered multiple times by the same thread. In such cases the, +** mutex must be exited an equal number of times before another thread +** can enter. If the same thread tries to enter any other kind of mutex +** more than once, the behavior is undefined. +*/ +static void pthreadMutexEnter(sqlite3_mutex *p){ + assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); + +#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX + /* If recursive mutexes are not available, then we have to grow + ** our own. This implementation assumes that pthread_equal() + ** is atomic - that it cannot be deceived into thinking self + ** and p->owner are equal if p->owner changes between two values + ** that are not equal to self while the comparison is taking place. + ** This implementation also assumes a coherent cache - that + ** separate processes cannot read different values from the same + ** address at the same time. If either of these two conditions + ** are not met, then the mutexes will fail and problems will result. + */ + { + pthread_t self = pthread_self(); + if( p->nRef>0 && pthread_equal(p->owner, self) ){ + p->nRef++; + }else{ + pthread_mutex_lock(&p->mutex); + assert( p->nRef==0 ); + p->owner = self; + p->nRef = 1; + } + } +#else + /* Use the built-in recursive mutexes if they are available. + */ + pthread_mutex_lock(&p->mutex); +#if SQLITE_MUTEX_NREF + assert( p->nRef>0 || p->owner==0 ); + p->owner = pthread_self(); + p->nRef++; +#endif +#endif + +#ifdef SQLITE_DEBUG + if( p->trace ){ + printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); + } +#endif +} +static int pthreadMutexTry(sqlite3_mutex *p){ + int rc; + assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); + +#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX + /* If recursive mutexes are not available, then we have to grow + ** our own. This implementation assumes that pthread_equal() + ** is atomic - that it cannot be deceived into thinking self + ** and p->owner are equal if p->owner changes between two values + ** that are not equal to self while the comparison is taking place. + ** This implementation also assumes a coherent cache - that + ** separate processes cannot read different values from the same + ** address at the same time. If either of these two conditions + ** are not met, then the mutexes will fail and problems will result. + */ + { + pthread_t self = pthread_self(); + if( p->nRef>0 && pthread_equal(p->owner, self) ){ + p->nRef++; + rc = SQLITE_OK; + }else if( pthread_mutex_trylock(&p->mutex)==0 ){ + assert( p->nRef==0 ); + p->owner = self; + p->nRef = 1; + rc = SQLITE_OK; + }else{ + rc = SQLITE_BUSY; + } + } +#else + /* Use the built-in recursive mutexes if they are available. + */ + if( pthread_mutex_trylock(&p->mutex)==0 ){ +#if SQLITE_MUTEX_NREF + p->owner = pthread_self(); + p->nRef++; +#endif + rc = SQLITE_OK; + }else{ + rc = SQLITE_BUSY; + } +#endif + +#ifdef SQLITE_DEBUG + if( rc==SQLITE_OK && p->trace ){ + printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); + } +#endif + return rc; +} + +/* +** The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. The behavior +** is undefined if the mutex is not currently entered or +** is not currently allocated. SQLite will never do either. +*/ +static void pthreadMutexLeave(sqlite3_mutex *p){ + assert( pthreadMutexHeld(p) ); +#if SQLITE_MUTEX_NREF + p->nRef--; + if( p->nRef==0 ) p->owner = 0; +#endif + assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE ); + +#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX + if( p->nRef==0 ){ + pthread_mutex_unlock(&p->mutex); + } +#else + pthread_mutex_unlock(&p->mutex); +#endif + +#ifdef SQLITE_DEBUG + if( p->trace ){ + printf("leave mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); + } +#endif +} + +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){ + static const sqlite3_mutex_methods sMutex = { + pthreadMutexInit, + pthreadMutexEnd, + pthreadMutexAlloc, + pthreadMutexFree, + pthreadMutexEnter, + pthreadMutexTry, + pthreadMutexLeave, +#ifdef SQLITE_DEBUG + pthreadMutexHeld, + pthreadMutexNotheld +#else + 0, + 0 +#endif + }; + + return &sMutex; +} + +#endif /* SQLITE_MUTEX_PTHREADS */ + +/************** End of mutex_unix.c ******************************************/ +/************** Begin file mutex_w32.c ***************************************/ +/* +** 2007 August 14 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement mutexes for Win32. +*/ +/* #include "sqliteInt.h" */ + +#if SQLITE_OS_WIN +/* +** Include code that is common to all os_*.c files +*/ +/************** Include os_common.h in the middle of mutex_w32.c *************/ +/************** Begin file os_common.h ***************************************/ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains macros and a little bit of code that is common to +** all of the platform-specific files (os_*.c) and is #included into those +** files. +** +** This file should be #included by the os_*.c files only. It is not a +** general purpose header file. +*/ +#ifndef _OS_COMMON_H_ +#define _OS_COMMON_H_ + +/* +** At least two bugs have slipped in because we changed the MEMORY_DEBUG +** macro to SQLITE_DEBUG and some older makefiles have not yet made the +** switch. The following code should catch this problem at compile-time. +*/ +#ifdef MEMORY_DEBUG +# error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead." +#endif + +/* +** Macros for performance tracing. Normally turned off. Only works +** on i486 hardware. +*/ +#ifdef SQLITE_PERFORMANCE_TRACE + +/* +** hwtime.h contains inline assembler code for implementing +** high-performance timing routines. +*/ +/************** Include hwtime.h in the middle of os_common.h ****************/ +/************** Begin file hwtime.h ******************************************/ +/* +** 2008 May 27 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains inline asm code for retrieving "high-performance" +** counters for x86 and x86_64 class CPUs. +*/ +#ifndef SQLITE_HWTIME_H +#define SQLITE_HWTIME_H + +/* +** The following routine only works on pentium-class (or newer) processors. +** It uses the RDTSC opcode to read the cycle count value out of the +** processor and returns that value. This can be used for high-res +** profiling. +*/ +#if !defined(__STRICT_ANSI__) && \ + (defined(__GNUC__) || defined(_MSC_VER)) && \ + (defined(i386) || defined(__i386__) || defined(_M_IX86)) + + #if defined(__GNUC__) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned int lo, hi; + __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); + return (sqlite_uint64)hi << 32 | lo; + } + + #elif defined(_MSC_VER) + + __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){ + __asm { + rdtsc + ret ; return value at EDX:EAX + } + } + + #endif + +#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long val; + __asm__ __volatile__ ("rdtsc" : "=A" (val)); + return val; + } + +#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long long retval; + unsigned long junk; + __asm__ __volatile__ ("\n\ + 1: mftbu %1\n\ + mftb %L0\n\ + mftbu %0\n\ + cmpw %0,%1\n\ + bne 1b" + : "=r" (retval), "=r" (junk)); + return retval; + } + +#else + + /* + ** asm() is needed for hardware timing support. Without asm(), + ** disable the sqlite3Hwtime() routine. + ** + ** sqlite3Hwtime() is only used for some obscure debugging + ** and analysis configurations, not in any deliverable, so this + ** should not be a great loss. + */ +SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); } + +#endif + +#endif /* !defined(SQLITE_HWTIME_H) */ + +/************** End of hwtime.h **********************************************/ +/************** Continuing where we left off in os_common.h ******************/ + +static sqlite_uint64 g_start; +static sqlite_uint64 g_elapsed; +#define TIMER_START g_start=sqlite3Hwtime() +#define TIMER_END g_elapsed=sqlite3Hwtime()-g_start +#define TIMER_ELAPSED g_elapsed +#else +#define TIMER_START +#define TIMER_END +#define TIMER_ELAPSED ((sqlite_uint64)0) +#endif + +/* +** If we compile with the SQLITE_TEST macro set, then the following block +** of code will give us the ability to simulate a disk I/O error. This +** is used for testing the I/O recovery logic. +*/ +#if defined(SQLITE_TEST) +SQLITE_API extern int sqlite3_io_error_hit; +SQLITE_API extern int sqlite3_io_error_hardhit; +SQLITE_API extern int sqlite3_io_error_pending; +SQLITE_API extern int sqlite3_io_error_persist; +SQLITE_API extern int sqlite3_io_error_benign; +SQLITE_API extern int sqlite3_diskfull_pending; +SQLITE_API extern int sqlite3_diskfull; +#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X) +#define SimulateIOError(CODE) \ + if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \ + || sqlite3_io_error_pending-- == 1 ) \ + { local_ioerr(); CODE; } +static void local_ioerr(){ + IOTRACE(("IOERR\n")); + sqlite3_io_error_hit++; + if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++; +} +#define SimulateDiskfullError(CODE) \ + if( sqlite3_diskfull_pending ){ \ + if( sqlite3_diskfull_pending == 1 ){ \ + local_ioerr(); \ + sqlite3_diskfull = 1; \ + sqlite3_io_error_hit = 1; \ + CODE; \ + }else{ \ + sqlite3_diskfull_pending--; \ + } \ + } +#else +#define SimulateIOErrorBenign(X) +#define SimulateIOError(A) +#define SimulateDiskfullError(A) +#endif /* defined(SQLITE_TEST) */ + +/* +** When testing, keep a count of the number of open files. +*/ +#if defined(SQLITE_TEST) +SQLITE_API extern int sqlite3_open_file_count; +#define OpenCounter(X) sqlite3_open_file_count+=(X) +#else +#define OpenCounter(X) +#endif /* defined(SQLITE_TEST) */ + +#endif /* !defined(_OS_COMMON_H_) */ + +/************** End of os_common.h *******************************************/ +/************** Continuing where we left off in mutex_w32.c ******************/ + +/* +** Include the header file for the Windows VFS. +*/ +/************** Include os_win.h in the middle of mutex_w32.c ****************/ +/************** Begin file os_win.h ******************************************/ +/* +** 2013 November 25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains code that is specific to Windows. +*/ +#ifndef SQLITE_OS_WIN_H +#define SQLITE_OS_WIN_H + +/* +** Include the primary Windows SDK header file. +*/ +#include "windows.h" + +#ifdef __CYGWIN__ +# include +# include /* amalgamator: dontcache */ +#endif + +/* +** Determine if we are dealing with Windows NT. +** +** We ought to be able to determine if we are compiling for Windows 9x or +** Windows NT using the _WIN32_WINNT macro as follows: +** +** #if defined(_WIN32_WINNT) +** # define SQLITE_OS_WINNT 1 +** #else +** # define SQLITE_OS_WINNT 0 +** #endif +** +** However, Visual Studio 2005 does not set _WIN32_WINNT by default, as +** it ought to, so the above test does not work. We'll just assume that +** everything is Windows NT unless the programmer explicitly says otherwise +** by setting SQLITE_OS_WINNT to 0. +*/ +#if SQLITE_OS_WIN && !defined(SQLITE_OS_WINNT) +# define SQLITE_OS_WINNT 1 +#endif + +/* +** Determine if we are dealing with Windows CE - which has a much reduced +** API. +*/ +#if defined(_WIN32_WCE) +# define SQLITE_OS_WINCE 1 +#else +# define SQLITE_OS_WINCE 0 +#endif + +/* +** Determine if we are dealing with WinRT, which provides only a subset of +** the full Win32 API. +*/ +#if !defined(SQLITE_OS_WINRT) +# define SQLITE_OS_WINRT 0 +#endif + +/* +** For WinCE, some API function parameters do not appear to be declared as +** volatile. +*/ +#if SQLITE_OS_WINCE +# define SQLITE_WIN32_VOLATILE +#else +# define SQLITE_WIN32_VOLATILE volatile +#endif + +/* +** For some Windows sub-platforms, the _beginthreadex() / _endthreadex() +** functions are not available (e.g. those not using MSVC, Cygwin, etc). +*/ +#if SQLITE_OS_WIN && !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && \ + SQLITE_THREADSAFE>0 && !defined(__CYGWIN__) +# define SQLITE_OS_WIN_THREADS 1 +#else +# define SQLITE_OS_WIN_THREADS 0 +#endif + +#endif /* SQLITE_OS_WIN_H */ + +/************** End of os_win.h **********************************************/ +/************** Continuing where we left off in mutex_w32.c ******************/ +#endif + +/* +** The code in this file is only used if we are compiling multithreaded +** on a Win32 system. +*/ +#ifdef SQLITE_MUTEX_W32 + +/* +** Each recursive mutex is an instance of the following structure. +*/ +struct sqlite3_mutex { + CRITICAL_SECTION mutex; /* Mutex controlling the lock */ + int id; /* Mutex type */ +#ifdef SQLITE_DEBUG + volatile int nRef; /* Number of enterances */ + volatile DWORD owner; /* Thread holding this mutex */ + volatile LONG trace; /* True to trace changes */ +#endif +}; + +/* +** These are the initializer values used when declaring a "static" mutex +** on Win32. It should be noted that all mutexes require initialization +** on the Win32 platform. +*/ +#define SQLITE_W32_MUTEX_INITIALIZER { 0 } + +#ifdef SQLITE_DEBUG +#define SQLITE3_MUTEX_INITIALIZER(id) { SQLITE_W32_MUTEX_INITIALIZER, id, \ + 0L, (DWORD)0, 0 } +#else +#define SQLITE3_MUTEX_INITIALIZER(id) { SQLITE_W32_MUTEX_INITIALIZER, id } +#endif + +#ifdef SQLITE_DEBUG +/* +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are +** intended for use only inside assert() statements. +*/ +static int winMutexHeld(sqlite3_mutex *p){ + return p->nRef!=0 && p->owner==GetCurrentThreadId(); +} + +static int winMutexNotheld2(sqlite3_mutex *p, DWORD tid){ + return p->nRef==0 || p->owner!=tid; +} + +static int winMutexNotheld(sqlite3_mutex *p){ + DWORD tid = GetCurrentThreadId(); + return winMutexNotheld2(p, tid); +} +#endif + +/* +** Try to provide a memory barrier operation, needed for initialization +** and also for the xShmBarrier method of the VFS in cases when SQLite is +** compiled without mutexes (SQLITE_THREADSAFE=0). +*/ +SQLITE_PRIVATE void sqlite3MemoryBarrier(void){ +#if defined(SQLITE_MEMORY_BARRIER) + SQLITE_MEMORY_BARRIER; +#elif defined(__GNUC__) + __sync_synchronize(); +#elif MSVC_VERSION>=1300 + _ReadWriteBarrier(); +#elif defined(MemoryBarrier) + MemoryBarrier(); +#endif +} + +/* +** Initialize and deinitialize the mutex subsystem. +*/ +static sqlite3_mutex winMutex_staticMutexes[] = { + SQLITE3_MUTEX_INITIALIZER(2), + SQLITE3_MUTEX_INITIALIZER(3), + SQLITE3_MUTEX_INITIALIZER(4), + SQLITE3_MUTEX_INITIALIZER(5), + SQLITE3_MUTEX_INITIALIZER(6), + SQLITE3_MUTEX_INITIALIZER(7), + SQLITE3_MUTEX_INITIALIZER(8), + SQLITE3_MUTEX_INITIALIZER(9), + SQLITE3_MUTEX_INITIALIZER(10), + SQLITE3_MUTEX_INITIALIZER(11), + SQLITE3_MUTEX_INITIALIZER(12), + SQLITE3_MUTEX_INITIALIZER(13) +}; + +static int winMutex_isInit = 0; +static int winMutex_isNt = -1; /* <0 means "need to query" */ + +/* As the winMutexInit() and winMutexEnd() functions are called as part +** of the sqlite3_initialize() and sqlite3_shutdown() processing, the +** "interlocked" magic used here is probably not strictly necessary. +*/ +static LONG SQLITE_WIN32_VOLATILE winMutex_lock = 0; + +SQLITE_API int sqlite3_win32_is_nt(void); /* os_win.c */ +SQLITE_API void sqlite3_win32_sleep(DWORD milliseconds); /* os_win.c */ + +static int winMutexInit(void){ + /* The first to increment to 1 does actual initialization */ + if( InterlockedCompareExchange(&winMutex_lock, 1, 0)==0 ){ + int i; + for(i=0; i +**
  • SQLITE_MUTEX_FAST +**
  • SQLITE_MUTEX_RECURSIVE +**
  • SQLITE_MUTEX_STATIC_MAIN +**
  • SQLITE_MUTEX_STATIC_MEM +**
  • SQLITE_MUTEX_STATIC_OPEN +**
  • SQLITE_MUTEX_STATIC_PRNG +**
  • SQLITE_MUTEX_STATIC_LRU +**
  • SQLITE_MUTEX_STATIC_PMEM +**
  • SQLITE_MUTEX_STATIC_APP1 +**
  • SQLITE_MUTEX_STATIC_APP2 +**
  • SQLITE_MUTEX_STATIC_APP3 +**
  • SQLITE_MUTEX_STATIC_VFS1 +**
  • SQLITE_MUTEX_STATIC_VFS2 +**
  • SQLITE_MUTEX_STATIC_VFS3 +** +** +** The first two constants cause sqlite3_mutex_alloc() to create +** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE +** is used but not necessarily so when SQLITE_MUTEX_FAST is used. +** The mutex implementation does not need to make a distinction +** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does +** not want to. But SQLite will only request a recursive mutex in +** cases where it really needs one. If a faster non-recursive mutex +** implementation is available on the host platform, the mutex subsystem +** might return such a mutex in response to SQLITE_MUTEX_FAST. +** +** The other allowed parameters to sqlite3_mutex_alloc() each return +** a pointer to a static preexisting mutex. Six static mutexes are +** used by the current version of SQLite. Future versions of SQLite +** may add additional static mutexes. Static mutexes are for internal +** use by SQLite only. Applications that use SQLite mutexes should +** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or +** SQLITE_MUTEX_RECURSIVE. +** +** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST +** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() +** returns a different mutex on every call. But for the static +** mutex types, the same mutex is returned on every call that has +** the same type number. +*/ +static sqlite3_mutex *winMutexAlloc(int iType){ + sqlite3_mutex *p; + + switch( iType ){ + case SQLITE_MUTEX_FAST: + case SQLITE_MUTEX_RECURSIVE: { + p = sqlite3MallocZero( sizeof(*p) ); + if( p ){ + p->id = iType; +#ifdef SQLITE_DEBUG +#ifdef SQLITE_WIN32_MUTEX_TRACE_DYNAMIC + p->trace = 1; +#endif +#endif +#if SQLITE_OS_WINRT + InitializeCriticalSectionEx(&p->mutex, 0, 0); +#else + InitializeCriticalSection(&p->mutex); +#endif + } + break; + } + default: { +#ifdef SQLITE_ENABLE_API_ARMOR + if( iType-2<0 || iType-2>=ArraySize(winMutex_staticMutexes) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + p = &winMutex_staticMutexes[iType-2]; +#ifdef SQLITE_DEBUG +#ifdef SQLITE_WIN32_MUTEX_TRACE_STATIC + InterlockedCompareExchange(&p->trace, 1, 0); +#endif +#endif + break; + } + } + assert( p==0 || p->id==iType ); + return p; +} + + +/* +** This routine deallocates a previously +** allocated mutex. SQLite is careful to deallocate every +** mutex that it allocates. +*/ +static void winMutexFree(sqlite3_mutex *p){ + assert( p ); + assert( p->nRef==0 && p->owner==0 ); + if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ){ + DeleteCriticalSection(&p->mutex); + sqlite3_free(p); + }else{ +#ifdef SQLITE_ENABLE_API_ARMOR + (void)SQLITE_MISUSE_BKPT; +#endif + } +} + +/* +** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK +** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can +** be entered multiple times by the same thread. In such cases the, +** mutex must be exited an equal number of times before another thread +** can enter. If the same thread tries to enter any other kind of mutex +** more than once, the behavior is undefined. +*/ +static void winMutexEnter(sqlite3_mutex *p){ +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + DWORD tid = GetCurrentThreadId(); +#endif +#ifdef SQLITE_DEBUG + assert( p ); + assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) ); +#else + assert( p ); +#endif + assert( winMutex_isInit==1 ); + EnterCriticalSection(&p->mutex); +#ifdef SQLITE_DEBUG + assert( p->nRef>0 || p->owner==0 ); + p->owner = tid; + p->nRef++; + if( p->trace ){ + OSTRACE(("ENTER-MUTEX tid=%lu, mutex(%d)=%p (%d), nRef=%d\n", + tid, p->id, p, p->trace, p->nRef)); + } +#endif +} + +static int winMutexTry(sqlite3_mutex *p){ +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + DWORD tid = GetCurrentThreadId(); +#endif + int rc = SQLITE_BUSY; + assert( p ); + assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) ); + /* + ** The sqlite3_mutex_try() routine is very rarely used, and when it + ** is used it is merely an optimization. So it is OK for it to always + ** fail. + ** + ** The TryEnterCriticalSection() interface is only available on WinNT. + ** And some windows compilers complain if you try to use it without + ** first doing some #defines that prevent SQLite from building on Win98. + ** For that reason, we will omit this optimization for now. See + ** ticket #2685. + */ +#if defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0400 + assert( winMutex_isInit==1 ); + assert( winMutex_isNt>=-1 && winMutex_isNt<=1 ); + if( winMutex_isNt<0 ){ + winMutex_isNt = sqlite3_win32_is_nt(); + } + assert( winMutex_isNt==0 || winMutex_isNt==1 ); + if( winMutex_isNt && TryEnterCriticalSection(&p->mutex) ){ +#ifdef SQLITE_DEBUG + p->owner = tid; + p->nRef++; +#endif + rc = SQLITE_OK; + } +#else + UNUSED_PARAMETER(p); +#endif +#ifdef SQLITE_DEBUG + if( p->trace ){ + OSTRACE(("TRY-MUTEX tid=%lu, mutex(%d)=%p (%d), owner=%lu, nRef=%d, rc=%s\n", + tid, p->id, p, p->trace, p->owner, p->nRef, sqlite3ErrName(rc))); + } +#endif + return rc; +} + +/* +** The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. The behavior +** is undefined if the mutex is not currently entered or +** is not currently allocated. SQLite will never do either. +*/ +static void winMutexLeave(sqlite3_mutex *p){ +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + DWORD tid = GetCurrentThreadId(); +#endif + assert( p ); +#ifdef SQLITE_DEBUG + assert( p->nRef>0 ); + assert( p->owner==tid ); + p->nRef--; + if( p->nRef==0 ) p->owner = 0; + assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE ); +#endif + assert( winMutex_isInit==1 ); + LeaveCriticalSection(&p->mutex); +#ifdef SQLITE_DEBUG + if( p->trace ){ + OSTRACE(("LEAVE-MUTEX tid=%lu, mutex(%d)=%p (%d), nRef=%d\n", + tid, p->id, p, p->trace, p->nRef)); + } +#endif +} + +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){ + static const sqlite3_mutex_methods sMutex = { + winMutexInit, + winMutexEnd, + winMutexAlloc, + winMutexFree, + winMutexEnter, + winMutexTry, + winMutexLeave, +#ifdef SQLITE_DEBUG + winMutexHeld, + winMutexNotheld +#else + 0, + 0 +#endif + }; + return &sMutex; +} + +#endif /* SQLITE_MUTEX_W32 */ + +/************** End of mutex_w32.c *******************************************/ +/************** Begin file malloc.c ******************************************/ +/* +** 2001 September 15 +** +** 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. +** +************************************************************************* +** +** Memory allocation functions used throughout sqlite. +*/ +/* #include "sqliteInt.h" */ +/* #include */ + +/* +** Attempt to release up to n bytes of non-essential memory currently +** held by SQLite. An example of non-essential memory is memory used to +** cache database pages that are not currently in use. +*/ +SQLITE_API int sqlite3_release_memory(int n){ +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + return sqlite3PcacheReleaseMemory(n); +#else + /* IMPLEMENTATION-OF: R-34391-24921 The sqlite3_release_memory() routine + ** is a no-op returning zero if SQLite is not compiled with + ** SQLITE_ENABLE_MEMORY_MANAGEMENT. */ + UNUSED_PARAMETER(n); + return 0; +#endif +} + +/* +** Default value of the hard heap limit. 0 means "no limit". +*/ +#ifndef SQLITE_MAX_MEMORY +# define SQLITE_MAX_MEMORY 0 +#endif + +/* +** State information local to the memory allocation subsystem. +*/ +static SQLITE_WSD struct Mem0Global { + sqlite3_mutex *mutex; /* Mutex to serialize access */ + sqlite3_int64 alarmThreshold; /* The soft heap limit */ + sqlite3_int64 hardLimit; /* The hard upper bound on memory */ + + /* + ** True if heap is nearly "full" where "full" is defined by the + ** sqlite3_soft_heap_limit() setting. + */ + int nearlyFull; +} mem0 = { 0, SQLITE_MAX_MEMORY, SQLITE_MAX_MEMORY, 0 }; + +#define mem0 GLOBAL(struct Mem0Global, mem0) + +/* +** Return the memory allocator mutex. sqlite3_status() needs it. +*/ +SQLITE_PRIVATE sqlite3_mutex *sqlite3MallocMutex(void){ + return mem0.mutex; +} + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Deprecated external interface. It used to set an alarm callback +** that was invoked when memory usage grew too large. Now it is a +** no-op. +*/ +SQLITE_API int sqlite3_memory_alarm( + void(*xCallback)(void *pArg, sqlite3_int64 used,int N), + void *pArg, + sqlite3_int64 iThreshold +){ + (void)xCallback; + (void)pArg; + (void)iThreshold; + return SQLITE_OK; +} +#endif + +/* +** Set the soft heap-size limit for the library. An argument of +** zero disables the limit. A negative argument is a no-op used to +** obtain the return value. +** +** The return value is the value of the heap limit just before this +** interface was called. +** +** If the hard heap limit is enabled, then the soft heap limit cannot +** be disabled nor raised above the hard heap limit. +*/ +SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 n){ + sqlite3_int64 priorLimit; + sqlite3_int64 excess; + sqlite3_int64 nUsed; +#ifndef SQLITE_OMIT_AUTOINIT + int rc = sqlite3_initialize(); + if( rc ) return -1; +#endif + sqlite3_mutex_enter(mem0.mutex); + priorLimit = mem0.alarmThreshold; + if( n<0 ){ + sqlite3_mutex_leave(mem0.mutex); + return priorLimit; + } + if( mem0.hardLimit>0 && (n>mem0.hardLimit || n==0) ){ + n = mem0.hardLimit; + } + mem0.alarmThreshold = n; + nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED); + AtomicStore(&mem0.nearlyFull, n>0 && n<=nUsed); + sqlite3_mutex_leave(mem0.mutex); + excess = sqlite3_memory_used() - n; + if( excess>0 ) sqlite3_release_memory((int)(excess & 0x7fffffff)); + return priorLimit; +} +SQLITE_API void sqlite3_soft_heap_limit(int n){ + if( n<0 ) n = 0; + sqlite3_soft_heap_limit64(n); +} + +/* +** Set the hard heap-size limit for the library. An argument of zero +** disables the hard heap limit. A negative argument is a no-op used +** to obtain the return value without affecting the hard heap limit. +** +** The return value is the value of the hard heap limit just prior to +** calling this interface. +** +** Setting the hard heap limit will also activate the soft heap limit +** and constrain the soft heap limit to be no more than the hard heap +** limit. +*/ +SQLITE_API sqlite3_int64 sqlite3_hard_heap_limit64(sqlite3_int64 n){ + sqlite3_int64 priorLimit; +#ifndef SQLITE_OMIT_AUTOINIT + int rc = sqlite3_initialize(); + if( rc ) return -1; +#endif + sqlite3_mutex_enter(mem0.mutex); + priorLimit = mem0.hardLimit; + if( n>=0 ){ + mem0.hardLimit = n; + if( n0 ); + + /* In Firefox (circa 2017-02-08), xRoundup() is remapped to an internal + ** implementation of malloc_good_size(), which must be called in debug + ** mode and specifically when the DMD "Dark Matter Detector" is enabled + ** or else a crash results. Hence, do not attempt to optimize out the + ** following xRoundup() call. */ + nFull = sqlite3GlobalConfig.m.xRoundup(n); + + sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n); + if( mem0.alarmThreshold>0 ){ + sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED); + if( nUsed >= mem0.alarmThreshold - nFull ){ + AtomicStore(&mem0.nearlyFull, 1); + sqlite3MallocAlarm(nFull); + if( mem0.hardLimit ){ + nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED); + if( nUsed >= mem0.hardLimit - nFull ){ + *pp = 0; + return; + } + } + }else{ + AtomicStore(&mem0.nearlyFull, 0); + } + } + p = sqlite3GlobalConfig.m.xMalloc(nFull); +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + if( p==0 && mem0.alarmThreshold>0 ){ + sqlite3MallocAlarm(nFull); + p = sqlite3GlobalConfig.m.xMalloc(nFull); + } +#endif + if( p ){ + nFull = sqlite3MallocSize(p); + sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nFull); + sqlite3StatusUp(SQLITE_STATUS_MALLOC_COUNT, 1); + } + *pp = p; +} + +/* +** Allocate memory. This routine is like sqlite3_malloc() except that it +** assumes the memory subsystem has already been initialized. +*/ +SQLITE_PRIVATE void *sqlite3Malloc(u64 n){ + void *p; + if( n==0 || n>=0x7fffff00 ){ + /* A memory allocation of a number of bytes which is near the maximum + ** signed integer value might cause an integer overflow inside of the + ** xMalloc(). Hence we limit the maximum size to 0x7fffff00, giving + ** 255 bytes of overhead. SQLite itself will never use anything near + ** this amount. The only way to reach the limit is with sqlite3_malloc() */ + p = 0; + }else if( sqlite3GlobalConfig.bMemstat ){ + sqlite3_mutex_enter(mem0.mutex); + mallocWithAlarm((int)n, &p); + sqlite3_mutex_leave(mem0.mutex); + }else{ + p = sqlite3GlobalConfig.m.xMalloc((int)n); + } + assert( EIGHT_BYTE_ALIGNMENT(p) ); /* IMP: R-11148-40995 */ + return p; +} + +/* +** This version of the memory allocation is for use by the application. +** First make sure the memory subsystem is initialized, then do the +** allocation. +*/ +SQLITE_API void *sqlite3_malloc(int n){ +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return n<=0 ? 0 : sqlite3Malloc(n); +} +SQLITE_API void *sqlite3_malloc64(sqlite3_uint64 n){ +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return sqlite3Malloc(n); +} + +/* +** TRUE if p is a lookaside memory allocation from db +*/ +#ifndef SQLITE_OMIT_LOOKASIDE +static int isLookaside(sqlite3 *db, void *p){ + return SQLITE_WITHIN(p, db->lookaside.pStart, db->lookaside.pEnd); +} +#else +#define isLookaside(A,B) 0 +#endif + +/* +** Return the size of a memory allocation previously obtained from +** sqlite3Malloc() or sqlite3_malloc(). +*/ +SQLITE_PRIVATE int sqlite3MallocSize(void *p){ + assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); + return sqlite3GlobalConfig.m.xSize(p); +} +static int lookasideMallocSize(sqlite3 *db, void *p){ +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + return plookaside.pMiddle ? db->lookaside.szTrue : LOOKASIDE_SMALL; +#else + return db->lookaside.szTrue; +#endif +} +SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){ + assert( p!=0 ); +#ifdef SQLITE_DEBUG + if( db==0 || !isLookaside(db,p) ){ + if( db==0 ){ + assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) ); + assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); + }else{ + assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + } + } +#endif + if( db ){ + if( ((uptr)p)<(uptr)(db->lookaside.pEnd) ){ +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + if( ((uptr)p)>=(uptr)(db->lookaside.pMiddle) ){ + assert( sqlite3_mutex_held(db->mutex) ); + return LOOKASIDE_SMALL; + } +#endif + if( ((uptr)p)>=(uptr)(db->lookaside.pStart) ){ + assert( sqlite3_mutex_held(db->mutex) ); + return db->lookaside.szTrue; + } + } + } + return sqlite3GlobalConfig.m.xSize(p); +} +SQLITE_API sqlite3_uint64 sqlite3_msize(void *p){ + assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) ); + assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); + return p ? sqlite3GlobalConfig.m.xSize(p) : 0; +} + +/* +** Free memory previously obtained from sqlite3Malloc(). +*/ +SQLITE_API void sqlite3_free(void *p){ + if( p==0 ) return; /* IMP: R-49053-54554 */ + assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); + assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) ); + if( sqlite3GlobalConfig.bMemstat ){ + sqlite3_mutex_enter(mem0.mutex); + sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, sqlite3MallocSize(p)); + sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1); + sqlite3GlobalConfig.m.xFree(p); + sqlite3_mutex_leave(mem0.mutex); + }else{ + sqlite3GlobalConfig.m.xFree(p); + } +} + +/* +** Add the size of memory allocation "p" to the count in +** *db->pnBytesFreed. +*/ +static SQLITE_NOINLINE void measureAllocationSize(sqlite3 *db, void *p){ + *db->pnBytesFreed += sqlite3DbMallocSize(db,p); +} + +/* +** Free memory that might be associated with a particular database +** connection. Calling sqlite3DbFree(D,X) for X==0 is a harmless no-op. +** The sqlite3DbFreeNN(D,X) version requires that X be non-NULL. +*/ +SQLITE_PRIVATE void sqlite3DbFreeNN(sqlite3 *db, void *p){ + assert( db==0 || sqlite3_mutex_held(db->mutex) ); + assert( p!=0 ); + if( db ){ + if( db->pnBytesFreed ){ + measureAllocationSize(db, p); + return; + } + if( ((uptr)p)<(uptr)(db->lookaside.pEnd) ){ +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + if( ((uptr)p)>=(uptr)(db->lookaside.pMiddle) ){ + LookasideSlot *pBuf = (LookasideSlot*)p; +#ifdef SQLITE_DEBUG + memset(p, 0xaa, LOOKASIDE_SMALL); /* Trash freed content */ +#endif + pBuf->pNext = db->lookaside.pSmallFree; + db->lookaside.pSmallFree = pBuf; + return; + } +#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */ + if( ((uptr)p)>=(uptr)(db->lookaside.pStart) ){ + LookasideSlot *pBuf = (LookasideSlot*)p; +#ifdef SQLITE_DEBUG + memset(p, 0xaa, db->lookaside.szTrue); /* Trash freed content */ +#endif + pBuf->pNext = db->lookaside.pFree; + db->lookaside.pFree = pBuf; + return; + } + } + } + assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) ); + sqlite3MemdebugSetType(p, MEMTYPE_HEAP); + sqlite3_free(p); +} +SQLITE_PRIVATE void sqlite3DbFree(sqlite3 *db, void *p){ + assert( db==0 || sqlite3_mutex_held(db->mutex) ); + if( p ) sqlite3DbFreeNN(db, p); +} + +/* +** Change the size of an existing memory allocation +*/ +SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, u64 nBytes){ + int nOld, nNew, nDiff; + void *pNew; + assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) ); + assert( sqlite3MemdebugNoType(pOld, (u8)~MEMTYPE_HEAP) ); + if( pOld==0 ){ + return sqlite3Malloc(nBytes); /* IMP: R-04300-56712 */ + } + if( nBytes==0 ){ + sqlite3_free(pOld); /* IMP: R-26507-47431 */ + return 0; + } + if( nBytes>=0x7fffff00 ){ + /* The 0x7ffff00 limit term is explained in comments on sqlite3Malloc() */ + return 0; + } + nOld = sqlite3MallocSize(pOld); + /* IMPLEMENTATION-OF: R-46199-30249 SQLite guarantees that the second + ** argument to xRealloc is always a value returned by a prior call to + ** xRoundup. */ + nNew = sqlite3GlobalConfig.m.xRoundup((int)nBytes); + if( nOld==nNew ){ + pNew = pOld; + }else if( sqlite3GlobalConfig.bMemstat ){ + sqlite3_int64 nUsed; + sqlite3_mutex_enter(mem0.mutex); + sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, (int)nBytes); + nDiff = nNew - nOld; + if( nDiff>0 && (nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED)) >= + mem0.alarmThreshold-nDiff ){ + sqlite3MallocAlarm(nDiff); + if( mem0.hardLimit>0 && nUsed >= mem0.hardLimit - nDiff ){ + sqlite3_mutex_leave(mem0.mutex); + return 0; + } + } + pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + if( pNew==0 && mem0.alarmThreshold>0 ){ + sqlite3MallocAlarm((int)nBytes); + pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); + } +#endif + if( pNew ){ + nNew = sqlite3MallocSize(pNew); + sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld); + } + sqlite3_mutex_leave(mem0.mutex); + }else{ + pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); + } + assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-11148-40995 */ + return pNew; +} + +/* +** The public interface to sqlite3Realloc. Make sure that the memory +** subsystem is initialized prior to invoking sqliteRealloc. +*/ +SQLITE_API void *sqlite3_realloc(void *pOld, int n){ +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + if( n<0 ) n = 0; /* IMP: R-26507-47431 */ + return sqlite3Realloc(pOld, n); +} +SQLITE_API void *sqlite3_realloc64(void *pOld, sqlite3_uint64 n){ +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return sqlite3Realloc(pOld, n); +} + + +/* +** Allocate and zero memory. +*/ +SQLITE_PRIVATE void *sqlite3MallocZero(u64 n){ + void *p = sqlite3Malloc(n); + if( p ){ + memset(p, 0, (size_t)n); + } + return p; +} + +/* +** Allocate and zero memory. If the allocation fails, make +** the mallocFailed flag in the connection pointer. +*/ +SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3 *db, u64 n){ + void *p; + testcase( db==0 ); + p = sqlite3DbMallocRaw(db, n); + if( p ) memset(p, 0, (size_t)n); + return p; +} + + +/* Finish the work of sqlite3DbMallocRawNN for the unusual and +** slower case when the allocation cannot be fulfilled using lookaside. +*/ +static SQLITE_NOINLINE void *dbMallocRawFinish(sqlite3 *db, u64 n){ + void *p; + assert( db!=0 ); + p = sqlite3Malloc(n); + if( !p ) sqlite3OomFault(db); + sqlite3MemdebugSetType(p, + (db->lookaside.bDisable==0) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP); + return p; +} + +/* +** Allocate memory, either lookaside (if possible) or heap. +** If the allocation fails, set the mallocFailed flag in +** the connection pointer. +** +** If db!=0 and db->mallocFailed is true (indicating a prior malloc +** failure on the same database connection) then always return 0. +** Hence for a particular database connection, once malloc starts +** failing, it fails consistently until mallocFailed is reset. +** This is an important assumption. There are many places in the +** code that do things like this: +** +** int *a = (int*)sqlite3DbMallocRaw(db, 100); +** int *b = (int*)sqlite3DbMallocRaw(db, 200); +** if( b ) a[10] = 9; +** +** In other words, if a subsequent malloc (ex: "b") worked, it is assumed +** that all prior mallocs (ex: "a") worked too. +** +** The sqlite3MallocRawNN() variant guarantees that the "db" parameter is +** not a NULL pointer. +*/ +SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3 *db, u64 n){ + void *p; + if( db ) return sqlite3DbMallocRawNN(db, n); + p = sqlite3Malloc(n); + sqlite3MemdebugSetType(p, MEMTYPE_HEAP); + return p; +} +SQLITE_PRIVATE void *sqlite3DbMallocRawNN(sqlite3 *db, u64 n){ +#ifndef SQLITE_OMIT_LOOKASIDE + LookasideSlot *pBuf; + assert( db!=0 ); + assert( sqlite3_mutex_held(db->mutex) ); + assert( db->pnBytesFreed==0 ); + if( n>db->lookaside.sz ){ + if( !db->lookaside.bDisable ){ + db->lookaside.anStat[1]++; + }else if( db->mallocFailed ){ + return 0; + } + return dbMallocRawFinish(db, n); + } +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + if( n<=LOOKASIDE_SMALL ){ + if( (pBuf = db->lookaside.pSmallFree)!=0 ){ + db->lookaside.pSmallFree = pBuf->pNext; + db->lookaside.anStat[0]++; + return (void*)pBuf; + }else if( (pBuf = db->lookaside.pSmallInit)!=0 ){ + db->lookaside.pSmallInit = pBuf->pNext; + db->lookaside.anStat[0]++; + return (void*)pBuf; + } + } +#endif + if( (pBuf = db->lookaside.pFree)!=0 ){ + db->lookaside.pFree = pBuf->pNext; + db->lookaside.anStat[0]++; + return (void*)pBuf; + }else if( (pBuf = db->lookaside.pInit)!=0 ){ + db->lookaside.pInit = pBuf->pNext; + db->lookaside.anStat[0]++; + return (void*)pBuf; + }else{ + db->lookaside.anStat[2]++; + } +#else + assert( db!=0 ); + assert( sqlite3_mutex_held(db->mutex) ); + assert( db->pnBytesFreed==0 ); + if( db->mallocFailed ){ + return 0; + } +#endif + return dbMallocRawFinish(db, n); +} + +/* Forward declaration */ +static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n); + +/* +** Resize the block of memory pointed to by p to n bytes. If the +** resize fails, set the mallocFailed flag in the connection object. +*/ +SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){ + assert( db!=0 ); + if( p==0 ) return sqlite3DbMallocRawNN(db, n); + assert( sqlite3_mutex_held(db->mutex) ); + if( ((uptr)p)<(uptr)db->lookaside.pEnd ){ +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + if( ((uptr)p)>=(uptr)db->lookaside.pMiddle ){ + if( n<=LOOKASIDE_SMALL ) return p; + }else +#endif + if( ((uptr)p)>=(uptr)db->lookaside.pStart ){ + if( n<=db->lookaside.szTrue ) return p; + } + } + return dbReallocFinish(db, p, n); +} +static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n){ + void *pNew = 0; + assert( db!=0 ); + assert( p!=0 ); + if( db->mallocFailed==0 ){ + if( isLookaside(db, p) ){ + pNew = sqlite3DbMallocRawNN(db, n); + if( pNew ){ + memcpy(pNew, p, lookasideMallocSize(db, p)); + sqlite3DbFree(db, p); + } + }else{ + assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + sqlite3MemdebugSetType(p, MEMTYPE_HEAP); + pNew = sqlite3Realloc(p, n); + if( !pNew ){ + sqlite3OomFault(db); + } + sqlite3MemdebugSetType(pNew, + (db->lookaside.bDisable==0 ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP)); + } + } + return pNew; +} + +/* +** Attempt to reallocate p. If the reallocation fails, then free p +** and set the mallocFailed flag in the database connection. +*/ +SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, u64 n){ + void *pNew; + pNew = sqlite3DbRealloc(db, p, n); + if( !pNew ){ + sqlite3DbFree(db, p); + } + return pNew; +} + +/* +** Make a copy of a string in memory obtained from sqliteMalloc(). These +** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This +** is because when memory debugging is turned on, these two functions are +** called via macros that record the current file and line number in the +** ThreadData structure. +*/ +SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3 *db, const char *z){ + char *zNew; + size_t n; + if( z==0 ){ + return 0; + } + n = strlen(z) + 1; + zNew = sqlite3DbMallocRaw(db, n); + if( zNew ){ + memcpy(zNew, z, n); + } + return zNew; +} +SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3 *db, const char *z, u64 n){ + char *zNew; + assert( db!=0 ); + assert( z!=0 || n==0 ); + assert( (n&0x7fffffff)==n ); + zNew = z ? sqlite3DbMallocRawNN(db, n+1) : 0; + if( zNew ){ + memcpy(zNew, z, (size_t)n); + zNew[n] = 0; + } + return zNew; +} + +/* +** The text between zStart and zEnd represents a phrase within a larger +** SQL statement. Make a copy of this phrase in space obtained form +** sqlite3DbMalloc(). Omit leading and trailing whitespace. +*/ +SQLITE_PRIVATE char *sqlite3DbSpanDup(sqlite3 *db, const char *zStart, const char *zEnd){ + int n; + while( sqlite3Isspace(zStart[0]) ) zStart++; + n = (int)(zEnd - zStart); + while( ALWAYS(n>0) && sqlite3Isspace(zStart[n-1]) ) n--; + return sqlite3DbStrNDup(db, zStart, n); +} + +/* +** Free any prior content in *pz and replace it with a copy of zNew. +*/ +SQLITE_PRIVATE void sqlite3SetString(char **pz, sqlite3 *db, const char *zNew){ + sqlite3DbFree(db, *pz); + *pz = sqlite3DbStrDup(db, zNew); +} + +/* +** Call this routine to record the fact that an OOM (out-of-memory) error +** has happened. This routine will set db->mallocFailed, and also +** temporarily disable the lookaside memory allocator and interrupt +** any running VDBEs. +*/ +SQLITE_PRIVATE void sqlite3OomFault(sqlite3 *db){ + if( db->mallocFailed==0 && db->bBenignMalloc==0 ){ + db->mallocFailed = 1; + if( db->nVdbeExec>0 ){ + AtomicStore(&db->u1.isInterrupted, 1); + } + DisableLookaside; + if( db->pParse ){ + db->pParse->rc = SQLITE_NOMEM_BKPT; + } + } +} + +/* +** This routine reactivates the memory allocator and clears the +** db->mallocFailed flag as necessary. +** +** The memory allocator is not restarted if there are running +** VDBEs. +*/ +SQLITE_PRIVATE void sqlite3OomClear(sqlite3 *db){ + if( db->mallocFailed && db->nVdbeExec==0 ){ + db->mallocFailed = 0; + AtomicStore(&db->u1.isInterrupted, 0); + assert( db->lookaside.bDisable>0 ); + EnableLookaside; + } +} + +/* +** Take actions at the end of an API call to deal with error codes. +*/ +static SQLITE_NOINLINE int apiHandleError(sqlite3 *db, int rc){ + if( db->mallocFailed || rc==SQLITE_IOERR_NOMEM ){ + sqlite3OomClear(db); + sqlite3Error(db, SQLITE_NOMEM); + return SQLITE_NOMEM_BKPT; + } + return rc & db->errMask; +} + +/* +** This function must be called before exiting any API function (i.e. +** returning control to the user) that has called sqlite3_malloc or +** sqlite3_realloc. +** +** The returned value is normally a copy of the second argument to this +** function. However, if a malloc() failure has occurred since the previous +** invocation SQLITE_NOMEM is returned instead. +** +** If an OOM as occurred, then the connection error-code (the value +** returned by sqlite3_errcode()) is set to SQLITE_NOMEM. +*/ +SQLITE_PRIVATE int sqlite3ApiExit(sqlite3* db, int rc){ + /* If the db handle must hold the connection handle mutex here. + ** Otherwise the read (and possible write) of db->mallocFailed + ** is unsafe, as is the call to sqlite3Error(). + */ + assert( db!=0 ); + assert( sqlite3_mutex_held(db->mutex) ); + if( db->mallocFailed || rc ){ + return apiHandleError(db, rc); + } + return rc & db->errMask; +} + +/************** End of malloc.c **********************************************/ +/************** Begin file printf.c ******************************************/ +/* +** The "printf" code that follows dates from the 1980's. It is in +** the public domain. +** +************************************************************************** +** +** This file contains code for a set of "printf"-like routines. These +** routines format strings much like the printf() from the standard C +** library, though the implementation here has enhancements to support +** SQLite. +*/ +/* #include "sqliteInt.h" */ + +/* +** Conversion types fall into various categories as defined by the +** following enumeration. +*/ +#define etRADIX 0 /* non-decimal integer types. %x %o */ +#define etFLOAT 1 /* Floating point. %f */ +#define etEXP 2 /* Exponentional notation. %e and %E */ +#define etGENERIC 3 /* Floating or exponential, depending on exponent. %g */ +#define etSIZE 4 /* Return number of characters processed so far. %n */ +#define etSTRING 5 /* Strings. %s */ +#define etDYNSTRING 6 /* Dynamically allocated strings. %z */ +#define etPERCENT 7 /* Percent symbol. %% */ +#define etCHARX 8 /* Characters. %c */ +/* The rest are extensions, not normally found in printf() */ +#define etSQLESCAPE 9 /* Strings with '\'' doubled. %q */ +#define etSQLESCAPE2 10 /* Strings with '\'' doubled and enclosed in '', + NULL pointers replaced by SQL NULL. %Q */ +#define etTOKEN 11 /* a pointer to a Token structure */ +#define etSRCLIST 12 /* a pointer to a SrcList */ +#define etPOINTER 13 /* The %p conversion */ +#define etSQLESCAPE3 14 /* %w -> Strings with '\"' doubled */ +#define etORDINAL 15 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */ +#define etDECIMAL 16 /* %d or %u, but not %x, %o */ + +#define etINVALID 17 /* Any unrecognized conversion type */ + + +/* +** An "etByte" is an 8-bit unsigned value. +*/ +typedef unsigned char etByte; + +/* +** Each builtin conversion character (ex: the 'd' in "%d") is described +** by an instance of the following structure +*/ +typedef struct et_info { /* Information about each format field */ + char fmttype; /* The format field code letter */ + etByte base; /* The base for radix conversion */ + etByte flags; /* One or more of FLAG_ constants below */ + etByte type; /* Conversion paradigm */ + etByte charset; /* Offset into aDigits[] of the digits string */ + etByte prefix; /* Offset into aPrefix[] of the prefix string */ +} et_info; + +/* +** Allowed values for et_info.flags +*/ +#define FLAG_SIGNED 1 /* True if the value to convert is signed */ +#define FLAG_STRING 4 /* Allow infinite precision */ + + +/* +** The following table is searched linearly, so it is good to put the +** most frequently used conversion types first. +*/ +static const char aDigits[] = "0123456789ABCDEF0123456789abcdef"; +static const char aPrefix[] = "-x0\000X0"; +static const et_info fmtinfo[] = { + { 'd', 10, 1, etDECIMAL, 0, 0 }, + { 's', 0, 4, etSTRING, 0, 0 }, + { 'g', 0, 1, etGENERIC, 30, 0 }, + { 'z', 0, 4, etDYNSTRING, 0, 0 }, + { 'q', 0, 4, etSQLESCAPE, 0, 0 }, + { 'Q', 0, 4, etSQLESCAPE2, 0, 0 }, + { 'w', 0, 4, etSQLESCAPE3, 0, 0 }, + { 'c', 0, 0, etCHARX, 0, 0 }, + { 'o', 8, 0, etRADIX, 0, 2 }, + { 'u', 10, 0, etDECIMAL, 0, 0 }, + { 'x', 16, 0, etRADIX, 16, 1 }, + { 'X', 16, 0, etRADIX, 0, 4 }, +#ifndef SQLITE_OMIT_FLOATING_POINT + { 'f', 0, 1, etFLOAT, 0, 0 }, + { 'e', 0, 1, etEXP, 30, 0 }, + { 'E', 0, 1, etEXP, 14, 0 }, + { 'G', 0, 1, etGENERIC, 14, 0 }, +#endif + { 'i', 10, 1, etDECIMAL, 0, 0 }, + { 'n', 0, 0, etSIZE, 0, 0 }, + { '%', 0, 0, etPERCENT, 0, 0 }, + { 'p', 16, 0, etPOINTER, 0, 1 }, + + /* All the rest are undocumented and are for internal use only */ + { 'T', 0, 0, etTOKEN, 0, 0 }, + { 'S', 0, 0, etSRCLIST, 0, 0 }, + { 'r', 10, 1, etORDINAL, 0, 0 }, +}; + +/* Floating point constants used for rounding */ +static const double arRound[] = { + 5.0e-01, 5.0e-02, 5.0e-03, 5.0e-04, 5.0e-05, + 5.0e-06, 5.0e-07, 5.0e-08, 5.0e-09, 5.0e-10, +}; + +/* +** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point +** conversions will work. +*/ +#ifndef SQLITE_OMIT_FLOATING_POINT +/* +** "*val" is a double such that 0.1 <= *val < 10.0 +** Return the ascii code for the leading digit of *val, then +** multiply "*val" by 10.0 to renormalize. +** +** Example: +** input: *val = 3.14159 +** output: *val = 1.4159 function return = '3' +** +** The counter *cnt is incremented each time. After counter exceeds +** 16 (the number of significant digits in a 64-bit float) '0' is +** always returned. +*/ +static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){ + int digit; + LONGDOUBLE_TYPE d; + if( (*cnt)<=0 ) return '0'; + (*cnt)--; + digit = (int)*val; + d = digit; + digit += '0'; + *val = (*val - d)*10.0; + return (char)digit; +} +#endif /* SQLITE_OMIT_FLOATING_POINT */ + +/* +** Set the StrAccum object to an error mode. +*/ +static void setStrAccumError(StrAccum *p, u8 eError){ + assert( eError==SQLITE_NOMEM || eError==SQLITE_TOOBIG ); + p->accError = eError; + if( p->mxAlloc ) sqlite3_str_reset(p); + if( eError==SQLITE_TOOBIG ) sqlite3ErrorToParser(p->db, eError); +} + +/* +** Extra argument values from a PrintfArguments object +*/ +static sqlite3_int64 getIntArg(PrintfArguments *p){ + if( p->nArg<=p->nUsed ) return 0; + return sqlite3_value_int64(p->apArg[p->nUsed++]); +} +static double getDoubleArg(PrintfArguments *p){ + if( p->nArg<=p->nUsed ) return 0.0; + return sqlite3_value_double(p->apArg[p->nUsed++]); +} +static char *getTextArg(PrintfArguments *p){ + if( p->nArg<=p->nUsed ) return 0; + return (char*)sqlite3_value_text(p->apArg[p->nUsed++]); +} + +/* +** Allocate memory for a temporary buffer needed for printf rendering. +** +** If the requested size of the temp buffer is larger than the size +** of the output buffer in pAccum, then cause an SQLITE_TOOBIG error. +** Do the size check before the memory allocation to prevent rogue +** SQL from requesting large allocations using the precision or width +** field of the printf() function. +*/ +static char *printfTempBuf(sqlite3_str *pAccum, sqlite3_int64 n){ + char *z; + if( pAccum->accError ) return 0; + if( n>pAccum->nAlloc && n>pAccum->mxAlloc ){ + setStrAccumError(pAccum, SQLITE_TOOBIG); + return 0; + } + z = sqlite3DbMallocRaw(pAccum->db, n); + if( z==0 ){ + setStrAccumError(pAccum, SQLITE_NOMEM); + } + return z; +} + +/* +** On machines with a small stack size, you can redefine the +** SQLITE_PRINT_BUF_SIZE to be something smaller, if desired. +*/ +#ifndef SQLITE_PRINT_BUF_SIZE +# define SQLITE_PRINT_BUF_SIZE 70 +#endif +#define etBUFSIZE SQLITE_PRINT_BUF_SIZE /* Size of the output buffer */ + +/* +** Hard limit on the precision of floating-point conversions. +*/ +#ifndef SQLITE_PRINTF_PRECISION_LIMIT +# define SQLITE_FP_PRECISION_LIMIT 100000000 +#endif + +/* +** Render a string given by "fmt" into the StrAccum object. +*/ +SQLITE_API void sqlite3_str_vappendf( + sqlite3_str *pAccum, /* Accumulate results here */ + const char *fmt, /* Format string */ + va_list ap /* arguments */ +){ + int c; /* Next character in the format string */ + char *bufpt; /* Pointer to the conversion buffer */ + int precision; /* Precision of the current field */ + int length; /* Length of the field */ + int idx; /* A general purpose loop counter */ + int width; /* Width of the current field */ + etByte flag_leftjustify; /* True if "-" flag is present */ + etByte flag_prefix; /* '+' or ' ' or 0 for prefix */ + etByte flag_alternateform; /* True if "#" flag is present */ + etByte flag_altform2; /* True if "!" flag is present */ + etByte flag_zeropad; /* True if field width constant starts with zero */ + etByte flag_long; /* 1 for the "l" flag, 2 for "ll", 0 by default */ + etByte done; /* Loop termination flag */ + etByte cThousand; /* Thousands separator for %d and %u */ + etByte xtype = etINVALID; /* Conversion paradigm */ + u8 bArgList; /* True for SQLITE_PRINTF_SQLFUNC */ + char prefix; /* Prefix character. "+" or "-" or " " or '\0'. */ + sqlite_uint64 longvalue; /* Value for integer types */ + LONGDOUBLE_TYPE realvalue; /* Value for real types */ + const et_info *infop; /* Pointer to the appropriate info structure */ + char *zOut; /* Rendering buffer */ + int nOut; /* Size of the rendering buffer */ + char *zExtra = 0; /* Malloced memory used by some conversion */ +#ifndef SQLITE_OMIT_FLOATING_POINT + int exp, e2; /* exponent of real numbers */ + int nsd; /* Number of significant digits returned */ + double rounder; /* Used for rounding floating point values */ + etByte flag_dp; /* True if decimal point should be shown */ + etByte flag_rtz; /* True if trailing zeros should be removed */ +#endif + PrintfArguments *pArgList = 0; /* Arguments for SQLITE_PRINTF_SQLFUNC */ + char buf[etBUFSIZE]; /* Conversion buffer */ + + /* pAccum never starts out with an empty buffer that was obtained from + ** malloc(). This precondition is required by the mprintf("%z...") + ** optimization. */ + assert( pAccum->nChar>0 || (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 ); + + bufpt = 0; + if( (pAccum->printfFlags & SQLITE_PRINTF_SQLFUNC)!=0 ){ + pArgList = va_arg(ap, PrintfArguments*); + bArgList = 1; + }else{ + bArgList = 0; + } + for(; (c=(*fmt))!=0; ++fmt){ + if( c!='%' ){ + bufpt = (char *)fmt; +#if HAVE_STRCHRNUL + fmt = strchrnul(fmt, '%'); +#else + do{ fmt++; }while( *fmt && *fmt != '%' ); +#endif + sqlite3_str_append(pAccum, bufpt, (int)(fmt - bufpt)); + if( *fmt==0 ) break; + } + if( (c=(*++fmt))==0 ){ + sqlite3_str_append(pAccum, "%", 1); + break; + } + /* Find out what flags are present */ + flag_leftjustify = flag_prefix = cThousand = + flag_alternateform = flag_altform2 = flag_zeropad = 0; + done = 0; + width = 0; + flag_long = 0; + precision = -1; + do{ + switch( c ){ + case '-': flag_leftjustify = 1; break; + case '+': flag_prefix = '+'; break; + case ' ': flag_prefix = ' '; break; + case '#': flag_alternateform = 1; break; + case '!': flag_altform2 = 1; break; + case '0': flag_zeropad = 1; break; + case ',': cThousand = ','; break; + default: done = 1; break; + case 'l': { + flag_long = 1; + c = *++fmt; + if( c=='l' ){ + c = *++fmt; + flag_long = 2; + } + done = 1; + break; + } + case '1': case '2': case '3': case '4': case '5': + case '6': case '7': case '8': case '9': { + unsigned wx = c - '0'; + while( (c = *++fmt)>='0' && c<='9' ){ + wx = wx*10 + c - '0'; + } + testcase( wx>0x7fffffff ); + width = wx & 0x7fffffff; +#ifdef SQLITE_PRINTF_PRECISION_LIMIT + if( width>SQLITE_PRINTF_PRECISION_LIMIT ){ + width = SQLITE_PRINTF_PRECISION_LIMIT; + } +#endif + if( c!='.' && c!='l' ){ + done = 1; + }else{ + fmt--; + } + break; + } + case '*': { + if( bArgList ){ + width = (int)getIntArg(pArgList); + }else{ + width = va_arg(ap,int); + } + if( width<0 ){ + flag_leftjustify = 1; + width = width >= -2147483647 ? -width : 0; + } +#ifdef SQLITE_PRINTF_PRECISION_LIMIT + if( width>SQLITE_PRINTF_PRECISION_LIMIT ){ + width = SQLITE_PRINTF_PRECISION_LIMIT; + } +#endif + if( (c = fmt[1])!='.' && c!='l' ){ + c = *++fmt; + done = 1; + } + break; + } + case '.': { + c = *++fmt; + if( c=='*' ){ + if( bArgList ){ + precision = (int)getIntArg(pArgList); + }else{ + precision = va_arg(ap,int); + } + if( precision<0 ){ + precision = precision >= -2147483647 ? -precision : -1; + } + c = *++fmt; + }else{ + unsigned px = 0; + while( c>='0' && c<='9' ){ + px = px*10 + c - '0'; + c = *++fmt; + } + testcase( px>0x7fffffff ); + precision = px & 0x7fffffff; + } +#ifdef SQLITE_PRINTF_PRECISION_LIMIT + if( precision>SQLITE_PRINTF_PRECISION_LIMIT ){ + precision = SQLITE_PRINTF_PRECISION_LIMIT; + } +#endif + if( c=='l' ){ + --fmt; + }else{ + done = 1; + } + break; + } + } + }while( !done && (c=(*++fmt))!=0 ); + + /* Fetch the info entry for the field */ + infop = &fmtinfo[0]; + xtype = etINVALID; + for(idx=0; idxtype; + break; + } + } + + /* + ** At this point, variables are initialized as follows: + ** + ** flag_alternateform TRUE if a '#' is present. + ** flag_altform2 TRUE if a '!' is present. + ** flag_prefix '+' or ' ' or zero + ** flag_leftjustify TRUE if a '-' is present or if the + ** field width was negative. + ** flag_zeropad TRUE if the width began with 0. + ** flag_long 1 for "l", 2 for "ll" + ** width The specified field width. This is + ** always non-negative. Zero is the default. + ** precision The specified precision. The default + ** is -1. + ** xtype The class of the conversion. + ** infop Pointer to the appropriate info struct. + */ + assert( width>=0 ); + assert( precision>=(-1) ); + switch( xtype ){ + case etPOINTER: + flag_long = sizeof(char*)==sizeof(i64) ? 2 : + sizeof(char*)==sizeof(long int) ? 1 : 0; + /* no break */ deliberate_fall_through + case etORDINAL: + case etRADIX: + cThousand = 0; + /* no break */ deliberate_fall_through + case etDECIMAL: + if( infop->flags & FLAG_SIGNED ){ + i64 v; + if( bArgList ){ + v = getIntArg(pArgList); + }else if( flag_long ){ + if( flag_long==2 ){ + v = va_arg(ap,i64) ; + }else{ + v = va_arg(ap,long int); + } + }else{ + v = va_arg(ap,int); + } + if( v<0 ){ + testcase( v==SMALLEST_INT64 ); + testcase( v==(-1) ); + longvalue = ~v; + longvalue++; + prefix = '-'; + }else{ + longvalue = v; + prefix = flag_prefix; + } + }else{ + if( bArgList ){ + longvalue = (u64)getIntArg(pArgList); + }else if( flag_long ){ + if( flag_long==2 ){ + longvalue = va_arg(ap,u64); + }else{ + longvalue = va_arg(ap,unsigned long int); + } + }else{ + longvalue = va_arg(ap,unsigned int); + } + prefix = 0; + } + if( longvalue==0 ) flag_alternateform = 0; + if( flag_zeropad && precision=4 || (longvalue/10)%10==1 ){ + x = 0; + } + *(--bufpt) = zOrd[x*2+1]; + *(--bufpt) = zOrd[x*2]; + } + { + const char *cset = &aDigits[infop->charset]; + u8 base = infop->base; + do{ /* Convert to ascii */ + *(--bufpt) = cset[longvalue%base]; + longvalue = longvalue/base; + }while( longvalue>0 ); + } + length = (int)(&zOut[nOut-1]-bufpt); + while( precision>length ){ + *(--bufpt) = '0'; /* Zero pad */ + length++; + } + if( cThousand ){ + int nn = (length - 1)/3; /* Number of "," to insert */ + int ix = (length - 1)%3 + 1; + bufpt -= nn; + for(idx=0; nn>0; idx++){ + bufpt[idx] = bufpt[idx+nn]; + ix--; + if( ix==0 ){ + bufpt[++idx] = cThousand; + nn--; + ix = 3; + } + } + } + if( prefix ) *(--bufpt) = prefix; /* Add sign */ + if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */ + const char *pre; + char x; + pre = &aPrefix[infop->prefix]; + for(; (x=(*pre))!=0; pre++) *(--bufpt) = x; + } + length = (int)(&zOut[nOut-1]-bufpt); + break; + case etFLOAT: + case etEXP: + case etGENERIC: + if( bArgList ){ + realvalue = getDoubleArg(pArgList); + }else{ + realvalue = va_arg(ap,double); + } +#ifdef SQLITE_OMIT_FLOATING_POINT + length = 0; +#else + if( precision<0 ) precision = 6; /* Set default precision */ +#ifdef SQLITE_FP_PRECISION_LIMIT + if( precision>SQLITE_FP_PRECISION_LIMIT ){ + precision = SQLITE_FP_PRECISION_LIMIT; + } +#endif + if( realvalue<0.0 ){ + realvalue = -realvalue; + prefix = '-'; + }else{ + prefix = flag_prefix; + } + if( xtype==etGENERIC && precision>0 ) precision--; + testcase( precision>0xfff ); + idx = precision & 0xfff; + rounder = arRound[idx%10]; + while( idx>=10 ){ rounder *= 1.0e-10; idx -= 10; } + if( xtype==etFLOAT ){ + double rx = (double)realvalue; + sqlite3_uint64 u; + int ex; + memcpy(&u, &rx, sizeof(u)); + ex = -1023 + (int)((u>>52)&0x7ff); + if( precision+(ex/3) < 15 ) rounder += realvalue*3e-16; + realvalue += rounder; + } + /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */ + exp = 0; + if( sqlite3IsNaN((double)realvalue) ){ + bufpt = "NaN"; + length = 3; + break; + } + if( realvalue>0.0 ){ + LONGDOUBLE_TYPE scale = 1.0; + while( realvalue>=1e100*scale && exp<=350 ){ scale *= 1e100;exp+=100;} + while( realvalue>=1e10*scale && exp<=350 ){ scale *= 1e10; exp+=10; } + while( realvalue>=10.0*scale && exp<=350 ){ scale *= 10.0; exp++; } + realvalue /= scale; + while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; } + while( realvalue<1.0 ){ realvalue *= 10.0; exp--; } + if( exp>350 ){ + bufpt = buf; + buf[0] = prefix; + memcpy(buf+(prefix!=0),"Inf",4); + length = 3+(prefix!=0); + break; + } + } + bufpt = buf; + /* + ** If the field type is etGENERIC, then convert to either etEXP + ** or etFLOAT, as appropriate. + */ + if( xtype!=etFLOAT ){ + realvalue += rounder; + if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; } + } + if( xtype==etGENERIC ){ + flag_rtz = !flag_alternateform; + if( exp<-4 || exp>precision ){ + xtype = etEXP; + }else{ + precision = precision - exp; + xtype = etFLOAT; + } + }else{ + flag_rtz = flag_altform2; + } + if( xtype==etEXP ){ + e2 = 0; + }else{ + e2 = exp; + } + { + i64 szBufNeeded; /* Size of a temporary buffer needed */ + szBufNeeded = MAX(e2,0)+(i64)precision+(i64)width+15; + if( szBufNeeded > etBUFSIZE ){ + bufpt = zExtra = printfTempBuf(pAccum, szBufNeeded); + if( bufpt==0 ) return; + } + } + zOut = bufpt; + nsd = 16 + flag_altform2*10; + flag_dp = (precision>0 ?1:0) | flag_alternateform | flag_altform2; + /* The sign in front of the number */ + if( prefix ){ + *(bufpt++) = prefix; + } + /* Digits prior to the decimal point */ + if( e2<0 ){ + *(bufpt++) = '0'; + }else{ + for(; e2>=0; e2--){ + *(bufpt++) = et_getdigit(&realvalue,&nsd); + } + } + /* The decimal point */ + if( flag_dp ){ + *(bufpt++) = '.'; + } + /* "0" digits after the decimal point but before the first + ** significant digit of the number */ + for(e2++; e2<0; precision--, e2++){ + assert( precision>0 ); + *(bufpt++) = '0'; + } + /* Significant digits after the decimal point */ + while( (precision--)>0 ){ + *(bufpt++) = et_getdigit(&realvalue,&nsd); + } + /* Remove trailing zeros and the "." if no digits follow the "." */ + if( flag_rtz && flag_dp ){ + while( bufpt[-1]=='0' ) *(--bufpt) = 0; + assert( bufpt>zOut ); + if( bufpt[-1]=='.' ){ + if( flag_altform2 ){ + *(bufpt++) = '0'; + }else{ + *(--bufpt) = 0; + } + } + } + /* Add the "eNNN" suffix */ + if( xtype==etEXP ){ + *(bufpt++) = aDigits[infop->charset]; + if( exp<0 ){ + *(bufpt++) = '-'; exp = -exp; + }else{ + *(bufpt++) = '+'; + } + if( exp>=100 ){ + *(bufpt++) = (char)((exp/100)+'0'); /* 100's digit */ + exp %= 100; + } + *(bufpt++) = (char)(exp/10+'0'); /* 10's digit */ + *(bufpt++) = (char)(exp%10+'0'); /* 1's digit */ + } + *bufpt = 0; + + /* The converted number is in buf[] and zero terminated. Output it. + ** Note that the number is in the usual order, not reversed as with + ** integer conversions. */ + length = (int)(bufpt-zOut); + bufpt = zOut; + + /* Special case: Add leading zeros if the flag_zeropad flag is + ** set and we are not left justified */ + if( flag_zeropad && !flag_leftjustify && length < width){ + int i; + int nPad = width - length; + for(i=width; i>=nPad; i--){ + bufpt[i] = bufpt[i-nPad]; + } + i = prefix!=0; + while( nPad-- ) bufpt[i++] = '0'; + length = width; + } +#endif /* !defined(SQLITE_OMIT_FLOATING_POINT) */ + break; + case etSIZE: + if( !bArgList ){ + *(va_arg(ap,int*)) = pAccum->nChar; + } + length = width = 0; + break; + case etPERCENT: + buf[0] = '%'; + bufpt = buf; + length = 1; + break; + case etCHARX: + if( bArgList ){ + bufpt = getTextArg(pArgList); + length = 1; + if( bufpt ){ + buf[0] = c = *(bufpt++); + if( (c&0xc0)==0xc0 ){ + while( length<4 && (bufpt[0]&0xc0)==0x80 ){ + buf[length++] = *(bufpt++); + } + } + }else{ + buf[0] = 0; + } + }else{ + unsigned int ch = va_arg(ap,unsigned int); + if( ch<0x00080 ){ + buf[0] = ch & 0xff; + length = 1; + }else if( ch<0x00800 ){ + buf[0] = 0xc0 + (u8)((ch>>6)&0x1f); + buf[1] = 0x80 + (u8)(ch & 0x3f); + length = 2; + }else if( ch<0x10000 ){ + buf[0] = 0xe0 + (u8)((ch>>12)&0x0f); + buf[1] = 0x80 + (u8)((ch>>6) & 0x3f); + buf[2] = 0x80 + (u8)(ch & 0x3f); + length = 3; + }else{ + buf[0] = 0xf0 + (u8)((ch>>18) & 0x07); + buf[1] = 0x80 + (u8)((ch>>12) & 0x3f); + buf[2] = 0x80 + (u8)((ch>>6) & 0x3f); + buf[3] = 0x80 + (u8)(ch & 0x3f); + length = 4; + } + } + if( precision>1 ){ + width -= precision-1; + if( width>1 && !flag_leftjustify ){ + sqlite3_str_appendchar(pAccum, width-1, ' '); + width = 0; + } + while( precision-- > 1 ){ + sqlite3_str_append(pAccum, buf, length); + } + } + bufpt = buf; + flag_altform2 = 1; + goto adjust_width_for_utf8; + case etSTRING: + case etDYNSTRING: + if( bArgList ){ + bufpt = getTextArg(pArgList); + xtype = etSTRING; + }else{ + bufpt = va_arg(ap,char*); + } + if( bufpt==0 ){ + bufpt = ""; + }else if( xtype==etDYNSTRING ){ + if( pAccum->nChar==0 + && pAccum->mxAlloc + && width==0 + && precision<0 + && pAccum->accError==0 + ){ + /* Special optimization for sqlite3_mprintf("%z..."): + ** Extend an existing memory allocation rather than creating + ** a new one. */ + assert( (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 ); + pAccum->zText = bufpt; + pAccum->nAlloc = sqlite3DbMallocSize(pAccum->db, bufpt); + pAccum->nChar = 0x7fffffff & (int)strlen(bufpt); + pAccum->printfFlags |= SQLITE_PRINTF_MALLOCED; + length = 0; + break; + } + zExtra = bufpt; + } + if( precision>=0 ){ + if( flag_altform2 ){ + /* Set length to the number of bytes needed in order to display + ** precision characters */ + unsigned char *z = (unsigned char*)bufpt; + while( precision-- > 0 && z[0] ){ + SQLITE_SKIP_UTF8(z); + } + length = (int)(z - (unsigned char*)bufpt); + }else{ + for(length=0; length0 ){ + /* Adjust width to account for extra bytes in UTF-8 characters */ + int ii = length - 1; + while( ii>=0 ) if( (bufpt[ii--] & 0xc0)==0x80 ) width++; + } + break; + case etSQLESCAPE: /* %q: Escape ' characters */ + case etSQLESCAPE2: /* %Q: Escape ' and enclose in '...' */ + case etSQLESCAPE3: { /* %w: Escape " characters */ + int i, j, k, n, isnull; + int needQuote; + char ch; + char q = ((xtype==etSQLESCAPE3)?'"':'\''); /* Quote character */ + char *escarg; + + if( bArgList ){ + escarg = getTextArg(pArgList); + }else{ + escarg = va_arg(ap,char*); + } + isnull = escarg==0; + if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)"); + /* For %q, %Q, and %w, the precision is the number of bytes (or + ** characters if the ! flags is present) to use from the input. + ** Because of the extra quoting characters inserted, the number + ** of output characters may be larger than the precision. + */ + k = precision; + for(i=n=0; k!=0 && (ch=escarg[i])!=0; i++, k--){ + if( ch==q ) n++; + if( flag_altform2 && (ch&0xc0)==0xc0 ){ + while( (escarg[i+1]&0xc0)==0x80 ){ i++; } + } + } + needQuote = !isnull && xtype==etSQLESCAPE2; + n += i + 3; + if( n>etBUFSIZE ){ + bufpt = zExtra = printfTempBuf(pAccum, n); + if( bufpt==0 ) return; + }else{ + bufpt = buf; + } + j = 0; + if( needQuote ) bufpt[j++] = q; + k = i; + for(i=0; iprintfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return; + pToken = va_arg(ap, Token*); + assert( bArgList==0 ); + if( pToken && pToken->n ){ + sqlite3_str_append(pAccum, (const char*)pToken->z, pToken->n); + } + length = width = 0; + break; + } + case etSRCLIST: { + SrcList *pSrc; + int k; + struct SrcList_item *pItem; + if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return; + pSrc = va_arg(ap, SrcList*); + k = va_arg(ap, int); + pItem = &pSrc->a[k]; + assert( bArgList==0 ); + assert( k>=0 && knSrc ); + if( pItem->zDatabase ){ + sqlite3_str_appendall(pAccum, pItem->zDatabase); + sqlite3_str_append(pAccum, ".", 1); + } + sqlite3_str_appendall(pAccum, pItem->zName); + length = width = 0; + break; + } + default: { + assert( xtype==etINVALID ); + return; + } + }/* End switch over the format type */ + /* + ** The text of the conversion is pointed to by "bufpt" and is + ** "length" characters long. The field width is "width". Do + ** the output. Both length and width are in bytes, not characters, + ** at this point. If the "!" flag was present on string conversions + ** indicating that width and precision should be expressed in characters, + ** then the values have been translated prior to reaching this point. + */ + width -= length; + if( width>0 ){ + if( !flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' '); + sqlite3_str_append(pAccum, bufpt, length); + if( flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' '); + }else{ + sqlite3_str_append(pAccum, bufpt, length); + } + + if( zExtra ){ + sqlite3DbFree(pAccum->db, zExtra); + zExtra = 0; + } + }/* End for loop over the format string */ +} /* End of function */ + +/* +** Enlarge the memory allocation on a StrAccum object so that it is +** able to accept at least N more bytes of text. +** +** Return the number of bytes of text that StrAccum is able to accept +** after the attempted enlargement. The value returned might be zero. +*/ +static int sqlite3StrAccumEnlarge(StrAccum *p, int N){ + char *zNew; + assert( p->nChar+(i64)N >= p->nAlloc ); /* Only called if really needed */ + if( p->accError ){ + testcase(p->accError==SQLITE_TOOBIG); + testcase(p->accError==SQLITE_NOMEM); + return 0; + } + if( p->mxAlloc==0 ){ + setStrAccumError(p, SQLITE_TOOBIG); + return p->nAlloc - p->nChar - 1; + }else{ + char *zOld = isMalloced(p) ? p->zText : 0; + i64 szNew = p->nChar; + szNew += N + 1; + if( szNew+p->nChar<=p->mxAlloc ){ + /* Force exponential buffer size growth as long as it does not overflow, + ** to avoid having to call this routine too often */ + szNew += p->nChar; + } + if( szNew > p->mxAlloc ){ + sqlite3_str_reset(p); + setStrAccumError(p, SQLITE_TOOBIG); + return 0; + }else{ + p->nAlloc = (int)szNew; + } + if( p->db ){ + zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc); + }else{ + zNew = sqlite3Realloc(zOld, p->nAlloc); + } + if( zNew ){ + assert( p->zText!=0 || p->nChar==0 ); + if( !isMalloced(p) && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar); + p->zText = zNew; + p->nAlloc = sqlite3DbMallocSize(p->db, zNew); + p->printfFlags |= SQLITE_PRINTF_MALLOCED; + }else{ + sqlite3_str_reset(p); + setStrAccumError(p, SQLITE_NOMEM); + return 0; + } + } + return N; +} + +/* +** Append N copies of character c to the given string buffer. +*/ +SQLITE_API void sqlite3_str_appendchar(sqlite3_str *p, int N, char c){ + testcase( p->nChar + (i64)N > 0x7fffffff ); + if( p->nChar+(i64)N >= p->nAlloc && (N = sqlite3StrAccumEnlarge(p, N))<=0 ){ + return; + } + while( (N--)>0 ) p->zText[p->nChar++] = c; +} + +/* +** The StrAccum "p" is not large enough to accept N new bytes of z[]. +** So enlarge if first, then do the append. +** +** This is a helper routine to sqlite3_str_append() that does special-case +** work (enlarging the buffer) using tail recursion, so that the +** sqlite3_str_append() routine can use fast calling semantics. +*/ +static void SQLITE_NOINLINE enlargeAndAppend(StrAccum *p, const char *z, int N){ + N = sqlite3StrAccumEnlarge(p, N); + if( N>0 ){ + memcpy(&p->zText[p->nChar], z, N); + p->nChar += N; + } +} + +/* +** Append N bytes of text from z to the StrAccum object. Increase the +** size of the memory allocation for StrAccum if necessary. +*/ +SQLITE_API void sqlite3_str_append(sqlite3_str *p, const char *z, int N){ + assert( z!=0 || N==0 ); + assert( p->zText!=0 || p->nChar==0 || p->accError ); + assert( N>=0 ); + assert( p->accError==0 || p->nAlloc==0 || p->mxAlloc==0 ); + if( p->nChar+N >= p->nAlloc ){ + enlargeAndAppend(p,z,N); + }else if( N ){ + assert( p->zText ); + p->nChar += N; + memcpy(&p->zText[p->nChar-N], z, N); + } +} + +/* +** Append the complete text of zero-terminated string z[] to the p string. +*/ +SQLITE_API void sqlite3_str_appendall(sqlite3_str *p, const char *z){ + sqlite3_str_append(p, z, sqlite3Strlen30(z)); +} + + +/* +** Finish off a string by making sure it is zero-terminated. +** Return a pointer to the resulting string. Return a NULL +** pointer if any kind of error was encountered. +*/ +static SQLITE_NOINLINE char *strAccumFinishRealloc(StrAccum *p){ + char *zText; + assert( p->mxAlloc>0 && !isMalloced(p) ); + zText = sqlite3DbMallocRaw(p->db, p->nChar+1 ); + if( zText ){ + memcpy(zText, p->zText, p->nChar+1); + p->printfFlags |= SQLITE_PRINTF_MALLOCED; + }else{ + setStrAccumError(p, SQLITE_NOMEM); + } + p->zText = zText; + return zText; +} +SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){ + if( p->zText ){ + p->zText[p->nChar] = 0; + if( p->mxAlloc>0 && !isMalloced(p) ){ + return strAccumFinishRealloc(p); + } + } + return p->zText; +} + +/* +** This singleton is an sqlite3_str object that is returned if +** sqlite3_malloc() fails to provide space for a real one. This +** sqlite3_str object accepts no new text and always returns +** an SQLITE_NOMEM error. +*/ +static sqlite3_str sqlite3OomStr = { + 0, 0, 0, 0, 0, SQLITE_NOMEM, 0 +}; + +/* Finalize a string created using sqlite3_str_new(). +*/ +SQLITE_API char *sqlite3_str_finish(sqlite3_str *p){ + char *z; + if( p!=0 && p!=&sqlite3OomStr ){ + z = sqlite3StrAccumFinish(p); + sqlite3_free(p); + }else{ + z = 0; + } + return z; +} + +/* Return any error code associated with p */ +SQLITE_API int sqlite3_str_errcode(sqlite3_str *p){ + return p ? p->accError : SQLITE_NOMEM; +} + +/* Return the current length of p in bytes */ +SQLITE_API int sqlite3_str_length(sqlite3_str *p){ + return p ? p->nChar : 0; +} + +/* Return the current value for p */ +SQLITE_API char *sqlite3_str_value(sqlite3_str *p){ + if( p==0 || p->nChar==0 ) return 0; + p->zText[p->nChar] = 0; + return p->zText; +} + +/* +** Reset an StrAccum string. Reclaim all malloced memory. +*/ +SQLITE_API void sqlite3_str_reset(StrAccum *p){ + if( isMalloced(p) ){ + sqlite3DbFree(p->db, p->zText); + p->printfFlags &= ~SQLITE_PRINTF_MALLOCED; + } + p->nAlloc = 0; + p->nChar = 0; + p->zText = 0; +} + +/* +** Initialize a string accumulator. +** +** p: The accumulator to be initialized. +** db: Pointer to a database connection. May be NULL. Lookaside +** memory is used if not NULL. db->mallocFailed is set appropriately +** when not NULL. +** zBase: An initial buffer. May be NULL in which case the initial buffer +** is malloced. +** n: Size of zBase in bytes. If total space requirements never exceed +** n then no memory allocations ever occur. +** mx: Maximum number of bytes to accumulate. If mx==0 then no memory +** allocations will ever occur. +*/ +SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum *p, sqlite3 *db, char *zBase, int n, int mx){ + p->zText = zBase; + p->db = db; + p->nAlloc = n; + p->mxAlloc = mx; + p->nChar = 0; + p->accError = 0; + p->printfFlags = 0; +} + +/* Allocate and initialize a new dynamic string object */ +SQLITE_API sqlite3_str *sqlite3_str_new(sqlite3 *db){ + sqlite3_str *p = sqlite3_malloc64(sizeof(*p)); + if( p ){ + sqlite3StrAccumInit(p, 0, 0, 0, + db ? db->aLimit[SQLITE_LIMIT_LENGTH] : SQLITE_MAX_LENGTH); + }else{ + p = &sqlite3OomStr; + } + return p; +} + +/* +** Print into memory obtained from sqliteMalloc(). Use the internal +** %-conversion extensions. +*/ +SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){ + char *z; + char zBase[SQLITE_PRINT_BUF_SIZE]; + StrAccum acc; + assert( db!=0 ); + sqlite3StrAccumInit(&acc, db, zBase, sizeof(zBase), + db->aLimit[SQLITE_LIMIT_LENGTH]); + acc.printfFlags = SQLITE_PRINTF_INTERNAL; + sqlite3_str_vappendf(&acc, zFormat, ap); + z = sqlite3StrAccumFinish(&acc); + if( acc.accError==SQLITE_NOMEM ){ + sqlite3OomFault(db); + } + return z; +} + +/* +** Print into memory obtained from sqliteMalloc(). Use the internal +** %-conversion extensions. +*/ +SQLITE_PRIVATE char *sqlite3MPrintf(sqlite3 *db, const char *zFormat, ...){ + va_list ap; + char *z; + va_start(ap, zFormat); + z = sqlite3VMPrintf(db, zFormat, ap); + va_end(ap); + return z; +} + +/* +** Print into memory obtained from sqlite3_malloc(). Omit the internal +** %-conversion extensions. +*/ +SQLITE_API char *sqlite3_vmprintf(const char *zFormat, va_list ap){ + char *z; + char zBase[SQLITE_PRINT_BUF_SIZE]; + StrAccum acc; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( zFormat==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + sqlite3StrAccumInit(&acc, 0, zBase, sizeof(zBase), SQLITE_MAX_LENGTH); + sqlite3_str_vappendf(&acc, zFormat, ap); + z = sqlite3StrAccumFinish(&acc); + return z; +} + +/* +** Print into memory obtained from sqlite3_malloc()(). Omit the internal +** %-conversion extensions. +*/ +SQLITE_API char *sqlite3_mprintf(const char *zFormat, ...){ + va_list ap; + char *z; +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + va_start(ap, zFormat); + z = sqlite3_vmprintf(zFormat, ap); + va_end(ap); + return z; +} + +/* +** sqlite3_snprintf() works like snprintf() except that it ignores the +** current locale settings. This is important for SQLite because we +** are not able to use a "," as the decimal point in place of "." as +** specified by some locales. +** +** Oops: The first two arguments of sqlite3_snprintf() are backwards +** from the snprintf() standard. Unfortunately, it is too late to change +** this without breaking compatibility, so we just have to live with the +** mistake. +** +** sqlite3_vsnprintf() is the varargs version. +*/ +SQLITE_API char *sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){ + StrAccum acc; + if( n<=0 ) return zBuf; +#ifdef SQLITE_ENABLE_API_ARMOR + if( zBuf==0 || zFormat==0 ) { + (void)SQLITE_MISUSE_BKPT; + if( zBuf ) zBuf[0] = 0; + return zBuf; + } +#endif + sqlite3StrAccumInit(&acc, 0, zBuf, n, 0); + sqlite3_str_vappendf(&acc, zFormat, ap); + zBuf[acc.nChar] = 0; + return zBuf; +} +SQLITE_API char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){ + char *z; + va_list ap; + va_start(ap,zFormat); + z = sqlite3_vsnprintf(n, zBuf, zFormat, ap); + va_end(ap); + return z; +} + +/* +** This is the routine that actually formats the sqlite3_log() message. +** We house it in a separate routine from sqlite3_log() to avoid using +** stack space on small-stack systems when logging is disabled. +** +** sqlite3_log() must render into a static buffer. It cannot dynamically +** allocate memory because it might be called while the memory allocator +** mutex is held. +** +** sqlite3_str_vappendf() might ask for *temporary* memory allocations for +** certain format characters (%q) or for very large precisions or widths. +** Care must be taken that any sqlite3_log() calls that occur while the +** memory mutex is held do not use these mechanisms. +*/ +static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap){ + StrAccum acc; /* String accumulator */ + char zMsg[SQLITE_PRINT_BUF_SIZE*3]; /* Complete log message */ + + sqlite3StrAccumInit(&acc, 0, zMsg, sizeof(zMsg), 0); + sqlite3_str_vappendf(&acc, zFormat, ap); + sqlite3GlobalConfig.xLog(sqlite3GlobalConfig.pLogArg, iErrCode, + sqlite3StrAccumFinish(&acc)); +} + +/* +** Format and write a message to the log if logging is enabled. +*/ +SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...){ + va_list ap; /* Vararg list */ + if( sqlite3GlobalConfig.xLog ){ + va_start(ap, zFormat); + renderLogMsg(iErrCode, zFormat, ap); + va_end(ap); + } +} + +#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) +/* +** A version of printf() that understands %lld. Used for debugging. +** The printf() built into some versions of windows does not understand %lld +** and segfaults if you give it a long long int. +*/ +SQLITE_PRIVATE void sqlite3DebugPrintf(const char *zFormat, ...){ + va_list ap; + StrAccum acc; + char zBuf[SQLITE_PRINT_BUF_SIZE*10]; + sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); + va_start(ap,zFormat); + sqlite3_str_vappendf(&acc, zFormat, ap); + va_end(ap); + sqlite3StrAccumFinish(&acc); +#ifdef SQLITE_OS_TRACE_PROC + { + extern void SQLITE_OS_TRACE_PROC(const char *zBuf, int nBuf); + SQLITE_OS_TRACE_PROC(zBuf, sizeof(zBuf)); + } +#else + fprintf(stdout,"%s", zBuf); + fflush(stdout); +#endif +} +#endif + + +/* +** variable-argument wrapper around sqlite3_str_vappendf(). The bFlags argument +** can contain the bit SQLITE_PRINTF_INTERNAL enable internal formats. +*/ +SQLITE_API void sqlite3_str_appendf(StrAccum *p, const char *zFormat, ...){ + va_list ap; + va_start(ap,zFormat); + sqlite3_str_vappendf(p, zFormat, ap); + va_end(ap); +} + +/************** End of printf.c **********************************************/ +/************** Begin file treeview.c ****************************************/ +/* +** 2015-06-08 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains C code to implement the TreeView debugging routines. +** These routines print a parse tree to standard output for debugging and +** analysis. +** +** The interfaces in this file is only available when compiling +** with SQLITE_DEBUG. +*/ +/* #include "sqliteInt.h" */ +#ifdef SQLITE_DEBUG + +/* +** Add a new subitem to the tree. The moreToFollow flag indicates that this +** is not the last item in the tree. +*/ +static TreeView *sqlite3TreeViewPush(TreeView *p, u8 moreToFollow){ + if( p==0 ){ + p = sqlite3_malloc64( sizeof(*p) ); + if( p==0 ) return 0; + memset(p, 0, sizeof(*p)); + }else{ + p->iLevel++; + } + assert( moreToFollow==0 || moreToFollow==1 ); + if( p->iLevelbLine) ) p->bLine[p->iLevel] = moreToFollow; + return p; +} + +/* +** Finished with one layer of the tree +*/ +static void sqlite3TreeViewPop(TreeView *p){ + if( p==0 ) return; + p->iLevel--; + if( p->iLevel<0 ) sqlite3_free(p); +} + +/* +** Generate a single line of output for the tree, with a prefix that contains +** all the appropriate tree lines +*/ +static void sqlite3TreeViewLine(TreeView *p, const char *zFormat, ...){ + va_list ap; + int i; + StrAccum acc; + char zBuf[500]; + sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); + if( p ){ + for(i=0; iiLevel && ibLine)-1; i++){ + sqlite3_str_append(&acc, p->bLine[i] ? "| " : " ", 4); + } + sqlite3_str_append(&acc, p->bLine[i] ? "|-- " : "'-- ", 4); + } + if( zFormat!=0 ){ + va_start(ap, zFormat); + sqlite3_str_vappendf(&acc, zFormat, ap); + va_end(ap); + assert( acc.nChar>0 || acc.accError ); + sqlite3_str_append(&acc, "\n", 1); + } + sqlite3StrAccumFinish(&acc); + fprintf(stdout,"%s", zBuf); + fflush(stdout); +} + +/* +** Shorthand for starting a new tree item that consists of a single label +*/ +static void sqlite3TreeViewItem(TreeView *p, const char *zLabel,u8 moreFollows){ + p = sqlite3TreeViewPush(p, moreFollows); + sqlite3TreeViewLine(p, "%s", zLabel); +} + +/* +** Generate a human-readable description of a WITH clause. +*/ +SQLITE_PRIVATE void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 moreToFollow){ + int i; + if( pWith==0 ) return; + if( pWith->nCte==0 ) return; + if( pWith->pOuter ){ + sqlite3TreeViewLine(pView, "WITH (0x%p, pOuter=0x%p)",pWith,pWith->pOuter); + }else{ + sqlite3TreeViewLine(pView, "WITH (0x%p)", pWith); + } + if( pWith->nCte>0 ){ + pView = sqlite3TreeViewPush(pView, 1); + for(i=0; inCte; i++){ + StrAccum x; + char zLine[1000]; + const struct Cte *pCte = &pWith->a[i]; + sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0); + sqlite3_str_appendf(&x, "%s", pCte->zName); + if( pCte->pCols && pCte->pCols->nExpr>0 ){ + char cSep = '('; + int j; + for(j=0; jpCols->nExpr; j++){ + sqlite3_str_appendf(&x, "%c%s", cSep, pCte->pCols->a[j].zEName); + cSep = ','; + } + sqlite3_str_appendf(&x, ")"); + } + sqlite3_str_appendf(&x, " AS"); + sqlite3StrAccumFinish(&x); + sqlite3TreeViewItem(pView, zLine, inCte-1); + sqlite3TreeViewSelect(pView, pCte->pSelect, 0); + sqlite3TreeViewPop(pView); + } + sqlite3TreeViewPop(pView); + } +} + +/* +** Generate a human-readable description of a SrcList object. +*/ +SQLITE_PRIVATE void sqlite3TreeViewSrcList(TreeView *pView, const SrcList *pSrc){ + int i; + for(i=0; inSrc; i++){ + const struct SrcList_item *pItem = &pSrc->a[i]; + StrAccum x; + char zLine[100]; + sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0); + sqlite3_str_appendf(&x, "{%d:*}", pItem->iCursor); + if( pItem->zDatabase ){ + sqlite3_str_appendf(&x, " %s.%s", pItem->zDatabase, pItem->zName); + }else if( pItem->zName ){ + sqlite3_str_appendf(&x, " %s", pItem->zName); + } + if( pItem->pTab ){ + sqlite3_str_appendf(&x, " tab=%Q nCol=%d ptr=%p used=%llx", + pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed); + } + if( pItem->zAlias ){ + sqlite3_str_appendf(&x, " (AS %s)", pItem->zAlias); + } + if( pItem->fg.jointype & JT_LEFT ){ + sqlite3_str_appendf(&x, " LEFT-JOIN"); + } + if( pItem->fg.fromDDL ){ + sqlite3_str_appendf(&x, " DDL"); + } + sqlite3StrAccumFinish(&x); + sqlite3TreeViewItem(pView, zLine, inSrc-1); + if( pItem->pSelect ){ + sqlite3TreeViewSelect(pView, pItem->pSelect, 0); + } + if( pItem->fg.isTabFunc ){ + sqlite3TreeViewExprList(pView, pItem->u1.pFuncArg, 0, "func-args:"); + } + sqlite3TreeViewPop(pView); + } +} + +/* +** Generate a human-readable description of a Select object. +*/ +SQLITE_PRIVATE void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 moreToFollow){ + int n = 0; + int cnt = 0; + if( p==0 ){ + sqlite3TreeViewLine(pView, "nil-SELECT"); + return; + } + pView = sqlite3TreeViewPush(pView, moreToFollow); + if( p->pWith ){ + sqlite3TreeViewWith(pView, p->pWith, 1); + cnt = 1; + sqlite3TreeViewPush(pView, 1); + } + do{ + if( p->selFlags & SF_WhereBegin ){ + sqlite3TreeViewLine(pView, "sqlite3WhereBegin()"); + }else{ + sqlite3TreeViewLine(pView, + "SELECT%s%s (%u/%p) selFlags=0x%x nSelectRow=%d", + ((p->selFlags & SF_Distinct) ? " DISTINCT" : ""), + ((p->selFlags & SF_Aggregate) ? " agg_flag" : ""), + p->selId, p, p->selFlags, + (int)p->nSelectRow + ); + } + if( cnt++ ) sqlite3TreeViewPop(pView); + if( p->pPrior ){ + n = 1000; + }else{ + n = 0; + if( p->pSrc && p->pSrc->nSrc ) n++; + if( p->pWhere ) n++; + if( p->pGroupBy ) n++; + if( p->pHaving ) n++; + if( p->pOrderBy ) n++; + if( p->pLimit ) n++; +#ifndef SQLITE_OMIT_WINDOWFUNC + if( p->pWin ) n++; + if( p->pWinDefn ) n++; +#endif + } + if( p->pEList ){ + sqlite3TreeViewExprList(pView, p->pEList, n>0, "result-set"); + } + n--; +#ifndef SQLITE_OMIT_WINDOWFUNC + if( p->pWin ){ + Window *pX; + pView = sqlite3TreeViewPush(pView, (n--)>0); + sqlite3TreeViewLine(pView, "window-functions"); + for(pX=p->pWin; pX; pX=pX->pNextWin){ + sqlite3TreeViewWinFunc(pView, pX, pX->pNextWin!=0); + } + sqlite3TreeViewPop(pView); + } +#endif + if( p->pSrc && p->pSrc->nSrc ){ + pView = sqlite3TreeViewPush(pView, (n--)>0); + sqlite3TreeViewLine(pView, "FROM"); + sqlite3TreeViewSrcList(pView, p->pSrc); + sqlite3TreeViewPop(pView); + } + if( p->pWhere ){ + sqlite3TreeViewItem(pView, "WHERE", (n--)>0); + sqlite3TreeViewExpr(pView, p->pWhere, 0); + sqlite3TreeViewPop(pView); + } + if( p->pGroupBy ){ + sqlite3TreeViewExprList(pView, p->pGroupBy, (n--)>0, "GROUPBY"); + } + if( p->pHaving ){ + sqlite3TreeViewItem(pView, "HAVING", (n--)>0); + sqlite3TreeViewExpr(pView, p->pHaving, 0); + sqlite3TreeViewPop(pView); + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( p->pWinDefn ){ + Window *pX; + sqlite3TreeViewItem(pView, "WINDOW", (n--)>0); + for(pX=p->pWinDefn; pX; pX=pX->pNextWin){ + sqlite3TreeViewWindow(pView, pX, pX->pNextWin!=0); + } + sqlite3TreeViewPop(pView); + } +#endif + if( p->pOrderBy ){ + sqlite3TreeViewExprList(pView, p->pOrderBy, (n--)>0, "ORDERBY"); + } + if( p->pLimit ){ + sqlite3TreeViewItem(pView, "LIMIT", (n--)>0); + sqlite3TreeViewExpr(pView, p->pLimit->pLeft, p->pLimit->pRight!=0); + if( p->pLimit->pRight ){ + sqlite3TreeViewItem(pView, "OFFSET", (n--)>0); + sqlite3TreeViewExpr(pView, p->pLimit->pRight, 0); + sqlite3TreeViewPop(pView); + } + sqlite3TreeViewPop(pView); + } + if( p->pPrior ){ + const char *zOp = "UNION"; + switch( p->op ){ + case TK_ALL: zOp = "UNION ALL"; break; + case TK_INTERSECT: zOp = "INTERSECT"; break; + case TK_EXCEPT: zOp = "EXCEPT"; break; + } + sqlite3TreeViewItem(pView, zOp, 1); + } + p = p->pPrior; + }while( p!=0 ); + sqlite3TreeViewPop(pView); +} + +#ifndef SQLITE_OMIT_WINDOWFUNC +/* +** Generate a description of starting or stopping bounds +*/ +SQLITE_PRIVATE void sqlite3TreeViewBound( + TreeView *pView, /* View context */ + u8 eBound, /* UNBOUNDED, CURRENT, PRECEDING, FOLLOWING */ + Expr *pExpr, /* Value for PRECEDING or FOLLOWING */ + u8 moreToFollow /* True if more to follow */ +){ + switch( eBound ){ + case TK_UNBOUNDED: { + sqlite3TreeViewItem(pView, "UNBOUNDED", moreToFollow); + sqlite3TreeViewPop(pView); + break; + } + case TK_CURRENT: { + sqlite3TreeViewItem(pView, "CURRENT", moreToFollow); + sqlite3TreeViewPop(pView); + break; + } + case TK_PRECEDING: { + sqlite3TreeViewItem(pView, "PRECEDING", moreToFollow); + sqlite3TreeViewExpr(pView, pExpr, 0); + sqlite3TreeViewPop(pView); + break; + } + case TK_FOLLOWING: { + sqlite3TreeViewItem(pView, "FOLLOWING", moreToFollow); + sqlite3TreeViewExpr(pView, pExpr, 0); + sqlite3TreeViewPop(pView); + break; + } + } +} +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +#ifndef SQLITE_OMIT_WINDOWFUNC +/* +** Generate a human-readable explanation for a Window object +*/ +SQLITE_PRIVATE void sqlite3TreeViewWindow(TreeView *pView, const Window *pWin, u8 more){ + int nElement = 0; + if( pWin->pFilter ){ + sqlite3TreeViewItem(pView, "FILTER", 1); + sqlite3TreeViewExpr(pView, pWin->pFilter, 0); + sqlite3TreeViewPop(pView); + } + pView = sqlite3TreeViewPush(pView, more); + if( pWin->zName ){ + sqlite3TreeViewLine(pView, "OVER %s (%p)", pWin->zName, pWin); + }else{ + sqlite3TreeViewLine(pView, "OVER (%p)", pWin); + } + if( pWin->zBase ) nElement++; + if( pWin->pOrderBy ) nElement++; + if( pWin->eFrmType ) nElement++; + if( pWin->eExclude ) nElement++; + if( pWin->zBase ){ + sqlite3TreeViewPush(pView, (--nElement)>0); + sqlite3TreeViewLine(pView, "window: %s", pWin->zBase); + sqlite3TreeViewPop(pView); + } + if( pWin->pPartition ){ + sqlite3TreeViewExprList(pView, pWin->pPartition, nElement>0,"PARTITION-BY"); + } + if( pWin->pOrderBy ){ + sqlite3TreeViewExprList(pView, pWin->pOrderBy, (--nElement)>0, "ORDER-BY"); + } + if( pWin->eFrmType ){ + char zBuf[30]; + const char *zFrmType = "ROWS"; + if( pWin->eFrmType==TK_RANGE ) zFrmType = "RANGE"; + if( pWin->eFrmType==TK_GROUPS ) zFrmType = "GROUPS"; + sqlite3_snprintf(sizeof(zBuf),zBuf,"%s%s",zFrmType, + pWin->bImplicitFrame ? " (implied)" : ""); + sqlite3TreeViewItem(pView, zBuf, (--nElement)>0); + sqlite3TreeViewBound(pView, pWin->eStart, pWin->pStart, 1); + sqlite3TreeViewBound(pView, pWin->eEnd, pWin->pEnd, 0); + sqlite3TreeViewPop(pView); + } + if( pWin->eExclude ){ + char zBuf[30]; + const char *zExclude; + switch( pWin->eExclude ){ + case TK_NO: zExclude = "NO OTHERS"; break; + case TK_CURRENT: zExclude = "CURRENT ROW"; break; + case TK_GROUP: zExclude = "GROUP"; break; + case TK_TIES: zExclude = "TIES"; break; + default: + sqlite3_snprintf(sizeof(zBuf),zBuf,"invalid(%d)", pWin->eExclude); + zExclude = zBuf; + break; + } + sqlite3TreeViewPush(pView, 0); + sqlite3TreeViewLine(pView, "EXCLUDE %s", zExclude); + sqlite3TreeViewPop(pView); + } + sqlite3TreeViewPop(pView); +} +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +#ifndef SQLITE_OMIT_WINDOWFUNC +/* +** Generate a human-readable explanation for a Window Function object +*/ +SQLITE_PRIVATE void sqlite3TreeViewWinFunc(TreeView *pView, const Window *pWin, u8 more){ + pView = sqlite3TreeViewPush(pView, more); + sqlite3TreeViewLine(pView, "WINFUNC %s(%d)", + pWin->pFunc->zName, pWin->pFunc->nArg); + sqlite3TreeViewWindow(pView, pWin, 0); + sqlite3TreeViewPop(pView); +} +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +/* +** Generate a human-readable explanation of an expression tree. +*/ +SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){ + const char *zBinOp = 0; /* Binary operator */ + const char *zUniOp = 0; /* Unary operator */ + char zFlgs[200]; + pView = sqlite3TreeViewPush(pView, moreToFollow); + if( pExpr==0 ){ + sqlite3TreeViewLine(pView, "nil"); + sqlite3TreeViewPop(pView); + return; + } + if( pExpr->flags || pExpr->affExpr || pExpr->vvaFlags ){ + StrAccum x; + sqlite3StrAccumInit(&x, 0, zFlgs, sizeof(zFlgs), 0); + sqlite3_str_appendf(&x, " fg.af=%x.%c", + pExpr->flags, pExpr->affExpr ? pExpr->affExpr : 'n'); + if( ExprHasProperty(pExpr, EP_FromJoin) ){ + sqlite3_str_appendf(&x, " iRJT=%d", pExpr->iRightJoinTable); + } + if( ExprHasProperty(pExpr, EP_FromDDL) ){ + sqlite3_str_appendf(&x, " DDL"); + } + if( ExprHasVVAProperty(pExpr, EP_Immutable) ){ + sqlite3_str_appendf(&x, " IMMUTABLE"); + } + sqlite3StrAccumFinish(&x); + }else{ + zFlgs[0] = 0; + } + switch( pExpr->op ){ + case TK_AGG_COLUMN: { + sqlite3TreeViewLine(pView, "AGG{%d:%d}%s", + pExpr->iTable, pExpr->iColumn, zFlgs); + break; + } + case TK_COLUMN: { + if( pExpr->iTable<0 ){ + /* This only happens when coding check constraints */ + char zOp2[16]; + if( pExpr->op2 ){ + sqlite3_snprintf(sizeof(zOp2),zOp2," op2=0x%02x",pExpr->op2); + }else{ + zOp2[0] = 0; + } + sqlite3TreeViewLine(pView, "COLUMN(%d)%s%s", + pExpr->iColumn, zFlgs, zOp2); + }else{ + sqlite3TreeViewLine(pView, "{%d:%d} pTab=%p%s", + pExpr->iTable, pExpr->iColumn, + pExpr->y.pTab, zFlgs); + } + if( ExprHasProperty(pExpr, EP_FixedCol) ){ + sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); + } + break; + } + case TK_INTEGER: { + if( pExpr->flags & EP_IntValue ){ + sqlite3TreeViewLine(pView, "%d", pExpr->u.iValue); + }else{ + sqlite3TreeViewLine(pView, "%s", pExpr->u.zToken); + } + break; + } +#ifndef SQLITE_OMIT_FLOATING_POINT + case TK_FLOAT: { + sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); + break; + } +#endif + case TK_STRING: { + sqlite3TreeViewLine(pView,"%Q", pExpr->u.zToken); + break; + } + case TK_NULL: { + sqlite3TreeViewLine(pView,"NULL"); + break; + } + case TK_TRUEFALSE: { + sqlite3TreeViewLine(pView, + sqlite3ExprTruthValue(pExpr) ? "TRUE" : "FALSE"); + break; + } +#ifndef SQLITE_OMIT_BLOB_LITERAL + case TK_BLOB: { + sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); + break; + } +#endif + case TK_VARIABLE: { + sqlite3TreeViewLine(pView,"VARIABLE(%s,%d)", + pExpr->u.zToken, pExpr->iColumn); + break; + } + case TK_REGISTER: { + sqlite3TreeViewLine(pView,"REGISTER(%d)", pExpr->iTable); + break; + } + case TK_ID: { + sqlite3TreeViewLine(pView,"ID \"%w\"", pExpr->u.zToken); + break; + } +#ifndef SQLITE_OMIT_CAST + case TK_CAST: { + /* Expressions of the form: CAST(pLeft AS token) */ + sqlite3TreeViewLine(pView,"CAST %Q", pExpr->u.zToken); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); + break; + } +#endif /* SQLITE_OMIT_CAST */ + case TK_LT: zBinOp = "LT"; break; + case TK_LE: zBinOp = "LE"; break; + case TK_GT: zBinOp = "GT"; break; + case TK_GE: zBinOp = "GE"; break; + case TK_NE: zBinOp = "NE"; break; + case TK_EQ: zBinOp = "EQ"; break; + case TK_IS: zBinOp = "IS"; break; + case TK_ISNOT: zBinOp = "ISNOT"; break; + case TK_AND: zBinOp = "AND"; break; + case TK_OR: zBinOp = "OR"; break; + case TK_PLUS: zBinOp = "ADD"; break; + case TK_STAR: zBinOp = "MUL"; break; + case TK_MINUS: zBinOp = "SUB"; break; + case TK_REM: zBinOp = "REM"; break; + case TK_BITAND: zBinOp = "BITAND"; break; + case TK_BITOR: zBinOp = "BITOR"; break; + case TK_SLASH: zBinOp = "DIV"; break; + case TK_LSHIFT: zBinOp = "LSHIFT"; break; + case TK_RSHIFT: zBinOp = "RSHIFT"; break; + case TK_CONCAT: zBinOp = "CONCAT"; break; + case TK_DOT: zBinOp = "DOT"; break; + case TK_LIMIT: zBinOp = "LIMIT"; break; + + case TK_UMINUS: zUniOp = "UMINUS"; break; + case TK_UPLUS: zUniOp = "UPLUS"; break; + case TK_BITNOT: zUniOp = "BITNOT"; break; + case TK_NOT: zUniOp = "NOT"; break; + case TK_ISNULL: zUniOp = "ISNULL"; break; + case TK_NOTNULL: zUniOp = "NOTNULL"; break; + + case TK_TRUTH: { + int x; + const char *azOp[] = { + "IS-FALSE", "IS-TRUE", "IS-NOT-FALSE", "IS-NOT-TRUE" + }; + assert( pExpr->op2==TK_IS || pExpr->op2==TK_ISNOT ); + assert( pExpr->pRight ); + assert( sqlite3ExprSkipCollate(pExpr->pRight)->op==TK_TRUEFALSE ); + x = (pExpr->op2==TK_ISNOT)*2 + sqlite3ExprTruthValue(pExpr->pRight); + zUniOp = azOp[x]; + break; + } + + case TK_SPAN: { + sqlite3TreeViewLine(pView, "SPAN %Q", pExpr->u.zToken); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); + break; + } + + case TK_COLLATE: { + /* COLLATE operators without the EP_Collate flag are intended to + ** emulate collation associated with a table column. These show + ** up in the treeview output as "SOFT-COLLATE". Explicit COLLATE + ** operators that appear in the original SQL always have the + ** EP_Collate bit set and appear in treeview output as just "COLLATE" */ + sqlite3TreeViewLine(pView, "%sCOLLATE %Q%s", + !ExprHasProperty(pExpr, EP_Collate) ? "SOFT-" : "", + pExpr->u.zToken, zFlgs); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); + break; + } + + case TK_AGG_FUNCTION: + case TK_FUNCTION: { + ExprList *pFarg; /* List of function arguments */ + Window *pWin; + if( ExprHasProperty(pExpr, EP_TokenOnly) ){ + pFarg = 0; + pWin = 0; + }else{ + pFarg = pExpr->x.pList; +#ifndef SQLITE_OMIT_WINDOWFUNC + pWin = ExprHasProperty(pExpr, EP_WinFunc) ? pExpr->y.pWin : 0; +#else + pWin = 0; +#endif + } + if( pExpr->op==TK_AGG_FUNCTION ){ + sqlite3TreeViewLine(pView, "AGG_FUNCTION%d %Q%s agg=%d[%d]/%p", + pExpr->op2, pExpr->u.zToken, zFlgs, + pExpr->pAggInfo ? pExpr->pAggInfo->selId : 0, + pExpr->iAgg, pExpr->pAggInfo); + }else if( pExpr->op2!=0 ){ + const char *zOp2; + char zBuf[8]; + sqlite3_snprintf(sizeof(zBuf),zBuf,"0x%02x",pExpr->op2); + zOp2 = zBuf; + if( pExpr->op2==NC_IsCheck ) zOp2 = "NC_IsCheck"; + if( pExpr->op2==NC_IdxExpr ) zOp2 = "NC_IdxExpr"; + if( pExpr->op2==NC_PartIdx ) zOp2 = "NC_PartIdx"; + if( pExpr->op2==NC_GenCol ) zOp2 = "NC_GenCol"; + sqlite3TreeViewLine(pView, "FUNCTION %Q%s op2=%s", + pExpr->u.zToken, zFlgs, zOp2); + }else{ + sqlite3TreeViewLine(pView, "FUNCTION %Q%s", pExpr->u.zToken, zFlgs); + } + if( pFarg ){ + sqlite3TreeViewExprList(pView, pFarg, pWin!=0, 0); + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( pWin ){ + sqlite3TreeViewWindow(pView, pWin, 0); + } +#endif + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_EXISTS: { + sqlite3TreeViewLine(pView, "EXISTS-expr flags=0x%x", pExpr->flags); + sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); + break; + } + case TK_SELECT: { + sqlite3TreeViewLine(pView, "subquery-expr flags=0x%x", pExpr->flags); + sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); + break; + } + case TK_IN: { + sqlite3TreeViewLine(pView, "IN flags=0x%x", pExpr->flags); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); + }else{ + sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); + } + break; + } +#endif /* SQLITE_OMIT_SUBQUERY */ + + /* + ** x BETWEEN y AND z + ** + ** This is equivalent to + ** + ** x>=y AND x<=z + ** + ** X is stored in pExpr->pLeft. + ** Y is stored in pExpr->pList->a[0].pExpr. + ** Z is stored in pExpr->pList->a[1].pExpr. + */ + case TK_BETWEEN: { + Expr *pX = pExpr->pLeft; + Expr *pY = pExpr->x.pList->a[0].pExpr; + Expr *pZ = pExpr->x.pList->a[1].pExpr; + sqlite3TreeViewLine(pView, "BETWEEN"); + sqlite3TreeViewExpr(pView, pX, 1); + sqlite3TreeViewExpr(pView, pY, 1); + sqlite3TreeViewExpr(pView, pZ, 0); + break; + } + case TK_TRIGGER: { + /* If the opcode is TK_TRIGGER, then the expression is a reference + ** to a column in the new.* or old.* pseudo-tables available to + ** trigger programs. In this case Expr.iTable is set to 1 for the + ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn + ** is set to the column of the pseudo-table to read, or to -1 to + ** read the rowid field. + */ + sqlite3TreeViewLine(pView, "%s(%d)", + pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn); + break; + } + case TK_CASE: { + sqlite3TreeViewLine(pView, "CASE"); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); + sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); + break; + } +#ifndef SQLITE_OMIT_TRIGGER + case TK_RAISE: { + const char *zType = "unk"; + switch( pExpr->affExpr ){ + case OE_Rollback: zType = "rollback"; break; + case OE_Abort: zType = "abort"; break; + case OE_Fail: zType = "fail"; break; + case OE_Ignore: zType = "ignore"; break; + } + sqlite3TreeViewLine(pView, "RAISE %s(%Q)", zType, pExpr->u.zToken); + break; + } +#endif + case TK_MATCH: { + sqlite3TreeViewLine(pView, "MATCH {%d:%d}%s", + pExpr->iTable, pExpr->iColumn, zFlgs); + sqlite3TreeViewExpr(pView, pExpr->pRight, 0); + break; + } + case TK_VECTOR: { + char *z = sqlite3_mprintf("VECTOR%s",zFlgs); + sqlite3TreeViewBareExprList(pView, pExpr->x.pList, z); + sqlite3_free(z); + break; + } + case TK_SELECT_COLUMN: { + sqlite3TreeViewLine(pView, "SELECT-COLUMN %d", pExpr->iColumn); + sqlite3TreeViewSelect(pView, pExpr->pLeft->x.pSelect, 0); + break; + } + case TK_IF_NULL_ROW: { + sqlite3TreeViewLine(pView, "IF-NULL-ROW %d", pExpr->iTable); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); + break; + } + default: { + sqlite3TreeViewLine(pView, "op=%d", pExpr->op); + break; + } + } + if( zBinOp ){ + sqlite3TreeViewLine(pView, "%s%s", zBinOp, zFlgs); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); + sqlite3TreeViewExpr(pView, pExpr->pRight, 0); + }else if( zUniOp ){ + sqlite3TreeViewLine(pView, "%s%s", zUniOp, zFlgs); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); + } + sqlite3TreeViewPop(pView); +} + + +/* +** Generate a human-readable explanation of an expression list. +*/ +SQLITE_PRIVATE void sqlite3TreeViewBareExprList( + TreeView *pView, + const ExprList *pList, + const char *zLabel +){ + if( zLabel==0 || zLabel[0]==0 ) zLabel = "LIST"; + if( pList==0 ){ + sqlite3TreeViewLine(pView, "%s (empty)", zLabel); + }else{ + int i; + sqlite3TreeViewLine(pView, "%s", zLabel); + for(i=0; inExpr; i++){ + int j = pList->a[i].u.x.iOrderByCol; + char *zName = pList->a[i].zEName; + int moreToFollow = inExpr - 1; + if( pList->a[i].eEName!=ENAME_NAME ) zName = 0; + if( j || zName ){ + sqlite3TreeViewPush(pView, moreToFollow); + moreToFollow = 0; + sqlite3TreeViewLine(pView, 0); + if( zName ){ + fprintf(stdout, "AS %s ", zName); + } + if( j ){ + fprintf(stdout, "iOrderByCol=%d", j); + } + fprintf(stdout, "\n"); + fflush(stdout); + } + sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow); + if( j || zName ){ + sqlite3TreeViewPop(pView); + } + } + } +} +SQLITE_PRIVATE void sqlite3TreeViewExprList( + TreeView *pView, + const ExprList *pList, + u8 moreToFollow, + const char *zLabel +){ + pView = sqlite3TreeViewPush(pView, moreToFollow); + sqlite3TreeViewBareExprList(pView, pList, zLabel); + sqlite3TreeViewPop(pView); +} + +#endif /* SQLITE_DEBUG */ + +/************** End of treeview.c ********************************************/ +/************** Begin file random.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code to implement a pseudo-random number +** generator (PRNG) for SQLite. +** +** Random numbers are used by some of the database backends in order +** to generate random integer keys for tables or random filenames. +*/ +/* #include "sqliteInt.h" */ + + +/* All threads share a single random number generator. +** This structure is the current state of the generator. +*/ +static SQLITE_WSD struct sqlite3PrngType { + unsigned char isInit; /* True if initialized */ + unsigned char i, j; /* State variables */ + unsigned char s[256]; /* State variables */ +} sqlite3Prng; + +/* +** Return N random bytes. +*/ +SQLITE_API void sqlite3_randomness(int N, void *pBuf){ + unsigned char t; + unsigned char *zBuf = pBuf; + + /* The "wsdPrng" macro will resolve to the pseudo-random number generator + ** state vector. If writable static data is unsupported on the target, + ** we have to locate the state vector at run-time. In the more common + ** case where writable static data is supported, wsdPrng can refer directly + ** to the "sqlite3Prng" state vector declared above. + */ +#ifdef SQLITE_OMIT_WSD + struct sqlite3PrngType *p = &GLOBAL(struct sqlite3PrngType, sqlite3Prng); +# define wsdPrng p[0] +#else +# define wsdPrng sqlite3Prng +#endif + +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex; +#endif + +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return; +#endif + +#if SQLITE_THREADSAFE + mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PRNG); +#endif + + sqlite3_mutex_enter(mutex); + if( N<=0 || pBuf==0 ){ + wsdPrng.isInit = 0; + sqlite3_mutex_leave(mutex); + return; + } + + /* Initialize the state of the random number generator once, + ** the first time this routine is called. The seed value does + ** not need to contain a lot of randomness since we are not + ** trying to do secure encryption or anything like that... + ** + ** Nothing in this file or anywhere else in SQLite does any kind of + ** encryption. The RC4 algorithm is being used as a PRNG (pseudo-random + ** number generator) not as an encryption device. + */ + if( !wsdPrng.isInit ){ + int i; + char k[256]; + wsdPrng.j = 0; + wsdPrng.i = 0; + sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k); + for(i=0; i<256; i++){ + wsdPrng.s[i] = (u8)i; + } + for(i=0; i<256; i++){ + wsdPrng.j += wsdPrng.s[i] + k[i]; + t = wsdPrng.s[wsdPrng.j]; + wsdPrng.s[wsdPrng.j] = wsdPrng.s[i]; + wsdPrng.s[i] = t; + } + wsdPrng.isInit = 1; + } + + assert( N>0 ); + do{ + wsdPrng.i++; + t = wsdPrng.s[wsdPrng.i]; + wsdPrng.j += t; + wsdPrng.s[wsdPrng.i] = wsdPrng.s[wsdPrng.j]; + wsdPrng.s[wsdPrng.j] = t; + t += wsdPrng.s[wsdPrng.i]; + *(zBuf++) = wsdPrng.s[t]; + }while( --N ); + sqlite3_mutex_leave(mutex); +} + +#ifndef SQLITE_UNTESTABLE +/* +** For testing purposes, we sometimes want to preserve the state of +** PRNG and restore the PRNG to its saved state at a later time, or +** to reset the PRNG to its initial state. These routines accomplish +** those tasks. +** +** The sqlite3_test_control() interface calls these routines to +** control the PRNG. +*/ +static SQLITE_WSD struct sqlite3PrngType sqlite3SavedPrng; +SQLITE_PRIVATE void sqlite3PrngSaveState(void){ + memcpy( + &GLOBAL(struct sqlite3PrngType, sqlite3SavedPrng), + &GLOBAL(struct sqlite3PrngType, sqlite3Prng), + sizeof(sqlite3Prng) + ); +} +SQLITE_PRIVATE void sqlite3PrngRestoreState(void){ + memcpy( + &GLOBAL(struct sqlite3PrngType, sqlite3Prng), + &GLOBAL(struct sqlite3PrngType, sqlite3SavedPrng), + sizeof(sqlite3Prng) + ); +} +#endif /* SQLITE_UNTESTABLE */ + +/************** End of random.c **********************************************/ +/************** Begin file threads.c *****************************************/ +/* +** 2012 July 21 +** +** 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 presents a simple cross-platform threading interface for +** use internally by SQLite. +** +** A "thread" can be created using sqlite3ThreadCreate(). This thread +** runs independently of its creator until it is joined using +** sqlite3ThreadJoin(), at which point it terminates. +** +** Threads do not have to be real. It could be that the work of the +** "thread" is done by the main thread at either the sqlite3ThreadCreate() +** or sqlite3ThreadJoin() call. This is, in fact, what happens in +** single threaded systems. Nothing in SQLite requires multiple threads. +** This interface exists so that applications that want to take advantage +** of multiple cores can do so, while also allowing applications to stay +** single-threaded if desired. +*/ +/* #include "sqliteInt.h" */ +#if SQLITE_OS_WIN +/* # include "os_win.h" */ +#endif + +#if SQLITE_MAX_WORKER_THREADS>0 + +/********************************* Unix Pthreads ****************************/ +#if SQLITE_OS_UNIX && defined(SQLITE_MUTEX_PTHREADS) && SQLITE_THREADSAFE>0 + +#define SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */ +/* #include */ + +/* A running thread */ +struct SQLiteThread { + pthread_t tid; /* Thread ID */ + int done; /* Set to true when thread finishes */ + void *pOut; /* Result returned by the thread */ + void *(*xTask)(void*); /* The thread routine */ + void *pIn; /* Argument to the thread */ +}; + +/* Create a new thread */ +SQLITE_PRIVATE int sqlite3ThreadCreate( + SQLiteThread **ppThread, /* OUT: Write the thread object here */ + void *(*xTask)(void*), /* Routine to run in a separate thread */ + void *pIn /* Argument passed into xTask() */ +){ + SQLiteThread *p; + int rc; + + assert( ppThread!=0 ); + assert( xTask!=0 ); + /* This routine is never used in single-threaded mode */ + assert( sqlite3GlobalConfig.bCoreMutex!=0 ); + + *ppThread = 0; + p = sqlite3Malloc(sizeof(*p)); + if( p==0 ) return SQLITE_NOMEM_BKPT; + memset(p, 0, sizeof(*p)); + p->xTask = xTask; + p->pIn = pIn; + /* If the SQLITE_TESTCTRL_FAULT_INSTALL callback is registered to a + ** function that returns SQLITE_ERROR when passed the argument 200, that + ** forces worker threads to run sequentially and deterministically + ** for testing purposes. */ + if( sqlite3FaultSim(200) ){ + rc = 1; + }else{ + rc = pthread_create(&p->tid, 0, xTask, pIn); + } + if( rc ){ + p->done = 1; + p->pOut = xTask(pIn); + } + *ppThread = p; + return SQLITE_OK; +} + +/* Get the results of the thread */ +SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){ + int rc; + + assert( ppOut!=0 ); + if( NEVER(p==0) ) return SQLITE_NOMEM_BKPT; + if( p->done ){ + *ppOut = p->pOut; + rc = SQLITE_OK; + }else{ + rc = pthread_join(p->tid, ppOut) ? SQLITE_ERROR : SQLITE_OK; + } + sqlite3_free(p); + return rc; +} + +#endif /* SQLITE_OS_UNIX && defined(SQLITE_MUTEX_PTHREADS) */ +/******************************** End Unix Pthreads *************************/ + + +/********************************* Win32 Threads ****************************/ +#if SQLITE_OS_WIN_THREADS + +#define SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */ +#include + +/* A running thread */ +struct SQLiteThread { + void *tid; /* The thread handle */ + unsigned id; /* The thread identifier */ + void *(*xTask)(void*); /* The routine to run as a thread */ + void *pIn; /* Argument to xTask */ + void *pResult; /* Result of xTask */ +}; + +/* Thread procedure Win32 compatibility shim */ +static unsigned __stdcall sqlite3ThreadProc( + void *pArg /* IN: Pointer to the SQLiteThread structure */ +){ + SQLiteThread *p = (SQLiteThread *)pArg; + + assert( p!=0 ); +#if 0 + /* + ** This assert appears to trigger spuriously on certain + ** versions of Windows, possibly due to _beginthreadex() + ** and/or CreateThread() not fully setting their thread + ** ID parameter before starting the thread. + */ + assert( p->id==GetCurrentThreadId() ); +#endif + assert( p->xTask!=0 ); + p->pResult = p->xTask(p->pIn); + + _endthreadex(0); + return 0; /* NOT REACHED */ +} + +/* Create a new thread */ +SQLITE_PRIVATE int sqlite3ThreadCreate( + SQLiteThread **ppThread, /* OUT: Write the thread object here */ + void *(*xTask)(void*), /* Routine to run in a separate thread */ + void *pIn /* Argument passed into xTask() */ +){ + SQLiteThread *p; + + assert( ppThread!=0 ); + assert( xTask!=0 ); + *ppThread = 0; + p = sqlite3Malloc(sizeof(*p)); + if( p==0 ) return SQLITE_NOMEM_BKPT; + /* If the SQLITE_TESTCTRL_FAULT_INSTALL callback is registered to a + ** function that returns SQLITE_ERROR when passed the argument 200, that + ** forces worker threads to run sequentially and deterministically + ** (via the sqlite3FaultSim() term of the conditional) for testing + ** purposes. */ + if( sqlite3GlobalConfig.bCoreMutex==0 || sqlite3FaultSim(200) ){ + memset(p, 0, sizeof(*p)); + }else{ + p->xTask = xTask; + p->pIn = pIn; + p->tid = (void*)_beginthreadex(0, 0, sqlite3ThreadProc, p, 0, &p->id); + if( p->tid==0 ){ + memset(p, 0, sizeof(*p)); + } + } + if( p->xTask==0 ){ + p->id = GetCurrentThreadId(); + p->pResult = xTask(pIn); + } + *ppThread = p; + return SQLITE_OK; +} + +SQLITE_PRIVATE DWORD sqlite3Win32Wait(HANDLE hObject); /* os_win.c */ + +/* Get the results of the thread */ +SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){ + DWORD rc; + BOOL bRc; + + assert( ppOut!=0 ); + if( NEVER(p==0) ) return SQLITE_NOMEM_BKPT; + if( p->xTask==0 ){ + /* assert( p->id==GetCurrentThreadId() ); */ + rc = WAIT_OBJECT_0; + assert( p->tid==0 ); + }else{ + assert( p->id!=0 && p->id!=GetCurrentThreadId() ); + rc = sqlite3Win32Wait((HANDLE)p->tid); + assert( rc!=WAIT_IO_COMPLETION ); + bRc = CloseHandle((HANDLE)p->tid); + assert( bRc ); + } + if( rc==WAIT_OBJECT_0 ) *ppOut = p->pResult; + sqlite3_free(p); + return (rc==WAIT_OBJECT_0) ? SQLITE_OK : SQLITE_ERROR; +} + +#endif /* SQLITE_OS_WIN_THREADS */ +/******************************** End Win32 Threads *************************/ + + +/********************************* Single-Threaded **************************/ +#ifndef SQLITE_THREADS_IMPLEMENTED +/* +** This implementation does not actually create a new thread. It does the +** work of the thread in the main thread, when either the thread is created +** or when it is joined +*/ + +/* A running thread */ +struct SQLiteThread { + void *(*xTask)(void*); /* The routine to run as a thread */ + void *pIn; /* Argument to xTask */ + void *pResult; /* Result of xTask */ +}; + +/* Create a new thread */ +SQLITE_PRIVATE int sqlite3ThreadCreate( + SQLiteThread **ppThread, /* OUT: Write the thread object here */ + void *(*xTask)(void*), /* Routine to run in a separate thread */ + void *pIn /* Argument passed into xTask() */ +){ + SQLiteThread *p; + + assert( ppThread!=0 ); + assert( xTask!=0 ); + *ppThread = 0; + p = sqlite3Malloc(sizeof(*p)); + if( p==0 ) return SQLITE_NOMEM_BKPT; + if( (SQLITE_PTR_TO_INT(p)/17)&1 ){ + p->xTask = xTask; + p->pIn = pIn; + }else{ + p->xTask = 0; + p->pResult = xTask(pIn); + } + *ppThread = p; + return SQLITE_OK; +} + +/* Get the results of the thread */ +SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){ + + assert( ppOut!=0 ); + if( NEVER(p==0) ) return SQLITE_NOMEM_BKPT; + if( p->xTask ){ + *ppOut = p->xTask(p->pIn); + }else{ + *ppOut = p->pResult; + } + sqlite3_free(p); + +#if defined(SQLITE_TEST) + { + void *pTstAlloc = sqlite3Malloc(10); + if (!pTstAlloc) return SQLITE_NOMEM_BKPT; + sqlite3_free(pTstAlloc); + } +#endif + + return SQLITE_OK; +} + +#endif /* !defined(SQLITE_THREADS_IMPLEMENTED) */ +/****************************** End Single-Threaded *************************/ +#endif /* SQLITE_MAX_WORKER_THREADS>0 */ + +/************** End of threads.c *********************************************/ +/************** Begin file utf.c *********************************************/ +/* +** 2004 April 13 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains routines used to translate between UTF-8, +** UTF-16, UTF-16BE, and UTF-16LE. +** +** Notes on UTF-8: +** +** Byte-0 Byte-1 Byte-2 Byte-3 Value +** 0xxxxxxx 00000000 00000000 0xxxxxxx +** 110yyyyy 10xxxxxx 00000000 00000yyy yyxxxxxx +** 1110zzzz 10yyyyyy 10xxxxxx 00000000 zzzzyyyy yyxxxxxx +** 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx 000uuuuu zzzzyyyy yyxxxxxx +** +** +** Notes on UTF-16: (with wwww+1==uuuuu) +** +** Word-0 Word-1 Value +** 110110ww wwzzzzyy 110111yy yyxxxxxx 000uuuuu zzzzyyyy yyxxxxxx +** zzzzyyyy yyxxxxxx 00000000 zzzzyyyy yyxxxxxx +** +** +** BOM or Byte Order Mark: +** 0xff 0xfe little-endian utf-16 follows +** 0xfe 0xff big-endian utf-16 follows +** +*/ +/* #include "sqliteInt.h" */ +/* #include */ +/* #include "vdbeInt.h" */ + +#if !defined(SQLITE_AMALGAMATION) && SQLITE_BYTEORDER==0 +/* +** The following constant value is used by the SQLITE_BIGENDIAN and +** SQLITE_LITTLEENDIAN macros. +*/ +SQLITE_PRIVATE const int sqlite3one = 1; +#endif /* SQLITE_AMALGAMATION && SQLITE_BYTEORDER==0 */ + +/* +** This lookup table is used to help decode the first byte of +** a multi-byte UTF8 character. +*/ +static const unsigned char sqlite3Utf8Trans1[] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00, +}; + + +#define WRITE_UTF8(zOut, c) { \ + if( c<0x00080 ){ \ + *zOut++ = (u8)(c&0xFF); \ + } \ + else if( c<0x00800 ){ \ + *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + } \ + else if( c<0x10000 ){ \ + *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); \ + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + }else{ \ + *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); \ + *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); \ + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + } \ +} + +#define WRITE_UTF16LE(zOut, c) { \ + if( c<=0xFFFF ){ \ + *zOut++ = (u8)(c&0x00FF); \ + *zOut++ = (u8)((c>>8)&0x00FF); \ + }else{ \ + *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \ + *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \ + *zOut++ = (u8)(c&0x00FF); \ + *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \ + } \ +} + +#define WRITE_UTF16BE(zOut, c) { \ + if( c<=0xFFFF ){ \ + *zOut++ = (u8)((c>>8)&0x00FF); \ + *zOut++ = (u8)(c&0x00FF); \ + }else{ \ + *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \ + *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \ + *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \ + *zOut++ = (u8)(c&0x00FF); \ + } \ +} + +/* +** Translate a single UTF-8 character. Return the unicode value. +** +** During translation, assume that the byte that zTerm points +** is a 0x00. +** +** Write a pointer to the next unread byte back into *pzNext. +** +** Notes On Invalid UTF-8: +** +** * This routine never allows a 7-bit character (0x00 through 0x7f) to +** be encoded as a multi-byte character. Any multi-byte character that +** attempts to encode a value between 0x00 and 0x7f is rendered as 0xfffd. +** +** * This routine never allows a UTF16 surrogate value to be encoded. +** If a multi-byte character attempts to encode a value between +** 0xd800 and 0xe000 then it is rendered as 0xfffd. +** +** * Bytes in the range of 0x80 through 0xbf which occur as the first +** byte of a character are interpreted as single-byte characters +** and rendered as themselves even though they are technically +** invalid characters. +** +** * This routine accepts over-length UTF8 encodings +** for unicode values 0x80 and greater. It does not change over-length +** encodings to 0xfffd as some systems recommend. +*/ +#define READ_UTF8(zIn, zTerm, c) \ + c = *(zIn++); \ + if( c>=0xc0 ){ \ + c = sqlite3Utf8Trans1[c-0xc0]; \ + while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){ \ + c = (c<<6) + (0x3f & *(zIn++)); \ + } \ + if( c<0x80 \ + || (c&0xFFFFF800)==0xD800 \ + || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \ + } +SQLITE_PRIVATE u32 sqlite3Utf8Read( + const unsigned char **pz /* Pointer to string from which to read char */ +){ + unsigned int c; + + /* Same as READ_UTF8() above but without the zTerm parameter. + ** For this routine, we assume the UTF8 string is always zero-terminated. + */ + c = *((*pz)++); + if( c>=0xc0 ){ + c = sqlite3Utf8Trans1[c-0xc0]; + while( (*(*pz) & 0xc0)==0x80 ){ + c = (c<<6) + (0x3f & *((*pz)++)); + } + if( c<0x80 + || (c&0xFFFFF800)==0xD800 + || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } + } + return c; +} + + + + +/* +** If the TRANSLATE_TRACE macro is defined, the value of each Mem is +** printed on stderr on the way into and out of sqlite3VdbeMemTranslate(). +*/ +/* #define TRANSLATE_TRACE 1 */ + +#ifndef SQLITE_OMIT_UTF16 +/* +** This routine transforms the internal text encoding used by pMem to +** desiredEnc. It is an error if the string is already of the desired +** encoding, or if *pMem does not contain a string value. +*/ +SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){ + sqlite3_int64 len; /* Maximum length of output string in bytes */ + unsigned char *zOut; /* Output buffer */ + unsigned char *zIn; /* Input iterator */ + unsigned char *zTerm; /* End of input */ + unsigned char *z; /* Output iterator */ + unsigned int c; + + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( pMem->flags&MEM_Str ); + assert( pMem->enc!=desiredEnc ); + assert( pMem->enc!=0 ); + assert( pMem->n>=0 ); + +#if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG) + { + StrAccum acc; + char zBuf[1000]; + sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); + sqlite3VdbeMemPrettyPrint(pMem, &acc); + fprintf(stderr, "INPUT: %s\n", sqlite3StrAccumFinish(&acc)); + } +#endif + + /* If the translation is between UTF-16 little and big endian, then + ** all that is required is to swap the byte order. This case is handled + ** differently from the others. + */ + if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){ + u8 temp; + int rc; + rc = sqlite3VdbeMemMakeWriteable(pMem); + if( rc!=SQLITE_OK ){ + assert( rc==SQLITE_NOMEM ); + return SQLITE_NOMEM_BKPT; + } + zIn = (u8*)pMem->z; + zTerm = &zIn[pMem->n&~1]; + while( zInenc = desiredEnc; + goto translate_out; + } + + /* Set len to the maximum number of bytes required in the output buffer. */ + if( desiredEnc==SQLITE_UTF8 ){ + /* When converting from UTF-16, the maximum growth results from + ** translating a 2-byte character to a 4-byte UTF-8 character. + ** A single byte is required for the output string + ** nul-terminator. + */ + pMem->n &= ~1; + len = 2 * (sqlite3_int64)pMem->n + 1; + }else{ + /* When converting from UTF-8 to UTF-16 the maximum growth is caused + ** when a 1-byte UTF-8 character is translated into a 2-byte UTF-16 + ** character. Two bytes are required in the output buffer for the + ** nul-terminator. + */ + len = 2 * (sqlite3_int64)pMem->n + 2; + } + + /* Set zIn to point at the start of the input buffer and zTerm to point 1 + ** byte past the end. + ** + ** Variable zOut is set to point at the output buffer, space obtained + ** from sqlite3_malloc(). + */ + zIn = (u8*)pMem->z; + zTerm = &zIn[pMem->n]; + zOut = sqlite3DbMallocRaw(pMem->db, len); + if( !zOut ){ + return SQLITE_NOMEM_BKPT; + } + z = zOut; + + if( pMem->enc==SQLITE_UTF8 ){ + if( desiredEnc==SQLITE_UTF16LE ){ + /* UTF-8 -> UTF-16 Little-endian */ + while( zIn UTF-16 Big-endian */ + while( zInn = (int)(z - zOut); + *z++ = 0; + }else{ + assert( desiredEnc==SQLITE_UTF8 ); + if( pMem->enc==SQLITE_UTF16LE ){ + /* UTF-16 Little-endian -> UTF-8 */ + while( zIn=0xd800 && c<0xe000 ){ +#ifdef SQLITE_REPLACE_INVALID_UTF + if( c>=0xdc00 || zIn>=zTerm ){ + c = 0xfffd; + }else{ + int c2 = *(zIn++); + c2 += (*(zIn++))<<8; + if( c2<0xdc00 || c2>=0xe000 ){ + zIn -= 2; + c = 0xfffd; + }else{ + c = ((c&0x3ff)<<10) + (c2&0x3ff) + 0x10000; + } + } +#else + if( zIn UTF-8 */ + while( zIn=0xd800 && c<0xe000 ){ +#ifdef SQLITE_REPLACE_INVALID_UTF + if( c>=0xdc00 || zIn>=zTerm ){ + c = 0xfffd; + }else{ + int c2 = (*(zIn++))<<8; + c2 += *(zIn++); + if( c2<0xdc00 || c2>=0xe000 ){ + zIn -= 2; + c = 0xfffd; + }else{ + c = ((c&0x3ff)<<10) + (c2&0x3ff) + 0x10000; + } + } +#else + if( zInn = (int)(z - zOut); + } + *z = 0; + assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len ); + + c = MEM_Str|MEM_Term|(pMem->flags&(MEM_AffMask|MEM_Subtype)); + sqlite3VdbeMemRelease(pMem); + pMem->flags = c; + pMem->enc = desiredEnc; + pMem->z = (char*)zOut; + pMem->zMalloc = pMem->z; + pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->z); + +translate_out: +#if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG) + { + StrAccum acc; + char zBuf[1000]; + sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); + sqlite3VdbeMemPrettyPrint(pMem, &acc); + fprintf(stderr, "OUTPUT: %s\n", sqlite3StrAccumFinish(&acc)); + } +#endif + return SQLITE_OK; +} +#endif /* SQLITE_OMIT_UTF16 */ + +#ifndef SQLITE_OMIT_UTF16 +/* +** This routine checks for a byte-order mark at the beginning of the +** UTF-16 string stored in *pMem. If one is present, it is removed and +** the encoding of the Mem adjusted. This routine does not do any +** byte-swapping, it just sets Mem.enc appropriately. +** +** The allocation (static, dynamic etc.) and encoding of the Mem may be +** changed by this function. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem){ + int rc = SQLITE_OK; + u8 bom = 0; + + assert( pMem->n>=0 ); + if( pMem->n>1 ){ + u8 b1 = *(u8 *)pMem->z; + u8 b2 = *(((u8 *)pMem->z) + 1); + if( b1==0xFE && b2==0xFF ){ + bom = SQLITE_UTF16BE; + } + if( b1==0xFF && b2==0xFE ){ + bom = SQLITE_UTF16LE; + } + } + + if( bom ){ + rc = sqlite3VdbeMemMakeWriteable(pMem); + if( rc==SQLITE_OK ){ + pMem->n -= 2; + memmove(pMem->z, &pMem->z[2], pMem->n); + pMem->z[pMem->n] = '\0'; + pMem->z[pMem->n+1] = '\0'; + pMem->flags |= MEM_Term; + pMem->enc = bom; + } + } + return rc; +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** pZ is a UTF-8 encoded unicode string. If nByte is less than zero, +** return the number of unicode characters in pZ up to (but not including) +** the first 0x00 byte. If nByte is not less than zero, return the +** number of unicode characters in the first nByte of pZ (or up to +** the first 0x00, whichever comes first). +*/ +SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *zIn, int nByte){ + int r = 0; + const u8 *z = (const u8*)zIn; + const u8 *zTerm; + if( nByte>=0 ){ + zTerm = &z[nByte]; + }else{ + zTerm = (const u8*)(-1); + } + assert( z<=zTerm ); + while( *z!=0 && zmallocFailed ){ + sqlite3VdbeMemRelease(&m); + m.z = 0; + } + assert( (m.flags & MEM_Term)!=0 || db->mallocFailed ); + assert( (m.flags & MEM_Str)!=0 || db->mallocFailed ); + assert( m.z || db->mallocFailed ); + return m.z; +} + +/* +** zIn is a UTF-16 encoded unicode string at least nChar characters long. +** Return the number of bytes in the first nChar unicode characters +** in pZ. nChar must be non-negative. +*/ +SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *zIn, int nChar){ + int c; + unsigned char const *z = zIn; + int n = 0; + + if( SQLITE_UTF16NATIVE==SQLITE_UTF16LE ) z++; + while( n=0xd8 && c<0xdc && z[0]>=0xdc && z[0]<0xe0 ) z += 2; + n++; + } + return (int)(z-(unsigned char const *)zIn) + - (SQLITE_UTF16NATIVE==SQLITE_UTF16LE); +} + +#if defined(SQLITE_TEST) +/* +** This routine is called from the TCL test function "translate_selftest". +** It checks that the primitives for serializing and deserializing +** characters in each encoding are inverses of each other. +*/ +SQLITE_PRIVATE void sqlite3UtfSelfTest(void){ + unsigned int i, t; + unsigned char zBuf[20]; + unsigned char *z; + int n; + unsigned int c; + + for(i=0; i<0x00110000; i++){ + z = zBuf; + WRITE_UTF8(z, i); + n = (int)(z-zBuf); + assert( n>0 && n<=4 ); + z[0] = 0; + z = zBuf; + c = sqlite3Utf8Read((const u8**)&z); + t = i; + if( i>=0xD800 && i<=0xDFFF ) t = 0xFFFD; + if( (i&0xFFFFFFFE)==0xFFFE ) t = 0xFFFD; + assert( c==t ); + assert( (z-zBuf)==n ); + } +} +#endif /* SQLITE_TEST */ +#endif /* SQLITE_OMIT_UTF16 */ + +/************** End of utf.c *************************************************/ +/************** Begin file util.c ********************************************/ +/* +** 2001 September 15 +** +** 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. +** +************************************************************************* +** Utility functions used throughout sqlite. +** +** This file contains functions for allocating memory, comparing +** strings, and stuff like that. +** +*/ +/* #include "sqliteInt.h" */ +/* #include */ +#ifndef SQLITE_OMIT_FLOATING_POINT +#include +#endif + +/* +** Routine needed to support the testcase() macro. +*/ +#ifdef SQLITE_COVERAGE_TEST +SQLITE_PRIVATE void sqlite3Coverage(int x){ + static unsigned dummy = 0; + dummy += (unsigned)x; +} +#endif + +/* +** Calls to sqlite3FaultSim() are used to simulate a failure during testing, +** or to bypass normal error detection during testing in order to let +** execute proceed futher downstream. +** +** In deployment, sqlite3FaultSim() *always* return SQLITE_OK (0). The +** sqlite3FaultSim() function only returns non-zero during testing. +** +** During testing, if the test harness has set a fault-sim callback using +** a call to sqlite3_test_control(SQLITE_TESTCTRL_FAULT_INSTALL), then +** each call to sqlite3FaultSim() is relayed to that application-supplied +** callback and the integer return value form the application-supplied +** callback is returned by sqlite3FaultSim(). +** +** The integer argument to sqlite3FaultSim() is a code to identify which +** sqlite3FaultSim() instance is being invoked. Each call to sqlite3FaultSim() +** should have a unique code. To prevent legacy testing applications from +** breaking, the codes should not be changed or reused. +*/ +#ifndef SQLITE_UNTESTABLE +SQLITE_PRIVATE int sqlite3FaultSim(int iTest){ + int (*xCallback)(int) = sqlite3GlobalConfig.xTestCallback; + return xCallback ? xCallback(iTest) : SQLITE_OK; +} +#endif + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* +** Return true if the floating point value is Not a Number (NaN). +*/ +SQLITE_PRIVATE int sqlite3IsNaN(double x){ + u64 y; + memcpy(&y,&x,sizeof(y)); + return IsNaN(y); +} +#endif /* SQLITE_OMIT_FLOATING_POINT */ + +/* +** Compute a string length that is limited to what can be stored in +** lower 30 bits of a 32-bit signed integer. +** +** The value returned will never be negative. Nor will it ever be greater +** than the actual length of the string. For very long strings (greater +** than 1GiB) the value returned might be less than the true string length. +*/ +SQLITE_PRIVATE int sqlite3Strlen30(const char *z){ + if( z==0 ) return 0; + return 0x3fffffff & (int)strlen(z); +} + +/* +** Return the declared type of a column. Or return zDflt if the column +** has no declared type. +** +** The column type is an extra string stored after the zero-terminator on +** the column name if and only if the COLFLAG_HASTYPE flag is set. +*/ +SQLITE_PRIVATE char *sqlite3ColumnType(Column *pCol, char *zDflt){ + if( (pCol->colFlags & COLFLAG_HASTYPE)==0 ) return zDflt; + return pCol->zName + strlen(pCol->zName) + 1; +} + +/* +** Helper function for sqlite3Error() - called rarely. Broken out into +** a separate routine to avoid unnecessary register saves on entry to +** sqlite3Error(). +*/ +static SQLITE_NOINLINE void sqlite3ErrorFinish(sqlite3 *db, int err_code){ + if( db->pErr ) sqlite3ValueSetNull(db->pErr); + sqlite3SystemError(db, err_code); +} + +/* +** Set the current error code to err_code and clear any prior error message. +** Also set iSysErrno (by calling sqlite3System) if the err_code indicates +** that would be appropriate. +*/ +SQLITE_PRIVATE void sqlite3Error(sqlite3 *db, int err_code){ + assert( db!=0 ); + db->errCode = err_code; + if( err_code || db->pErr ) sqlite3ErrorFinish(db, err_code); +} + +/* +** Load the sqlite3.iSysErrno field if that is an appropriate thing +** to do based on the SQLite error code in rc. +*/ +SQLITE_PRIVATE void sqlite3SystemError(sqlite3 *db, int rc){ + if( rc==SQLITE_IOERR_NOMEM ) return; + rc &= 0xff; + if( rc==SQLITE_CANTOPEN || rc==SQLITE_IOERR ){ + db->iSysErrno = sqlite3OsGetLastError(db->pVfs); + } +} + +/* +** Set the most recent error code and error string for the sqlite +** handle "db". The error code is set to "err_code". +** +** If it is not NULL, string zFormat specifies the format of the +** error string in the style of the printf functions: The following +** format characters are allowed: +** +** %s Insert a string +** %z A string that should be freed after use +** %d Insert an integer +** %T Insert a token +** %S Insert the first element of a SrcList +** +** zFormat and any string tokens that follow it are assumed to be +** encoded in UTF-8. +** +** To clear the most recent error for sqlite handle "db", sqlite3Error +** should be called with err_code set to SQLITE_OK and zFormat set +** to NULL. +*/ +SQLITE_PRIVATE void sqlite3ErrorWithMsg(sqlite3 *db, int err_code, const char *zFormat, ...){ + assert( db!=0 ); + db->errCode = err_code; + sqlite3SystemError(db, err_code); + if( zFormat==0 ){ + sqlite3Error(db, err_code); + }else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){ + char *z; + va_list ap; + va_start(ap, zFormat); + z = sqlite3VMPrintf(db, zFormat, ap); + va_end(ap); + sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC); + } +} + +/* +** Add an error message to pParse->zErrMsg and increment pParse->nErr. +** The following formatting characters are allowed: +** +** %s Insert a string +** %z A string that should be freed after use +** %d Insert an integer +** %T Insert a token +** %S Insert the first element of a SrcList +** +** This function should be used to report any error that occurs while +** compiling an SQL statement (i.e. within sqlite3_prepare()). The +** last thing the sqlite3_prepare() function does is copy the error +** stored by this function into the database handle using sqlite3Error(). +** Functions sqlite3Error() or sqlite3ErrorWithMsg() should be used +** during statement execution (sqlite3_step() etc.). +*/ +SQLITE_PRIVATE void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){ + char *zMsg; + va_list ap; + sqlite3 *db = pParse->db; + va_start(ap, zFormat); + zMsg = sqlite3VMPrintf(db, zFormat, ap); + va_end(ap); + if( db->suppressErr ){ + sqlite3DbFree(db, zMsg); + }else{ + pParse->nErr++; + sqlite3DbFree(db, pParse->zErrMsg); + pParse->zErrMsg = zMsg; + pParse->rc = SQLITE_ERROR; + pParse->pWith = 0; + } +} + +/* +** If database connection db is currently parsing SQL, then transfer +** error code errCode to that parser if the parser has not already +** encountered some other kind of error. +*/ +SQLITE_PRIVATE int sqlite3ErrorToParser(sqlite3 *db, int errCode){ + Parse *pParse; + if( db==0 || (pParse = db->pParse)==0 ) return errCode; + pParse->rc = errCode; + pParse->nErr++; + return errCode; +} + +/* +** Convert an SQL-style quoted string into a normal string by removing +** the quote characters. The conversion is done in-place. If the +** input does not begin with a quote character, then this routine +** is a no-op. +** +** The input string must be zero-terminated. A new zero-terminator +** is added to the dequoted string. +** +** The return value is -1 if no dequoting occurs or the length of the +** dequoted string, exclusive of the zero terminator, if dequoting does +** occur. +** +** 2002-02-14: This routine is extended to remove MS-Access style +** brackets from around identifiers. For example: "[a-b-c]" becomes +** "a-b-c". +*/ +SQLITE_PRIVATE void sqlite3Dequote(char *z){ + char quote; + int i, j; + if( z==0 ) return; + quote = z[0]; + if( !sqlite3Isquote(quote) ) return; + if( quote=='[' ) quote = ']'; + for(i=1, j=0;; i++){ + assert( z[i] ); + if( z[i]==quote ){ + if( z[i+1]==quote ){ + z[j++] = quote; + i++; + }else{ + break; + } + }else{ + z[j++] = z[i]; + } + } + z[j] = 0; +} +SQLITE_PRIVATE void sqlite3DequoteExpr(Expr *p){ + assert( sqlite3Isquote(p->u.zToken[0]) ); + p->flags |= p->u.zToken[0]=='"' ? EP_Quoted|EP_DblQuoted : EP_Quoted; + sqlite3Dequote(p->u.zToken); +} + +/* +** Generate a Token object from a string +*/ +SQLITE_PRIVATE void sqlite3TokenInit(Token *p, char *z){ + p->z = z; + p->n = sqlite3Strlen30(z); +} + +/* Convenient short-hand */ +#define UpperToLower sqlite3UpperToLower + +/* +** Some systems have stricmp(). Others have strcasecmp(). Because +** there is no consistency, we will define our own. +** +** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and +** sqlite3_strnicmp() APIs allow applications and extensions to compare +** the contents of two buffers containing UTF-8 strings in a +** case-independent fashion, using the same definition of "case +** independence" that SQLite uses internally when comparing identifiers. +*/ +SQLITE_API int sqlite3_stricmp(const char *zLeft, const char *zRight){ + if( zLeft==0 ){ + return zRight ? -1 : 0; + }else if( zRight==0 ){ + return 1; + } + return sqlite3StrICmp(zLeft, zRight); +} +SQLITE_PRIVATE int sqlite3StrICmp(const char *zLeft, const char *zRight){ + unsigned char *a, *b; + int c, x; + a = (unsigned char *)zLeft; + b = (unsigned char *)zRight; + for(;;){ + c = *a; + x = *b; + if( c==x ){ + if( c==0 ) break; + }else{ + c = (int)UpperToLower[c] - (int)UpperToLower[x]; + if( c ) break; + } + a++; + b++; + } + return c; +} +SQLITE_API int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){ + register unsigned char *a, *b; + if( zLeft==0 ){ + return zRight ? -1 : 0; + }else if( zRight==0 ){ + return 1; + } + a = (unsigned char *)zLeft; + b = (unsigned char *)zRight; + while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } + return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b]; +} + +/* +** Compute an 8-bit hash on a string that is insensitive to case differences +*/ +SQLITE_PRIVATE u8 sqlite3StrIHash(const char *z){ + u8 h = 0; + if( z==0 ) return 0; + while( z[0] ){ + h += UpperToLower[(unsigned char)z[0]]; + z++; + } + return h; +} + +/* +** Compute 10 to the E-th power. Examples: E==1 results in 10. +** E==2 results in 100. E==50 results in 1.0e50. +** +** This routine only works for values of E between 1 and 341. +*/ +static LONGDOUBLE_TYPE sqlite3Pow10(int E){ +#if defined(_MSC_VER) + static const LONGDOUBLE_TYPE x[] = { + 1.0e+001L, + 1.0e+002L, + 1.0e+004L, + 1.0e+008L, + 1.0e+016L, + 1.0e+032L, + 1.0e+064L, + 1.0e+128L, + 1.0e+256L + }; + LONGDOUBLE_TYPE r = 1.0; + int i; + assert( E>=0 && E<=307 ); + for(i=0; E!=0; i++, E >>=1){ + if( E & 1 ) r *= x[i]; + } + return r; +#else + LONGDOUBLE_TYPE x = 10.0; + LONGDOUBLE_TYPE r = 1.0; + while(1){ + if( E & 1 ) r *= x; + E >>= 1; + if( E==0 ) break; + x *= x; + } + return r; +#endif +} + +/* +** The string z[] is an text representation of a real number. +** Convert this string to a double and write it into *pResult. +** +** The string z[] is length bytes in length (bytes, not characters) and +** uses the encoding enc. The string is not necessarily zero-terminated. +** +** Return TRUE if the result is a valid real number (or integer) and FALSE +** if the string is empty or contains extraneous text. More specifically +** return +** 1 => The input string is a pure integer +** 2 or more => The input has a decimal point or eNNN clause +** 0 or less => The input string is not a valid number +** -1 => Not a valid number, but has a valid prefix which +** includes a decimal point and/or an eNNN clause +** +** Valid numbers are in one of these formats: +** +** [+-]digits[E[+-]digits] +** [+-]digits.[digits][E[+-]digits] +** [+-].digits[E[+-]digits] +** +** Leading and trailing whitespace is ignored for the purpose of determining +** validity. +** +** If some prefix of the input string is a valid number, this routine +** returns FALSE but it still converts the prefix and writes the result +** into *pResult. +*/ +#if defined(_MSC_VER) +#pragma warning(disable : 4756) +#endif +SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){ +#ifndef SQLITE_OMIT_FLOATING_POINT + int incr; + const char *zEnd; + /* sign * significand * (10 ^ (esign * exponent)) */ + int sign = 1; /* sign of significand */ + i64 s = 0; /* significand */ + int d = 0; /* adjust exponent for shifting decimal point */ + int esign = 1; /* sign of exponent */ + int e = 0; /* exponent */ + int eValid = 1; /* True exponent is either not used or is well-formed */ + double result; + int nDigit = 0; /* Number of digits processed */ + int eType = 1; /* 1: pure integer, 2+: fractional -1 or less: bad UTF16 */ + + assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); + *pResult = 0.0; /* Default return value, in case of an error */ + if( length==0 ) return 0; + + if( enc==SQLITE_UTF8 ){ + incr = 1; + zEnd = z + length; + }else{ + int i; + incr = 2; + length &= ~1; + assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); + testcase( enc==SQLITE_UTF16LE ); + testcase( enc==SQLITE_UTF16BE ); + for(i=3-enc; i=zEnd ) return 0; + + /* get sign of significand */ + if( *z=='-' ){ + sign = -1; + z+=incr; + }else if( *z=='+' ){ + z+=incr; + } + + /* copy max significant digits to significand */ + while( z=((LARGEST_INT64-9)/10) ){ + /* skip non-significant significand digits + ** (increase exponent by d to shift decimal left) */ + while( z=zEnd ) goto do_atof_calc; + + /* if decimal point is present */ + if( *z=='.' ){ + z+=incr; + eType++; + /* copy digits from after decimal to significand + ** (decrease exponent by d to shift decimal right) */ + while( z=zEnd ) goto do_atof_calc; + + /* if exponent is present */ + if( *z=='e' || *z=='E' ){ + z+=incr; + eValid = 0; + eType++; + + /* This branch is needed to avoid a (harmless) buffer overread. The + ** special comment alerts the mutation tester that the correct answer + ** is obtained even if the branch is omitted */ + if( z>=zEnd ) goto do_atof_calc; /*PREVENTS-HARMLESS-OVERREAD*/ + + /* get sign of exponent */ + if( *z=='-' ){ + esign = -1; + z+=incr; + }else if( *z=='+' ){ + z+=incr; + } + /* copy digits to exponent */ + while( z0 ){ /*OPTIMIZATION-IF-TRUE*/ + if( esign>0 ){ + if( s>=(LARGEST_INT64/10) ) break; /*OPTIMIZATION-IF-FALSE*/ + s *= 10; + }else{ + if( s%10!=0 ) break; /*OPTIMIZATION-IF-FALSE*/ + s /= 10; + } + e--; + } + + /* adjust the sign of significand */ + s = sign<0 ? -s : s; + + if( e==0 ){ /*OPTIMIZATION-IF-TRUE*/ + result = (double)s; + }else{ + /* attempt to handle extremely small/large numbers better */ + if( e>307 ){ /*OPTIMIZATION-IF-TRUE*/ + if( e<342 ){ /*OPTIMIZATION-IF-TRUE*/ + LONGDOUBLE_TYPE scale = sqlite3Pow10(e-308); + if( esign<0 ){ + result = s / scale; + result /= 1.0e+308; + }else{ + result = s * scale; + result *= 1.0e+308; + } + }else{ assert( e>=342 ); + if( esign<0 ){ + result = 0.0*s; + }else{ +#ifdef INFINITY + result = INFINITY*s; +#else + result = 1e308*1e308*s; /* Infinity */ +#endif + } + } + }else{ + LONGDOUBLE_TYPE scale = sqlite3Pow10(e); + if( esign<0 ){ + result = s / scale; + }else{ + result = s * scale; + } + } + } + } + + /* store the result */ + *pResult = result; + + /* return true if number and no extra non-whitespace chracters after */ + if( z==zEnd && nDigit>0 && eValid && eType>0 ){ + return eType; + }else if( eType>=2 && (eType==3 || eValid) && nDigit>0 ){ + return -1; + }else{ + return 0; + } +#else + return !sqlite3Atoi64(z, pResult, length, enc); +#endif /* SQLITE_OMIT_FLOATING_POINT */ +} +#if defined(_MSC_VER) +#pragma warning(default : 4756) +#endif + +/* +** Render an signed 64-bit integer as text. Store the result in zOut[]. +** +** The caller must ensure that zOut[] is at least 21 bytes in size. +*/ +SQLITE_PRIVATE void sqlite3Int64ToText(i64 v, char *zOut){ + int i; + u64 x; + char zTemp[22]; + if( v<0 ){ + x = (v==SMALLEST_INT64) ? ((u64)1)<<63 : (u64)-v; + }else{ + x = v; + } + i = sizeof(zTemp)-2; + zTemp[sizeof(zTemp)-1] = 0; + do{ + zTemp[i--] = (x%10) + '0'; + x = x/10; + }while( x ); + if( v<0 ) zTemp[i--] = '-'; + memcpy(zOut, &zTemp[i+1], sizeof(zTemp)-1-i); +} + +/* +** Compare the 19-character string zNum against the text representation +** value 2^63: 9223372036854775808. Return negative, zero, or positive +** if zNum is less than, equal to, or greater than the string. +** Note that zNum must contain exactly 19 characters. +** +** Unlike memcmp() this routine is guaranteed to return the difference +** in the values of the last digit if the only difference is in the +** last digit. So, for example, +** +** compare2pow63("9223372036854775800", 1) +** +** will return -8. +*/ +static int compare2pow63(const char *zNum, int incr){ + int c = 0; + int i; + /* 012345678901234567 */ + const char *pow63 = "922337203685477580"; + for(i=0; c==0 && i<18; i++){ + c = (zNum[i*incr]-pow63[i])*10; + } + if( c==0 ){ + c = zNum[18*incr] - '8'; + testcase( c==(-1) ); + testcase( c==0 ); + testcase( c==(+1) ); + } + return c; +} + +/* +** Convert zNum to a 64-bit signed integer. zNum must be decimal. This +** routine does *not* accept hexadecimal notation. +** +** Returns: +** +** -1 Not even a prefix of the input text looks like an integer +** 0 Successful transformation. Fits in a 64-bit signed integer. +** 1 Excess non-space text after the integer value +** 2 Integer too large for a 64-bit signed integer or is malformed +** 3 Special case of 9223372036854775808 +** +** length is the number of bytes in the string (bytes, not characters). +** The string is not necessarily zero-terminated. The encoding is +** given by enc. +*/ +SQLITE_PRIVATE int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){ + int incr; + u64 u = 0; + int neg = 0; /* assume positive */ + int i; + int c = 0; + int nonNum = 0; /* True if input contains UTF16 with high byte non-zero */ + int rc; /* Baseline return code */ + const char *zStart; + const char *zEnd = zNum + length; + assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); + if( enc==SQLITE_UTF8 ){ + incr = 1; + }else{ + incr = 2; + length &= ~1; + assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); + for(i=3-enc; i='0' && c<='9'; i+=incr){ + u = u*10 + c - '0'; + } + testcase( i==18*incr ); + testcase( i==19*incr ); + testcase( i==20*incr ); + if( u>LARGEST_INT64 ){ + /* This test and assignment is needed only to suppress UB warnings + ** from clang and -fsanitize=undefined. This test and assignment make + ** the code a little larger and slower, and no harm comes from omitting + ** them, but we must appaise the undefined-behavior pharisees. */ + *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64; + }else if( neg ){ + *pNum = -(i64)u; + }else{ + *pNum = (i64)u; + } + rc = 0; + if( i==0 && zStart==zNum ){ /* No digits */ + rc = -1; + }else if( nonNum ){ /* UTF16 with high-order bytes non-zero */ + rc = 1; + }else if( &zNum[i]19*incr ? 1 : compare2pow63(zNum, incr); + if( c<0 ){ + /* zNum is less than 9223372036854775808 so it fits */ + assert( u<=LARGEST_INT64 ); + return rc; + }else{ + *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64; + if( c>0 ){ + /* zNum is greater than 9223372036854775808 so it overflows */ + return 2; + }else{ + /* zNum is exactly 9223372036854775808. Fits if negative. The + ** special case 2 overflow if positive */ + assert( u-1==LARGEST_INT64 ); + return neg ? rc : 3; + } + } + } +} + +/* +** Transform a UTF-8 integer literal, in either decimal or hexadecimal, +** into a 64-bit signed integer. This routine accepts hexadecimal literals, +** whereas sqlite3Atoi64() does not. +** +** Returns: +** +** 0 Successful transformation. Fits in a 64-bit signed integer. +** 1 Excess text after the integer value +** 2 Integer too large for a 64-bit signed integer or is malformed +** 3 Special case of 9223372036854775808 +*/ +SQLITE_PRIVATE int sqlite3DecOrHexToI64(const char *z, i64 *pOut){ +#ifndef SQLITE_OMIT_HEX_INTEGER + if( z[0]=='0' + && (z[1]=='x' || z[1]=='X') + ){ + u64 u = 0; + int i, k; + for(i=2; z[i]=='0'; i++){} + for(k=i; sqlite3Isxdigit(z[k]); k++){ + u = u*16 + sqlite3HexToInt(z[k]); + } + memcpy(pOut, &u, 8); + return (z[k]==0 && k-i<=16) ? 0 : 2; + }else +#endif /* SQLITE_OMIT_HEX_INTEGER */ + { + return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8); + } +} + +/* +** If zNum represents an integer that will fit in 32-bits, then set +** *pValue to that integer and return true. Otherwise return false. +** +** This routine accepts both decimal and hexadecimal notation for integers. +** +** Any non-numeric characters that following zNum are ignored. +** This is different from sqlite3Atoi64() which requires the +** input number to be zero-terminated. +*/ +SQLITE_PRIVATE int sqlite3GetInt32(const char *zNum, int *pValue){ + sqlite_int64 v = 0; + int i, c; + int neg = 0; + if( zNum[0]=='-' ){ + neg = 1; + zNum++; + }else if( zNum[0]=='+' ){ + zNum++; + } +#ifndef SQLITE_OMIT_HEX_INTEGER + else if( zNum[0]=='0' + && (zNum[1]=='x' || zNum[1]=='X') + && sqlite3Isxdigit(zNum[2]) + ){ + u32 u = 0; + zNum += 2; + while( zNum[0]=='0' ) zNum++; + for(i=0; sqlite3Isxdigit(zNum[i]) && i<8; i++){ + u = u*16 + sqlite3HexToInt(zNum[i]); + } + if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){ + memcpy(pValue, &u, 4); + return 1; + }else{ + return 0; + } + } +#endif + if( !sqlite3Isdigit(zNum[0]) ) return 0; + while( zNum[0]=='0' ) zNum++; + for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){ + v = v*10 + c; + } + + /* The longest decimal representation of a 32 bit integer is 10 digits: + ** + ** 1234567890 + ** 2^31 -> 2147483648 + */ + testcase( i==10 ); + if( i>10 ){ + return 0; + } + testcase( v-neg==2147483647 ); + if( v-neg>2147483647 ){ + return 0; + } + if( neg ){ + v = -v; + } + *pValue = (int)v; + return 1; +} + +/* +** Return a 32-bit integer value extracted from a string. If the +** string is not an integer, just return 0. +*/ +SQLITE_PRIVATE int sqlite3Atoi(const char *z){ + int x = 0; + sqlite3GetInt32(z, &x); + return x; +} + +/* +** Try to convert z into an unsigned 32-bit integer. Return true on +** success and false if there is an error. +** +** Only decimal notation is accepted. +*/ +SQLITE_PRIVATE int sqlite3GetUInt32(const char *z, u32 *pI){ + u64 v = 0; + int i; + for(i=0; sqlite3Isdigit(z[i]); i++){ + v = v*10 + z[i] - '0'; + if( v>4294967296LL ){ *pI = 0; return 0; } + } + if( i==0 || z[i]!=0 ){ *pI = 0; return 0; } + *pI = (u32)v; + return 1; +} + +/* +** The variable-length integer encoding is as follows: +** +** KEY: +** A = 0xxxxxxx 7 bits of data and one flag bit +** B = 1xxxxxxx 7 bits of data and one flag bit +** C = xxxxxxxx 8 bits of data +** +** 7 bits - A +** 14 bits - BA +** 21 bits - BBA +** 28 bits - BBBA +** 35 bits - BBBBA +** 42 bits - BBBBBA +** 49 bits - BBBBBBA +** 56 bits - BBBBBBBA +** 64 bits - BBBBBBBBC +*/ + +/* +** Write a 64-bit variable-length integer to memory starting at p[0]. +** The length of data write will be between 1 and 9 bytes. The number +** of bytes written is returned. +** +** A variable-length integer consists of the lower 7 bits of each byte +** for all bytes that have the 8th bit set and one byte with the 8th +** bit clear. Except, if we get to the 9th byte, it stores the full +** 8 bits and is the last byte. +*/ +static int SQLITE_NOINLINE putVarint64(unsigned char *p, u64 v){ + int i, j, n; + u8 buf[10]; + if( v & (((u64)0xff000000)<<32) ){ + p[8] = (u8)v; + v >>= 8; + for(i=7; i>=0; i--){ + p[i] = (u8)((v & 0x7f) | 0x80); + v >>= 7; + } + return 9; + } + n = 0; + do{ + buf[n++] = (u8)((v & 0x7f) | 0x80); + v >>= 7; + }while( v!=0 ); + buf[0] &= 0x7f; + assert( n<=9 ); + for(i=0, j=n-1; j>=0; j--, i++){ + p[i] = buf[j]; + } + return n; +} +SQLITE_PRIVATE int sqlite3PutVarint(unsigned char *p, u64 v){ + if( v<=0x7f ){ + p[0] = v&0x7f; + return 1; + } + if( v<=0x3fff ){ + p[0] = ((v>>7)&0x7f)|0x80; + p[1] = v&0x7f; + return 2; + } + return putVarint64(p,v); +} + +/* +** Bitmasks used by sqlite3GetVarint(). These precomputed constants +** are defined here rather than simply putting the constant expressions +** inline in order to work around bugs in the RVT compiler. +** +** SLOT_2_0 A mask for (0x7f<<14) | 0x7f +** +** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0 +*/ +#define SLOT_2_0 0x001fc07f +#define SLOT_4_2_0 0xf01fc07f + + +/* +** Read a 64-bit variable-length integer from memory starting at p[0]. +** Return the number of bytes read. The value is stored in *v. +*/ +SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *p, u64 *v){ + u32 a,b,s; + + if( ((signed char*)p)[0]>=0 ){ + *v = *p; + return 1; + } + if( ((signed char*)p)[1]>=0 ){ + *v = ((u32)(p[0]&0x7f)<<7) | p[1]; + return 2; + } + + /* Verify that constants are precomputed correctly */ + assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) ); + assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) ); + + a = ((u32)p[0])<<14; + b = p[1]; + p += 2; + a |= *p; + /* a: p0<<14 | p2 (unmasked) */ + if (!(a&0x80)) + { + a &= SLOT_2_0; + b &= 0x7f; + b = b<<7; + a |= b; + *v = a; + return 3; + } + + /* CSE1 from below */ + a &= SLOT_2_0; + p++; + b = b<<14; + b |= *p; + /* b: p1<<14 | p3 (unmasked) */ + if (!(b&0x80)) + { + b &= SLOT_2_0; + /* moved CSE1 up */ + /* a &= (0x7f<<14)|(0x7f); */ + a = a<<7; + a |= b; + *v = a; + return 4; + } + + /* a: p0<<14 | p2 (masked) */ + /* b: p1<<14 | p3 (unmasked) */ + /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ + /* moved CSE1 up */ + /* a &= (0x7f<<14)|(0x7f); */ + b &= SLOT_2_0; + s = a; + /* s: p0<<14 | p2 (masked) */ + + p++; + a = a<<14; + a |= *p; + /* a: p0<<28 | p2<<14 | p4 (unmasked) */ + if (!(a&0x80)) + { + /* we can skip these cause they were (effectively) done above + ** while calculating s */ + /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */ + /* b &= (0x7f<<14)|(0x7f); */ + b = b<<7; + a |= b; + s = s>>18; + *v = ((u64)s)<<32 | a; + return 5; + } + + /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ + s = s<<7; + s |= b; + /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ + + p++; + b = b<<14; + b |= *p; + /* b: p1<<28 | p3<<14 | p5 (unmasked) */ + if (!(b&0x80)) + { + /* we can skip this cause it was (effectively) done above in calc'ing s */ + /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */ + a &= SLOT_2_0; + a = a<<7; + a |= b; + s = s>>18; + *v = ((u64)s)<<32 | a; + return 6; + } + + p++; + a = a<<14; + a |= *p; + /* a: p2<<28 | p4<<14 | p6 (unmasked) */ + if (!(a&0x80)) + { + a &= SLOT_4_2_0; + b &= SLOT_2_0; + b = b<<7; + a |= b; + s = s>>11; + *v = ((u64)s)<<32 | a; + return 7; + } + + /* CSE2 from below */ + a &= SLOT_2_0; + p++; + b = b<<14; + b |= *p; + /* b: p3<<28 | p5<<14 | p7 (unmasked) */ + if (!(b&0x80)) + { + b &= SLOT_4_2_0; + /* moved CSE2 up */ + /* a &= (0x7f<<14)|(0x7f); */ + a = a<<7; + a |= b; + s = s>>4; + *v = ((u64)s)<<32 | a; + return 8; + } + + p++; + a = a<<15; + a |= *p; + /* a: p4<<29 | p6<<15 | p8 (unmasked) */ + + /* moved CSE2 up */ + /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */ + b &= SLOT_2_0; + b = b<<8; + a |= b; + + s = s<<4; + b = p[-4]; + b &= 0x7f; + b = b>>3; + s |= b; + + *v = ((u64)s)<<32 | a; + + return 9; +} + +/* +** Read a 32-bit variable-length integer from memory starting at p[0]. +** Return the number of bytes read. The value is stored in *v. +** +** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned +** integer, then set *v to 0xffffffff. +** +** A MACRO version, getVarint32, is provided which inlines the +** single-byte case. All code should use the MACRO version as +** this function assumes the single-byte case has already been handled. +*/ +SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){ + u32 a,b; + + /* The 1-byte case. Overwhelmingly the most common. Handled inline + ** by the getVarin32() macro */ + a = *p; + /* a: p0 (unmasked) */ +#ifndef getVarint32 + if (!(a&0x80)) + { + /* Values between 0 and 127 */ + *v = a; + return 1; + } +#endif + + /* The 2-byte case */ + p++; + b = *p; + /* b: p1 (unmasked) */ + if (!(b&0x80)) + { + /* Values between 128 and 16383 */ + a &= 0x7f; + a = a<<7; + *v = a | b; + return 2; + } + + /* The 3-byte case */ + p++; + a = a<<14; + a |= *p; + /* a: p0<<14 | p2 (unmasked) */ + if (!(a&0x80)) + { + /* Values between 16384 and 2097151 */ + a &= (0x7f<<14)|(0x7f); + b &= 0x7f; + b = b<<7; + *v = a | b; + return 3; + } + + /* A 32-bit varint is used to store size information in btrees. + ** Objects are rarely larger than 2MiB limit of a 3-byte varint. + ** A 3-byte varint is sufficient, for example, to record the size + ** of a 1048569-byte BLOB or string. + ** + ** We only unroll the first 1-, 2-, and 3- byte cases. The very + ** rare larger cases can be handled by the slower 64-bit varint + ** routine. + */ +#if 1 + { + u64 v64; + u8 n; + + n = sqlite3GetVarint(p-2, &v64); + assert( n>3 && n<=9 ); + if( (v64 & SQLITE_MAX_U32)!=v64 ){ + *v = 0xffffffff; + }else{ + *v = (u32)v64; + } + return n; + } + +#else + /* For following code (kept for historical record only) shows an + ** unrolling for the 3- and 4-byte varint cases. This code is + ** slightly faster, but it is also larger and much harder to test. + */ + p++; + b = b<<14; + b |= *p; + /* b: p1<<14 | p3 (unmasked) */ + if (!(b&0x80)) + { + /* Values between 2097152 and 268435455 */ + b &= (0x7f<<14)|(0x7f); + a &= (0x7f<<14)|(0x7f); + a = a<<7; + *v = a | b; + return 4; + } + + p++; + a = a<<14; + a |= *p; + /* a: p0<<28 | p2<<14 | p4 (unmasked) */ + if (!(a&0x80)) + { + /* Values between 268435456 and 34359738367 */ + a &= SLOT_4_2_0; + b &= SLOT_4_2_0; + b = b<<7; + *v = a | b; + return 5; + } + + /* We can only reach this point when reading a corrupt database + ** file. In that case we are not in any hurry. Use the (relatively + ** slow) general-purpose sqlite3GetVarint() routine to extract the + ** value. */ + { + u64 v64; + u8 n; + + p -= 4; + n = sqlite3GetVarint(p, &v64); + assert( n>5 && n<=9 ); + *v = (u32)v64; + return n; + } +#endif +} + +/* +** Return the number of bytes that will be needed to store the given +** 64-bit integer. +*/ +SQLITE_PRIVATE int sqlite3VarintLen(u64 v){ + int i; + for(i=1; (v >>= 7)!=0; i++){ assert( i<10 ); } + return i; +} + + +/* +** Read or write a four-byte big-endian integer value. +*/ +SQLITE_PRIVATE u32 sqlite3Get4byte(const u8 *p){ +#if SQLITE_BYTEORDER==4321 + u32 x; + memcpy(&x,p,4); + return x; +#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 + u32 x; + memcpy(&x,p,4); + return __builtin_bswap32(x); +#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 + u32 x; + memcpy(&x,p,4); + return _byteswap_ulong(x); +#else + testcase( p[0]&0x80 ); + return ((unsigned)p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3]; +#endif +} +SQLITE_PRIVATE void sqlite3Put4byte(unsigned char *p, u32 v){ +#if SQLITE_BYTEORDER==4321 + memcpy(p,&v,4); +#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 + u32 x = __builtin_bswap32(v); + memcpy(p,&x,4); +#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 + u32 x = _byteswap_ulong(v); + memcpy(p,&x,4); +#else + p[0] = (u8)(v>>24); + p[1] = (u8)(v>>16); + p[2] = (u8)(v>>8); + p[3] = (u8)v; +#endif +} + + + +/* +** Translate a single byte of Hex into an integer. +** This routine only works if h really is a valid hexadecimal +** character: 0..9a..fA..F +*/ +SQLITE_PRIVATE u8 sqlite3HexToInt(int h){ + assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') ); +#ifdef SQLITE_ASCII + h += 9*(1&(h>>6)); +#endif +#ifdef SQLITE_EBCDIC + h += 9*(1&~(h>>4)); +#endif + return (u8)(h & 0xf); +} + +#if !defined(SQLITE_OMIT_BLOB_LITERAL) +/* +** Convert a BLOB literal of the form "x'hhhhhh'" into its binary +** value. Return a pointer to its binary value. Space to hold the +** binary value has been obtained from malloc and must be freed by +** the calling routine. +*/ +SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){ + char *zBlob; + int i; + + zBlob = (char *)sqlite3DbMallocRawNN(db, n/2 + 1); + n--; + if( zBlob ){ + for(i=0; imagic; + if( magic!=SQLITE_MAGIC_OPEN ){ + if( sqlite3SafetyCheckSickOrOk(db) ){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + logBadConnection("unopened"); + } + return 0; + }else{ + return 1; + } +} +SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3 *db){ + u32 magic; + magic = db->magic; + if( magic!=SQLITE_MAGIC_SICK && + magic!=SQLITE_MAGIC_OPEN && + magic!=SQLITE_MAGIC_BUSY ){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + logBadConnection("invalid"); + return 0; + }else{ + return 1; + } +} + +/* +** Attempt to add, substract, or multiply the 64-bit signed value iB against +** the other 64-bit signed integer at *pA and store the result in *pA. +** Return 0 on success. Or if the operation would have resulted in an +** overflow, leave *pA unchanged and return 1. +*/ +SQLITE_PRIVATE int sqlite3AddInt64(i64 *pA, i64 iB){ +#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER) + return __builtin_add_overflow(*pA, iB, pA); +#else + i64 iA = *pA; + testcase( iA==0 ); testcase( iA==1 ); + testcase( iB==-1 ); testcase( iB==0 ); + if( iB>=0 ){ + testcase( iA>0 && LARGEST_INT64 - iA == iB ); + testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 ); + if( iA>0 && LARGEST_INT64 - iA < iB ) return 1; + }else{ + testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 ); + testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 ); + if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1; + } + *pA += iB; + return 0; +#endif +} +SQLITE_PRIVATE int sqlite3SubInt64(i64 *pA, i64 iB){ +#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER) + return __builtin_sub_overflow(*pA, iB, pA); +#else + testcase( iB==SMALLEST_INT64+1 ); + if( iB==SMALLEST_INT64 ){ + testcase( (*pA)==(-1) ); testcase( (*pA)==0 ); + if( (*pA)>=0 ) return 1; + *pA -= iB; + return 0; + }else{ + return sqlite3AddInt64(pA, -iB); + } +#endif +} +SQLITE_PRIVATE int sqlite3MulInt64(i64 *pA, i64 iB){ +#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER) + return __builtin_mul_overflow(*pA, iB, pA); +#else + i64 iA = *pA; + if( iB>0 ){ + if( iA>LARGEST_INT64/iB ) return 1; + if( iA0 ){ + if( iBLARGEST_INT64/-iB ) return 1; + } + } + *pA = iA*iB; + return 0; +#endif +} + +/* +** Compute the absolute value of a 32-bit signed integer, of possible. Or +** if the integer has a value of -2147483648, return +2147483647 +*/ +SQLITE_PRIVATE int sqlite3AbsInt32(int x){ + if( x>=0 ) return x; + if( x==(int)0x80000000 ) return 0x7fffffff; + return -x; +} + +#ifdef SQLITE_ENABLE_8_3_NAMES +/* +** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database +** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and +** if filename in z[] has a suffix (a.k.a. "extension") that is longer than +** three characters, then shorten the suffix on z[] to be the last three +** characters of the original suffix. +** +** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always +** do the suffix shortening regardless of URI parameter. +** +** Examples: +** +** test.db-journal => test.nal +** test.db-wal => test.wal +** test.db-shm => test.shm +** test.db-mj7f3319fa => test.9fa +*/ +SQLITE_PRIVATE void sqlite3FileSuffix3(const char *zBaseFilename, char *z){ +#if SQLITE_ENABLE_8_3_NAMES<2 + if( sqlite3_uri_boolean(zBaseFilename, "8_3_names", 0) ) +#endif + { + int i, sz; + sz = sqlite3Strlen30(z); + for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){} + if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4); + } +} +#endif + +/* +** Find (an approximate) sum of two LogEst values. This computation is +** not a simple "+" operator because LogEst is stored as a logarithmic +** value. +** +*/ +SQLITE_PRIVATE LogEst sqlite3LogEstAdd(LogEst a, LogEst b){ + static const unsigned char x[] = { + 10, 10, /* 0,1 */ + 9, 9, /* 2,3 */ + 8, 8, /* 4,5 */ + 7, 7, 7, /* 6,7,8 */ + 6, 6, 6, /* 9,10,11 */ + 5, 5, 5, /* 12-14 */ + 4, 4, 4, 4, /* 15-18 */ + 3, 3, 3, 3, 3, 3, /* 19-24 */ + 2, 2, 2, 2, 2, 2, 2, /* 25-31 */ + }; + if( a>=b ){ + if( a>b+49 ) return a; + if( a>b+31 ) return a+1; + return a+x[a-b]; + }else{ + if( b>a+49 ) return b; + if( b>a+31 ) return b+1; + return b+x[b-a]; + } +} + +/* +** Convert an integer into a LogEst. In other words, compute an +** approximation for 10*log2(x). +*/ +SQLITE_PRIVATE LogEst sqlite3LogEst(u64 x){ + static LogEst a[] = { 0, 2, 3, 5, 6, 7, 8, 9 }; + LogEst y = 40; + if( x<8 ){ + if( x<2 ) return 0; + while( x<8 ){ y -= 10; x <<= 1; } + }else{ +#if GCC_VERSION>=5004000 + int i = 60 - __builtin_clzll(x); + y += i*10; + x >>= i; +#else + while( x>255 ){ y += 40; x >>= 4; } /*OPTIMIZATION-IF-TRUE*/ + while( x>15 ){ y += 10; x >>= 1; } +#endif + } + return a[x&7] + y - 10; +} + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Convert a double into a LogEst +** In other words, compute an approximation for 10*log2(x). +*/ +SQLITE_PRIVATE LogEst sqlite3LogEstFromDouble(double x){ + u64 a; + LogEst e; + assert( sizeof(x)==8 && sizeof(a)==8 ); + if( x<=1 ) return 0; + if( x<=2000000000 ) return sqlite3LogEst((u64)x); + memcpy(&a, &x, 8); + e = (a>>52) - 1022; + return e*10; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \ + defined(SQLITE_ENABLE_STAT4) || \ + defined(SQLITE_EXPLAIN_ESTIMATED_ROWS) +/* +** Convert a LogEst into an integer. +** +** Note that this routine is only used when one or more of various +** non-standard compile-time options is enabled. +*/ +SQLITE_PRIVATE u64 sqlite3LogEstToInt(LogEst x){ + u64 n; + n = x%10; + x /= 10; + if( n>=5 ) n -= 2; + else if( n>=1 ) n -= 1; +#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \ + defined(SQLITE_EXPLAIN_ESTIMATED_ROWS) + if( x>60 ) return (u64)LARGEST_INT64; +#else + /* If only SQLITE_ENABLE_STAT4 is on, then the largest input + ** possible to this routine is 310, resulting in a maximum x of 31 */ + assert( x<=60 ); +#endif + return x>=3 ? (n+8)<<(x-3) : (n+8)>>(3-x); +} +#endif /* defined SCANSTAT or STAT4 or ESTIMATED_ROWS */ + +/* +** Add a new name/number pair to a VList. This might require that the +** VList object be reallocated, so return the new VList. If an OOM +** error occurs, the original VList returned and the +** db->mallocFailed flag is set. +** +** A VList is really just an array of integers. To destroy a VList, +** simply pass it to sqlite3DbFree(). +** +** The first integer is the number of integers allocated for the whole +** VList. The second integer is the number of integers actually used. +** Each name/number pair is encoded by subsequent groups of 3 or more +** integers. +** +** Each name/number pair starts with two integers which are the numeric +** value for the pair and the size of the name/number pair, respectively. +** The text name overlays one or more following integers. The text name +** is always zero-terminated. +** +** Conceptually: +** +** struct VList { +** int nAlloc; // Number of allocated slots +** int nUsed; // Number of used slots +** struct VListEntry { +** int iValue; // Value for this entry +** int nSlot; // Slots used by this entry +** // ... variable name goes here +** } a[0]; +** } +** +** During code generation, pointers to the variable names within the +** VList are taken. When that happens, nAlloc is set to zero as an +** indication that the VList may never again be enlarged, since the +** accompanying realloc() would invalidate the pointers. +*/ +SQLITE_PRIVATE VList *sqlite3VListAdd( + sqlite3 *db, /* The database connection used for malloc() */ + VList *pIn, /* The input VList. Might be NULL */ + const char *zName, /* Name of symbol to add */ + int nName, /* Bytes of text in zName */ + int iVal /* Value to associate with zName */ +){ + int nInt; /* number of sizeof(int) objects needed for zName */ + char *z; /* Pointer to where zName will be stored */ + int i; /* Index in pIn[] where zName is stored */ + + nInt = nName/4 + 3; + assert( pIn==0 || pIn[0]>=3 ); /* Verify ok to add new elements */ + if( pIn==0 || pIn[1]+nInt > pIn[0] ){ + /* Enlarge the allocation */ + sqlite3_int64 nAlloc = (pIn ? 2*(sqlite3_int64)pIn[0] : 10) + nInt; + VList *pOut = sqlite3DbRealloc(db, pIn, nAlloc*sizeof(int)); + if( pOut==0 ) return pIn; + if( pIn==0 ) pOut[1] = 2; + pIn = pOut; + pIn[0] = nAlloc; + } + i = pIn[1]; + pIn[i] = iVal; + pIn[i+1] = nInt; + z = (char*)&pIn[i+2]; + pIn[1] = i+nInt; + assert( pIn[1]<=pIn[0] ); + memcpy(z, zName, nName); + z[nName] = 0; + return pIn; +} + +/* +** Return a pointer to the name of a variable in the given VList that +** has the value iVal. Or return a NULL if there is no such variable in +** the list +*/ +SQLITE_PRIVATE const char *sqlite3VListNumToName(VList *pIn, int iVal){ + int i, mx; + if( pIn==0 ) return 0; + mx = pIn[1]; + i = 2; + do{ + if( pIn[i]==iVal ) return (char*)&pIn[i+2]; + i += pIn[i+1]; + }while( i */ + +/* Turn bulk memory into a hash table object by initializing the +** fields of the Hash structure. +** +** "pNew" is a pointer to the hash table that is to be initialized. +*/ +SQLITE_PRIVATE void sqlite3HashInit(Hash *pNew){ + assert( pNew!=0 ); + pNew->first = 0; + pNew->count = 0; + pNew->htsize = 0; + pNew->ht = 0; +} + +/* Remove all entries from a hash table. Reclaim all memory. +** Call this routine to delete a hash table or to reset a hash table +** to the empty state. +*/ +SQLITE_PRIVATE void sqlite3HashClear(Hash *pH){ + HashElem *elem; /* For looping over all elements of the table */ + + assert( pH!=0 ); + elem = pH->first; + pH->first = 0; + sqlite3_free(pH->ht); + pH->ht = 0; + pH->htsize = 0; + while( elem ){ + HashElem *next_elem = elem->next; + sqlite3_free(elem); + elem = next_elem; + } + pH->count = 0; +} + +/* +** The hashing function. +*/ +static unsigned int strHash(const char *z){ + unsigned int h = 0; + unsigned char c; + while( (c = (unsigned char)*z++)!=0 ){ /*OPTIMIZATION-IF-TRUE*/ + /* Knuth multiplicative hashing. (Sorting & Searching, p. 510). + ** 0x9e3779b1 is 2654435761 which is the closest prime number to + ** (2**32)*golden_ratio, where golden_ratio = (sqrt(5) - 1)/2. */ + h += sqlite3UpperToLower[c]; + h *= 0x9e3779b1; + } + return h; +} + + +/* Link pNew element into the hash table pH. If pEntry!=0 then also +** insert pNew into the pEntry hash bucket. +*/ +static void insertElement( + Hash *pH, /* The complete hash table */ + struct _ht *pEntry, /* The entry into which pNew is inserted */ + HashElem *pNew /* The element to be inserted */ +){ + HashElem *pHead; /* First element already in pEntry */ + if( pEntry ){ + pHead = pEntry->count ? pEntry->chain : 0; + pEntry->count++; + pEntry->chain = pNew; + }else{ + pHead = 0; + } + if( pHead ){ + pNew->next = pHead; + pNew->prev = pHead->prev; + if( pHead->prev ){ pHead->prev->next = pNew; } + else { pH->first = pNew; } + pHead->prev = pNew; + }else{ + pNew->next = pH->first; + if( pH->first ){ pH->first->prev = pNew; } + pNew->prev = 0; + pH->first = pNew; + } +} + + +/* Resize the hash table so that it cantains "new_size" buckets. +** +** The hash table might fail to resize if sqlite3_malloc() fails or +** if the new size is the same as the prior size. +** Return TRUE if the resize occurs and false if not. +*/ +static int rehash(Hash *pH, unsigned int new_size){ + struct _ht *new_ht; /* The new hash table */ + HashElem *elem, *next_elem; /* For looping over existing elements */ + +#if SQLITE_MALLOC_SOFT_LIMIT>0 + if( new_size*sizeof(struct _ht)>SQLITE_MALLOC_SOFT_LIMIT ){ + new_size = SQLITE_MALLOC_SOFT_LIMIT/sizeof(struct _ht); + } + if( new_size==pH->htsize ) return 0; +#endif + + /* The inability to allocates space for a larger hash table is + ** a performance hit but it is not a fatal error. So mark the + ** allocation as a benign. Use sqlite3Malloc()/memset(0) instead of + ** sqlite3MallocZero() to make the allocation, as sqlite3MallocZero() + ** only zeroes the requested number of bytes whereas this module will + ** use the actual amount of space allocated for the hash table (which + ** may be larger than the requested amount). + */ + sqlite3BeginBenignMalloc(); + new_ht = (struct _ht *)sqlite3Malloc( new_size*sizeof(struct _ht) ); + sqlite3EndBenignMalloc(); + + if( new_ht==0 ) return 0; + sqlite3_free(pH->ht); + pH->ht = new_ht; + pH->htsize = new_size = sqlite3MallocSize(new_ht)/sizeof(struct _ht); + memset(new_ht, 0, new_size*sizeof(struct _ht)); + for(elem=pH->first, pH->first=0; elem; elem = next_elem){ + unsigned int h = strHash(elem->pKey) % new_size; + next_elem = elem->next; + insertElement(pH, &new_ht[h], elem); + } + return 1; +} + +/* This function (for internal use only) locates an element in an +** hash table that matches the given key. If no element is found, +** a pointer to a static null element with HashElem.data==0 is returned. +** If pH is not NULL, then the hash for this key is written to *pH. +*/ +static HashElem *findElementWithHash( + const Hash *pH, /* The pH to be searched */ + const char *pKey, /* The key we are searching for */ + unsigned int *pHash /* Write the hash value here */ +){ + HashElem *elem; /* Used to loop thru the element list */ + unsigned int count; /* Number of elements left to test */ + unsigned int h; /* The computed hash */ + static HashElem nullElement = { 0, 0, 0, 0 }; + + if( pH->ht ){ /*OPTIMIZATION-IF-TRUE*/ + struct _ht *pEntry; + h = strHash(pKey) % pH->htsize; + pEntry = &pH->ht[h]; + elem = pEntry->chain; + count = pEntry->count; + }else{ + h = 0; + elem = pH->first; + count = pH->count; + } + if( pHash ) *pHash = h; + while( count-- ){ + assert( elem!=0 ); + if( sqlite3StrICmp(elem->pKey,pKey)==0 ){ + return elem; + } + elem = elem->next; + } + return &nullElement; +} + +/* Remove a single entry from the hash table given a pointer to that +** element and a hash on the element's key. +*/ +static void removeElementGivenHash( + Hash *pH, /* The pH containing "elem" */ + HashElem* elem, /* The element to be removed from the pH */ + unsigned int h /* Hash value for the element */ +){ + struct _ht *pEntry; + if( elem->prev ){ + elem->prev->next = elem->next; + }else{ + pH->first = elem->next; + } + if( elem->next ){ + elem->next->prev = elem->prev; + } + if( pH->ht ){ + pEntry = &pH->ht[h]; + if( pEntry->chain==elem ){ + pEntry->chain = elem->next; + } + assert( pEntry->count>0 ); + pEntry->count--; + } + sqlite3_free( elem ); + pH->count--; + if( pH->count==0 ){ + assert( pH->first==0 ); + assert( pH->count==0 ); + sqlite3HashClear(pH); + } +} + +/* Attempt to locate an element of the hash table pH with a key +** that matches pKey. Return the data for this element if it is +** found, or NULL if there is no match. +*/ +SQLITE_PRIVATE void *sqlite3HashFind(const Hash *pH, const char *pKey){ + assert( pH!=0 ); + assert( pKey!=0 ); + return findElementWithHash(pH, pKey, 0)->data; +} + +/* Insert an element into the hash table pH. The key is pKey +** and the data is "data". +** +** If no element exists with a matching key, then a new +** element is created and NULL is returned. +** +** If another element already exists with the same key, then the +** new data replaces the old data and the old data is returned. +** The key is not copied in this instance. If a malloc fails, then +** the new data is returned and the hash table is unchanged. +** +** If the "data" parameter to this function is NULL, then the +** element corresponding to "key" is removed from the hash table. +*/ +SQLITE_PRIVATE void *sqlite3HashInsert(Hash *pH, const char *pKey, void *data){ + unsigned int h; /* the hash of the key modulo hash table size */ + HashElem *elem; /* Used to loop thru the element list */ + HashElem *new_elem; /* New element added to the pH */ + + assert( pH!=0 ); + assert( pKey!=0 ); + elem = findElementWithHash(pH,pKey,&h); + if( elem->data ){ + void *old_data = elem->data; + if( data==0 ){ + removeElementGivenHash(pH,elem,h); + }else{ + elem->data = data; + elem->pKey = pKey; + } + return old_data; + } + if( data==0 ) return 0; + new_elem = (HashElem*)sqlite3Malloc( sizeof(HashElem) ); + if( new_elem==0 ) return data; + new_elem->pKey = pKey; + new_elem->data = data; + pH->count++; + if( pH->count>=10 && pH->count > 2*pH->htsize ){ + if( rehash(pH, pH->count*2) ){ + assert( pH->htsize>0 ); + h = strHash(pKey) % pH->htsize; + } + } + insertElement(pH, pH->ht ? &pH->ht[h] : 0, new_elem); + return 0; +} + +/************** End of hash.c ************************************************/ +/************** Begin file opcodes.c *****************************************/ +/* Automatically generated. Do not edit */ +/* See the tool/mkopcodec.tcl script for details. */ +#if !defined(SQLITE_OMIT_EXPLAIN) \ + || defined(VDBE_PROFILE) \ + || defined(SQLITE_DEBUG) +#if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) || defined(SQLITE_DEBUG) +# define OpHelp(X) "\0" X +#else +# define OpHelp(X) +#endif +SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){ + static const char *const azName[] = { + /* 0 */ "Savepoint" OpHelp(""), + /* 1 */ "AutoCommit" OpHelp(""), + /* 2 */ "Transaction" OpHelp(""), + /* 3 */ "SorterNext" OpHelp(""), + /* 4 */ "Prev" OpHelp(""), + /* 5 */ "Next" OpHelp(""), + /* 6 */ "Checkpoint" OpHelp(""), + /* 7 */ "JournalMode" OpHelp(""), + /* 8 */ "Vacuum" OpHelp(""), + /* 9 */ "VFilter" OpHelp("iplan=r[P3] zplan='P4'"), + /* 10 */ "VUpdate" OpHelp("data=r[P3@P2]"), + /* 11 */ "Goto" OpHelp(""), + /* 12 */ "Gosub" OpHelp(""), + /* 13 */ "InitCoroutine" OpHelp(""), + /* 14 */ "Yield" OpHelp(""), + /* 15 */ "MustBeInt" OpHelp(""), + /* 16 */ "Jump" OpHelp(""), + /* 17 */ "Once" OpHelp(""), + /* 18 */ "If" OpHelp(""), + /* 19 */ "Not" OpHelp("r[P2]= !r[P1]"), + /* 20 */ "IfNot" OpHelp(""), + /* 21 */ "IfNullRow" OpHelp("if P1.nullRow then r[P3]=NULL, goto P2"), + /* 22 */ "SeekLT" OpHelp("key=r[P3@P4]"), + /* 23 */ "SeekLE" OpHelp("key=r[P3@P4]"), + /* 24 */ "SeekGE" OpHelp("key=r[P3@P4]"), + /* 25 */ "SeekGT" OpHelp("key=r[P3@P4]"), + /* 26 */ "IfNotOpen" OpHelp("if( !csr[P1] ) goto P2"), + /* 27 */ "IfNoHope" OpHelp("key=r[P3@P4]"), + /* 28 */ "NoConflict" OpHelp("key=r[P3@P4]"), + /* 29 */ "NotFound" OpHelp("key=r[P3@P4]"), + /* 30 */ "Found" OpHelp("key=r[P3@P4]"), + /* 31 */ "SeekRowid" OpHelp("intkey=r[P3]"), + /* 32 */ "NotExists" OpHelp("intkey=r[P3]"), + /* 33 */ "Last" OpHelp(""), + /* 34 */ "IfSmaller" OpHelp(""), + /* 35 */ "SorterSort" OpHelp(""), + /* 36 */ "Sort" OpHelp(""), + /* 37 */ "Rewind" OpHelp(""), + /* 38 */ "IdxLE" OpHelp("key=r[P3@P4]"), + /* 39 */ "IdxGT" OpHelp("key=r[P3@P4]"), + /* 40 */ "IdxLT" OpHelp("key=r[P3@P4]"), + /* 41 */ "IdxGE" OpHelp("key=r[P3@P4]"), + /* 42 */ "RowSetRead" OpHelp("r[P3]=rowset(P1)"), + /* 43 */ "Or" OpHelp("r[P3]=(r[P1] || r[P2])"), + /* 44 */ "And" OpHelp("r[P3]=(r[P1] && r[P2])"), + /* 45 */ "RowSetTest" OpHelp("if r[P3] in rowset(P1) goto P2"), + /* 46 */ "Program" OpHelp(""), + /* 47 */ "FkIfZero" OpHelp("if fkctr[P1]==0 goto P2"), + /* 48 */ "IfPos" OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"), + /* 49 */ "IfNotZero" OpHelp("if r[P1]!=0 then r[P1]--, goto P2"), + /* 50 */ "IsNull" OpHelp("if r[P1]==NULL goto P2"), + /* 51 */ "NotNull" OpHelp("if r[P1]!=NULL goto P2"), + /* 52 */ "Ne" OpHelp("IF r[P3]!=r[P1]"), + /* 53 */ "Eq" OpHelp("IF r[P3]==r[P1]"), + /* 54 */ "Gt" OpHelp("IF r[P3]>r[P1]"), + /* 55 */ "Le" OpHelp("IF r[P3]<=r[P1]"), + /* 56 */ "Lt" OpHelp("IF r[P3]=r[P1]"), + /* 58 */ "ElseNotEq" OpHelp(""), + /* 59 */ "DecrJumpZero" OpHelp("if (--r[P1])==0 goto P2"), + /* 60 */ "IncrVacuum" OpHelp(""), + /* 61 */ "VNext" OpHelp(""), + /* 62 */ "Init" OpHelp("Start at P2"), + /* 63 */ "PureFunc" OpHelp("r[P3]=func(r[P2@NP])"), + /* 64 */ "Function" OpHelp("r[P3]=func(r[P2@NP])"), + /* 65 */ "Return" OpHelp(""), + /* 66 */ "EndCoroutine" OpHelp(""), + /* 67 */ "HaltIfNull" OpHelp("if r[P3]=null halt"), + /* 68 */ "Halt" OpHelp(""), + /* 69 */ "Integer" OpHelp("r[P2]=P1"), + /* 70 */ "Int64" OpHelp("r[P2]=P4"), + /* 71 */ "String" OpHelp("r[P2]='P4' (len=P1)"), + /* 72 */ "Null" OpHelp("r[P2..P3]=NULL"), + /* 73 */ "SoftNull" OpHelp("r[P1]=NULL"), + /* 74 */ "Blob" OpHelp("r[P2]=P4 (len=P1)"), + /* 75 */ "Variable" OpHelp("r[P2]=parameter(P1,P4)"), + /* 76 */ "Move" OpHelp("r[P2@P3]=r[P1@P3]"), + /* 77 */ "Copy" OpHelp("r[P2@P3+1]=r[P1@P3+1]"), + /* 78 */ "SCopy" OpHelp("r[P2]=r[P1]"), + /* 79 */ "IntCopy" OpHelp("r[P2]=r[P1]"), + /* 80 */ "ResultRow" OpHelp("output=r[P1@P2]"), + /* 81 */ "CollSeq" OpHelp(""), + /* 82 */ "AddImm" OpHelp("r[P1]=r[P1]+P2"), + /* 83 */ "RealAffinity" OpHelp(""), + /* 84 */ "Cast" OpHelp("affinity(r[P1])"), + /* 85 */ "Permutation" OpHelp(""), + /* 86 */ "Compare" OpHelp("r[P1@P3] <-> r[P2@P3]"), + /* 87 */ "IsTrue" OpHelp("r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4"), + /* 88 */ "Offset" OpHelp("r[P3] = sqlite_offset(P1)"), + /* 89 */ "Column" OpHelp("r[P3]=PX"), + /* 90 */ "Affinity" OpHelp("affinity(r[P1@P2])"), + /* 91 */ "MakeRecord" OpHelp("r[P3]=mkrec(r[P1@P2])"), + /* 92 */ "Count" OpHelp("r[P2]=count()"), + /* 93 */ "ReadCookie" OpHelp(""), + /* 94 */ "SetCookie" OpHelp(""), + /* 95 */ "ReopenIdx" OpHelp("root=P2 iDb=P3"), + /* 96 */ "OpenRead" OpHelp("root=P2 iDb=P3"), + /* 97 */ "OpenWrite" OpHelp("root=P2 iDb=P3"), + /* 98 */ "OpenDup" OpHelp(""), + /* 99 */ "OpenAutoindex" OpHelp("nColumn=P2"), + /* 100 */ "OpenEphemeral" OpHelp("nColumn=P2"), + /* 101 */ "BitAnd" OpHelp("r[P3]=r[P1]&r[P2]"), + /* 102 */ "BitOr" OpHelp("r[P3]=r[P1]|r[P2]"), + /* 103 */ "ShiftLeft" OpHelp("r[P3]=r[P2]<>r[P1]"), + /* 105 */ "Add" OpHelp("r[P3]=r[P1]+r[P2]"), + /* 106 */ "Subtract" OpHelp("r[P3]=r[P2]-r[P1]"), + /* 107 */ "Multiply" OpHelp("r[P3]=r[P1]*r[P2]"), + /* 108 */ "Divide" OpHelp("r[P3]=r[P2]/r[P1]"), + /* 109 */ "Remainder" OpHelp("r[P3]=r[P2]%r[P1]"), + /* 110 */ "Concat" OpHelp("r[P3]=r[P2]+r[P1]"), + /* 111 */ "SorterOpen" OpHelp(""), + /* 112 */ "BitNot" OpHelp("r[P2]= ~r[P1]"), + /* 113 */ "SequenceTest" OpHelp("if( cursor[P1].ctr++ ) pc = P2"), + /* 114 */ "OpenPseudo" OpHelp("P3 columns in r[P2]"), + /* 115 */ "String8" OpHelp("r[P2]='P4'"), + /* 116 */ "Close" OpHelp(""), + /* 117 */ "ColumnsUsed" OpHelp(""), + /* 118 */ "SeekScan" OpHelp("Scan-ahead up to P1 rows"), + /* 119 */ "SeekHit" OpHelp("set P2<=seekHit<=P3"), + /* 120 */ "Sequence" OpHelp("r[P2]=cursor[P1].ctr++"), + /* 121 */ "NewRowid" OpHelp("r[P2]=rowid"), + /* 122 */ "Insert" OpHelp("intkey=r[P3] data=r[P2]"), + /* 123 */ "Delete" OpHelp(""), + /* 124 */ "ResetCount" OpHelp(""), + /* 125 */ "SorterCompare" OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"), + /* 126 */ "SorterData" OpHelp("r[P2]=data"), + /* 127 */ "RowData" OpHelp("r[P2]=data"), + /* 128 */ "Rowid" OpHelp("r[P2]=rowid"), + /* 129 */ "NullRow" OpHelp(""), + /* 130 */ "SeekEnd" OpHelp(""), + /* 131 */ "IdxInsert" OpHelp("key=r[P2]"), + /* 132 */ "SorterInsert" OpHelp("key=r[P2]"), + /* 133 */ "IdxDelete" OpHelp("key=r[P2@P3]"), + /* 134 */ "DeferredSeek" OpHelp("Move P3 to P1.rowid if needed"), + /* 135 */ "IdxRowid" OpHelp("r[P2]=rowid"), + /* 136 */ "FinishSeek" OpHelp(""), + /* 137 */ "Destroy" OpHelp(""), + /* 138 */ "Clear" OpHelp(""), + /* 139 */ "ResetSorter" OpHelp(""), + /* 140 */ "CreateBtree" OpHelp("r[P2]=root iDb=P1 flags=P3"), + /* 141 */ "SqlExec" OpHelp(""), + /* 142 */ "ParseSchema" OpHelp(""), + /* 143 */ "LoadAnalysis" OpHelp(""), + /* 144 */ "DropTable" OpHelp(""), + /* 145 */ "DropIndex" OpHelp(""), + /* 146 */ "DropTrigger" OpHelp(""), + /* 147 */ "IntegrityCk" OpHelp(""), + /* 148 */ "RowSetAdd" OpHelp("rowset(P1)=r[P2]"), + /* 149 */ "Param" OpHelp(""), + /* 150 */ "Real" OpHelp("r[P2]=P4"), + /* 151 */ "FkCounter" OpHelp("fkctr[P1]+=P2"), + /* 152 */ "MemMax" OpHelp("r[P1]=max(r[P1],r[P2])"), + /* 153 */ "OffsetLimit" OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"), + /* 154 */ "AggInverse" OpHelp("accum=r[P3] inverse(r[P2@P5])"), + /* 155 */ "AggStep" OpHelp("accum=r[P3] step(r[P2@P5])"), + /* 156 */ "AggStep1" OpHelp("accum=r[P3] step(r[P2@P5])"), + /* 157 */ "AggValue" OpHelp("r[P3]=value N=P2"), + /* 158 */ "AggFinal" OpHelp("accum=r[P1] N=P2"), + /* 159 */ "Expire" OpHelp(""), + /* 160 */ "CursorLock" OpHelp(""), + /* 161 */ "CursorUnlock" OpHelp(""), + /* 162 */ "TableLock" OpHelp("iDb=P1 root=P2 write=P3"), + /* 163 */ "VBegin" OpHelp(""), + /* 164 */ "VCreate" OpHelp(""), + /* 165 */ "VDestroy" OpHelp(""), + /* 166 */ "VOpen" OpHelp(""), + /* 167 */ "VColumn" OpHelp("r[P3]=vcolumn(P2)"), + /* 168 */ "VRename" OpHelp(""), + /* 169 */ "Pagecount" OpHelp(""), + /* 170 */ "MaxPgcnt" OpHelp(""), + /* 171 */ "Trace" OpHelp(""), + /* 172 */ "CursorHint" OpHelp(""), + /* 173 */ "ReleaseReg" OpHelp("release r[P1@P2] mask P3"), + /* 174 */ "Noop" OpHelp(""), + /* 175 */ "Explain" OpHelp(""), + /* 176 */ "Abortable" OpHelp(""), + }; + return azName[i]; +} +#endif + +/************** End of opcodes.c *********************************************/ +/************** Begin file os_unix.c *****************************************/ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains the VFS implementation for unix-like operating systems +** include Linux, MacOSX, *BSD, QNX, VxWorks, AIX, HPUX, and others. +** +** There are actually several different VFS implementations in this file. +** The differences are in the way that file locking is done. The default +** implementation uses Posix Advisory Locks. Alternative implementations +** use flock(), dot-files, various proprietary locking schemas, or simply +** skip locking all together. +** +** This source file is organized into divisions where the logic for various +** subfunctions is contained within the appropriate division. PLEASE +** KEEP THE STRUCTURE OF THIS FILE INTACT. New code should be placed +** in the correct division and should be clearly labeled. +** +** The layout of divisions is as follows: +** +** * General-purpose declarations and utility functions. +** * Unique file ID logic used by VxWorks. +** * Various locking primitive implementations (all except proxy locking): +** + for Posix Advisory Locks +** + for no-op locks +** + for dot-file locks +** + for flock() locking +** + for named semaphore locks (VxWorks only) +** + for AFP filesystem locks (MacOSX only) +** * sqlite3_file methods not associated with locking. +** * Definitions of sqlite3_io_methods objects for all locking +** methods plus "finder" functions for each locking method. +** * sqlite3_vfs method implementations. +** * Locking primitives for the proxy uber-locking-method. (MacOSX only) +** * Definitions of sqlite3_vfs objects for all locking methods +** plus implementations of sqlite3_os_init() and sqlite3_os_end(). +*/ +/* #include "sqliteInt.h" */ +#if SQLITE_OS_UNIX /* This file is used on unix only */ + +/* +** There are various methods for file locking used for concurrency +** control: +** +** 1. POSIX locking (the default), +** 2. No locking, +** 3. Dot-file locking, +** 4. flock() locking, +** 5. AFP locking (OSX only), +** 6. Named POSIX semaphores (VXWorks only), +** 7. proxy locking. (OSX only) +** +** Styles 4, 5, and 7 are only available of SQLITE_ENABLE_LOCKING_STYLE +** is defined to 1. The SQLITE_ENABLE_LOCKING_STYLE also enables automatic +** selection of the appropriate locking style based on the filesystem +** where the database is located. +*/ +#if !defined(SQLITE_ENABLE_LOCKING_STYLE) +# if defined(__APPLE__) +# define SQLITE_ENABLE_LOCKING_STYLE 1 +# else +# define SQLITE_ENABLE_LOCKING_STYLE 0 +# endif +#endif + +/* Use pread() and pwrite() if they are available */ +#if defined(__APPLE__) +# define HAVE_PREAD 1 +# define HAVE_PWRITE 1 +#endif +#if defined(HAVE_PREAD64) && defined(HAVE_PWRITE64) +# undef USE_PREAD +# define USE_PREAD64 1 +#elif defined(HAVE_PREAD) && defined(HAVE_PWRITE) +# undef USE_PREAD64 +# define USE_PREAD 1 +#endif + +/* +** standard include files. +*/ +#include +#include +#include +#include +#include +/* #include */ +#include +#include +#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 +# include +#endif + +#if SQLITE_ENABLE_LOCKING_STYLE +/* # include */ +# include +# include +#endif /* SQLITE_ENABLE_LOCKING_STYLE */ + +/* +** Try to determine if gethostuuid() is available based on standard +** macros. This might sometimes compute the wrong value for some +** obscure platforms. For those cases, simply compile with one of +** the following: +** +** -DHAVE_GETHOSTUUID=0 +** -DHAVE_GETHOSTUUID=1 +** +** None if this matters except when building on Apple products with +** -DSQLITE_ENABLE_LOCKING_STYLE. +*/ +#ifndef HAVE_GETHOSTUUID +# define HAVE_GETHOSTUUID 0 +# if defined(__APPLE__) && ((__MAC_OS_X_VERSION_MIN_REQUIRED > 1050) || \ + (__IPHONE_OS_VERSION_MIN_REQUIRED > 2000)) +# if (!defined(TARGET_OS_EMBEDDED) || (TARGET_OS_EMBEDDED==0)) \ + && (!defined(TARGET_IPHONE_SIMULATOR) || (TARGET_IPHONE_SIMULATOR==0))\ + && (!defined(TARGET_OS_MACCATALYST) || (TARGET_OS_MACCATALYST==0)) +# undef HAVE_GETHOSTUUID +# define HAVE_GETHOSTUUID 1 +# else +# warning "gethostuuid() is disabled." +# endif +# endif +#endif + + +#if OS_VXWORKS +/* # include */ +# include +# include +#endif /* OS_VXWORKS */ + +#if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE +# include +#endif + +#ifdef HAVE_UTIME +# include +#endif + +/* +** Allowed values of unixFile.fsFlags +*/ +#define SQLITE_FSFLAGS_IS_MSDOS 0x1 + +/* +** If we are to be thread-safe, include the pthreads header. +*/ +#if SQLITE_THREADSAFE +/* # include */ +#endif + +/* +** Default permissions when creating a new file +*/ +#ifndef SQLITE_DEFAULT_FILE_PERMISSIONS +# define SQLITE_DEFAULT_FILE_PERMISSIONS 0644 +#endif + +/* +** Default permissions when creating auto proxy dir +*/ +#ifndef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS +# define SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755 +#endif + +/* +** Maximum supported path-length. +*/ +#define MAX_PATHNAME 512 + +/* +** Maximum supported symbolic links +*/ +#define SQLITE_MAX_SYMLINKS 100 + +/* Always cast the getpid() return type for compatibility with +** kernel modules in VxWorks. */ +#define osGetpid(X) (pid_t)getpid() + +/* +** Only set the lastErrno if the error code is a real error and not +** a normal expected return code of SQLITE_BUSY or SQLITE_OK +*/ +#define IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY)) + +/* Forward references */ +typedef struct unixShm unixShm; /* Connection shared memory */ +typedef struct unixShmNode unixShmNode; /* Shared memory instance */ +typedef struct unixInodeInfo unixInodeInfo; /* An i-node */ +typedef struct UnixUnusedFd UnixUnusedFd; /* An unused file descriptor */ + +/* +** Sometimes, after a file handle is closed by SQLite, the file descriptor +** cannot be closed immediately. In these cases, instances of the following +** structure are used to store the file descriptor while waiting for an +** opportunity to either close or reuse it. +*/ +struct UnixUnusedFd { + int fd; /* File descriptor to close */ + int flags; /* Flags this file descriptor was opened with */ + UnixUnusedFd *pNext; /* Next unused file descriptor on same file */ +}; + +/* +** The unixFile structure is subclass of sqlite3_file specific to the unix +** VFS implementations. +*/ +typedef struct unixFile unixFile; +struct unixFile { + sqlite3_io_methods const *pMethod; /* Always the first entry */ + sqlite3_vfs *pVfs; /* The VFS that created this unixFile */ + unixInodeInfo *pInode; /* Info about locks on this inode */ + int h; /* The file descriptor */ + unsigned char eFileLock; /* The type of lock held on this fd */ + unsigned short int ctrlFlags; /* Behavioral bits. UNIXFILE_* flags */ + int lastErrno; /* The unix errno from last I/O error */ + void *lockingContext; /* Locking style specific state */ + UnixUnusedFd *pPreallocatedUnused; /* Pre-allocated UnixUnusedFd */ + const char *zPath; /* Name of the file */ + unixShm *pShm; /* Shared memory segment information */ + int szChunk; /* Configured by FCNTL_CHUNK_SIZE */ +#if SQLITE_MAX_MMAP_SIZE>0 + int nFetchOut; /* Number of outstanding xFetch refs */ + sqlite3_int64 mmapSize; /* Usable size of mapping at pMapRegion */ + sqlite3_int64 mmapSizeActual; /* Actual size of mapping at pMapRegion */ + sqlite3_int64 mmapSizeMax; /* Configured FCNTL_MMAP_SIZE value */ + void *pMapRegion; /* Memory mapped region */ +#endif + int sectorSize; /* Device sector size */ + int deviceCharacteristics; /* Precomputed device characteristics */ +#if SQLITE_ENABLE_LOCKING_STYLE + int openFlags; /* The flags specified at open() */ +#endif +#if SQLITE_ENABLE_LOCKING_STYLE || defined(__APPLE__) + unsigned fsFlags; /* cached details from statfs() */ +#endif +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + unsigned iBusyTimeout; /* Wait this many millisec on locks */ +#endif +#if OS_VXWORKS + struct vxworksFileId *pId; /* Unique file ID */ +#endif +#ifdef SQLITE_DEBUG + /* The next group of variables are used to track whether or not the + ** transaction counter in bytes 24-27 of database files are updated + ** whenever any part of the database changes. An assertion fault will + ** occur if a file is updated without also updating the transaction + ** counter. This test is made to avoid new problems similar to the + ** one described by ticket #3584. + */ + unsigned char transCntrChng; /* True if the transaction counter changed */ + unsigned char dbUpdate; /* True if any part of database file changed */ + unsigned char inNormalWrite; /* True if in a normal write operation */ + +#endif + +#ifdef SQLITE_TEST + /* In test mode, increase the size of this structure a bit so that + ** it is larger than the struct CrashFile defined in test6.c. + */ + char aPadding[32]; +#endif +}; + +/* This variable holds the process id (pid) from when the xRandomness() +** method was called. If xOpen() is called from a different process id, +** indicating that a fork() has occurred, the PRNG will be reset. +*/ +static pid_t randomnessPid = 0; + +/* +** Allowed values for the unixFile.ctrlFlags bitmask: +*/ +#define UNIXFILE_EXCL 0x01 /* Connections from one process only */ +#define UNIXFILE_RDONLY 0x02 /* Connection is read only */ +#define UNIXFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */ +#ifndef SQLITE_DISABLE_DIRSYNC +# define UNIXFILE_DIRSYNC 0x08 /* Directory sync needed */ +#else +# define UNIXFILE_DIRSYNC 0x00 +#endif +#define UNIXFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */ +#define UNIXFILE_DELETE 0x20 /* Delete on close */ +#define UNIXFILE_URI 0x40 /* Filename might have query parameters */ +#define UNIXFILE_NOLOCK 0x80 /* Do no file locking */ + +/* +** Include code that is common to all os_*.c files +*/ +/************** Include os_common.h in the middle of os_unix.c ***************/ +/************** Begin file os_common.h ***************************************/ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains macros and a little bit of code that is common to +** all of the platform-specific files (os_*.c) and is #included into those +** files. +** +** This file should be #included by the os_*.c files only. It is not a +** general purpose header file. +*/ +#ifndef _OS_COMMON_H_ +#define _OS_COMMON_H_ + +/* +** At least two bugs have slipped in because we changed the MEMORY_DEBUG +** macro to SQLITE_DEBUG and some older makefiles have not yet made the +** switch. The following code should catch this problem at compile-time. +*/ +#ifdef MEMORY_DEBUG +# error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead." +#endif + +/* +** Macros for performance tracing. Normally turned off. Only works +** on i486 hardware. +*/ +#ifdef SQLITE_PERFORMANCE_TRACE + +/* +** hwtime.h contains inline assembler code for implementing +** high-performance timing routines. +*/ +/************** Include hwtime.h in the middle of os_common.h ****************/ +/************** Begin file hwtime.h ******************************************/ +/* +** 2008 May 27 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains inline asm code for retrieving "high-performance" +** counters for x86 and x86_64 class CPUs. +*/ +#ifndef SQLITE_HWTIME_H +#define SQLITE_HWTIME_H + +/* +** The following routine only works on pentium-class (or newer) processors. +** It uses the RDTSC opcode to read the cycle count value out of the +** processor and returns that value. This can be used for high-res +** profiling. +*/ +#if !defined(__STRICT_ANSI__) && \ + (defined(__GNUC__) || defined(_MSC_VER)) && \ + (defined(i386) || defined(__i386__) || defined(_M_IX86)) + + #if defined(__GNUC__) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned int lo, hi; + __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); + return (sqlite_uint64)hi << 32 | lo; + } + + #elif defined(_MSC_VER) + + __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){ + __asm { + rdtsc + ret ; return value at EDX:EAX + } + } + + #endif + +#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long val; + __asm__ __volatile__ ("rdtsc" : "=A" (val)); + return val; + } + +#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long long retval; + unsigned long junk; + __asm__ __volatile__ ("\n\ + 1: mftbu %1\n\ + mftb %L0\n\ + mftbu %0\n\ + cmpw %0,%1\n\ + bne 1b" + : "=r" (retval), "=r" (junk)); + return retval; + } + +#else + + /* + ** asm() is needed for hardware timing support. Without asm(), + ** disable the sqlite3Hwtime() routine. + ** + ** sqlite3Hwtime() is only used for some obscure debugging + ** and analysis configurations, not in any deliverable, so this + ** should not be a great loss. + */ +SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); } + +#endif + +#endif /* !defined(SQLITE_HWTIME_H) */ + +/************** End of hwtime.h **********************************************/ +/************** Continuing where we left off in os_common.h ******************/ + +static sqlite_uint64 g_start; +static sqlite_uint64 g_elapsed; +#define TIMER_START g_start=sqlite3Hwtime() +#define TIMER_END g_elapsed=sqlite3Hwtime()-g_start +#define TIMER_ELAPSED g_elapsed +#else +#define TIMER_START +#define TIMER_END +#define TIMER_ELAPSED ((sqlite_uint64)0) +#endif + +/* +** If we compile with the SQLITE_TEST macro set, then the following block +** of code will give us the ability to simulate a disk I/O error. This +** is used for testing the I/O recovery logic. +*/ +#if defined(SQLITE_TEST) +SQLITE_API extern int sqlite3_io_error_hit; +SQLITE_API extern int sqlite3_io_error_hardhit; +SQLITE_API extern int sqlite3_io_error_pending; +SQLITE_API extern int sqlite3_io_error_persist; +SQLITE_API extern int sqlite3_io_error_benign; +SQLITE_API extern int sqlite3_diskfull_pending; +SQLITE_API extern int sqlite3_diskfull; +#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X) +#define SimulateIOError(CODE) \ + if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \ + || sqlite3_io_error_pending-- == 1 ) \ + { local_ioerr(); CODE; } +static void local_ioerr(){ + IOTRACE(("IOERR\n")); + sqlite3_io_error_hit++; + if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++; +} +#define SimulateDiskfullError(CODE) \ + if( sqlite3_diskfull_pending ){ \ + if( sqlite3_diskfull_pending == 1 ){ \ + local_ioerr(); \ + sqlite3_diskfull = 1; \ + sqlite3_io_error_hit = 1; \ + CODE; \ + }else{ \ + sqlite3_diskfull_pending--; \ + } \ + } +#else +#define SimulateIOErrorBenign(X) +#define SimulateIOError(A) +#define SimulateDiskfullError(A) +#endif /* defined(SQLITE_TEST) */ + +/* +** When testing, keep a count of the number of open files. +*/ +#if defined(SQLITE_TEST) +SQLITE_API extern int sqlite3_open_file_count; +#define OpenCounter(X) sqlite3_open_file_count+=(X) +#else +#define OpenCounter(X) +#endif /* defined(SQLITE_TEST) */ + +#endif /* !defined(_OS_COMMON_H_) */ + +/************** End of os_common.h *******************************************/ +/************** Continuing where we left off in os_unix.c ********************/ + +/* +** Define various macros that are missing from some systems. +*/ +#ifndef O_LARGEFILE +# define O_LARGEFILE 0 +#endif +#ifdef SQLITE_DISABLE_LFS +# undef O_LARGEFILE +# define O_LARGEFILE 0 +#endif +#ifndef O_NOFOLLOW +# define O_NOFOLLOW 0 +#endif +#ifndef O_BINARY +# define O_BINARY 0 +#endif + +/* +** The threadid macro resolves to the thread-id or to 0. Used for +** testing and debugging only. +*/ +#if SQLITE_THREADSAFE +#define threadid pthread_self() +#else +#define threadid 0 +#endif + +/* +** HAVE_MREMAP defaults to true on Linux and false everywhere else. +*/ +#if !defined(HAVE_MREMAP) +# if defined(__linux__) && defined(_GNU_SOURCE) +# define HAVE_MREMAP 1 +# else +# define HAVE_MREMAP 0 +# endif +#endif + +/* +** Explicitly call the 64-bit version of lseek() on Android. Otherwise, lseek() +** is the 32-bit version, even if _FILE_OFFSET_BITS=64 is defined. +*/ +#ifdef __ANDROID__ +# define lseek lseek64 +#endif + +#ifdef __linux__ +/* +** Linux-specific IOCTL magic numbers used for controlling F2FS +*/ +#define F2FS_IOCTL_MAGIC 0xf5 +#define F2FS_IOC_START_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 1) +#define F2FS_IOC_COMMIT_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 2) +#define F2FS_IOC_START_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 3) +#define F2FS_IOC_ABORT_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 5) +#define F2FS_IOC_GET_FEATURES _IOR(F2FS_IOCTL_MAGIC, 12, u32) +#define F2FS_FEATURE_ATOMIC_WRITE 0x0004 +#endif /* __linux__ */ + + +/* +** Different Unix systems declare open() in different ways. Same use +** open(const char*,int,mode_t). Others use open(const char*,int,...). +** The difference is important when using a pointer to the function. +** +** The safest way to deal with the problem is to always use this wrapper +** which always has the same well-defined interface. +*/ +static int posixOpen(const char *zFile, int flags, int mode){ + return open(zFile, flags, mode); +} + +/* Forward reference */ +static int openDirectory(const char*, int*); +static int unixGetpagesize(void); + +/* +** Many system calls are accessed through pointer-to-functions so that +** they may be overridden at runtime to facilitate fault injection during +** testing and sandboxing. The following array holds the names and pointers +** to all overrideable system calls. +*/ +static struct unix_syscall { + const char *zName; /* Name of the system call */ + sqlite3_syscall_ptr pCurrent; /* Current value of the system call */ + sqlite3_syscall_ptr pDefault; /* Default value */ +} aSyscall[] = { + { "open", (sqlite3_syscall_ptr)posixOpen, 0 }, +#define osOpen ((int(*)(const char*,int,int))aSyscall[0].pCurrent) + + { "close", (sqlite3_syscall_ptr)close, 0 }, +#define osClose ((int(*)(int))aSyscall[1].pCurrent) + + { "access", (sqlite3_syscall_ptr)access, 0 }, +#define osAccess ((int(*)(const char*,int))aSyscall[2].pCurrent) + + { "getcwd", (sqlite3_syscall_ptr)getcwd, 0 }, +#define osGetcwd ((char*(*)(char*,size_t))aSyscall[3].pCurrent) + + { "stat", (sqlite3_syscall_ptr)stat, 0 }, +#define osStat ((int(*)(const char*,struct stat*))aSyscall[4].pCurrent) + +/* +** The DJGPP compiler environment looks mostly like Unix, but it +** lacks the fcntl() system call. So redefine fcntl() to be something +** that always succeeds. This means that locking does not occur under +** DJGPP. But it is DOS - what did you expect? +*/ +#ifdef __DJGPP__ + { "fstat", 0, 0 }, +#define osFstat(a,b,c) 0 +#else + { "fstat", (sqlite3_syscall_ptr)fstat, 0 }, +#define osFstat ((int(*)(int,struct stat*))aSyscall[5].pCurrent) +#endif + + { "ftruncate", (sqlite3_syscall_ptr)ftruncate, 0 }, +#define osFtruncate ((int(*)(int,off_t))aSyscall[6].pCurrent) + + { "fcntl", (sqlite3_syscall_ptr)fcntl, 0 }, +#define osFcntl ((int(*)(int,int,...))aSyscall[7].pCurrent) + + { "read", (sqlite3_syscall_ptr)read, 0 }, +#define osRead ((ssize_t(*)(int,void*,size_t))aSyscall[8].pCurrent) + +#if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE + { "pread", (sqlite3_syscall_ptr)pread, 0 }, +#else + { "pread", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osPread ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].pCurrent) + +#if defined(USE_PREAD64) + { "pread64", (sqlite3_syscall_ptr)pread64, 0 }, +#else + { "pread64", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osPread64 ((ssize_t(*)(int,void*,size_t,off64_t))aSyscall[10].pCurrent) + + { "write", (sqlite3_syscall_ptr)write, 0 }, +#define osWrite ((ssize_t(*)(int,const void*,size_t))aSyscall[11].pCurrent) + +#if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE + { "pwrite", (sqlite3_syscall_ptr)pwrite, 0 }, +#else + { "pwrite", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osPwrite ((ssize_t(*)(int,const void*,size_t,off_t))\ + aSyscall[12].pCurrent) + +#if defined(USE_PREAD64) + { "pwrite64", (sqlite3_syscall_ptr)pwrite64, 0 }, +#else + { "pwrite64", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osPwrite64 ((ssize_t(*)(int,const void*,size_t,off64_t))\ + aSyscall[13].pCurrent) + + { "fchmod", (sqlite3_syscall_ptr)fchmod, 0 }, +#define osFchmod ((int(*)(int,mode_t))aSyscall[14].pCurrent) + +#if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE + { "fallocate", (sqlite3_syscall_ptr)posix_fallocate, 0 }, +#else + { "fallocate", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent) + + { "unlink", (sqlite3_syscall_ptr)unlink, 0 }, +#define osUnlink ((int(*)(const char*))aSyscall[16].pCurrent) + + { "openDirectory", (sqlite3_syscall_ptr)openDirectory, 0 }, +#define osOpenDirectory ((int(*)(const char*,int*))aSyscall[17].pCurrent) + + { "mkdir", (sqlite3_syscall_ptr)mkdir, 0 }, +#define osMkdir ((int(*)(const char*,mode_t))aSyscall[18].pCurrent) + + { "rmdir", (sqlite3_syscall_ptr)rmdir, 0 }, +#define osRmdir ((int(*)(const char*))aSyscall[19].pCurrent) + +#if defined(HAVE_FCHOWN) + { "fchown", (sqlite3_syscall_ptr)fchown, 0 }, +#else + { "fchown", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osFchown ((int(*)(int,uid_t,gid_t))aSyscall[20].pCurrent) + +#if defined(HAVE_FCHOWN) + { "geteuid", (sqlite3_syscall_ptr)geteuid, 0 }, +#else + { "geteuid", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osGeteuid ((uid_t(*)(void))aSyscall[21].pCurrent) + +#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 + { "mmap", (sqlite3_syscall_ptr)mmap, 0 }, +#else + { "mmap", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osMmap ((void*(*)(void*,size_t,int,int,int,off_t))aSyscall[22].pCurrent) + +#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 + { "munmap", (sqlite3_syscall_ptr)munmap, 0 }, +#else + { "munmap", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osMunmap ((int(*)(void*,size_t))aSyscall[23].pCurrent) + +#if HAVE_MREMAP && (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) + { "mremap", (sqlite3_syscall_ptr)mremap, 0 }, +#else + { "mremap", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osMremap ((void*(*)(void*,size_t,size_t,int,...))aSyscall[24].pCurrent) + +#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 + { "getpagesize", (sqlite3_syscall_ptr)unixGetpagesize, 0 }, +#else + { "getpagesize", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osGetpagesize ((int(*)(void))aSyscall[25].pCurrent) + +#if defined(HAVE_READLINK) + { "readlink", (sqlite3_syscall_ptr)readlink, 0 }, +#else + { "readlink", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osReadlink ((ssize_t(*)(const char*,char*,size_t))aSyscall[26].pCurrent) + +#if defined(HAVE_LSTAT) + { "lstat", (sqlite3_syscall_ptr)lstat, 0 }, +#else + { "lstat", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osLstat ((int(*)(const char*,struct stat*))aSyscall[27].pCurrent) + +#if defined(__linux__) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE) +# ifdef __ANDROID__ + { "ioctl", (sqlite3_syscall_ptr)(int(*)(int, int, ...))ioctl, 0 }, +#define osIoctl ((int(*)(int,int,...))aSyscall[28].pCurrent) +# else + { "ioctl", (sqlite3_syscall_ptr)ioctl, 0 }, +#define osIoctl ((int(*)(int,unsigned long,...))aSyscall[28].pCurrent) +# endif +#else + { "ioctl", (sqlite3_syscall_ptr)0, 0 }, +#endif + +}; /* End of the overrideable system calls */ + + +/* +** On some systems, calls to fchown() will trigger a message in a security +** log if they come from non-root processes. So avoid calling fchown() if +** we are not running as root. +*/ +static int robustFchown(int fd, uid_t uid, gid_t gid){ +#if defined(HAVE_FCHOWN) + return osGeteuid() ? 0 : osFchown(fd,uid,gid); +#else + return 0; +#endif +} + +/* +** This is the xSetSystemCall() method of sqlite3_vfs for all of the +** "unix" VFSes. Return SQLITE_OK opon successfully updating the +** system call pointer, or SQLITE_NOTFOUND if there is no configurable +** system call named zName. +*/ +static int unixSetSystemCall( + sqlite3_vfs *pNotUsed, /* The VFS pointer. Not used */ + const char *zName, /* Name of system call to override */ + sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */ +){ + unsigned int i; + int rc = SQLITE_NOTFOUND; + + UNUSED_PARAMETER(pNotUsed); + if( zName==0 ){ + /* If no zName is given, restore all system calls to their default + ** settings and return NULL + */ + rc = SQLITE_OK; + for(i=0; i=SQLITE_MINIMUM_FILE_DESCRIPTOR ) break; + osClose(fd); + sqlite3_log(SQLITE_WARNING, + "attempt to open \"%s\" as file descriptor %d", z, fd); + fd = -1; + if( osOpen("/dev/null", O_RDONLY, m)<0 ) break; + } + if( fd>=0 ){ + if( m!=0 ){ + struct stat statbuf; + if( osFstat(fd, &statbuf)==0 + && statbuf.st_size==0 + && (statbuf.st_mode&0777)!=m + ){ + osFchmod(fd, m); + } + } +#if defined(FD_CLOEXEC) && (!defined(O_CLOEXEC) || O_CLOEXEC==0) + osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC); +#endif + } + return fd; +} + +/* +** Helper functions to obtain and relinquish the global mutex. The +** global mutex is used to protect the unixInodeInfo and +** vxworksFileId objects used by this file, all of which may be +** shared by multiple threads. +** +** Function unixMutexHeld() is used to assert() that the global mutex +** is held when required. This function is only used as part of assert() +** statements. e.g. +** +** unixEnterMutex() +** assert( unixMutexHeld() ); +** unixEnterLeave() +** +** To prevent deadlock, the global unixBigLock must must be acquired +** before the unixInodeInfo.pLockMutex mutex, if both are held. It is +** OK to get the pLockMutex without holding unixBigLock first, but if +** that happens, the unixBigLock mutex must not be acquired until after +** pLockMutex is released. +** +** OK: enter(unixBigLock), enter(pLockInfo) +** OK: enter(unixBigLock) +** OK: enter(pLockInfo) +** ERROR: enter(pLockInfo), enter(unixBigLock) +*/ +static sqlite3_mutex *unixBigLock = 0; +static void unixEnterMutex(void){ + assert( sqlite3_mutex_notheld(unixBigLock) ); /* Not a recursive mutex */ + sqlite3_mutex_enter(unixBigLock); +} +static void unixLeaveMutex(void){ + assert( sqlite3_mutex_held(unixBigLock) ); + sqlite3_mutex_leave(unixBigLock); +} +#ifdef SQLITE_DEBUG +static int unixMutexHeld(void) { + return sqlite3_mutex_held(unixBigLock); +} +#endif + + +#ifdef SQLITE_HAVE_OS_TRACE +/* +** Helper function for printing out trace information from debugging +** binaries. This returns the string representation of the supplied +** integer lock-type. +*/ +static const char *azFileLock(int eFileLock){ + switch( eFileLock ){ + case NO_LOCK: return "NONE"; + case SHARED_LOCK: return "SHARED"; + case RESERVED_LOCK: return "RESERVED"; + case PENDING_LOCK: return "PENDING"; + case EXCLUSIVE_LOCK: return "EXCLUSIVE"; + } + return "ERROR"; +} +#endif + +#ifdef SQLITE_LOCK_TRACE +/* +** Print out information about all locking operations. +** +** This routine is used for troubleshooting locks on multithreaded +** platforms. Enable by compiling with the -DSQLITE_LOCK_TRACE +** command-line option on the compiler. This code is normally +** turned off. +*/ +static int lockTrace(int fd, int op, struct flock *p){ + char *zOpName, *zType; + int s; + int savedErrno; + if( op==F_GETLK ){ + zOpName = "GETLK"; + }else if( op==F_SETLK ){ + zOpName = "SETLK"; + }else{ + s = osFcntl(fd, op, p); + sqlite3DebugPrintf("fcntl unknown %d %d %d\n", fd, op, s); + return s; + } + if( p->l_type==F_RDLCK ){ + zType = "RDLCK"; + }else if( p->l_type==F_WRLCK ){ + zType = "WRLCK"; + }else if( p->l_type==F_UNLCK ){ + zType = "UNLCK"; + }else{ + assert( 0 ); + } + assert( p->l_whence==SEEK_SET ); + s = osFcntl(fd, op, p); + savedErrno = errno; + sqlite3DebugPrintf("fcntl %d %d %s %s %d %d %d %d\n", + threadid, fd, zOpName, zType, (int)p->l_start, (int)p->l_len, + (int)p->l_pid, s); + if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){ + struct flock l2; + l2 = *p; + osFcntl(fd, F_GETLK, &l2); + if( l2.l_type==F_RDLCK ){ + zType = "RDLCK"; + }else if( l2.l_type==F_WRLCK ){ + zType = "WRLCK"; + }else if( l2.l_type==F_UNLCK ){ + zType = "UNLCK"; + }else{ + assert( 0 ); + } + sqlite3DebugPrintf("fcntl-failure-reason: %s %d %d %d\n", + zType, (int)l2.l_start, (int)l2.l_len, (int)l2.l_pid); + } + errno = savedErrno; + return s; +} +#undef osFcntl +#define osFcntl lockTrace +#endif /* SQLITE_LOCK_TRACE */ + +/* +** Retry ftruncate() calls that fail due to EINTR +** +** All calls to ftruncate() within this file should be made through +** this wrapper. On the Android platform, bypassing the logic below +** could lead to a corrupt database. +*/ +static int robust_ftruncate(int h, sqlite3_int64 sz){ + int rc; +#ifdef __ANDROID__ + /* On Android, ftruncate() always uses 32-bit offsets, even if + ** _FILE_OFFSET_BITS=64 is defined. This means it is unsafe to attempt to + ** truncate a file to any size larger than 2GiB. Silently ignore any + ** such attempts. */ + if( sz>(sqlite3_int64)0x7FFFFFFF ){ + rc = SQLITE_OK; + }else +#endif + do{ rc = osFtruncate(h,sz); }while( rc<0 && errno==EINTR ); + return rc; +} + +/* +** This routine translates a standard POSIX errno code into something +** useful to the clients of the sqlite3 functions. Specifically, it is +** intended to translate a variety of "try again" errors into SQLITE_BUSY +** and a variety of "please close the file descriptor NOW" errors into +** SQLITE_IOERR +** +** Errors during initialization of locks, or file system support for locks, +** should handle ENOLCK, ENOTSUP, EOPNOTSUPP separately. +*/ +static int sqliteErrorFromPosixError(int posixError, int sqliteIOErr) { + assert( (sqliteIOErr == SQLITE_IOERR_LOCK) || + (sqliteIOErr == SQLITE_IOERR_UNLOCK) || + (sqliteIOErr == SQLITE_IOERR_RDLOCK) || + (sqliteIOErr == SQLITE_IOERR_CHECKRESERVEDLOCK) ); + switch (posixError) { + case EACCES: + case EAGAIN: + case ETIMEDOUT: + case EBUSY: + case EINTR: + case ENOLCK: + /* random NFS retry error, unless during file system support + * introspection, in which it actually means what it says */ + return SQLITE_BUSY; + + case EPERM: + return SQLITE_PERM; + + default: + return sqliteIOErr; + } +} + + +/****************************************************************************** +****************** Begin Unique File ID Utility Used By VxWorks *************** +** +** On most versions of unix, we can get a unique ID for a file by concatenating +** the device number and the inode number. But this does not work on VxWorks. +** On VxWorks, a unique file id must be based on the canonical filename. +** +** A pointer to an instance of the following structure can be used as a +** unique file ID in VxWorks. Each instance of this structure contains +** a copy of the canonical filename. There is also a reference count. +** The structure is reclaimed when the number of pointers to it drops to +** zero. +** +** There are never very many files open at one time and lookups are not +** a performance-critical path, so it is sufficient to put these +** structures on a linked list. +*/ +struct vxworksFileId { + struct vxworksFileId *pNext; /* Next in a list of them all */ + int nRef; /* Number of references to this one */ + int nName; /* Length of the zCanonicalName[] string */ + char *zCanonicalName; /* Canonical filename */ +}; + +#if OS_VXWORKS +/* +** All unique filenames are held on a linked list headed by this +** variable: +*/ +static struct vxworksFileId *vxworksFileList = 0; + +/* +** Simplify a filename into its canonical form +** by making the following changes: +** +** * removing any trailing and duplicate / +** * convert /./ into just / +** * convert /A/../ where A is any simple name into just / +** +** Changes are made in-place. Return the new name length. +** +** The original filename is in z[0..n-1]. Return the number of +** characters in the simplified name. +*/ +static int vxworksSimplifyName(char *z, int n){ + int i, j; + while( n>1 && z[n-1]=='/' ){ n--; } + for(i=j=0; i0 && z[j-1]!='/' ){ j--; } + if( j>0 ){ j--; } + i += 2; + continue; + } + } + z[j++] = z[i]; + } + z[j] = 0; + return j; +} + +/* +** Find a unique file ID for the given absolute pathname. Return +** a pointer to the vxworksFileId object. This pointer is the unique +** file ID. +** +** The nRef field of the vxworksFileId object is incremented before +** the object is returned. A new vxworksFileId object is created +** and added to the global list if necessary. +** +** If a memory allocation error occurs, return NULL. +*/ +static struct vxworksFileId *vxworksFindFileId(const char *zAbsoluteName){ + struct vxworksFileId *pNew; /* search key and new file ID */ + struct vxworksFileId *pCandidate; /* For looping over existing file IDs */ + int n; /* Length of zAbsoluteName string */ + + assert( zAbsoluteName[0]=='/' ); + n = (int)strlen(zAbsoluteName); + pNew = sqlite3_malloc64( sizeof(*pNew) + (n+1) ); + if( pNew==0 ) return 0; + pNew->zCanonicalName = (char*)&pNew[1]; + memcpy(pNew->zCanonicalName, zAbsoluteName, n+1); + n = vxworksSimplifyName(pNew->zCanonicalName, n); + + /* Search for an existing entry that matching the canonical name. + ** If found, increment the reference count and return a pointer to + ** the existing file ID. + */ + unixEnterMutex(); + for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){ + if( pCandidate->nName==n + && memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0 + ){ + sqlite3_free(pNew); + pCandidate->nRef++; + unixLeaveMutex(); + return pCandidate; + } + } + + /* No match was found. We will make a new file ID */ + pNew->nRef = 1; + pNew->nName = n; + pNew->pNext = vxworksFileList; + vxworksFileList = pNew; + unixLeaveMutex(); + return pNew; +} + +/* +** Decrement the reference count on a vxworksFileId object. Free +** the object when the reference count reaches zero. +*/ +static void vxworksReleaseFileId(struct vxworksFileId *pId){ + unixEnterMutex(); + assert( pId->nRef>0 ); + pId->nRef--; + if( pId->nRef==0 ){ + struct vxworksFileId **pp; + for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){} + assert( *pp==pId ); + *pp = pId->pNext; + sqlite3_free(pId); + } + unixLeaveMutex(); +} +#endif /* OS_VXWORKS */ +/*************** End of Unique File ID Utility Used By VxWorks **************** +******************************************************************************/ + + +/****************************************************************************** +*************************** Posix Advisory Locking **************************** +** +** POSIX advisory locks are broken by design. ANSI STD 1003.1 (1996) +** section 6.5.2.2 lines 483 through 490 specify that when a process +** sets or clears a lock, that operation overrides any prior locks set +** by the same process. It does not explicitly say so, but this implies +** that it overrides locks set by the same process using a different +** file descriptor. Consider this test case: +** +** int fd1 = open("./file1", O_RDWR|O_CREAT, 0644); +** int fd2 = open("./file2", O_RDWR|O_CREAT, 0644); +** +** Suppose ./file1 and ./file2 are really the same file (because +** one is a hard or symbolic link to the other) then if you set +** an exclusive lock on fd1, then try to get an exclusive lock +** on fd2, it works. I would have expected the second lock to +** fail since there was already a lock on the file due to fd1. +** But not so. Since both locks came from the same process, the +** second overrides the first, even though they were on different +** file descriptors opened on different file names. +** +** This means that we cannot use POSIX locks to synchronize file access +** among competing threads of the same process. POSIX locks will work fine +** to synchronize access for threads in separate processes, but not +** threads within the same process. +** +** To work around the problem, SQLite has to manage file locks internally +** on its own. Whenever a new database is opened, we have to find the +** specific inode of the database file (the inode is determined by the +** st_dev and st_ino fields of the stat structure that fstat() fills in) +** and check for locks already existing on that inode. When locks are +** created or removed, we have to look at our own internal record of the +** locks to see if another thread has previously set a lock on that same +** inode. +** +** (Aside: The use of inode numbers as unique IDs does not work on VxWorks. +** For VxWorks, we have to use the alternative unique ID system based on +** canonical filename and implemented in the previous division.) +** +** The sqlite3_file structure for POSIX is no longer just an integer file +** descriptor. It is now a structure that holds the integer file +** descriptor and a pointer to a structure that describes the internal +** locks on the corresponding inode. There is one locking structure +** per inode, so if the same inode is opened twice, both unixFile structures +** point to the same locking structure. The locking structure keeps +** a reference count (so we will know when to delete it) and a "cnt" +** field that tells us its internal lock status. cnt==0 means the +** file is unlocked. cnt==-1 means the file has an exclusive lock. +** cnt>0 means there are cnt shared locks on the file. +** +** Any attempt to lock or unlock a file first checks the locking +** structure. The fcntl() system call is only invoked to set a +** POSIX lock if the internal lock structure transitions between +** a locked and an unlocked state. +** +** But wait: there are yet more problems with POSIX advisory locks. +** +** If you close a file descriptor that points to a file that has locks, +** all locks on that file that are owned by the current process are +** released. To work around this problem, each unixInodeInfo object +** maintains a count of the number of pending locks on tha inode. +** When an attempt is made to close an unixFile, if there are +** other unixFile open on the same inode that are holding locks, the call +** to close() the file descriptor is deferred until all of the locks clear. +** The unixInodeInfo structure keeps a list of file descriptors that need to +** be closed and that list is walked (and cleared) when the last lock +** clears. +** +** Yet another problem: LinuxThreads do not play well with posix locks. +** +** Many older versions of linux use the LinuxThreads library which is +** not posix compliant. Under LinuxThreads, a lock created by thread +** A cannot be modified or overridden by a different thread B. +** Only thread A can modify the lock. Locking behavior is correct +** if the appliation uses the newer Native Posix Thread Library (NPTL) +** on linux - with NPTL a lock created by thread A can override locks +** in thread B. But there is no way to know at compile-time which +** threading library is being used. So there is no way to know at +** compile-time whether or not thread A can override locks on thread B. +** One has to do a run-time check to discover the behavior of the +** current process. +** +** SQLite used to support LinuxThreads. But support for LinuxThreads +** was dropped beginning with version 3.7.0. SQLite will still work with +** LinuxThreads provided that (1) there is no more than one connection +** per database file in the same process and (2) database connections +** do not move across threads. +*/ + +/* +** An instance of the following structure serves as the key used +** to locate a particular unixInodeInfo object. +*/ +struct unixFileId { + dev_t dev; /* Device number */ +#if OS_VXWORKS + struct vxworksFileId *pId; /* Unique file ID for vxworks. */ +#else + /* We are told that some versions of Android contain a bug that + ** sizes ino_t at only 32-bits instead of 64-bits. (See + ** https://android-review.googlesource.com/#/c/115351/3/dist/sqlite3.c) + ** To work around this, always allocate 64-bits for the inode number. + ** On small machines that only have 32-bit inodes, this wastes 4 bytes, + ** but that should not be a big deal. */ + /* WAS: ino_t ino; */ + u64 ino; /* Inode number */ +#endif +}; + +/* +** An instance of the following structure is allocated for each open +** inode. +** +** A single inode can have multiple file descriptors, so each unixFile +** structure contains a pointer to an instance of this object and this +** object keeps a count of the number of unixFile pointing to it. +** +** Mutex rules: +** +** (1) Only the pLockMutex mutex must be held in order to read or write +** any of the locking fields: +** nShared, nLock, eFileLock, bProcessLock, pUnused +** +** (2) When nRef>0, then the following fields are unchanging and can +** be read (but not written) without holding any mutex: +** fileId, pLockMutex +** +** (3) With the exceptions above, all the fields may only be read +** or written while holding the global unixBigLock mutex. +** +** Deadlock prevention: The global unixBigLock mutex may not +** be acquired while holding the pLockMutex mutex. If both unixBigLock +** and pLockMutex are needed, then unixBigLock must be acquired first. +*/ +struct unixInodeInfo { + struct unixFileId fileId; /* The lookup key */ + sqlite3_mutex *pLockMutex; /* Hold this mutex for... */ + int nShared; /* Number of SHARED locks held */ + int nLock; /* Number of outstanding file locks */ + unsigned char eFileLock; /* One of SHARED_LOCK, RESERVED_LOCK etc. */ + unsigned char bProcessLock; /* An exclusive process lock is held */ + UnixUnusedFd *pUnused; /* Unused file descriptors to close */ + int nRef; /* Number of pointers to this structure */ + unixShmNode *pShmNode; /* Shared memory associated with this inode */ + unixInodeInfo *pNext; /* List of all unixInodeInfo objects */ + unixInodeInfo *pPrev; /* .... doubly linked */ +#if SQLITE_ENABLE_LOCKING_STYLE + unsigned long long sharedByte; /* for AFP simulated shared lock */ +#endif +#if OS_VXWORKS + sem_t *pSem; /* Named POSIX semaphore */ + char aSemName[MAX_PATHNAME+2]; /* Name of that semaphore */ +#endif +}; + +/* +** A lists of all unixInodeInfo objects. +** +** Must hold unixBigLock in order to read or write this variable. +*/ +static unixInodeInfo *inodeList = 0; /* All unixInodeInfo objects */ + +#ifdef SQLITE_DEBUG +/* +** True if the inode mutex (on the unixFile.pFileMutex field) is held, or not. +** This routine is used only within assert() to help verify correct mutex +** usage. +*/ +int unixFileMutexHeld(unixFile *pFile){ + assert( pFile->pInode ); + return sqlite3_mutex_held(pFile->pInode->pLockMutex); +} +int unixFileMutexNotheld(unixFile *pFile){ + assert( pFile->pInode ); + return sqlite3_mutex_notheld(pFile->pInode->pLockMutex); +} +#endif + +/* +** +** This function - unixLogErrorAtLine(), is only ever called via the macro +** unixLogError(). +** +** It is invoked after an error occurs in an OS function and errno has been +** set. It logs a message using sqlite3_log() containing the current value of +** errno and, if possible, the human-readable equivalent from strerror() or +** strerror_r(). +** +** The first argument passed to the macro should be the error code that +** will be returned to SQLite (e.g. SQLITE_IOERR_DELETE, SQLITE_CANTOPEN). +** The two subsequent arguments should be the name of the OS function that +** failed (e.g. "unlink", "open") and the associated file-system path, +** if any. +*/ +#define unixLogError(a,b,c) unixLogErrorAtLine(a,b,c,__LINE__) +static int unixLogErrorAtLine( + int errcode, /* SQLite error code */ + const char *zFunc, /* Name of OS function that failed */ + const char *zPath, /* File path associated with error */ + int iLine /* Source line number where error occurred */ +){ + char *zErr; /* Message from strerror() or equivalent */ + int iErrno = errno; /* Saved syscall error number */ + + /* If this is not a threadsafe build (SQLITE_THREADSAFE==0), then use + ** the strerror() function to obtain the human-readable error message + ** equivalent to errno. Otherwise, use strerror_r(). + */ +#if SQLITE_THREADSAFE && defined(HAVE_STRERROR_R) + char aErr[80]; + memset(aErr, 0, sizeof(aErr)); + zErr = aErr; + + /* If STRERROR_R_CHAR_P (set by autoconf scripts) or __USE_GNU is defined, + ** assume that the system provides the GNU version of strerror_r() that + ** returns a pointer to a buffer containing the error message. That pointer + ** may point to aErr[], or it may point to some static storage somewhere. + ** Otherwise, assume that the system provides the POSIX version of + ** strerror_r(), which always writes an error message into aErr[]. + ** + ** If the code incorrectly assumes that it is the POSIX version that is + ** available, the error message will often be an empty string. Not a + ** huge problem. Incorrectly concluding that the GNU version is available + ** could lead to a segfault though. + */ +#if defined(STRERROR_R_CHAR_P) || defined(__USE_GNU) + zErr = +# endif + strerror_r(iErrno, aErr, sizeof(aErr)-1); + +#elif SQLITE_THREADSAFE + /* This is a threadsafe build, but strerror_r() is not available. */ + zErr = ""; +#else + /* Non-threadsafe build, use strerror(). */ + zErr = strerror(iErrno); +#endif + + if( zPath==0 ) zPath = ""; + sqlite3_log(errcode, + "os_unix.c:%d: (%d) %s(%s) - %s", + iLine, iErrno, zFunc, zPath, zErr + ); + + return errcode; +} + +/* +** Close a file descriptor. +** +** We assume that close() almost always works, since it is only in a +** very sick application or on a very sick platform that it might fail. +** If it does fail, simply leak the file descriptor, but do log the +** error. +** +** Note that it is not safe to retry close() after EINTR since the +** file descriptor might have already been reused by another thread. +** So we don't even try to recover from an EINTR. Just log the error +** and move on. +*/ +static void robust_close(unixFile *pFile, int h, int lineno){ + if( osClose(h) ){ + unixLogErrorAtLine(SQLITE_IOERR_CLOSE, "close", + pFile ? pFile->zPath : 0, lineno); + } +} + +/* +** Set the pFile->lastErrno. Do this in a subroutine as that provides +** a convenient place to set a breakpoint. +*/ +static void storeLastErrno(unixFile *pFile, int error){ + pFile->lastErrno = error; +} + +/* +** Close all file descriptors accumuated in the unixInodeInfo->pUnused list. +*/ +static void closePendingFds(unixFile *pFile){ + unixInodeInfo *pInode = pFile->pInode; + UnixUnusedFd *p; + UnixUnusedFd *pNext; + assert( unixFileMutexHeld(pFile) ); + for(p=pInode->pUnused; p; p=pNext){ + pNext = p->pNext; + robust_close(pFile, p->fd, __LINE__); + sqlite3_free(p); + } + pInode->pUnused = 0; +} + +/* +** Release a unixInodeInfo structure previously allocated by findInodeInfo(). +** +** The global mutex must be held when this routine is called, but the mutex +** on the inode being deleted must NOT be held. +*/ +static void releaseInodeInfo(unixFile *pFile){ + unixInodeInfo *pInode = pFile->pInode; + assert( unixMutexHeld() ); + assert( unixFileMutexNotheld(pFile) ); + if( ALWAYS(pInode) ){ + pInode->nRef--; + if( pInode->nRef==0 ){ + assert( pInode->pShmNode==0 ); + sqlite3_mutex_enter(pInode->pLockMutex); + closePendingFds(pFile); + sqlite3_mutex_leave(pInode->pLockMutex); + if( pInode->pPrev ){ + assert( pInode->pPrev->pNext==pInode ); + pInode->pPrev->pNext = pInode->pNext; + }else{ + assert( inodeList==pInode ); + inodeList = pInode->pNext; + } + if( pInode->pNext ){ + assert( pInode->pNext->pPrev==pInode ); + pInode->pNext->pPrev = pInode->pPrev; + } + sqlite3_mutex_free(pInode->pLockMutex); + sqlite3_free(pInode); + } + } +} + +/* +** Given a file descriptor, locate the unixInodeInfo object that +** describes that file descriptor. Create a new one if necessary. The +** return value might be uninitialized if an error occurs. +** +** The global mutex must held when calling this routine. +** +** Return an appropriate error code. +*/ +static int findInodeInfo( + unixFile *pFile, /* Unix file with file desc used in the key */ + unixInodeInfo **ppInode /* Return the unixInodeInfo object here */ +){ + int rc; /* System call return code */ + int fd; /* The file descriptor for pFile */ + struct unixFileId fileId; /* Lookup key for the unixInodeInfo */ + struct stat statbuf; /* Low-level file information */ + unixInodeInfo *pInode = 0; /* Candidate unixInodeInfo object */ + + assert( unixMutexHeld() ); + + /* Get low-level information about the file that we can used to + ** create a unique name for the file. + */ + fd = pFile->h; + rc = osFstat(fd, &statbuf); + if( rc!=0 ){ + storeLastErrno(pFile, errno); +#if defined(EOVERFLOW) && defined(SQLITE_DISABLE_LFS) + if( pFile->lastErrno==EOVERFLOW ) return SQLITE_NOLFS; +#endif + return SQLITE_IOERR; + } + +#ifdef __APPLE__ + /* On OS X on an msdos filesystem, the inode number is reported + ** incorrectly for zero-size files. See ticket #3260. To work + ** around this problem (we consider it a bug in OS X, not SQLite) + ** we always increase the file size to 1 by writing a single byte + ** prior to accessing the inode number. The one byte written is + ** an ASCII 'S' character which also happens to be the first byte + ** in the header of every SQLite database. In this way, if there + ** is a race condition such that another thread has already populated + ** the first page of the database, no damage is done. + */ + if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){ + do{ rc = osWrite(fd, "S", 1); }while( rc<0 && errno==EINTR ); + if( rc!=1 ){ + storeLastErrno(pFile, errno); + return SQLITE_IOERR; + } + rc = osFstat(fd, &statbuf); + if( rc!=0 ){ + storeLastErrno(pFile, errno); + return SQLITE_IOERR; + } + } +#endif + + memset(&fileId, 0, sizeof(fileId)); + fileId.dev = statbuf.st_dev; +#if OS_VXWORKS + fileId.pId = pFile->pId; +#else + fileId.ino = (u64)statbuf.st_ino; +#endif + assert( unixMutexHeld() ); + pInode = inodeList; + while( pInode && memcmp(&fileId, &pInode->fileId, sizeof(fileId)) ){ + pInode = pInode->pNext; + } + if( pInode==0 ){ + pInode = sqlite3_malloc64( sizeof(*pInode) ); + if( pInode==0 ){ + return SQLITE_NOMEM_BKPT; + } + memset(pInode, 0, sizeof(*pInode)); + memcpy(&pInode->fileId, &fileId, sizeof(fileId)); + if( sqlite3GlobalConfig.bCoreMutex ){ + pInode->pLockMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); + if( pInode->pLockMutex==0 ){ + sqlite3_free(pInode); + return SQLITE_NOMEM_BKPT; + } + } + pInode->nRef = 1; + assert( unixMutexHeld() ); + pInode->pNext = inodeList; + pInode->pPrev = 0; + if( inodeList ) inodeList->pPrev = pInode; + inodeList = pInode; + }else{ + pInode->nRef++; + } + *ppInode = pInode; + return SQLITE_OK; +} + +/* +** Return TRUE if pFile has been renamed or unlinked since it was first opened. +*/ +static int fileHasMoved(unixFile *pFile){ +#if OS_VXWORKS + return pFile->pInode!=0 && pFile->pId!=pFile->pInode->fileId.pId; +#else + struct stat buf; + return pFile->pInode!=0 && + (osStat(pFile->zPath, &buf)!=0 + || (u64)buf.st_ino!=pFile->pInode->fileId.ino); +#endif +} + + +/* +** Check a unixFile that is a database. Verify the following: +** +** (1) There is exactly one hard link on the file +** (2) The file is not a symbolic link +** (3) The file has not been renamed or unlinked +** +** Issue sqlite3_log(SQLITE_WARNING,...) messages if anything is not right. +*/ +static void verifyDbFile(unixFile *pFile){ + struct stat buf; + int rc; + + /* These verifications occurs for the main database only */ + if( pFile->ctrlFlags & UNIXFILE_NOLOCK ) return; + + rc = osFstat(pFile->h, &buf); + if( rc!=0 ){ + sqlite3_log(SQLITE_WARNING, "cannot fstat db file %s", pFile->zPath); + return; + } + if( buf.st_nlink==0 ){ + sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath); + return; + } + if( buf.st_nlink>1 ){ + sqlite3_log(SQLITE_WARNING, "multiple links to file: %s", pFile->zPath); + return; + } + if( fileHasMoved(pFile) ){ + sqlite3_log(SQLITE_WARNING, "file renamed while open: %s", pFile->zPath); + return; + } +} + + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +*/ +static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){ + int rc = SQLITE_OK; + int reserved = 0; + unixFile *pFile = (unixFile*)id; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + + assert( pFile ); + assert( pFile->eFileLock<=SHARED_LOCK ); + sqlite3_mutex_enter(pFile->pInode->pLockMutex); + + /* Check if a thread in this process holds such a lock */ + if( pFile->pInode->eFileLock>SHARED_LOCK ){ + reserved = 1; + } + + /* Otherwise see if some other process holds it. + */ +#ifndef __DJGPP__ + if( !reserved && !pFile->pInode->bProcessLock ){ + struct flock lock; + lock.l_whence = SEEK_SET; + lock.l_start = RESERVED_BYTE; + lock.l_len = 1; + lock.l_type = F_WRLCK; + if( osFcntl(pFile->h, F_GETLK, &lock) ){ + rc = SQLITE_IOERR_CHECKRESERVEDLOCK; + storeLastErrno(pFile, errno); + } else if( lock.l_type!=F_UNLCK ){ + reserved = 1; + } + } +#endif + + sqlite3_mutex_leave(pFile->pInode->pLockMutex); + OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved)); + + *pResOut = reserved; + return rc; +} + +/* Forward declaration*/ +static int unixSleep(sqlite3_vfs*,int); + +/* +** Set a posix-advisory-lock. +** +** There are two versions of this routine. If compiled with +** SQLITE_ENABLE_SETLK_TIMEOUT then the routine has an extra parameter +** which is a pointer to a unixFile. If the unixFile->iBusyTimeout +** value is set, then it is the number of milliseconds to wait before +** failing the lock. The iBusyTimeout value is always reset back to +** zero on each call. +** +** If SQLITE_ENABLE_SETLK_TIMEOUT is not defined, then do a non-blocking +** attempt to set the lock. +*/ +#ifndef SQLITE_ENABLE_SETLK_TIMEOUT +# define osSetPosixAdvisoryLock(h,x,t) osFcntl(h,F_SETLK,x) +#else +static int osSetPosixAdvisoryLock( + int h, /* The file descriptor on which to take the lock */ + struct flock *pLock, /* The description of the lock */ + unixFile *pFile /* Structure holding timeout value */ +){ + int tm = pFile->iBusyTimeout; + int rc = osFcntl(h,F_SETLK,pLock); + while( rc<0 && tm>0 ){ + /* On systems that support some kind of blocking file lock with a timeout, + ** make appropriate changes here to invoke that blocking file lock. On + ** generic posix, however, there is no such API. So we simply try the + ** lock once every millisecond until either the timeout expires, or until + ** the lock is obtained. */ + unixSleep(0,1000); + rc = osFcntl(h,F_SETLK,pLock); + tm--; + } + return rc; +} +#endif /* SQLITE_ENABLE_SETLK_TIMEOUT */ + + +/* +** Attempt to set a system-lock on the file pFile. The lock is +** described by pLock. +** +** If the pFile was opened read/write from unix-excl, then the only lock +** ever obtained is an exclusive lock, and it is obtained exactly once +** the first time any lock is attempted. All subsequent system locking +** operations become no-ops. Locking operations still happen internally, +** in order to coordinate access between separate database connections +** within this process, but all of that is handled in memory and the +** operating system does not participate. +** +** This function is a pass-through to fcntl(F_SETLK) if pFile is using +** any VFS other than "unix-excl" or if pFile is opened on "unix-excl" +** and is read-only. +** +** Zero is returned if the call completes successfully, or -1 if a call +** to fcntl() fails. In this case, errno is set appropriately (by fcntl()). +*/ +static int unixFileLock(unixFile *pFile, struct flock *pLock){ + int rc; + unixInodeInfo *pInode = pFile->pInode; + assert( pInode!=0 ); + assert( sqlite3_mutex_held(pInode->pLockMutex) ); + if( (pFile->ctrlFlags & (UNIXFILE_EXCL|UNIXFILE_RDONLY))==UNIXFILE_EXCL ){ + if( pInode->bProcessLock==0 ){ + struct flock lock; + assert( pInode->nLock==0 ); + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST; + lock.l_len = SHARED_SIZE; + lock.l_type = F_WRLCK; + rc = osSetPosixAdvisoryLock(pFile->h, &lock, pFile); + if( rc<0 ) return rc; + pInode->bProcessLock = 1; + pInode->nLock++; + }else{ + rc = 0; + } + }else{ + rc = osSetPosixAdvisoryLock(pFile->h, pLock, pFile); + } + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int unixLock(sqlite3_file *id, int eFileLock){ + /* The following describes the implementation of the various locks and + ** lock transitions in terms of the POSIX advisory shared and exclusive + ** lock primitives (called read-locks and write-locks below, to avoid + ** confusion with SQLite lock names). The algorithms are complicated + ** slightly in order to be compatible with Windows95 systems simultaneously + ** accessing the same database file, in case that is ever required. + ** + ** Symbols defined in os.h indentify the 'pending byte' and the 'reserved + ** byte', each single bytes at well known offsets, and the 'shared byte + ** range', a range of 510 bytes at a well known offset. + ** + ** To obtain a SHARED lock, a read-lock is obtained on the 'pending + ** byte'. If this is successful, 'shared byte range' is read-locked + ** and the lock on the 'pending byte' released. (Legacy note: When + ** SQLite was first developed, Windows95 systems were still very common, + ** and Widnows95 lacks a shared-lock capability. So on Windows95, a + ** single randomly selected by from the 'shared byte range' is locked. + ** Windows95 is now pretty much extinct, but this work-around for the + ** lack of shared-locks on Windows95 lives on, for backwards + ** compatibility.) + ** + ** A process may only obtain a RESERVED lock after it has a SHARED lock. + ** A RESERVED lock is implemented by grabbing a write-lock on the + ** 'reserved byte'. + ** + ** A process may only obtain a PENDING lock after it has obtained a + ** SHARED lock. A PENDING lock is implemented by obtaining a write-lock + ** on the 'pending byte'. This ensures that no new SHARED locks can be + ** obtained, but existing SHARED locks are allowed to persist. A process + ** does not have to obtain a RESERVED lock on the way to a PENDING lock. + ** This property is used by the algorithm for rolling back a journal file + ** after a crash. + ** + ** An EXCLUSIVE lock, obtained after a PENDING lock is held, is + ** implemented by obtaining a write-lock on the entire 'shared byte + ** range'. Since all other locks require a read-lock on one of the bytes + ** within this range, this ensures that no other locks are held on the + ** database. + */ + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + unixInodeInfo *pInode; + struct flock lock; + int tErrno = 0; + + assert( pFile ); + OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h, + azFileLock(eFileLock), azFileLock(pFile->eFileLock), + azFileLock(pFile->pInode->eFileLock), pFile->pInode->nShared, + osGetpid(0))); + + /* If there is already a lock of this type or more restrictive on the + ** unixFile, do nothing. Don't use the end_lock: exit path, as + ** unixEnterMutex() hasn't been called yet. + */ + if( pFile->eFileLock>=eFileLock ){ + OSTRACE(("LOCK %d %s ok (already held) (unix)\n", pFile->h, + azFileLock(eFileLock))); + return SQLITE_OK; + } + + /* Make sure the locking sequence is correct. + ** (1) We never move from unlocked to anything higher than shared lock. + ** (2) SQLite never explicitly requests a pendig lock. + ** (3) A shared lock is always held when a reserve lock is requested. + */ + assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK ); + assert( eFileLock!=PENDING_LOCK ); + assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK ); + + /* This mutex is needed because pFile->pInode is shared across threads + */ + pInode = pFile->pInode; + sqlite3_mutex_enter(pInode->pLockMutex); + + /* If some thread using this PID has a lock via a different unixFile* + ** handle that precludes the requested lock, return BUSY. + */ + if( (pFile->eFileLock!=pInode->eFileLock && + (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK)) + ){ + rc = SQLITE_BUSY; + goto end_lock; + } + + /* If a SHARED lock is requested, and some thread using this PID already + ** has a SHARED or RESERVED lock, then increment reference counts and + ** return SQLITE_OK. + */ + if( eFileLock==SHARED_LOCK && + (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){ + assert( eFileLock==SHARED_LOCK ); + assert( pFile->eFileLock==0 ); + assert( pInode->nShared>0 ); + pFile->eFileLock = SHARED_LOCK; + pInode->nShared++; + pInode->nLock++; + goto end_lock; + } + + + /* A PENDING lock is needed before acquiring a SHARED lock and before + ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will + ** be released. + */ + lock.l_len = 1L; + lock.l_whence = SEEK_SET; + if( eFileLock==SHARED_LOCK + || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLocknShared==0 ); + assert( pInode->eFileLock==0 ); + assert( rc==SQLITE_OK ); + + /* Now get the read-lock */ + lock.l_start = SHARED_FIRST; + lock.l_len = SHARED_SIZE; + if( unixFileLock(pFile, &lock) ){ + tErrno = errno; + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + } + + /* Drop the temporary PENDING lock */ + lock.l_start = PENDING_BYTE; + lock.l_len = 1L; + lock.l_type = F_UNLCK; + if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){ + /* This could happen with a network mount */ + tErrno = errno; + rc = SQLITE_IOERR_UNLOCK; + } + + if( rc ){ + if( rc!=SQLITE_BUSY ){ + storeLastErrno(pFile, tErrno); + } + goto end_lock; + }else{ + pFile->eFileLock = SHARED_LOCK; + pInode->nLock++; + pInode->nShared = 1; + } + }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){ + /* We are trying for an exclusive lock but another thread in this + ** same process is still holding a shared lock. */ + rc = SQLITE_BUSY; + }else{ + /* The request was for a RESERVED or EXCLUSIVE lock. It is + ** assumed that there is a SHARED or greater lock on the file + ** already. + */ + assert( 0!=pFile->eFileLock ); + lock.l_type = F_WRLCK; + + assert( eFileLock==RESERVED_LOCK || eFileLock==EXCLUSIVE_LOCK ); + if( eFileLock==RESERVED_LOCK ){ + lock.l_start = RESERVED_BYTE; + lock.l_len = 1L; + }else{ + lock.l_start = SHARED_FIRST; + lock.l_len = SHARED_SIZE; + } + + if( unixFileLock(pFile, &lock) ){ + tErrno = errno; + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + if( rc!=SQLITE_BUSY ){ + storeLastErrno(pFile, tErrno); + } + } + } + + +#ifdef SQLITE_DEBUG + /* Set up the transaction-counter change checking flags when + ** transitioning from a SHARED to a RESERVED lock. The change + ** from SHARED to RESERVED marks the beginning of a normal + ** write operation (not a hot journal rollback). + */ + if( rc==SQLITE_OK + && pFile->eFileLock<=SHARED_LOCK + && eFileLock==RESERVED_LOCK + ){ + pFile->transCntrChng = 0; + pFile->dbUpdate = 0; + pFile->inNormalWrite = 1; + } +#endif + + + if( rc==SQLITE_OK ){ + pFile->eFileLock = eFileLock; + pInode->eFileLock = eFileLock; + }else if( eFileLock==EXCLUSIVE_LOCK ){ + pFile->eFileLock = PENDING_LOCK; + pInode->eFileLock = PENDING_LOCK; + } + +end_lock: + sqlite3_mutex_leave(pInode->pLockMutex); + OSTRACE(("LOCK %d %s %s (unix)\n", pFile->h, azFileLock(eFileLock), + rc==SQLITE_OK ? "ok" : "failed")); + return rc; +} + +/* +** Add the file descriptor used by file handle pFile to the corresponding +** pUnused list. +*/ +static void setPendingFd(unixFile *pFile){ + unixInodeInfo *pInode = pFile->pInode; + UnixUnusedFd *p = pFile->pPreallocatedUnused; + assert( unixFileMutexHeld(pFile) ); + p->pNext = pInode->pUnused; + pInode->pUnused = p; + pFile->h = -1; + pFile->pPreallocatedUnused = 0; +} + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +** +** If handleNFSUnlock is true, then on downgrading an EXCLUSIVE_LOCK to SHARED +** the byte range is divided into 2 parts and the first part is unlocked then +** set to a read lock, then the other part is simply unlocked. This works +** around a bug in BSD NFS lockd (also seen on MacOSX 10.3+) that fails to +** remove the write lock on a region when a read lock is set. +*/ +static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){ + unixFile *pFile = (unixFile*)id; + unixInodeInfo *pInode; + struct flock lock; + int rc = SQLITE_OK; + + assert( pFile ); + OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock, + pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared, + osGetpid(0))); + + assert( eFileLock<=SHARED_LOCK ); + if( pFile->eFileLock<=eFileLock ){ + return SQLITE_OK; + } + pInode = pFile->pInode; + sqlite3_mutex_enter(pInode->pLockMutex); + assert( pInode->nShared!=0 ); + if( pFile->eFileLock>SHARED_LOCK ){ + assert( pInode->eFileLock==pFile->eFileLock ); + +#ifdef SQLITE_DEBUG + /* When reducing a lock such that other processes can start + ** reading the database file again, make sure that the + ** transaction counter was updated if any part of the database + ** file changed. If the transaction counter is not updated, + ** other connections to the same file might not realize that + ** the file has changed and hence might not know to flush their + ** cache. The use of a stale cache can lead to database corruption. + */ + pFile->inNormalWrite = 0; +#endif + + /* downgrading to a shared lock on NFS involves clearing the write lock + ** before establishing the readlock - to avoid a race condition we downgrade + ** the lock in 2 blocks, so that part of the range will be covered by a + ** write lock until the rest is covered by a read lock: + ** 1: [WWWWW] + ** 2: [....W] + ** 3: [RRRRW] + ** 4: [RRRR.] + */ + if( eFileLock==SHARED_LOCK ){ +#if !defined(__APPLE__) || !SQLITE_ENABLE_LOCKING_STYLE + (void)handleNFSUnlock; + assert( handleNFSUnlock==0 ); +#endif +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE + if( handleNFSUnlock ){ + int tErrno; /* Error code from system call errors */ + off_t divSize = SHARED_SIZE - 1; + + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST; + lock.l_len = divSize; + if( unixFileLock(pFile, &lock)==(-1) ){ + tErrno = errno; + rc = SQLITE_IOERR_UNLOCK; + storeLastErrno(pFile, tErrno); + goto end_unlock; + } + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST; + lock.l_len = divSize; + if( unixFileLock(pFile, &lock)==(-1) ){ + tErrno = errno; + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_RDLOCK); + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + goto end_unlock; + } + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST+divSize; + lock.l_len = SHARED_SIZE-divSize; + if( unixFileLock(pFile, &lock)==(-1) ){ + tErrno = errno; + rc = SQLITE_IOERR_UNLOCK; + storeLastErrno(pFile, tErrno); + goto end_unlock; + } + }else +#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */ + { + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST; + lock.l_len = SHARED_SIZE; + if( unixFileLock(pFile, &lock) ){ + /* In theory, the call to unixFileLock() cannot fail because another + ** process is holding an incompatible lock. If it does, this + ** indicates that the other process is not following the locking + ** protocol. If this happens, return SQLITE_IOERR_RDLOCK. Returning + ** SQLITE_BUSY would confuse the upper layer (in practice it causes + ** an assert to fail). */ + rc = SQLITE_IOERR_RDLOCK; + storeLastErrno(pFile, errno); + goto end_unlock; + } + } + } + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = PENDING_BYTE; + lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE ); + if( unixFileLock(pFile, &lock)==0 ){ + pInode->eFileLock = SHARED_LOCK; + }else{ + rc = SQLITE_IOERR_UNLOCK; + storeLastErrno(pFile, errno); + goto end_unlock; + } + } + if( eFileLock==NO_LOCK ){ + /* Decrement the shared lock counter. Release the lock using an + ** OS call only when all threads in this same process have released + ** the lock. + */ + pInode->nShared--; + if( pInode->nShared==0 ){ + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = lock.l_len = 0L; + if( unixFileLock(pFile, &lock)==0 ){ + pInode->eFileLock = NO_LOCK; + }else{ + rc = SQLITE_IOERR_UNLOCK; + storeLastErrno(pFile, errno); + pInode->eFileLock = NO_LOCK; + pFile->eFileLock = NO_LOCK; + } + } + + /* Decrement the count of locks against this same file. When the + ** count reaches zero, close any other file descriptors whose close + ** was deferred because of outstanding locks. + */ + pInode->nLock--; + assert( pInode->nLock>=0 ); + if( pInode->nLock==0 ) closePendingFds(pFile); + } + +end_unlock: + sqlite3_mutex_leave(pInode->pLockMutex); + if( rc==SQLITE_OK ){ + pFile->eFileLock = eFileLock; + } + return rc; +} + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int unixUnlock(sqlite3_file *id, int eFileLock){ +#if SQLITE_MAX_MMAP_SIZE>0 + assert( eFileLock==SHARED_LOCK || ((unixFile *)id)->nFetchOut==0 ); +#endif + return posixUnlock(id, eFileLock, 0); +} + +#if SQLITE_MAX_MMAP_SIZE>0 +static int unixMapfile(unixFile *pFd, i64 nByte); +static void unixUnmapfile(unixFile *pFd); +#endif + +/* +** This function performs the parts of the "close file" operation +** common to all locking schemes. It closes the directory and file +** handles, if they are valid, and sets all fields of the unixFile +** structure to 0. +** +** It is *not* necessary to hold the mutex when this routine is called, +** even on VxWorks. A mutex will be acquired on VxWorks by the +** vxworksReleaseFileId() routine. +*/ +static int closeUnixFile(sqlite3_file *id){ + unixFile *pFile = (unixFile*)id; +#if SQLITE_MAX_MMAP_SIZE>0 + unixUnmapfile(pFile); +#endif + if( pFile->h>=0 ){ + robust_close(pFile, pFile->h, __LINE__); + pFile->h = -1; + } +#if OS_VXWORKS + if( pFile->pId ){ + if( pFile->ctrlFlags & UNIXFILE_DELETE ){ + osUnlink(pFile->pId->zCanonicalName); + } + vxworksReleaseFileId(pFile->pId); + pFile->pId = 0; + } +#endif +#ifdef SQLITE_UNLINK_AFTER_CLOSE + if( pFile->ctrlFlags & UNIXFILE_DELETE ){ + osUnlink(pFile->zPath); + sqlite3_free(*(char**)&pFile->zPath); + pFile->zPath = 0; + } +#endif + OSTRACE(("CLOSE %-3d\n", pFile->h)); + OpenCounter(-1); + sqlite3_free(pFile->pPreallocatedUnused); + memset(pFile, 0, sizeof(unixFile)); + return SQLITE_OK; +} + +/* +** Close a file. +*/ +static int unixClose(sqlite3_file *id){ + int rc = SQLITE_OK; + unixFile *pFile = (unixFile *)id; + unixInodeInfo *pInode = pFile->pInode; + + assert( pInode!=0 ); + verifyDbFile(pFile); + unixUnlock(id, NO_LOCK); + assert( unixFileMutexNotheld(pFile) ); + unixEnterMutex(); + + /* unixFile.pInode is always valid here. Otherwise, a different close + ** routine (e.g. nolockClose()) would be called instead. + */ + assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 ); + sqlite3_mutex_enter(pInode->pLockMutex); + if( pInode->nLock ){ + /* If there are outstanding locks, do not actually close the file just + ** yet because that would clear those locks. Instead, add the file + ** descriptor to pInode->pUnused list. It will be automatically closed + ** when the last lock is cleared. + */ + setPendingFd(pFile); + } + sqlite3_mutex_leave(pInode->pLockMutex); + releaseInodeInfo(pFile); + assert( pFile->pShm==0 ); + rc = closeUnixFile(id); + unixLeaveMutex(); + return rc; +} + +/************** End of the posix advisory lock implementation ***************** +******************************************************************************/ + +/****************************************************************************** +****************************** No-op Locking ********************************** +** +** Of the various locking implementations available, this is by far the +** simplest: locking is ignored. No attempt is made to lock the database +** file for reading or writing. +** +** This locking mode is appropriate for use on read-only databases +** (ex: databases that are burned into CD-ROM, for example.) It can +** also be used if the application employs some external mechanism to +** prevent simultaneous access of the same database by two or more +** database connections. But there is a serious risk of database +** corruption if this locking mode is used in situations where multiple +** database connections are accessing the same database file at the same +** time and one or more of those connections are writing. +*/ + +static int nolockCheckReservedLock(sqlite3_file *NotUsed, int *pResOut){ + UNUSED_PARAMETER(NotUsed); + *pResOut = 0; + return SQLITE_OK; +} +static int nolockLock(sqlite3_file *NotUsed, int NotUsed2){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + return SQLITE_OK; +} +static int nolockUnlock(sqlite3_file *NotUsed, int NotUsed2){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + return SQLITE_OK; +} + +/* +** Close the file. +*/ +static int nolockClose(sqlite3_file *id) { + return closeUnixFile(id); +} + +/******************* End of the no-op lock implementation ********************* +******************************************************************************/ + +/****************************************************************************** +************************* Begin dot-file Locking ****************************** +** +** The dotfile locking implementation uses the existence of separate lock +** files (really a directory) to control access to the database. This works +** on just about every filesystem imaginable. But there are serious downsides: +** +** (1) There is zero concurrency. A single reader blocks all other +** connections from reading or writing the database. +** +** (2) An application crash or power loss can leave stale lock files +** sitting around that need to be cleared manually. +** +** Nevertheless, a dotlock is an appropriate locking mode for use if no +** other locking strategy is available. +** +** Dotfile locking works by creating a subdirectory in the same directory as +** the database and with the same name but with a ".lock" extension added. +** The existence of a lock directory implies an EXCLUSIVE lock. All other +** lock types (SHARED, RESERVED, PENDING) are mapped into EXCLUSIVE. +*/ + +/* +** The file suffix added to the data base filename in order to create the +** lock directory. +*/ +#define DOTLOCK_SUFFIX ".lock" + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +** +** In dotfile locking, either a lock exists or it does not. So in this +** variation of CheckReservedLock(), *pResOut is set to true if any lock +** is held on the file and false if the file is unlocked. +*/ +static int dotlockCheckReservedLock(sqlite3_file *id, int *pResOut) { + int rc = SQLITE_OK; + int reserved = 0; + unixFile *pFile = (unixFile*)id; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + + assert( pFile ); + reserved = osAccess((const char*)pFile->lockingContext, 0)==0; + OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved)); + *pResOut = reserved; + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +** +** With dotfile locking, we really only support state (4): EXCLUSIVE. +** But we track the other locking levels internally. +*/ +static int dotlockLock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + char *zLockFile = (char *)pFile->lockingContext; + int rc = SQLITE_OK; + + + /* If we have any lock, then the lock file already exists. All we have + ** to do is adjust our internal record of the lock level. + */ + if( pFile->eFileLock > NO_LOCK ){ + pFile->eFileLock = eFileLock; + /* Always update the timestamp on the old file */ +#ifdef HAVE_UTIME + utime(zLockFile, NULL); +#else + utimes(zLockFile, NULL); +#endif + return SQLITE_OK; + } + + /* grab an exclusive lock */ + rc = osMkdir(zLockFile, 0777); + if( rc<0 ){ + /* failed to open/create the lock directory */ + int tErrno = errno; + if( EEXIST == tErrno ){ + rc = SQLITE_BUSY; + } else { + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + if( rc!=SQLITE_BUSY ){ + storeLastErrno(pFile, tErrno); + } + } + return rc; + } + + /* got it, set the type and return ok */ + pFile->eFileLock = eFileLock; + return rc; +} + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +** +** When the locking level reaches NO_LOCK, delete the lock file. +*/ +static int dotlockUnlock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + char *zLockFile = (char *)pFile->lockingContext; + int rc; + + assert( pFile ); + OSTRACE(("UNLOCK %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock, + pFile->eFileLock, osGetpid(0))); + assert( eFileLock<=SHARED_LOCK ); + + /* no-op if possible */ + if( pFile->eFileLock==eFileLock ){ + return SQLITE_OK; + } + + /* To downgrade to shared, simply update our internal notion of the + ** lock state. No need to mess with the file on disk. + */ + if( eFileLock==SHARED_LOCK ){ + pFile->eFileLock = SHARED_LOCK; + return SQLITE_OK; + } + + /* To fully unlock the database, delete the lock file */ + assert( eFileLock==NO_LOCK ); + rc = osRmdir(zLockFile); + if( rc<0 ){ + int tErrno = errno; + if( tErrno==ENOENT ){ + rc = SQLITE_OK; + }else{ + rc = SQLITE_IOERR_UNLOCK; + storeLastErrno(pFile, tErrno); + } + return rc; + } + pFile->eFileLock = NO_LOCK; + return SQLITE_OK; +} + +/* +** Close a file. Make sure the lock has been released before closing. +*/ +static int dotlockClose(sqlite3_file *id) { + unixFile *pFile = (unixFile*)id; + assert( id!=0 ); + dotlockUnlock(id, NO_LOCK); + sqlite3_free(pFile->lockingContext); + return closeUnixFile(id); +} +/****************** End of the dot-file lock implementation ******************* +******************************************************************************/ + +/****************************************************************************** +************************** Begin flock Locking ******************************** +** +** Use the flock() system call to do file locking. +** +** flock() locking is like dot-file locking in that the various +** fine-grain locking levels supported by SQLite are collapsed into +** a single exclusive lock. In other words, SHARED, RESERVED, and +** PENDING locks are the same thing as an EXCLUSIVE lock. SQLite +** still works when you do this, but concurrency is reduced since +** only a single process can be reading the database at a time. +** +** Omit this section if SQLITE_ENABLE_LOCKING_STYLE is turned off +*/ +#if SQLITE_ENABLE_LOCKING_STYLE + +/* +** Retry flock() calls that fail with EINTR +*/ +#ifdef EINTR +static int robust_flock(int fd, int op){ + int rc; + do{ rc = flock(fd,op); }while( rc<0 && errno==EINTR ); + return rc; +} +#else +# define robust_flock(a,b) flock(a,b) +#endif + + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +*/ +static int flockCheckReservedLock(sqlite3_file *id, int *pResOut){ + int rc = SQLITE_OK; + int reserved = 0; + unixFile *pFile = (unixFile*)id; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + + assert( pFile ); + + /* Check if a thread in this process holds such a lock */ + if( pFile->eFileLock>SHARED_LOCK ){ + reserved = 1; + } + + /* Otherwise see if some other process holds it. */ + if( !reserved ){ + /* attempt to get the lock */ + int lrc = robust_flock(pFile->h, LOCK_EX | LOCK_NB); + if( !lrc ){ + /* got the lock, unlock it */ + lrc = robust_flock(pFile->h, LOCK_UN); + if ( lrc ) { + int tErrno = errno; + /* unlock failed with an error */ + lrc = SQLITE_IOERR_UNLOCK; + storeLastErrno(pFile, tErrno); + rc = lrc; + } + } else { + int tErrno = errno; + reserved = 1; + /* someone else might have it reserved */ + lrc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + if( IS_LOCK_ERROR(lrc) ){ + storeLastErrno(pFile, tErrno); + rc = lrc; + } + } + } + OSTRACE(("TEST WR-LOCK %d %d %d (flock)\n", pFile->h, rc, reserved)); + +#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS + if( (rc & 0xff) == SQLITE_IOERR ){ + rc = SQLITE_OK; + reserved=1; + } +#endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */ + *pResOut = reserved; + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** flock() only really support EXCLUSIVE locks. We track intermediate +** lock states in the sqlite3_file structure, but all locks SHARED or +** above are really EXCLUSIVE locks and exclude all other processes from +** access the file. +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int flockLock(sqlite3_file *id, int eFileLock) { + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + + assert( pFile ); + + /* if we already have a lock, it is exclusive. + ** Just adjust level and punt on outta here. */ + if (pFile->eFileLock > NO_LOCK) { + pFile->eFileLock = eFileLock; + return SQLITE_OK; + } + + /* grab an exclusive lock */ + + if (robust_flock(pFile->h, LOCK_EX | LOCK_NB)) { + int tErrno = errno; + /* didn't get, must be busy */ + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + } else { + /* got it, set the type and return ok */ + pFile->eFileLock = eFileLock; + } + OSTRACE(("LOCK %d %s %s (flock)\n", pFile->h, azFileLock(eFileLock), + rc==SQLITE_OK ? "ok" : "failed")); +#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS + if( (rc & 0xff) == SQLITE_IOERR ){ + rc = SQLITE_BUSY; + } +#endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */ + return rc; +} + + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int flockUnlock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + + assert( pFile ); + OSTRACE(("UNLOCK %d %d was %d pid=%d (flock)\n", pFile->h, eFileLock, + pFile->eFileLock, osGetpid(0))); + assert( eFileLock<=SHARED_LOCK ); + + /* no-op if possible */ + if( pFile->eFileLock==eFileLock ){ + return SQLITE_OK; + } + + /* shared can just be set because we always have an exclusive */ + if (eFileLock==SHARED_LOCK) { + pFile->eFileLock = eFileLock; + return SQLITE_OK; + } + + /* no, really, unlock. */ + if( robust_flock(pFile->h, LOCK_UN) ){ +#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS + return SQLITE_OK; +#endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */ + return SQLITE_IOERR_UNLOCK; + }else{ + pFile->eFileLock = NO_LOCK; + return SQLITE_OK; + } +} + +/* +** Close a file. +*/ +static int flockClose(sqlite3_file *id) { + assert( id!=0 ); + flockUnlock(id, NO_LOCK); + return closeUnixFile(id); +} + +#endif /* SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORK */ + +/******************* End of the flock lock implementation ********************* +******************************************************************************/ + +/****************************************************************************** +************************ Begin Named Semaphore Locking ************************ +** +** Named semaphore locking is only supported on VxWorks. +** +** Semaphore locking is like dot-lock and flock in that it really only +** supports EXCLUSIVE locking. Only a single process can read or write +** the database file at a time. This reduces potential concurrency, but +** makes the lock implementation much easier. +*/ +#if OS_VXWORKS + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +*/ +static int semXCheckReservedLock(sqlite3_file *id, int *pResOut) { + int rc = SQLITE_OK; + int reserved = 0; + unixFile *pFile = (unixFile*)id; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + + assert( pFile ); + + /* Check if a thread in this process holds such a lock */ + if( pFile->eFileLock>SHARED_LOCK ){ + reserved = 1; + } + + /* Otherwise see if some other process holds it. */ + if( !reserved ){ + sem_t *pSem = pFile->pInode->pSem; + + if( sem_trywait(pSem)==-1 ){ + int tErrno = errno; + if( EAGAIN != tErrno ){ + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_CHECKRESERVEDLOCK); + storeLastErrno(pFile, tErrno); + } else { + /* someone else has the lock when we are in NO_LOCK */ + reserved = (pFile->eFileLock < SHARED_LOCK); + } + }else{ + /* we could have it if we want it */ + sem_post(pSem); + } + } + OSTRACE(("TEST WR-LOCK %d %d %d (sem)\n", pFile->h, rc, reserved)); + + *pResOut = reserved; + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** Semaphore locks only really support EXCLUSIVE locks. We track intermediate +** lock states in the sqlite3_file structure, but all locks SHARED or +** above are really EXCLUSIVE locks and exclude all other processes from +** access the file. +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int semXLock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + sem_t *pSem = pFile->pInode->pSem; + int rc = SQLITE_OK; + + /* if we already have a lock, it is exclusive. + ** Just adjust level and punt on outta here. */ + if (pFile->eFileLock > NO_LOCK) { + pFile->eFileLock = eFileLock; + rc = SQLITE_OK; + goto sem_end_lock; + } + + /* lock semaphore now but bail out when already locked. */ + if( sem_trywait(pSem)==-1 ){ + rc = SQLITE_BUSY; + goto sem_end_lock; + } + + /* got it, set the type and return ok */ + pFile->eFileLock = eFileLock; + + sem_end_lock: + return rc; +} + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int semXUnlock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + sem_t *pSem = pFile->pInode->pSem; + + assert( pFile ); + assert( pSem ); + OSTRACE(("UNLOCK %d %d was %d pid=%d (sem)\n", pFile->h, eFileLock, + pFile->eFileLock, osGetpid(0))); + assert( eFileLock<=SHARED_LOCK ); + + /* no-op if possible */ + if( pFile->eFileLock==eFileLock ){ + return SQLITE_OK; + } + + /* shared can just be set because we always have an exclusive */ + if (eFileLock==SHARED_LOCK) { + pFile->eFileLock = eFileLock; + return SQLITE_OK; + } + + /* no, really unlock. */ + if ( sem_post(pSem)==-1 ) { + int rc, tErrno = errno; + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK); + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + return rc; + } + pFile->eFileLock = NO_LOCK; + return SQLITE_OK; +} + +/* + ** Close a file. + */ +static int semXClose(sqlite3_file *id) { + if( id ){ + unixFile *pFile = (unixFile*)id; + semXUnlock(id, NO_LOCK); + assert( pFile ); + assert( unixFileMutexNotheld(pFile) ); + unixEnterMutex(); + releaseInodeInfo(pFile); + unixLeaveMutex(); + closeUnixFile(id); + } + return SQLITE_OK; +} + +#endif /* OS_VXWORKS */ +/* +** Named semaphore locking is only available on VxWorks. +** +*************** End of the named semaphore lock implementation **************** +******************************************************************************/ + + +/****************************************************************************** +*************************** Begin AFP Locking ********************************* +** +** AFP is the Apple Filing Protocol. AFP is a network filesystem found +** on Apple Macintosh computers - both OS9 and OSX. +** +** Third-party implementations of AFP are available. But this code here +** only works on OSX. +*/ + +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +/* +** The afpLockingContext structure contains all afp lock specific state +*/ +typedef struct afpLockingContext afpLockingContext; +struct afpLockingContext { + int reserved; + const char *dbPath; /* Name of the open file */ +}; + +struct ByteRangeLockPB2 +{ + unsigned long long offset; /* offset to first byte to lock */ + unsigned long long length; /* nbr of bytes to lock */ + unsigned long long retRangeStart; /* nbr of 1st byte locked if successful */ + unsigned char unLockFlag; /* 1 = unlock, 0 = lock */ + unsigned char startEndFlag; /* 1=rel to end of fork, 0=rel to start */ + int fd; /* file desc to assoc this lock with */ +}; + +#define afpfsByteRangeLock2FSCTL _IOWR('z', 23, struct ByteRangeLockPB2) + +/* +** This is a utility for setting or clearing a bit-range lock on an +** AFP filesystem. +** +** Return SQLITE_OK on success, SQLITE_BUSY on failure. +*/ +static int afpSetLock( + const char *path, /* Name of the file to be locked or unlocked */ + unixFile *pFile, /* Open file descriptor on path */ + unsigned long long offset, /* First byte to be locked */ + unsigned long long length, /* Number of bytes to lock */ + int setLockFlag /* True to set lock. False to clear lock */ +){ + struct ByteRangeLockPB2 pb; + int err; + + pb.unLockFlag = setLockFlag ? 0 : 1; + pb.startEndFlag = 0; + pb.offset = offset; + pb.length = length; + pb.fd = pFile->h; + + OSTRACE(("AFPSETLOCK [%s] for %d%s in range %llx:%llx\n", + (setLockFlag?"ON":"OFF"), pFile->h, (pb.fd==-1?"[testval-1]":""), + offset, length)); + err = fsctl(path, afpfsByteRangeLock2FSCTL, &pb, 0); + if ( err==-1 ) { + int rc; + int tErrno = errno; + OSTRACE(("AFPSETLOCK failed to fsctl() '%s' %d %s\n", + path, tErrno, strerror(tErrno))); +#ifdef SQLITE_IGNORE_AFP_LOCK_ERRORS + rc = SQLITE_BUSY; +#else + rc = sqliteErrorFromPosixError(tErrno, + setLockFlag ? SQLITE_IOERR_LOCK : SQLITE_IOERR_UNLOCK); +#endif /* SQLITE_IGNORE_AFP_LOCK_ERRORS */ + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + return rc; + } else { + return SQLITE_OK; + } +} + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +*/ +static int afpCheckReservedLock(sqlite3_file *id, int *pResOut){ + int rc = SQLITE_OK; + int reserved = 0; + unixFile *pFile = (unixFile*)id; + afpLockingContext *context; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + + assert( pFile ); + context = (afpLockingContext *) pFile->lockingContext; + if( context->reserved ){ + *pResOut = 1; + return SQLITE_OK; + } + sqlite3_mutex_enter(pFile->pInode->pLockMutex); + /* Check if a thread in this process holds such a lock */ + if( pFile->pInode->eFileLock>SHARED_LOCK ){ + reserved = 1; + } + + /* Otherwise see if some other process holds it. + */ + if( !reserved ){ + /* lock the RESERVED byte */ + int lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1); + if( SQLITE_OK==lrc ){ + /* if we succeeded in taking the reserved lock, unlock it to restore + ** the original state */ + lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0); + } else { + /* if we failed to get the lock then someone else must have it */ + reserved = 1; + } + if( IS_LOCK_ERROR(lrc) ){ + rc=lrc; + } + } + + sqlite3_mutex_leave(pFile->pInode->pLockMutex); + OSTRACE(("TEST WR-LOCK %d %d %d (afp)\n", pFile->h, rc, reserved)); + + *pResOut = reserved; + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int afpLock(sqlite3_file *id, int eFileLock){ + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + unixInodeInfo *pInode = pFile->pInode; + afpLockingContext *context = (afpLockingContext *) pFile->lockingContext; + + assert( pFile ); + OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (afp)\n", pFile->h, + azFileLock(eFileLock), azFileLock(pFile->eFileLock), + azFileLock(pInode->eFileLock), pInode->nShared , osGetpid(0))); + + /* If there is already a lock of this type or more restrictive on the + ** unixFile, do nothing. Don't use the afp_end_lock: exit path, as + ** unixEnterMutex() hasn't been called yet. + */ + if( pFile->eFileLock>=eFileLock ){ + OSTRACE(("LOCK %d %s ok (already held) (afp)\n", pFile->h, + azFileLock(eFileLock))); + return SQLITE_OK; + } + + /* Make sure the locking sequence is correct + ** (1) We never move from unlocked to anything higher than shared lock. + ** (2) SQLite never explicitly requests a pendig lock. + ** (3) A shared lock is always held when a reserve lock is requested. + */ + assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK ); + assert( eFileLock!=PENDING_LOCK ); + assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK ); + + /* This mutex is needed because pFile->pInode is shared across threads + */ + pInode = pFile->pInode; + sqlite3_mutex_enter(pInode->pLockMutex); + + /* If some thread using this PID has a lock via a different unixFile* + ** handle that precludes the requested lock, return BUSY. + */ + if( (pFile->eFileLock!=pInode->eFileLock && + (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK)) + ){ + rc = SQLITE_BUSY; + goto afp_end_lock; + } + + /* If a SHARED lock is requested, and some thread using this PID already + ** has a SHARED or RESERVED lock, then increment reference counts and + ** return SQLITE_OK. + */ + if( eFileLock==SHARED_LOCK && + (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){ + assert( eFileLock==SHARED_LOCK ); + assert( pFile->eFileLock==0 ); + assert( pInode->nShared>0 ); + pFile->eFileLock = SHARED_LOCK; + pInode->nShared++; + pInode->nLock++; + goto afp_end_lock; + } + + /* A PENDING lock is needed before acquiring a SHARED lock and before + ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will + ** be released. + */ + if( eFileLock==SHARED_LOCK + || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLockdbPath, pFile, PENDING_BYTE, 1, 1); + if (failed) { + rc = failed; + goto afp_end_lock; + } + } + + /* If control gets to this point, then actually go ahead and make + ** operating system calls for the specified lock. + */ + if( eFileLock==SHARED_LOCK ){ + int lrc1, lrc2, lrc1Errno = 0; + long lk, mask; + + assert( pInode->nShared==0 ); + assert( pInode->eFileLock==0 ); + + mask = (sizeof(long)==8) ? LARGEST_INT64 : 0x7fffffff; + /* Now get the read-lock SHARED_LOCK */ + /* note that the quality of the randomness doesn't matter that much */ + lk = random(); + pInode->sharedByte = (lk & mask)%(SHARED_SIZE - 1); + lrc1 = afpSetLock(context->dbPath, pFile, + SHARED_FIRST+pInode->sharedByte, 1, 1); + if( IS_LOCK_ERROR(lrc1) ){ + lrc1Errno = pFile->lastErrno; + } + /* Drop the temporary PENDING lock */ + lrc2 = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0); + + if( IS_LOCK_ERROR(lrc1) ) { + storeLastErrno(pFile, lrc1Errno); + rc = lrc1; + goto afp_end_lock; + } else if( IS_LOCK_ERROR(lrc2) ){ + rc = lrc2; + goto afp_end_lock; + } else if( lrc1 != SQLITE_OK ) { + rc = lrc1; + } else { + pFile->eFileLock = SHARED_LOCK; + pInode->nLock++; + pInode->nShared = 1; + } + }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){ + /* We are trying for an exclusive lock but another thread in this + ** same process is still holding a shared lock. */ + rc = SQLITE_BUSY; + }else{ + /* The request was for a RESERVED or EXCLUSIVE lock. It is + ** assumed that there is a SHARED or greater lock on the file + ** already. + */ + int failed = 0; + assert( 0!=pFile->eFileLock ); + if (eFileLock >= RESERVED_LOCK && pFile->eFileLock < RESERVED_LOCK) { + /* Acquire a RESERVED lock */ + failed = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1); + if( !failed ){ + context->reserved = 1; + } + } + if (!failed && eFileLock == EXCLUSIVE_LOCK) { + /* Acquire an EXCLUSIVE lock */ + + /* Remove the shared lock before trying the range. we'll need to + ** reestablish the shared lock if we can't get the afpUnlock + */ + if( !(failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST + + pInode->sharedByte, 1, 0)) ){ + int failed2 = SQLITE_OK; + /* now attemmpt to get the exclusive lock range */ + failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST, + SHARED_SIZE, 1); + if( failed && (failed2 = afpSetLock(context->dbPath, pFile, + SHARED_FIRST + pInode->sharedByte, 1, 1)) ){ + /* Can't reestablish the shared lock. Sqlite can't deal, this is + ** a critical I/O error + */ + rc = ((failed & 0xff) == SQLITE_IOERR) ? failed2 : + SQLITE_IOERR_LOCK; + goto afp_end_lock; + } + }else{ + rc = failed; + } + } + if( failed ){ + rc = failed; + } + } + + if( rc==SQLITE_OK ){ + pFile->eFileLock = eFileLock; + pInode->eFileLock = eFileLock; + }else if( eFileLock==EXCLUSIVE_LOCK ){ + pFile->eFileLock = PENDING_LOCK; + pInode->eFileLock = PENDING_LOCK; + } + +afp_end_lock: + sqlite3_mutex_leave(pInode->pLockMutex); + OSTRACE(("LOCK %d %s %s (afp)\n", pFile->h, azFileLock(eFileLock), + rc==SQLITE_OK ? "ok" : "failed")); + return rc; +} + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int afpUnlock(sqlite3_file *id, int eFileLock) { + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + unixInodeInfo *pInode; + afpLockingContext *context = (afpLockingContext *) pFile->lockingContext; + int skipShared = 0; +#ifdef SQLITE_TEST + int h = pFile->h; +#endif + + assert( pFile ); + OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (afp)\n", pFile->h, eFileLock, + pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared, + osGetpid(0))); + + assert( eFileLock<=SHARED_LOCK ); + if( pFile->eFileLock<=eFileLock ){ + return SQLITE_OK; + } + pInode = pFile->pInode; + sqlite3_mutex_enter(pInode->pLockMutex); + assert( pInode->nShared!=0 ); + if( pFile->eFileLock>SHARED_LOCK ){ + assert( pInode->eFileLock==pFile->eFileLock ); + SimulateIOErrorBenign(1); + SimulateIOError( h=(-1) ) + SimulateIOErrorBenign(0); + +#ifdef SQLITE_DEBUG + /* When reducing a lock such that other processes can start + ** reading the database file again, make sure that the + ** transaction counter was updated if any part of the database + ** file changed. If the transaction counter is not updated, + ** other connections to the same file might not realize that + ** the file has changed and hence might not know to flush their + ** cache. The use of a stale cache can lead to database corruption. + */ + assert( pFile->inNormalWrite==0 + || pFile->dbUpdate==0 + || pFile->transCntrChng==1 ); + pFile->inNormalWrite = 0; +#endif + + if( pFile->eFileLock==EXCLUSIVE_LOCK ){ + rc = afpSetLock(context->dbPath, pFile, SHARED_FIRST, SHARED_SIZE, 0); + if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1) ){ + /* only re-establish the shared lock if necessary */ + int sharedLockByte = SHARED_FIRST+pInode->sharedByte; + rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 1); + } else { + skipShared = 1; + } + } + if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){ + rc = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0); + } + if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){ + rc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0); + if( !rc ){ + context->reserved = 0; + } + } + if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1)){ + pInode->eFileLock = SHARED_LOCK; + } + } + if( rc==SQLITE_OK && eFileLock==NO_LOCK ){ + + /* Decrement the shared lock counter. Release the lock using an + ** OS call only when all threads in this same process have released + ** the lock. + */ + unsigned long long sharedLockByte = SHARED_FIRST+pInode->sharedByte; + pInode->nShared--; + if( pInode->nShared==0 ){ + SimulateIOErrorBenign(1); + SimulateIOError( h=(-1) ) + SimulateIOErrorBenign(0); + if( !skipShared ){ + rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 0); + } + if( !rc ){ + pInode->eFileLock = NO_LOCK; + pFile->eFileLock = NO_LOCK; + } + } + if( rc==SQLITE_OK ){ + pInode->nLock--; + assert( pInode->nLock>=0 ); + if( pInode->nLock==0 ) closePendingFds(pFile); + } + } + + sqlite3_mutex_leave(pInode->pLockMutex); + if( rc==SQLITE_OK ){ + pFile->eFileLock = eFileLock; + } + return rc; +} + +/* +** Close a file & cleanup AFP specific locking context +*/ +static int afpClose(sqlite3_file *id) { + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + assert( id!=0 ); + afpUnlock(id, NO_LOCK); + assert( unixFileMutexNotheld(pFile) ); + unixEnterMutex(); + if( pFile->pInode ){ + unixInodeInfo *pInode = pFile->pInode; + sqlite3_mutex_enter(pInode->pLockMutex); + if( pInode->nLock ){ + /* If there are outstanding locks, do not actually close the file just + ** yet because that would clear those locks. Instead, add the file + ** descriptor to pInode->aPending. It will be automatically closed when + ** the last lock is cleared. + */ + setPendingFd(pFile); + } + sqlite3_mutex_leave(pInode->pLockMutex); + } + releaseInodeInfo(pFile); + sqlite3_free(pFile->lockingContext); + rc = closeUnixFile(id); + unixLeaveMutex(); + return rc; +} + +#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */ +/* +** The code above is the AFP lock implementation. The code is specific +** to MacOSX and does not work on other unix platforms. No alternative +** is available. If you don't compile for a mac, then the "unix-afp" +** VFS is not available. +** +********************* End of the AFP lock implementation ********************** +******************************************************************************/ + +/****************************************************************************** +*************************** Begin NFS Locking ********************************/ + +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +/* + ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock + ** must be either NO_LOCK or SHARED_LOCK. + ** + ** If the locking level of the file descriptor is already at or below + ** the requested locking level, this routine is a no-op. + */ +static int nfsUnlock(sqlite3_file *id, int eFileLock){ + return posixUnlock(id, eFileLock, 1); +} + +#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */ +/* +** The code above is the NFS lock implementation. The code is specific +** to MacOSX and does not work on other unix platforms. No alternative +** is available. +** +********************* End of the NFS lock implementation ********************** +******************************************************************************/ + +/****************************************************************************** +**************** Non-locking sqlite3_file methods ***************************** +** +** The next division contains implementations for all methods of the +** sqlite3_file object other than the locking methods. The locking +** methods were defined in divisions above (one locking method per +** division). Those methods that are common to all locking modes +** are gather together into this division. +*/ + +/* +** Seek to the offset passed as the second argument, then read cnt +** bytes into pBuf. Return the number of bytes actually read. +** +** NB: If you define USE_PREAD or USE_PREAD64, then it might also +** be necessary to define _XOPEN_SOURCE to be 500. This varies from +** one system to another. Since SQLite does not define USE_PREAD +** in any form by default, we will not attempt to define _XOPEN_SOURCE. +** See tickets #2741 and #2681. +** +** To avoid stomping the errno value on a failed read the lastErrno value +** is set before returning. +*/ +static int seekAndRead(unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt){ + int got; + int prior = 0; +#if (!defined(USE_PREAD) && !defined(USE_PREAD64)) + i64 newOffset; +#endif + TIMER_START; + assert( cnt==(cnt&0x1ffff) ); + assert( id->h>2 ); + do{ +#if defined(USE_PREAD) + got = osPread(id->h, pBuf, cnt, offset); + SimulateIOError( got = -1 ); +#elif defined(USE_PREAD64) + got = osPread64(id->h, pBuf, cnt, offset); + SimulateIOError( got = -1 ); +#else + newOffset = lseek(id->h, offset, SEEK_SET); + SimulateIOError( newOffset = -1 ); + if( newOffset<0 ){ + storeLastErrno((unixFile*)id, errno); + return -1; + } + got = osRead(id->h, pBuf, cnt); +#endif + if( got==cnt ) break; + if( got<0 ){ + if( errno==EINTR ){ got = 1; continue; } + prior = 0; + storeLastErrno((unixFile*)id, errno); + break; + }else if( got>0 ){ + cnt -= got; + offset += got; + prior += got; + pBuf = (void*)(got + (char*)pBuf); + } + }while( got>0 ); + TIMER_END; + OSTRACE(("READ %-3d %5d %7lld %llu\n", + id->h, got+prior, offset-prior, TIMER_ELAPSED)); + return got+prior; +} + +/* +** Read data from a file into a buffer. Return SQLITE_OK if all +** bytes were read successfully and SQLITE_IOERR if anything goes +** wrong. +*/ +static int unixRead( + sqlite3_file *id, + void *pBuf, + int amt, + sqlite3_int64 offset +){ + unixFile *pFile = (unixFile *)id; + int got; + assert( id ); + assert( offset>=0 ); + assert( amt>0 ); + + /* If this is a database file (not a journal, super-journal or temp + ** file), the bytes in the locking range should never be read or written. */ +#if 0 + assert( pFile->pPreallocatedUnused==0 + || offset>=PENDING_BYTE+512 + || offset+amt<=PENDING_BYTE + ); +#endif + +#if SQLITE_MAX_MMAP_SIZE>0 + /* Deal with as much of this read request as possible by transfering + ** data from the memory mapping using memcpy(). */ + if( offsetmmapSize ){ + if( offset+amt <= pFile->mmapSize ){ + memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt); + return SQLITE_OK; + }else{ + int nCopy = pFile->mmapSize - offset; + memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy); + pBuf = &((u8 *)pBuf)[nCopy]; + amt -= nCopy; + offset += nCopy; + } + } +#endif + + got = seekAndRead(pFile, offset, pBuf, amt); + if( got==amt ){ + return SQLITE_OK; + }else if( got<0 ){ + /* pFile->lastErrno has been set by seekAndRead(). + ** Usually we return SQLITE_IOERR_READ here, though for some + ** kinds of errors we return SQLITE_IOERR_CORRUPTFS. The + ** SQLITE_IOERR_CORRUPTFS will be converted into SQLITE_CORRUPT + ** prior to returning to the application by the sqlite3ApiExit() + ** routine. + */ + switch( pFile->lastErrno ){ + case ERANGE: + case EIO: +#ifdef ENXIO + case ENXIO: +#endif +#ifdef EDEVERR + case EDEVERR: +#endif + return SQLITE_IOERR_CORRUPTFS; + } + return SQLITE_IOERR_READ; + }else{ + storeLastErrno(pFile, 0); /* not a system error */ + /* Unread parts of the buffer must be zero-filled */ + memset(&((char*)pBuf)[got], 0, amt-got); + return SQLITE_IOERR_SHORT_READ; + } +} + +/* +** Attempt to seek the file-descriptor passed as the first argument to +** absolute offset iOff, then attempt to write nBuf bytes of data from +** pBuf to it. If an error occurs, return -1 and set *piErrno. Otherwise, +** return the actual number of bytes written (which may be less than +** nBuf). +*/ +static int seekAndWriteFd( + int fd, /* File descriptor to write to */ + i64 iOff, /* File offset to begin writing at */ + const void *pBuf, /* Copy data from this buffer to the file */ + int nBuf, /* Size of buffer pBuf in bytes */ + int *piErrno /* OUT: Error number if error occurs */ +){ + int rc = 0; /* Value returned by system call */ + + assert( nBuf==(nBuf&0x1ffff) ); + assert( fd>2 ); + assert( piErrno!=0 ); + nBuf &= 0x1ffff; + TIMER_START; + +#if defined(USE_PREAD) + do{ rc = (int)osPwrite(fd, pBuf, nBuf, iOff); }while( rc<0 && errno==EINTR ); +#elif defined(USE_PREAD64) + do{ rc = (int)osPwrite64(fd, pBuf, nBuf, iOff);}while( rc<0 && errno==EINTR); +#else + do{ + i64 iSeek = lseek(fd, iOff, SEEK_SET); + SimulateIOError( iSeek = -1 ); + if( iSeek<0 ){ + rc = -1; + break; + } + rc = osWrite(fd, pBuf, nBuf); + }while( rc<0 && errno==EINTR ); +#endif + + TIMER_END; + OSTRACE(("WRITE %-3d %5d %7lld %llu\n", fd, rc, iOff, TIMER_ELAPSED)); + + if( rc<0 ) *piErrno = errno; + return rc; +} + + +/* +** Seek to the offset in id->offset then read cnt bytes into pBuf. +** Return the number of bytes actually read. Update the offset. +** +** To avoid stomping the errno value on a failed write the lastErrno value +** is set before returning. +*/ +static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){ + return seekAndWriteFd(id->h, offset, pBuf, cnt, &id->lastErrno); +} + + +/* +** Write data from a buffer into a file. Return SQLITE_OK on success +** or some other error code on failure. +*/ +static int unixWrite( + sqlite3_file *id, + const void *pBuf, + int amt, + sqlite3_int64 offset +){ + unixFile *pFile = (unixFile*)id; + int wrote = 0; + assert( id ); + assert( amt>0 ); + + /* If this is a database file (not a journal, super-journal or temp + ** file), the bytes in the locking range should never be read or written. */ +#if 0 + assert( pFile->pPreallocatedUnused==0 + || offset>=PENDING_BYTE+512 + || offset+amt<=PENDING_BYTE + ); +#endif + +#ifdef SQLITE_DEBUG + /* If we are doing a normal write to a database file (as opposed to + ** doing a hot-journal rollback or a write to some file other than a + ** normal database file) then record the fact that the database + ** has changed. If the transaction counter is modified, record that + ** fact too. + */ + if( pFile->inNormalWrite ){ + pFile->dbUpdate = 1; /* The database has been modified */ + if( offset<=24 && offset+amt>=27 ){ + int rc; + char oldCntr[4]; + SimulateIOErrorBenign(1); + rc = seekAndRead(pFile, 24, oldCntr, 4); + SimulateIOErrorBenign(0); + if( rc!=4 || memcmp(oldCntr, &((char*)pBuf)[24-offset], 4)!=0 ){ + pFile->transCntrChng = 1; /* The transaction counter has changed */ + } + } + } +#endif + +#if defined(SQLITE_MMAP_READWRITE) && SQLITE_MAX_MMAP_SIZE>0 + /* Deal with as much of this write request as possible by transfering + ** data from the memory mapping using memcpy(). */ + if( offsetmmapSize ){ + if( offset+amt <= pFile->mmapSize ){ + memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt); + return SQLITE_OK; + }else{ + int nCopy = pFile->mmapSize - offset; + memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy); + pBuf = &((u8 *)pBuf)[nCopy]; + amt -= nCopy; + offset += nCopy; + } + } +#endif + + while( (wrote = seekAndWrite(pFile, offset, pBuf, amt))0 ){ + amt -= wrote; + offset += wrote; + pBuf = &((char*)pBuf)[wrote]; + } + SimulateIOError(( wrote=(-1), amt=1 )); + SimulateDiskfullError(( wrote=0, amt=1 )); + + if( amt>wrote ){ + if( wrote<0 && pFile->lastErrno!=ENOSPC ){ + /* lastErrno set by seekAndWrite */ + return SQLITE_IOERR_WRITE; + }else{ + storeLastErrno(pFile, 0); /* not a system error */ + return SQLITE_FULL; + } + } + + return SQLITE_OK; +} + +#ifdef SQLITE_TEST +/* +** Count the number of fullsyncs and normal syncs. This is used to test +** that syncs and fullsyncs are occurring at the right times. +*/ +SQLITE_API int sqlite3_sync_count = 0; +SQLITE_API int sqlite3_fullsync_count = 0; +#endif + +/* +** We do not trust systems to provide a working fdatasync(). Some do. +** Others do no. To be safe, we will stick with the (slightly slower) +** fsync(). If you know that your system does support fdatasync() correctly, +** then simply compile with -Dfdatasync=fdatasync or -DHAVE_FDATASYNC +*/ +#if !defined(fdatasync) && !HAVE_FDATASYNC +# define fdatasync fsync +#endif + +/* +** Define HAVE_FULLFSYNC to 0 or 1 depending on whether or not +** the F_FULLFSYNC macro is defined. F_FULLFSYNC is currently +** only available on Mac OS X. But that could change. +*/ +#ifdef F_FULLFSYNC +# define HAVE_FULLFSYNC 1 +#else +# define HAVE_FULLFSYNC 0 +#endif + + +/* +** The fsync() system call does not work as advertised on many +** unix systems. The following procedure is an attempt to make +** it work better. +** +** The SQLITE_NO_SYNC macro disables all fsync()s. This is useful +** for testing when we want to run through the test suite quickly. +** You are strongly advised *not* to deploy with SQLITE_NO_SYNC +** enabled, however, since with SQLITE_NO_SYNC enabled, an OS crash +** or power failure will likely corrupt the database file. +** +** SQLite sets the dataOnly flag if the size of the file is unchanged. +** The idea behind dataOnly is that it should only write the file content +** to disk, not the inode. We only set dataOnly if the file size is +** unchanged since the file size is part of the inode. However, +** Ted Ts'o tells us that fdatasync() will also write the inode if the +** file size has changed. The only real difference between fdatasync() +** and fsync(), Ted tells us, is that fdatasync() will not flush the +** inode if the mtime or owner or other inode attributes have changed. +** We only care about the file size, not the other file attributes, so +** as far as SQLite is concerned, an fdatasync() is always adequate. +** So, we always use fdatasync() if it is available, regardless of +** the value of the dataOnly flag. +*/ +static int full_fsync(int fd, int fullSync, int dataOnly){ + int rc; + + /* The following "ifdef/elif/else/" block has the same structure as + ** the one below. It is replicated here solely to avoid cluttering + ** up the real code with the UNUSED_PARAMETER() macros. + */ +#ifdef SQLITE_NO_SYNC + UNUSED_PARAMETER(fd); + UNUSED_PARAMETER(fullSync); + UNUSED_PARAMETER(dataOnly); +#elif HAVE_FULLFSYNC + UNUSED_PARAMETER(dataOnly); +#else + UNUSED_PARAMETER(fullSync); + UNUSED_PARAMETER(dataOnly); +#endif + + /* Record the number of times that we do a normal fsync() and + ** FULLSYNC. This is used during testing to verify that this procedure + ** gets called with the correct arguments. + */ +#ifdef SQLITE_TEST + if( fullSync ) sqlite3_fullsync_count++; + sqlite3_sync_count++; +#endif + + /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a + ** no-op. But go ahead and call fstat() to validate the file + ** descriptor as we need a method to provoke a failure during + ** coverate testing. + */ +#ifdef SQLITE_NO_SYNC + { + struct stat buf; + rc = osFstat(fd, &buf); + } +#elif HAVE_FULLFSYNC + if( fullSync ){ + rc = osFcntl(fd, F_FULLFSYNC, 0); + }else{ + rc = 1; + } + /* If the FULLFSYNC failed, fall back to attempting an fsync(). + ** It shouldn't be possible for fullfsync to fail on the local + ** file system (on OSX), so failure indicates that FULLFSYNC + ** isn't supported for this file system. So, attempt an fsync + ** and (for now) ignore the overhead of a superfluous fcntl call. + ** It'd be better to detect fullfsync support once and avoid + ** the fcntl call every time sync is called. + */ + if( rc ) rc = fsync(fd); + +#elif defined(__APPLE__) + /* fdatasync() on HFS+ doesn't yet flush the file size if it changed correctly + ** so currently we default to the macro that redefines fdatasync to fsync + */ + rc = fsync(fd); +#else + rc = fdatasync(fd); +#if OS_VXWORKS + if( rc==-1 && errno==ENOTSUP ){ + rc = fsync(fd); + } +#endif /* OS_VXWORKS */ +#endif /* ifdef SQLITE_NO_SYNC elif HAVE_FULLFSYNC */ + + if( OS_VXWORKS && rc!= -1 ){ + rc = 0; + } + return rc; +} + +/* +** Open a file descriptor to the directory containing file zFilename. +** If successful, *pFd is set to the opened file descriptor and +** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM +** or SQLITE_CANTOPEN is returned and *pFd is set to an undefined +** value. +** +** The directory file descriptor is used for only one thing - to +** fsync() a directory to make sure file creation and deletion events +** are flushed to disk. Such fsyncs are not needed on newer +** journaling filesystems, but are required on older filesystems. +** +** This routine can be overridden using the xSetSysCall interface. +** The ability to override this routine was added in support of the +** chromium sandbox. Opening a directory is a security risk (we are +** told) so making it overrideable allows the chromium sandbox to +** replace this routine with a harmless no-op. To make this routine +** a no-op, replace it with a stub that returns SQLITE_OK but leaves +** *pFd set to a negative number. +** +** If SQLITE_OK is returned, the caller is responsible for closing +** the file descriptor *pFd using close(). +*/ +static int openDirectory(const char *zFilename, int *pFd){ + int ii; + int fd = -1; + char zDirname[MAX_PATHNAME+1]; + + sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename); + for(ii=(int)strlen(zDirname); ii>0 && zDirname[ii]!='/'; ii--); + if( ii>0 ){ + zDirname[ii] = '\0'; + }else{ + if( zDirname[0]!='/' ) zDirname[0] = '.'; + zDirname[1] = 0; + } + fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0); + if( fd>=0 ){ + OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname)); + } + *pFd = fd; + if( fd>=0 ) return SQLITE_OK; + return unixLogError(SQLITE_CANTOPEN_BKPT, "openDirectory", zDirname); +} + +/* +** Make sure all writes to a particular file are committed to disk. +** +** If dataOnly==0 then both the file itself and its metadata (file +** size, access time, etc) are synced. If dataOnly!=0 then only the +** file data is synced. +** +** Under Unix, also make sure that the directory entry for the file +** has been created by fsync-ing the directory that contains the file. +** If we do not do this and we encounter a power failure, the directory +** entry for the journal might not exist after we reboot. The next +** SQLite to access the file will not know that the journal exists (because +** the directory entry for the journal was never created) and the transaction +** will not roll back - possibly leading to database corruption. +*/ +static int unixSync(sqlite3_file *id, int flags){ + int rc; + unixFile *pFile = (unixFile*)id; + + int isDataOnly = (flags&SQLITE_SYNC_DATAONLY); + int isFullsync = (flags&0x0F)==SQLITE_SYNC_FULL; + + /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */ + assert((flags&0x0F)==SQLITE_SYNC_NORMAL + || (flags&0x0F)==SQLITE_SYNC_FULL + ); + + /* Unix cannot, but some systems may return SQLITE_FULL from here. This + ** line is to test that doing so does not cause any problems. + */ + SimulateDiskfullError( return SQLITE_FULL ); + + assert( pFile ); + OSTRACE(("SYNC %-3d\n", pFile->h)); + rc = full_fsync(pFile->h, isFullsync, isDataOnly); + SimulateIOError( rc=1 ); + if( rc ){ + storeLastErrno(pFile, errno); + return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath); + } + + /* Also fsync the directory containing the file if the DIRSYNC flag + ** is set. This is a one-time occurrence. Many systems (examples: AIX) + ** are unable to fsync a directory, so ignore errors on the fsync. + */ + if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){ + int dirfd; + OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath, + HAVE_FULLFSYNC, isFullsync)); + rc = osOpenDirectory(pFile->zPath, &dirfd); + if( rc==SQLITE_OK ){ + full_fsync(dirfd, 0, 0); + robust_close(pFile, dirfd, __LINE__); + }else{ + assert( rc==SQLITE_CANTOPEN ); + rc = SQLITE_OK; + } + pFile->ctrlFlags &= ~UNIXFILE_DIRSYNC; + } + return rc; +} + +/* +** Truncate an open file to a specified size +*/ +static int unixTruncate(sqlite3_file *id, i64 nByte){ + unixFile *pFile = (unixFile *)id; + int rc; + assert( pFile ); + SimulateIOError( return SQLITE_IOERR_TRUNCATE ); + + /* If the user has configured a chunk-size for this file, truncate the + ** file so that it consists of an integer number of chunks (i.e. the + ** actual file size after the operation may be larger than the requested + ** size). + */ + if( pFile->szChunk>0 ){ + nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk; + } + + rc = robust_ftruncate(pFile->h, nByte); + if( rc ){ + storeLastErrno(pFile, errno); + return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath); + }else{ +#ifdef SQLITE_DEBUG + /* If we are doing a normal write to a database file (as opposed to + ** doing a hot-journal rollback or a write to some file other than a + ** normal database file) and we truncate the file to zero length, + ** that effectively updates the change counter. This might happen + ** when restoring a database using the backup API from a zero-length + ** source. + */ + if( pFile->inNormalWrite && nByte==0 ){ + pFile->transCntrChng = 1; + } +#endif + +#if SQLITE_MAX_MMAP_SIZE>0 + /* If the file was just truncated to a size smaller than the currently + ** mapped region, reduce the effective mapping size as well. SQLite will + ** use read() and write() to access data beyond this point from now on. + */ + if( nBytemmapSize ){ + pFile->mmapSize = nByte; + } +#endif + + return SQLITE_OK; + } +} + +/* +** Determine the current size of a file in bytes +*/ +static int unixFileSize(sqlite3_file *id, i64 *pSize){ + int rc; + struct stat buf; + assert( id ); + rc = osFstat(((unixFile*)id)->h, &buf); + SimulateIOError( rc=1 ); + if( rc!=0 ){ + storeLastErrno((unixFile*)id, errno); + return SQLITE_IOERR_FSTAT; + } + *pSize = buf.st_size; + + /* When opening a zero-size database, the findInodeInfo() procedure + ** writes a single byte into that file in order to work around a bug + ** in the OS-X msdos filesystem. In order to avoid problems with upper + ** layers, we need to report this file size as zero even though it is + ** really 1. Ticket #3260. + */ + if( *pSize==1 ) *pSize = 0; + + + return SQLITE_OK; +} + +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) +/* +** Handler for proxy-locking file-control verbs. Defined below in the +** proxying locking division. +*/ +static int proxyFileControl(sqlite3_file*,int,void*); +#endif + +/* +** This function is called to handle the SQLITE_FCNTL_SIZE_HINT +** file-control operation. Enlarge the database to nBytes in size +** (rounded up to the next chunk-size). If the database is already +** nBytes or larger, this routine is a no-op. +*/ +static int fcntlSizeHint(unixFile *pFile, i64 nByte){ + if( pFile->szChunk>0 ){ + i64 nSize; /* Required file size */ + struct stat buf; /* Used to hold return values of fstat() */ + + if( osFstat(pFile->h, &buf) ){ + return SQLITE_IOERR_FSTAT; + } + + nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk; + if( nSize>(i64)buf.st_size ){ + +#if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE + /* The code below is handling the return value of osFallocate() + ** correctly. posix_fallocate() is defined to "returns zero on success, + ** or an error number on failure". See the manpage for details. */ + int err; + do{ + err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size); + }while( err==EINTR ); + if( err && err!=EINVAL ) return SQLITE_IOERR_WRITE; +#else + /* If the OS does not have posix_fallocate(), fake it. Write a + ** single byte to the last byte in each block that falls entirely + ** within the extended region. Then, if required, a single byte + ** at offset (nSize-1), to set the size of the file correctly. + ** This is a similar technique to that used by glibc on systems + ** that do not have a real fallocate() call. + */ + int nBlk = buf.st_blksize; /* File-system block size */ + int nWrite = 0; /* Number of bytes written by seekAndWrite */ + i64 iWrite; /* Next offset to write to */ + + iWrite = (buf.st_size/nBlk)*nBlk + nBlk - 1; + assert( iWrite>=buf.st_size ); + assert( ((iWrite+1)%nBlk)==0 ); + for(/*no-op*/; iWrite=nSize ) iWrite = nSize - 1; + nWrite = seekAndWrite(pFile, iWrite, "", 1); + if( nWrite!=1 ) return SQLITE_IOERR_WRITE; + } +#endif + } + } + +#if SQLITE_MAX_MMAP_SIZE>0 + if( pFile->mmapSizeMax>0 && nByte>pFile->mmapSize ){ + int rc; + if( pFile->szChunk<=0 ){ + if( robust_ftruncate(pFile->h, nByte) ){ + storeLastErrno(pFile, errno); + return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath); + } + } + + rc = unixMapfile(pFile, nByte); + return rc; + } +#endif + + return SQLITE_OK; +} + +/* +** If *pArg is initially negative then this is a query. Set *pArg to +** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set. +** +** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags. +*/ +static void unixModeBit(unixFile *pFile, unsigned char mask, int *pArg){ + if( *pArg<0 ){ + *pArg = (pFile->ctrlFlags & mask)!=0; + }else if( (*pArg)==0 ){ + pFile->ctrlFlags &= ~mask; + }else{ + pFile->ctrlFlags |= mask; + } +} + +/* Forward declaration */ +static int unixGetTempname(int nBuf, char *zBuf); + +/* +** Information and control of an open file handle. +*/ +static int unixFileControl(sqlite3_file *id, int op, void *pArg){ + unixFile *pFile = (unixFile*)id; + switch( op ){ +#if defined(__linux__) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE) + case SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: { + int rc = osIoctl(pFile->h, F2FS_IOC_START_ATOMIC_WRITE); + return rc ? SQLITE_IOERR_BEGIN_ATOMIC : SQLITE_OK; + } + case SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: { + int rc = osIoctl(pFile->h, F2FS_IOC_COMMIT_ATOMIC_WRITE); + return rc ? SQLITE_IOERR_COMMIT_ATOMIC : SQLITE_OK; + } + case SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: { + int rc = osIoctl(pFile->h, F2FS_IOC_ABORT_VOLATILE_WRITE); + return rc ? SQLITE_IOERR_ROLLBACK_ATOMIC : SQLITE_OK; + } +#endif /* __linux__ && SQLITE_ENABLE_BATCH_ATOMIC_WRITE */ + + case SQLITE_FCNTL_LOCKSTATE: { + *(int*)pArg = pFile->eFileLock; + return SQLITE_OK; + } + case SQLITE_FCNTL_LAST_ERRNO: { + *(int*)pArg = pFile->lastErrno; + return SQLITE_OK; + } + case SQLITE_FCNTL_CHUNK_SIZE: { + pFile->szChunk = *(int *)pArg; + return SQLITE_OK; + } + case SQLITE_FCNTL_SIZE_HINT: { + int rc; + SimulateIOErrorBenign(1); + rc = fcntlSizeHint(pFile, *(i64 *)pArg); + SimulateIOErrorBenign(0); + return rc; + } + case SQLITE_FCNTL_PERSIST_WAL: { + unixModeBit(pFile, UNIXFILE_PERSIST_WAL, (int*)pArg); + return SQLITE_OK; + } + case SQLITE_FCNTL_POWERSAFE_OVERWRITE: { + unixModeBit(pFile, UNIXFILE_PSOW, (int*)pArg); + return SQLITE_OK; + } + case SQLITE_FCNTL_VFSNAME: { + *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName); + return SQLITE_OK; + } + case SQLITE_FCNTL_TEMPFILENAME: { + char *zTFile = sqlite3_malloc64( pFile->pVfs->mxPathname ); + if( zTFile ){ + unixGetTempname(pFile->pVfs->mxPathname, zTFile); + *(char**)pArg = zTFile; + } + return SQLITE_OK; + } + case SQLITE_FCNTL_HAS_MOVED: { + *(int*)pArg = fileHasMoved(pFile); + return SQLITE_OK; + } +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + case SQLITE_FCNTL_LOCK_TIMEOUT: { + int iOld = pFile->iBusyTimeout; + pFile->iBusyTimeout = *(int*)pArg; + *(int*)pArg = iOld; + return SQLITE_OK; + } +#endif +#if SQLITE_MAX_MMAP_SIZE>0 + case SQLITE_FCNTL_MMAP_SIZE: { + i64 newLimit = *(i64*)pArg; + int rc = SQLITE_OK; + if( newLimit>sqlite3GlobalConfig.mxMmap ){ + newLimit = sqlite3GlobalConfig.mxMmap; + } + + /* The value of newLimit may be eventually cast to (size_t) and passed + ** to mmap(). Restrict its value to 2GB if (size_t) is not at least a + ** 64-bit type. */ + if( newLimit>0 && sizeof(size_t)<8 ){ + newLimit = (newLimit & 0x7FFFFFFF); + } + + *(i64*)pArg = pFile->mmapSizeMax; + if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){ + pFile->mmapSizeMax = newLimit; + if( pFile->mmapSize>0 ){ + unixUnmapfile(pFile); + rc = unixMapfile(pFile, -1); + } + } + return rc; + } +#endif +#ifdef SQLITE_DEBUG + /* The pager calls this method to signal that it has done + ** a rollback and that the database is therefore unchanged and + ** it hence it is OK for the transaction change counter to be + ** unchanged. + */ + case SQLITE_FCNTL_DB_UNCHANGED: { + ((unixFile*)id)->dbUpdate = 0; + return SQLITE_OK; + } +#endif +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) + case SQLITE_FCNTL_SET_LOCKPROXYFILE: + case SQLITE_FCNTL_GET_LOCKPROXYFILE: { + return proxyFileControl(id,op,pArg); + } +#endif /* SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) */ + } + return SQLITE_NOTFOUND; +} + +/* +** If pFd->sectorSize is non-zero when this function is called, it is a +** no-op. Otherwise, the values of pFd->sectorSize and +** pFd->deviceCharacteristics are set according to the file-system +** characteristics. +** +** There are two versions of this function. One for QNX and one for all +** other systems. +*/ +#ifndef __QNXNTO__ +static void setDeviceCharacteristics(unixFile *pFd){ + assert( pFd->deviceCharacteristics==0 || pFd->sectorSize!=0 ); + if( pFd->sectorSize==0 ){ +#if defined(__linux__) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE) + int res; + u32 f = 0; + + /* Check for support for F2FS atomic batch writes. */ + res = osIoctl(pFd->h, F2FS_IOC_GET_FEATURES, &f); + if( res==0 && (f & F2FS_FEATURE_ATOMIC_WRITE) ){ + pFd->deviceCharacteristics = SQLITE_IOCAP_BATCH_ATOMIC; + } +#endif /* __linux__ && SQLITE_ENABLE_BATCH_ATOMIC_WRITE */ + + /* Set the POWERSAFE_OVERWRITE flag if requested. */ + if( pFd->ctrlFlags & UNIXFILE_PSOW ){ + pFd->deviceCharacteristics |= SQLITE_IOCAP_POWERSAFE_OVERWRITE; + } + + pFd->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE; + } +} +#else +#include +#include +static void setDeviceCharacteristics(unixFile *pFile){ + if( pFile->sectorSize == 0 ){ + struct statvfs fsInfo; + + /* Set defaults for non-supported filesystems */ + pFile->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE; + pFile->deviceCharacteristics = 0; + if( fstatvfs(pFile->h, &fsInfo) == -1 ) { + return; + } + + if( !strcmp(fsInfo.f_basetype, "tmp") ) { + pFile->sectorSize = fsInfo.f_bsize; + pFile->deviceCharacteristics = + SQLITE_IOCAP_ATOMIC4K | /* All ram filesystem writes are atomic */ + SQLITE_IOCAP_SAFE_APPEND | /* growing the file does not occur until + ** the write succeeds */ + SQLITE_IOCAP_SEQUENTIAL | /* The ram filesystem has no write behind + ** so it is ordered */ + 0; + }else if( strstr(fsInfo.f_basetype, "etfs") ){ + pFile->sectorSize = fsInfo.f_bsize; + pFile->deviceCharacteristics = + /* etfs cluster size writes are atomic */ + (pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) | + SQLITE_IOCAP_SAFE_APPEND | /* growing the file does not occur until + ** the write succeeds */ + SQLITE_IOCAP_SEQUENTIAL | /* The ram filesystem has no write behind + ** so it is ordered */ + 0; + }else if( !strcmp(fsInfo.f_basetype, "qnx6") ){ + pFile->sectorSize = fsInfo.f_bsize; + pFile->deviceCharacteristics = + SQLITE_IOCAP_ATOMIC | /* All filesystem writes are atomic */ + SQLITE_IOCAP_SAFE_APPEND | /* growing the file does not occur until + ** the write succeeds */ + SQLITE_IOCAP_SEQUENTIAL | /* The ram filesystem has no write behind + ** so it is ordered */ + 0; + }else if( !strcmp(fsInfo.f_basetype, "qnx4") ){ + pFile->sectorSize = fsInfo.f_bsize; + pFile->deviceCharacteristics = + /* full bitset of atomics from max sector size and smaller */ + ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 | + SQLITE_IOCAP_SEQUENTIAL | /* The ram filesystem has no write behind + ** so it is ordered */ + 0; + }else if( strstr(fsInfo.f_basetype, "dos") ){ + pFile->sectorSize = fsInfo.f_bsize; + pFile->deviceCharacteristics = + /* full bitset of atomics from max sector size and smaller */ + ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 | + SQLITE_IOCAP_SEQUENTIAL | /* The ram filesystem has no write behind + ** so it is ordered */ + 0; + }else{ + pFile->deviceCharacteristics = + SQLITE_IOCAP_ATOMIC512 | /* blocks are atomic */ + SQLITE_IOCAP_SAFE_APPEND | /* growing the file does not occur until + ** the write succeeds */ + 0; + } + } + /* Last chance verification. If the sector size isn't a multiple of 512 + ** then it isn't valid.*/ + if( pFile->sectorSize % 512 != 0 ){ + pFile->deviceCharacteristics = 0; + pFile->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE; + } +} +#endif + +/* +** Return the sector size in bytes of the underlying block device for +** the specified file. This is almost always 512 bytes, but may be +** larger for some devices. +** +** SQLite code assumes this function cannot fail. It also assumes that +** if two files are created in the same file-system directory (i.e. +** a database and its journal file) that the sector size will be the +** same for both. +*/ +static int unixSectorSize(sqlite3_file *id){ + unixFile *pFd = (unixFile*)id; + setDeviceCharacteristics(pFd); + return pFd->sectorSize; +} + +/* +** Return the device characteristics for the file. +** +** This VFS is set up to return SQLITE_IOCAP_POWERSAFE_OVERWRITE by default. +** However, that choice is controversial since technically the underlying +** file system does not always provide powersafe overwrites. (In other +** words, after a power-loss event, parts of the file that were never +** written might end up being altered.) However, non-PSOW behavior is very, +** very rare. And asserting PSOW makes a large reduction in the amount +** of required I/O for journaling, since a lot of padding is eliminated. +** Hence, while POWERSAFE_OVERWRITE is on by default, there is a file-control +** available to turn it off and URI query parameter available to turn it off. +*/ +static int unixDeviceCharacteristics(sqlite3_file *id){ + unixFile *pFd = (unixFile*)id; + setDeviceCharacteristics(pFd); + return pFd->deviceCharacteristics; +} + +#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 + +/* +** Return the system page size. +** +** This function should not be called directly by other code in this file. +** Instead, it should be called via macro osGetpagesize(). +*/ +static int unixGetpagesize(void){ +#if OS_VXWORKS + return 1024; +#elif defined(_BSD_SOURCE) + return getpagesize(); +#else + return (int)sysconf(_SC_PAGESIZE); +#endif +} + +#endif /* !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 */ + +#ifndef SQLITE_OMIT_WAL + +/* +** Object used to represent an shared memory buffer. +** +** When multiple threads all reference the same wal-index, each thread +** has its own unixShm object, but they all point to a single instance +** of this unixShmNode object. In other words, each wal-index is opened +** only once per process. +** +** Each unixShmNode object is connected to a single unixInodeInfo object. +** We could coalesce this object into unixInodeInfo, but that would mean +** every open file that does not use shared memory (in other words, most +** open files) would have to carry around this extra information. So +** the unixInodeInfo object contains a pointer to this unixShmNode object +** and the unixShmNode object is created only when needed. +** +** unixMutexHeld() must be true when creating or destroying +** this object or while reading or writing the following fields: +** +** nRef +** +** The following fields are read-only after the object is created: +** +** hShm +** zFilename +** +** Either unixShmNode.pShmMutex must be held or unixShmNode.nRef==0 and +** unixMutexHeld() is true when reading or writing any other field +** in this structure. +*/ +struct unixShmNode { + unixInodeInfo *pInode; /* unixInodeInfo that owns this SHM node */ + sqlite3_mutex *pShmMutex; /* Mutex to access this object */ + char *zFilename; /* Name of the mmapped file */ + int hShm; /* Open file descriptor */ + int szRegion; /* Size of shared-memory regions */ + u16 nRegion; /* Size of array apRegion */ + u8 isReadonly; /* True if read-only */ + u8 isUnlocked; /* True if no DMS lock held */ + char **apRegion; /* Array of mapped shared-memory regions */ + int nRef; /* Number of unixShm objects pointing to this */ + unixShm *pFirst; /* All unixShm objects pointing to this */ + int aLock[SQLITE_SHM_NLOCK]; /* # shared locks on slot, -1==excl lock */ +#ifdef SQLITE_DEBUG + u8 exclMask; /* Mask of exclusive locks held */ + u8 sharedMask; /* Mask of shared locks held */ + u8 nextShmId; /* Next available unixShm.id value */ +#endif +}; + +/* +** Structure used internally by this VFS to record the state of an +** open shared memory connection. +** +** The following fields are initialized when this object is created and +** are read-only thereafter: +** +** unixShm.pShmNode +** unixShm.id +** +** All other fields are read/write. The unixShm.pShmNode->pShmMutex must +** be held while accessing any read/write fields. +*/ +struct unixShm { + unixShmNode *pShmNode; /* The underlying unixShmNode object */ + unixShm *pNext; /* Next unixShm with the same unixShmNode */ + u8 hasMutex; /* True if holding the unixShmNode->pShmMutex */ + u8 id; /* Id of this connection within its unixShmNode */ + u16 sharedMask; /* Mask of shared locks held */ + u16 exclMask; /* Mask of exclusive locks held */ +}; + +/* +** Constants used for locking +*/ +#define UNIX_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */ +#define UNIX_SHM_DMS (UNIX_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */ + +/* +** Apply posix advisory locks for all bytes from ofst through ofst+n-1. +** +** Locks block if the mask is exactly UNIX_SHM_C and are non-blocking +** otherwise. +*/ +static int unixShmSystemLock( + unixFile *pFile, /* Open connection to the WAL file */ + int lockType, /* F_UNLCK, F_RDLCK, or F_WRLCK */ + int ofst, /* First byte of the locking range */ + int n /* Number of bytes to lock */ +){ + unixShmNode *pShmNode; /* Apply locks to this open shared-memory segment */ + struct flock f; /* The posix advisory locking structure */ + int rc = SQLITE_OK; /* Result code form fcntl() */ + + /* Access to the unixShmNode object is serialized by the caller */ + pShmNode = pFile->pInode->pShmNode; + assert( pShmNode->nRef==0 || sqlite3_mutex_held(pShmNode->pShmMutex) ); + assert( pShmNode->nRef>0 || unixMutexHeld() ); + + /* Shared locks never span more than one byte */ + assert( n==1 || lockType!=F_RDLCK ); + + /* Locks are within range */ + assert( n>=1 && n<=SQLITE_SHM_NLOCK ); + + if( pShmNode->hShm>=0 ){ + int res; + /* Initialize the locking parameters */ + f.l_type = lockType; + f.l_whence = SEEK_SET; + f.l_start = ofst; + f.l_len = n; + res = osSetPosixAdvisoryLock(pShmNode->hShm, &f, pFile); + if( res==-1 ){ +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + rc = (pFile->iBusyTimeout ? SQLITE_BUSY_TIMEOUT : SQLITE_BUSY); +#else + rc = SQLITE_BUSY; +#endif + } + } + + /* Update the global lock state and do debug tracing */ +#ifdef SQLITE_DEBUG + { u16 mask; + OSTRACE(("SHM-LOCK ")); + mask = ofst>31 ? 0xffff : (1<<(ofst+n)) - (1<exclMask &= ~mask; + pShmNode->sharedMask &= ~mask; + }else if( lockType==F_RDLCK ){ + OSTRACE(("read-lock %d ok", ofst)); + pShmNode->exclMask &= ~mask; + pShmNode->sharedMask |= mask; + }else{ + assert( lockType==F_WRLCK ); + OSTRACE(("write-lock %d ok", ofst)); + pShmNode->exclMask |= mask; + pShmNode->sharedMask &= ~mask; + } + }else{ + if( lockType==F_UNLCK ){ + OSTRACE(("unlock %d failed", ofst)); + }else if( lockType==F_RDLCK ){ + OSTRACE(("read-lock failed")); + }else{ + assert( lockType==F_WRLCK ); + OSTRACE(("write-lock %d failed", ofst)); + } + } + OSTRACE((" - afterwards %03x,%03x\n", + pShmNode->sharedMask, pShmNode->exclMask)); + } +#endif + + return rc; +} + +/* +** Return the minimum number of 32KB shm regions that should be mapped at +** a time, assuming that each mapping must be an integer multiple of the +** current system page-size. +** +** Usually, this is 1. The exception seems to be systems that are configured +** to use 64KB pages - in this case each mapping must cover at least two +** shm regions. +*/ +static int unixShmRegionPerMap(void){ + int shmsz = 32*1024; /* SHM region size */ + int pgsz = osGetpagesize(); /* System page size */ + assert( ((pgsz-1)&pgsz)==0 ); /* Page size must be a power of 2 */ + if( pgszpInode->pShmNode; + assert( unixMutexHeld() ); + if( p && ALWAYS(p->nRef==0) ){ + int nShmPerMap = unixShmRegionPerMap(); + int i; + assert( p->pInode==pFd->pInode ); + sqlite3_mutex_free(p->pShmMutex); + for(i=0; inRegion; i+=nShmPerMap){ + if( p->hShm>=0 ){ + osMunmap(p->apRegion[i], p->szRegion); + }else{ + sqlite3_free(p->apRegion[i]); + } + } + sqlite3_free(p->apRegion); + if( p->hShm>=0 ){ + robust_close(pFd, p->hShm, __LINE__); + p->hShm = -1; + } + p->pInode->pShmNode = 0; + sqlite3_free(p); + } +} + +/* +** The DMS lock has not yet been taken on shm file pShmNode. Attempt to +** take it now. Return SQLITE_OK if successful, or an SQLite error +** code otherwise. +** +** If the DMS cannot be locked because this is a readonly_shm=1 +** connection and no other process already holds a lock, return +** SQLITE_READONLY_CANTINIT and set pShmNode->isUnlocked=1. +*/ +static int unixLockSharedMemory(unixFile *pDbFd, unixShmNode *pShmNode){ + struct flock lock; + int rc = SQLITE_OK; + + /* Use F_GETLK to determine the locks other processes are holding + ** on the DMS byte. If it indicates that another process is holding + ** a SHARED lock, then this process may also take a SHARED lock + ** and proceed with opening the *-shm file. + ** + ** Or, if no other process is holding any lock, then this process + ** is the first to open it. In this case take an EXCLUSIVE lock on the + ** DMS byte and truncate the *-shm file to zero bytes in size. Then + ** downgrade to a SHARED lock on the DMS byte. + ** + ** If another process is holding an EXCLUSIVE lock on the DMS byte, + ** return SQLITE_BUSY to the caller (it will try again). An earlier + ** version of this code attempted the SHARED lock at this point. But + ** this introduced a subtle race condition: if the process holding + ** EXCLUSIVE failed just before truncating the *-shm file, then this + ** process might open and use the *-shm file without truncating it. + ** And if the *-shm file has been corrupted by a power failure or + ** system crash, the database itself may also become corrupt. */ + lock.l_whence = SEEK_SET; + lock.l_start = UNIX_SHM_DMS; + lock.l_len = 1; + lock.l_type = F_WRLCK; + if( osFcntl(pShmNode->hShm, F_GETLK, &lock)!=0 ) { + rc = SQLITE_IOERR_LOCK; + }else if( lock.l_type==F_UNLCK ){ + if( pShmNode->isReadonly ){ + pShmNode->isUnlocked = 1; + rc = SQLITE_READONLY_CANTINIT; + }else{ + rc = unixShmSystemLock(pDbFd, F_WRLCK, UNIX_SHM_DMS, 1); + /* The first connection to attach must truncate the -shm file. We + ** truncate to 3 bytes (an arbitrary small number, less than the + ** -shm header size) rather than 0 as a system debugging aid, to + ** help detect if a -shm file truncation is legitimate or is the work + ** or a rogue process. */ + if( rc==SQLITE_OK && robust_ftruncate(pShmNode->hShm, 3) ){ + rc = unixLogError(SQLITE_IOERR_SHMOPEN,"ftruncate",pShmNode->zFilename); + } + } + }else if( lock.l_type==F_WRLCK ){ + rc = SQLITE_BUSY; + } + + if( rc==SQLITE_OK ){ + assert( lock.l_type==F_UNLCK || lock.l_type==F_RDLCK ); + rc = unixShmSystemLock(pDbFd, F_RDLCK, UNIX_SHM_DMS, 1); + } + return rc; +} + +/* +** Open a shared-memory area associated with open database file pDbFd. +** This particular implementation uses mmapped files. +** +** The file used to implement shared-memory is in the same directory +** as the open database file and has the same name as the open database +** file with the "-shm" suffix added. For example, if the database file +** is "/home/user1/config.db" then the file that is created and mmapped +** for shared memory will be called "/home/user1/config.db-shm". +** +** Another approach to is to use files in /dev/shm or /dev/tmp or an +** some other tmpfs mount. But if a file in a different directory +** from the database file is used, then differing access permissions +** or a chroot() might cause two different processes on the same +** database to end up using different files for shared memory - +** meaning that their memory would not really be shared - resulting +** in database corruption. Nevertheless, this tmpfs file usage +** can be enabled at compile-time using -DSQLITE_SHM_DIRECTORY="/dev/shm" +** or the equivalent. The use of the SQLITE_SHM_DIRECTORY compile-time +** option results in an incompatible build of SQLite; builds of SQLite +** that with differing SQLITE_SHM_DIRECTORY settings attempt to use the +** same database file at the same time, database corruption will likely +** result. The SQLITE_SHM_DIRECTORY compile-time option is considered +** "unsupported" and may go away in a future SQLite release. +** +** When opening a new shared-memory file, if no other instances of that +** file are currently open, in this process or in other processes, then +** the file must be truncated to zero length or have its header cleared. +** +** If the original database file (pDbFd) is using the "unix-excl" VFS +** that means that an exclusive lock is held on the database file and +** that no other processes are able to read or write the database. In +** that case, we do not really need shared memory. No shared memory +** file is created. The shared memory will be simulated with heap memory. +*/ +static int unixOpenSharedMemory(unixFile *pDbFd){ + struct unixShm *p = 0; /* The connection to be opened */ + struct unixShmNode *pShmNode; /* The underlying mmapped file */ + int rc = SQLITE_OK; /* Result code */ + unixInodeInfo *pInode; /* The inode of fd */ + char *zShm; /* Name of the file used for SHM */ + int nShmFilename; /* Size of the SHM filename in bytes */ + + /* Allocate space for the new unixShm object. */ + p = sqlite3_malloc64( sizeof(*p) ); + if( p==0 ) return SQLITE_NOMEM_BKPT; + memset(p, 0, sizeof(*p)); + assert( pDbFd->pShm==0 ); + + /* Check to see if a unixShmNode object already exists. Reuse an existing + ** one if present. Create a new one if necessary. + */ + assert( unixFileMutexNotheld(pDbFd) ); + unixEnterMutex(); + pInode = pDbFd->pInode; + pShmNode = pInode->pShmNode; + if( pShmNode==0 ){ + struct stat sStat; /* fstat() info for database file */ +#ifndef SQLITE_SHM_DIRECTORY + const char *zBasePath = pDbFd->zPath; +#endif + + /* Call fstat() to figure out the permissions on the database file. If + ** a new *-shm file is created, an attempt will be made to create it + ** with the same permissions. + */ + if( osFstat(pDbFd->h, &sStat) ){ + rc = SQLITE_IOERR_FSTAT; + goto shm_open_err; + } + +#ifdef SQLITE_SHM_DIRECTORY + nShmFilename = sizeof(SQLITE_SHM_DIRECTORY) + 31; +#else + nShmFilename = 6 + (int)strlen(zBasePath); +#endif + pShmNode = sqlite3_malloc64( sizeof(*pShmNode) + nShmFilename ); + if( pShmNode==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto shm_open_err; + } + memset(pShmNode, 0, sizeof(*pShmNode)+nShmFilename); + zShm = pShmNode->zFilename = (char*)&pShmNode[1]; +#ifdef SQLITE_SHM_DIRECTORY + sqlite3_snprintf(nShmFilename, zShm, + SQLITE_SHM_DIRECTORY "/sqlite-shm-%x-%x", + (u32)sStat.st_ino, (u32)sStat.st_dev); +#else + sqlite3_snprintf(nShmFilename, zShm, "%s-shm", zBasePath); + sqlite3FileSuffix3(pDbFd->zPath, zShm); +#endif + pShmNode->hShm = -1; + pDbFd->pInode->pShmNode = pShmNode; + pShmNode->pInode = pDbFd->pInode; + if( sqlite3GlobalConfig.bCoreMutex ){ + pShmNode->pShmMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); + if( pShmNode->pShmMutex==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto shm_open_err; + } + } + + if( pInode->bProcessLock==0 ){ + if( 0==sqlite3_uri_boolean(pDbFd->zPath, "readonly_shm", 0) ){ + pShmNode->hShm = robust_open(zShm, O_RDWR|O_CREAT|O_NOFOLLOW, + (sStat.st_mode&0777)); + } + if( pShmNode->hShm<0 ){ + pShmNode->hShm = robust_open(zShm, O_RDONLY|O_NOFOLLOW, + (sStat.st_mode&0777)); + if( pShmNode->hShm<0 ){ + rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zShm); + goto shm_open_err; + } + pShmNode->isReadonly = 1; + } + + /* If this process is running as root, make sure that the SHM file + ** is owned by the same user that owns the original database. Otherwise, + ** the original owner will not be able to connect. + */ + robustFchown(pShmNode->hShm, sStat.st_uid, sStat.st_gid); + + rc = unixLockSharedMemory(pDbFd, pShmNode); + if( rc!=SQLITE_OK && rc!=SQLITE_READONLY_CANTINIT ) goto shm_open_err; + } + } + + /* Make the new connection a child of the unixShmNode */ + p->pShmNode = pShmNode; +#ifdef SQLITE_DEBUG + p->id = pShmNode->nextShmId++; +#endif + pShmNode->nRef++; + pDbFd->pShm = p; + unixLeaveMutex(); + + /* The reference count on pShmNode has already been incremented under + ** the cover of the unixEnterMutex() mutex and the pointer from the + ** new (struct unixShm) object to the pShmNode has been set. All that is + ** left to do is to link the new object into the linked list starting + ** at pShmNode->pFirst. This must be done while holding the + ** pShmNode->pShmMutex. + */ + sqlite3_mutex_enter(pShmNode->pShmMutex); + p->pNext = pShmNode->pFirst; + pShmNode->pFirst = p; + sqlite3_mutex_leave(pShmNode->pShmMutex); + return rc; + + /* Jump here on any error */ +shm_open_err: + unixShmPurge(pDbFd); /* This call frees pShmNode if required */ + sqlite3_free(p); + unixLeaveMutex(); + return rc; +} + +/* +** This function is called to obtain a pointer to region iRegion of the +** shared-memory associated with the database file fd. Shared-memory regions +** are numbered starting from zero. Each shared-memory region is szRegion +** bytes in size. +** +** If an error occurs, an error code is returned and *pp is set to NULL. +** +** Otherwise, if the bExtend parameter is 0 and the requested shared-memory +** region has not been allocated (by any client, including one running in a +** separate process), then *pp is set to NULL and SQLITE_OK returned. If +** bExtend is non-zero and the requested shared-memory region has not yet +** been allocated, it is allocated by this function. +** +** If the shared-memory region has already been allocated or is allocated by +** this call as described above, then it is mapped into this processes +** address space (if it is not already), *pp is set to point to the mapped +** memory and SQLITE_OK returned. +*/ +static int unixShmMap( + sqlite3_file *fd, /* Handle open on database file */ + int iRegion, /* Region to retrieve */ + int szRegion, /* Size of regions */ + int bExtend, /* True to extend file if necessary */ + void volatile **pp /* OUT: Mapped memory */ +){ + unixFile *pDbFd = (unixFile*)fd; + unixShm *p; + unixShmNode *pShmNode; + int rc = SQLITE_OK; + int nShmPerMap = unixShmRegionPerMap(); + int nReqRegion; + + /* If the shared-memory file has not yet been opened, open it now. */ + if( pDbFd->pShm==0 ){ + rc = unixOpenSharedMemory(pDbFd); + if( rc!=SQLITE_OK ) return rc; + } + + p = pDbFd->pShm; + pShmNode = p->pShmNode; + sqlite3_mutex_enter(pShmNode->pShmMutex); + if( pShmNode->isUnlocked ){ + rc = unixLockSharedMemory(pDbFd, pShmNode); + if( rc!=SQLITE_OK ) goto shmpage_out; + pShmNode->isUnlocked = 0; + } + assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 ); + assert( pShmNode->pInode==pDbFd->pInode ); + assert( pShmNode->hShm>=0 || pDbFd->pInode->bProcessLock==1 ); + assert( pShmNode->hShm<0 || pDbFd->pInode->bProcessLock==0 ); + + /* Minimum number of regions required to be mapped. */ + nReqRegion = ((iRegion+nShmPerMap) / nShmPerMap) * nShmPerMap; + + if( pShmNode->nRegionszRegion = szRegion; + + if( pShmNode->hShm>=0 ){ + /* The requested region is not mapped into this processes address space. + ** Check to see if it has been allocated (i.e. if the wal-index file is + ** large enough to contain the requested region). + */ + if( osFstat(pShmNode->hShm, &sStat) ){ + rc = SQLITE_IOERR_SHMSIZE; + goto shmpage_out; + } + + if( sStat.st_sizehShm, iPg*pgsz + pgsz-1,"",1,&x)!=1 ){ + const char *zFile = pShmNode->zFilename; + rc = unixLogError(SQLITE_IOERR_SHMSIZE, "write", zFile); + goto shmpage_out; + } + } + } + } + } + + /* Map the requested memory region into this processes address space. */ + apNew = (char **)sqlite3_realloc( + pShmNode->apRegion, nReqRegion*sizeof(char *) + ); + if( !apNew ){ + rc = SQLITE_IOERR_NOMEM_BKPT; + goto shmpage_out; + } + pShmNode->apRegion = apNew; + while( pShmNode->nRegionhShm>=0 ){ + pMem = osMmap(0, nMap, + pShmNode->isReadonly ? PROT_READ : PROT_READ|PROT_WRITE, + MAP_SHARED, pShmNode->hShm, szRegion*(i64)pShmNode->nRegion + ); + if( pMem==MAP_FAILED ){ + rc = unixLogError(SQLITE_IOERR_SHMMAP, "mmap", pShmNode->zFilename); + goto shmpage_out; + } + }else{ + pMem = sqlite3_malloc64(nMap); + if( pMem==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto shmpage_out; + } + memset(pMem, 0, nMap); + } + + for(i=0; iapRegion[pShmNode->nRegion+i] = &((char*)pMem)[szRegion*i]; + } + pShmNode->nRegion += nShmPerMap; + } + } + +shmpage_out: + if( pShmNode->nRegion>iRegion ){ + *pp = pShmNode->apRegion[iRegion]; + }else{ + *pp = 0; + } + if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY; + sqlite3_mutex_leave(pShmNode->pShmMutex); + return rc; +} + +/* +** Check that the pShmNode->aLock[] array comports with the locking bitmasks +** held by each client. Return true if it does, or false otherwise. This +** is to be used in an assert(). e.g. +** +** assert( assertLockingArrayOk(pShmNode) ); +*/ +#ifdef SQLITE_DEBUG +static int assertLockingArrayOk(unixShmNode *pShmNode){ + unixShm *pX; + int aLock[SQLITE_SHM_NLOCK]; + assert( sqlite3_mutex_held(pShmNode->pShmMutex) ); + + memset(aLock, 0, sizeof(aLock)); + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){ + int i; + for(i=0; iexclMask & (1<sharedMask & (1<=0 ); + aLock[i]++; + } + } + } + + assert( 0==memcmp(pShmNode->aLock, aLock, sizeof(aLock)) ); + return (memcmp(pShmNode->aLock, aLock, sizeof(aLock))==0); +} +#endif + +/* +** Change the lock state for a shared-memory segment. +** +** Note that the relationship between SHAREd and EXCLUSIVE locks is a little +** different here than in posix. In xShmLock(), one can go from unlocked +** to shared and back or from unlocked to exclusive and back. But one may +** not go from shared to exclusive or from exclusive to shared. +*/ +static int unixShmLock( + sqlite3_file *fd, /* Database file holding the shared memory */ + int ofst, /* First lock to acquire or release */ + int n, /* Number of locks to acquire or release */ + int flags /* What to do with the lock */ +){ + unixFile *pDbFd = (unixFile*)fd; /* Connection holding shared memory */ + unixShm *p = pDbFd->pShm; /* The shared memory being locked */ + unixShmNode *pShmNode = p->pShmNode; /* The underlying file iNode */ + int rc = SQLITE_OK; /* Result code */ + u16 mask; /* Mask of locks to take or release */ + int *aLock = pShmNode->aLock; + + assert( pShmNode==pDbFd->pInode->pShmNode ); + assert( pShmNode->pInode==pDbFd->pInode ); + assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK ); + assert( n>=1 ); + assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED) + || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE) + || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED) + || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) ); + assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 ); + assert( pShmNode->hShm>=0 || pDbFd->pInode->bProcessLock==1 ); + assert( pShmNode->hShm<0 || pDbFd->pInode->bProcessLock==0 ); + + /* Check that, if this to be a blocking lock, no locks that occur later + ** in the following list than the lock being obtained are already held: + ** + ** 1. Checkpointer lock (ofst==1). + ** 2. Write lock (ofst==0). + ** 3. Read locks (ofst>=3 && ofstiBusyTimeout==0 || ( + (ofst!=2) /* not RECOVER */ + && (ofst!=1 || (p->exclMask|p->sharedMask)==0) + && (ofst!=0 || (p->exclMask|p->sharedMask)<3) + && (ofst<3 || (p->exclMask|p->sharedMask)<(1<1 || mask==(1<pShmMutex); + assert( assertLockingArrayOk(pShmNode) ); + if( flags & SQLITE_SHM_UNLOCK ){ + if( (p->exclMask|p->sharedMask) & mask ){ + int ii; + int bUnlock = 1; + + for(ii=ofst; ii((p->sharedMask & (1<sharedMask & (1<1 ); + aLock[ofst]--; + } + + /* Undo the local locks */ + if( rc==SQLITE_OK ){ + p->exclMask &= ~mask; + p->sharedMask &= ~mask; + } + } + }else if( flags & SQLITE_SHM_SHARED ){ + assert( n==1 ); + assert( (p->exclMask & (1<sharedMask & mask)==0 ){ + if( aLock[ofst]<0 ){ + rc = SQLITE_BUSY; + }else if( aLock[ofst]==0 ){ + rc = unixShmSystemLock(pDbFd, F_RDLCK, ofst+UNIX_SHM_BASE, n); + } + + /* Get the local shared locks */ + if( rc==SQLITE_OK ){ + p->sharedMask |= mask; + aLock[ofst]++; + } + } + }else{ + /* Make sure no sibling connections hold locks that will block this + ** lock. If any do, return SQLITE_BUSY right away. */ + int ii; + for(ii=ofst; iisharedMask & mask)==0 ); + if( ALWAYS((p->exclMask & (1<sharedMask & mask)==0 ); + p->exclMask |= mask; + for(ii=ofst; iipShmMutex); + OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x\n", + p->id, osGetpid(0), p->sharedMask, p->exclMask)); + return rc; +} + +/* +** Implement a memory barrier or memory fence on shared memory. +** +** All loads and stores begun before the barrier must complete before +** any load or store begun after the barrier. +*/ +static void unixShmBarrier( + sqlite3_file *fd /* Database file holding the shared memory */ +){ + UNUSED_PARAMETER(fd); + sqlite3MemoryBarrier(); /* compiler-defined memory barrier */ + assert( fd->pMethods->xLock==nolockLock + || unixFileMutexNotheld((unixFile*)fd) + ); + unixEnterMutex(); /* Also mutex, for redundancy */ + unixLeaveMutex(); +} + +/* +** Close a connection to shared-memory. Delete the underlying +** storage if deleteFlag is true. +** +** If there is no shared memory associated with the connection then this +** routine is a harmless no-op. +*/ +static int unixShmUnmap( + sqlite3_file *fd, /* The underlying database file */ + int deleteFlag /* Delete shared-memory if true */ +){ + unixShm *p; /* The connection to be closed */ + unixShmNode *pShmNode; /* The underlying shared-memory file */ + unixShm **pp; /* For looping over sibling connections */ + unixFile *pDbFd; /* The underlying database file */ + + pDbFd = (unixFile*)fd; + p = pDbFd->pShm; + if( p==0 ) return SQLITE_OK; + pShmNode = p->pShmNode; + + assert( pShmNode==pDbFd->pInode->pShmNode ); + assert( pShmNode->pInode==pDbFd->pInode ); + + /* Remove connection p from the set of connections associated + ** with pShmNode */ + sqlite3_mutex_enter(pShmNode->pShmMutex); + for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){} + *pp = p->pNext; + + /* Free the connection p */ + sqlite3_free(p); + pDbFd->pShm = 0; + sqlite3_mutex_leave(pShmNode->pShmMutex); + + /* If pShmNode->nRef has reached 0, then close the underlying + ** shared-memory file, too */ + assert( unixFileMutexNotheld(pDbFd) ); + unixEnterMutex(); + assert( pShmNode->nRef>0 ); + pShmNode->nRef--; + if( pShmNode->nRef==0 ){ + if( deleteFlag && pShmNode->hShm>=0 ){ + osUnlink(pShmNode->zFilename); + } + unixShmPurge(pDbFd); + } + unixLeaveMutex(); + + return SQLITE_OK; +} + + +#else +# define unixShmMap 0 +# define unixShmLock 0 +# define unixShmBarrier 0 +# define unixShmUnmap 0 +#endif /* #ifndef SQLITE_OMIT_WAL */ + +#if SQLITE_MAX_MMAP_SIZE>0 +/* +** If it is currently memory mapped, unmap file pFd. +*/ +static void unixUnmapfile(unixFile *pFd){ + assert( pFd->nFetchOut==0 ); + if( pFd->pMapRegion ){ + osMunmap(pFd->pMapRegion, pFd->mmapSizeActual); + pFd->pMapRegion = 0; + pFd->mmapSize = 0; + pFd->mmapSizeActual = 0; + } +} + +/* +** Attempt to set the size of the memory mapping maintained by file +** descriptor pFd to nNew bytes. Any existing mapping is discarded. +** +** If successful, this function sets the following variables: +** +** unixFile.pMapRegion +** unixFile.mmapSize +** unixFile.mmapSizeActual +** +** If unsuccessful, an error message is logged via sqlite3_log() and +** the three variables above are zeroed. In this case SQLite should +** continue accessing the database using the xRead() and xWrite() +** methods. +*/ +static void unixRemapfile( + unixFile *pFd, /* File descriptor object */ + i64 nNew /* Required mapping size */ +){ + const char *zErr = "mmap"; + int h = pFd->h; /* File descriptor open on db file */ + u8 *pOrig = (u8 *)pFd->pMapRegion; /* Pointer to current file mapping */ + i64 nOrig = pFd->mmapSizeActual; /* Size of pOrig region in bytes */ + u8 *pNew = 0; /* Location of new mapping */ + int flags = PROT_READ; /* Flags to pass to mmap() */ + + assert( pFd->nFetchOut==0 ); + assert( nNew>pFd->mmapSize ); + assert( nNew<=pFd->mmapSizeMax ); + assert( nNew>0 ); + assert( pFd->mmapSizeActual>=pFd->mmapSize ); + assert( MAP_FAILED!=0 ); + +#ifdef SQLITE_MMAP_READWRITE + if( (pFd->ctrlFlags & UNIXFILE_RDONLY)==0 ) flags |= PROT_WRITE; +#endif + + if( pOrig ){ +#if HAVE_MREMAP + i64 nReuse = pFd->mmapSize; +#else + const int szSyspage = osGetpagesize(); + i64 nReuse = (pFd->mmapSize & ~(szSyspage-1)); +#endif + u8 *pReq = &pOrig[nReuse]; + + /* Unmap any pages of the existing mapping that cannot be reused. */ + if( nReuse!=nOrig ){ + osMunmap(pReq, nOrig-nReuse); + } + +#if HAVE_MREMAP + pNew = osMremap(pOrig, nReuse, nNew, MREMAP_MAYMOVE); + zErr = "mremap"; +#else + pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse); + if( pNew!=MAP_FAILED ){ + if( pNew!=pReq ){ + osMunmap(pNew, nNew - nReuse); + pNew = 0; + }else{ + pNew = pOrig; + } + } +#endif + + /* The attempt to extend the existing mapping failed. Free it. */ + if( pNew==MAP_FAILED || pNew==0 ){ + osMunmap(pOrig, nReuse); + } + } + + /* If pNew is still NULL, try to create an entirely new mapping. */ + if( pNew==0 ){ + pNew = osMmap(0, nNew, flags, MAP_SHARED, h, 0); + } + + if( pNew==MAP_FAILED ){ + pNew = 0; + nNew = 0; + unixLogError(SQLITE_OK, zErr, pFd->zPath); + + /* If the mmap() above failed, assume that all subsequent mmap() calls + ** will probably fail too. Fall back to using xRead/xWrite exclusively + ** in this case. */ + pFd->mmapSizeMax = 0; + } + pFd->pMapRegion = (void *)pNew; + pFd->mmapSize = pFd->mmapSizeActual = nNew; +} + +/* +** Memory map or remap the file opened by file-descriptor pFd (if the file +** is already mapped, the existing mapping is replaced by the new). Or, if +** there already exists a mapping for this file, and there are still +** outstanding xFetch() references to it, this function is a no-op. +** +** If parameter nByte is non-negative, then it is the requested size of +** the mapping to create. Otherwise, if nByte is less than zero, then the +** requested size is the size of the file on disk. The actual size of the +** created mapping is either the requested size or the value configured +** using SQLITE_FCNTL_MMAP_LIMIT, whichever is smaller. +** +** SQLITE_OK is returned if no error occurs (even if the mapping is not +** recreated as a result of outstanding references) or an SQLite error +** code otherwise. +*/ +static int unixMapfile(unixFile *pFd, i64 nMap){ + assert( nMap>=0 || pFd->nFetchOut==0 ); + assert( nMap>0 || (pFd->mmapSize==0 && pFd->pMapRegion==0) ); + if( pFd->nFetchOut>0 ) return SQLITE_OK; + + if( nMap<0 ){ + struct stat statbuf; /* Low-level file information */ + if( osFstat(pFd->h, &statbuf) ){ + return SQLITE_IOERR_FSTAT; + } + nMap = statbuf.st_size; + } + if( nMap>pFd->mmapSizeMax ){ + nMap = pFd->mmapSizeMax; + } + + assert( nMap>0 || (pFd->mmapSize==0 && pFd->pMapRegion==0) ); + if( nMap!=pFd->mmapSize ){ + unixRemapfile(pFd, nMap); + } + + return SQLITE_OK; +} +#endif /* SQLITE_MAX_MMAP_SIZE>0 */ + +/* +** If possible, return a pointer to a mapping of file fd starting at offset +** iOff. The mapping must be valid for at least nAmt bytes. +** +** If such a pointer can be obtained, store it in *pp and return SQLITE_OK. +** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK. +** Finally, if an error does occur, return an SQLite error code. The final +** value of *pp is undefined in this case. +** +** If this function does return a pointer, the caller must eventually +** release the reference by calling unixUnfetch(). +*/ +static int unixFetch(sqlite3_file *fd, i64 iOff, int nAmt, void **pp){ +#if SQLITE_MAX_MMAP_SIZE>0 + unixFile *pFd = (unixFile *)fd; /* The underlying database file */ +#endif + *pp = 0; + +#if SQLITE_MAX_MMAP_SIZE>0 + if( pFd->mmapSizeMax>0 ){ + if( pFd->pMapRegion==0 ){ + int rc = unixMapfile(pFd, -1); + if( rc!=SQLITE_OK ) return rc; + } + if( pFd->mmapSize >= iOff+nAmt ){ + *pp = &((u8 *)pFd->pMapRegion)[iOff]; + pFd->nFetchOut++; + } + } +#endif + return SQLITE_OK; +} + +/* +** If the third argument is non-NULL, then this function releases a +** reference obtained by an earlier call to unixFetch(). The second +** argument passed to this function must be the same as the corresponding +** argument that was passed to the unixFetch() invocation. +** +** Or, if the third argument is NULL, then this function is being called +** to inform the VFS layer that, according to POSIX, any existing mapping +** may now be invalid and should be unmapped. +*/ +static int unixUnfetch(sqlite3_file *fd, i64 iOff, void *p){ +#if SQLITE_MAX_MMAP_SIZE>0 + unixFile *pFd = (unixFile *)fd; /* The underlying database file */ + UNUSED_PARAMETER(iOff); + + /* If p==0 (unmap the entire file) then there must be no outstanding + ** xFetch references. Or, if p!=0 (meaning it is an xFetch reference), + ** then there must be at least one outstanding. */ + assert( (p==0)==(pFd->nFetchOut==0) ); + + /* If p!=0, it must match the iOff value. */ + assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] ); + + if( p ){ + pFd->nFetchOut--; + }else{ + unixUnmapfile(pFd); + } + + assert( pFd->nFetchOut>=0 ); +#else + UNUSED_PARAMETER(fd); + UNUSED_PARAMETER(p); + UNUSED_PARAMETER(iOff); +#endif + return SQLITE_OK; +} + +/* +** Here ends the implementation of all sqlite3_file methods. +** +********************** End sqlite3_file Methods ******************************* +******************************************************************************/ + +/* +** This division contains definitions of sqlite3_io_methods objects that +** implement various file locking strategies. It also contains definitions +** of "finder" functions. A finder-function is used to locate the appropriate +** sqlite3_io_methods object for a particular database file. The pAppData +** field of the sqlite3_vfs VFS objects are initialized to be pointers to +** the correct finder-function for that VFS. +** +** Most finder functions return a pointer to a fixed sqlite3_io_methods +** object. The only interesting finder-function is autolockIoFinder, which +** looks at the filesystem type and tries to guess the best locking +** strategy from that. +** +** For finder-function F, two objects are created: +** +** (1) The real finder-function named "FImpt()". +** +** (2) A constant pointer to this function named just "F". +** +** +** A pointer to the F pointer is used as the pAppData value for VFS +** objects. We have to do this instead of letting pAppData point +** directly at the finder-function since C90 rules prevent a void* +** from be cast into a function pointer. +** +** +** Each instance of this macro generates two objects: +** +** * A constant sqlite3_io_methods object call METHOD that has locking +** methods CLOSE, LOCK, UNLOCK, CKRESLOCK. +** +** * An I/O method finder function called FINDER that returns a pointer +** to the METHOD object in the previous bullet. +*/ +#define IOMETHODS(FINDER,METHOD,VERSION,CLOSE,LOCK,UNLOCK,CKLOCK,SHMMAP) \ +static const sqlite3_io_methods METHOD = { \ + VERSION, /* iVersion */ \ + CLOSE, /* xClose */ \ + unixRead, /* xRead */ \ + unixWrite, /* xWrite */ \ + unixTruncate, /* xTruncate */ \ + unixSync, /* xSync */ \ + unixFileSize, /* xFileSize */ \ + LOCK, /* xLock */ \ + UNLOCK, /* xUnlock */ \ + CKLOCK, /* xCheckReservedLock */ \ + unixFileControl, /* xFileControl */ \ + unixSectorSize, /* xSectorSize */ \ + unixDeviceCharacteristics, /* xDeviceCapabilities */ \ + SHMMAP, /* xShmMap */ \ + unixShmLock, /* xShmLock */ \ + unixShmBarrier, /* xShmBarrier */ \ + unixShmUnmap, /* xShmUnmap */ \ + unixFetch, /* xFetch */ \ + unixUnfetch, /* xUnfetch */ \ +}; \ +static const sqlite3_io_methods *FINDER##Impl(const char *z, unixFile *p){ \ + UNUSED_PARAMETER(z); UNUSED_PARAMETER(p); \ + return &METHOD; \ +} \ +static const sqlite3_io_methods *(*const FINDER)(const char*,unixFile *p) \ + = FINDER##Impl; + +/* +** Here are all of the sqlite3_io_methods objects for each of the +** locking strategies. Functions that return pointers to these methods +** are also created. +*/ +IOMETHODS( + posixIoFinder, /* Finder function name */ + posixIoMethods, /* sqlite3_io_methods object name */ + 3, /* shared memory and mmap are enabled */ + unixClose, /* xClose method */ + unixLock, /* xLock method */ + unixUnlock, /* xUnlock method */ + unixCheckReservedLock, /* xCheckReservedLock method */ + unixShmMap /* xShmMap method */ +) +IOMETHODS( + nolockIoFinder, /* Finder function name */ + nolockIoMethods, /* sqlite3_io_methods object name */ + 3, /* shared memory and mmap are enabled */ + nolockClose, /* xClose method */ + nolockLock, /* xLock method */ + nolockUnlock, /* xUnlock method */ + nolockCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +IOMETHODS( + dotlockIoFinder, /* Finder function name */ + dotlockIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + dotlockClose, /* xClose method */ + dotlockLock, /* xLock method */ + dotlockUnlock, /* xUnlock method */ + dotlockCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) + +#if SQLITE_ENABLE_LOCKING_STYLE +IOMETHODS( + flockIoFinder, /* Finder function name */ + flockIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + flockClose, /* xClose method */ + flockLock, /* xLock method */ + flockUnlock, /* xUnlock method */ + flockCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +#endif + +#if OS_VXWORKS +IOMETHODS( + semIoFinder, /* Finder function name */ + semIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + semXClose, /* xClose method */ + semXLock, /* xLock method */ + semXUnlock, /* xUnlock method */ + semXCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +#endif + +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +IOMETHODS( + afpIoFinder, /* Finder function name */ + afpIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + afpClose, /* xClose method */ + afpLock, /* xLock method */ + afpUnlock, /* xUnlock method */ + afpCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +#endif + +/* +** The proxy locking method is a "super-method" in the sense that it +** opens secondary file descriptors for the conch and lock files and +** it uses proxy, dot-file, AFP, and flock() locking methods on those +** secondary files. For this reason, the division that implements +** proxy locking is located much further down in the file. But we need +** to go ahead and define the sqlite3_io_methods and finder function +** for proxy locking here. So we forward declare the I/O methods. +*/ +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +static int proxyClose(sqlite3_file*); +static int proxyLock(sqlite3_file*, int); +static int proxyUnlock(sqlite3_file*, int); +static int proxyCheckReservedLock(sqlite3_file*, int*); +IOMETHODS( + proxyIoFinder, /* Finder function name */ + proxyIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + proxyClose, /* xClose method */ + proxyLock, /* xLock method */ + proxyUnlock, /* xUnlock method */ + proxyCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +#endif + +/* nfs lockd on OSX 10.3+ doesn't clear write locks when a read lock is set */ +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +IOMETHODS( + nfsIoFinder, /* Finder function name */ + nfsIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + unixClose, /* xClose method */ + unixLock, /* xLock method */ + nfsUnlock, /* xUnlock method */ + unixCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +#endif + +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +/* +** This "finder" function attempts to determine the best locking strategy +** for the database file "filePath". It then returns the sqlite3_io_methods +** object that implements that strategy. +** +** This is for MacOSX only. +*/ +static const sqlite3_io_methods *autolockIoFinderImpl( + const char *filePath, /* name of the database file */ + unixFile *pNew /* open file object for the database file */ +){ + static const struct Mapping { + const char *zFilesystem; /* Filesystem type name */ + const sqlite3_io_methods *pMethods; /* Appropriate locking method */ + } aMap[] = { + { "hfs", &posixIoMethods }, + { "ufs", &posixIoMethods }, + { "afpfs", &afpIoMethods }, + { "smbfs", &afpIoMethods }, + { "webdav", &nolockIoMethods }, + { 0, 0 } + }; + int i; + struct statfs fsInfo; + struct flock lockInfo; + + if( !filePath ){ + /* If filePath==NULL that means we are dealing with a transient file + ** that does not need to be locked. */ + return &nolockIoMethods; + } + if( statfs(filePath, &fsInfo) != -1 ){ + if( fsInfo.f_flags & MNT_RDONLY ){ + return &nolockIoMethods; + } + for(i=0; aMap[i].zFilesystem; i++){ + if( strcmp(fsInfo.f_fstypename, aMap[i].zFilesystem)==0 ){ + return aMap[i].pMethods; + } + } + } + + /* Default case. Handles, amongst others, "nfs". + ** Test byte-range lock using fcntl(). If the call succeeds, + ** assume that the file-system supports POSIX style locks. + */ + lockInfo.l_len = 1; + lockInfo.l_start = 0; + lockInfo.l_whence = SEEK_SET; + lockInfo.l_type = F_RDLCK; + if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) { + if( strcmp(fsInfo.f_fstypename, "nfs")==0 ){ + return &nfsIoMethods; + } else { + return &posixIoMethods; + } + }else{ + return &dotlockIoMethods; + } +} +static const sqlite3_io_methods + *(*const autolockIoFinder)(const char*,unixFile*) = autolockIoFinderImpl; + +#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */ + +#if OS_VXWORKS +/* +** This "finder" function for VxWorks checks to see if posix advisory +** locking works. If it does, then that is what is used. If it does not +** work, then fallback to named semaphore locking. +*/ +static const sqlite3_io_methods *vxworksIoFinderImpl( + const char *filePath, /* name of the database file */ + unixFile *pNew /* the open file object */ +){ + struct flock lockInfo; + + if( !filePath ){ + /* If filePath==NULL that means we are dealing with a transient file + ** that does not need to be locked. */ + return &nolockIoMethods; + } + + /* Test if fcntl() is supported and use POSIX style locks. + ** Otherwise fall back to the named semaphore method. + */ + lockInfo.l_len = 1; + lockInfo.l_start = 0; + lockInfo.l_whence = SEEK_SET; + lockInfo.l_type = F_RDLCK; + if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) { + return &posixIoMethods; + }else{ + return &semIoMethods; + } +} +static const sqlite3_io_methods + *(*const vxworksIoFinder)(const char*,unixFile*) = vxworksIoFinderImpl; + +#endif /* OS_VXWORKS */ + +/* +** An abstract type for a pointer to an IO method finder function: +*/ +typedef const sqlite3_io_methods *(*finder_type)(const char*,unixFile*); + + +/**************************************************************************** +**************************** sqlite3_vfs methods **************************** +** +** This division contains the implementation of methods on the +** sqlite3_vfs object. +*/ + +/* +** Initialize the contents of the unixFile structure pointed to by pId. +*/ +static int fillInUnixFile( + sqlite3_vfs *pVfs, /* Pointer to vfs object */ + int h, /* Open file descriptor of file being opened */ + sqlite3_file *pId, /* Write to the unixFile structure here */ + const char *zFilename, /* Name of the file being opened */ + int ctrlFlags /* Zero or more UNIXFILE_* values */ +){ + const sqlite3_io_methods *pLockingStyle; + unixFile *pNew = (unixFile *)pId; + int rc = SQLITE_OK; + + assert( pNew->pInode==NULL ); + + /* No locking occurs in temporary files */ + assert( zFilename!=0 || (ctrlFlags & UNIXFILE_NOLOCK)!=0 ); + + OSTRACE(("OPEN %-3d %s\n", h, zFilename)); + pNew->h = h; + pNew->pVfs = pVfs; + pNew->zPath = zFilename; + pNew->ctrlFlags = (u8)ctrlFlags; +#if SQLITE_MAX_MMAP_SIZE>0 + pNew->mmapSizeMax = sqlite3GlobalConfig.szMmap; +#endif + if( sqlite3_uri_boolean(((ctrlFlags & UNIXFILE_URI) ? zFilename : 0), + "psow", SQLITE_POWERSAFE_OVERWRITE) ){ + pNew->ctrlFlags |= UNIXFILE_PSOW; + } + if( strcmp(pVfs->zName,"unix-excl")==0 ){ + pNew->ctrlFlags |= UNIXFILE_EXCL; + } + +#if OS_VXWORKS + pNew->pId = vxworksFindFileId(zFilename); + if( pNew->pId==0 ){ + ctrlFlags |= UNIXFILE_NOLOCK; + rc = SQLITE_NOMEM_BKPT; + } +#endif + + if( ctrlFlags & UNIXFILE_NOLOCK ){ + pLockingStyle = &nolockIoMethods; + }else{ + pLockingStyle = (**(finder_type*)pVfs->pAppData)(zFilename, pNew); +#if SQLITE_ENABLE_LOCKING_STYLE + /* Cache zFilename in the locking context (AFP and dotlock override) for + ** proxyLock activation is possible (remote proxy is based on db name) + ** zFilename remains valid until file is closed, to support */ + pNew->lockingContext = (void*)zFilename; +#endif + } + + if( pLockingStyle == &posixIoMethods +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE + || pLockingStyle == &nfsIoMethods +#endif + ){ + unixEnterMutex(); + rc = findInodeInfo(pNew, &pNew->pInode); + if( rc!=SQLITE_OK ){ + /* If an error occurred in findInodeInfo(), close the file descriptor + ** immediately, before releasing the mutex. findInodeInfo() may fail + ** in two scenarios: + ** + ** (a) A call to fstat() failed. + ** (b) A malloc failed. + ** + ** Scenario (b) may only occur if the process is holding no other + ** file descriptors open on the same file. If there were other file + ** descriptors on this file, then no malloc would be required by + ** findInodeInfo(). If this is the case, it is quite safe to close + ** handle h - as it is guaranteed that no posix locks will be released + ** by doing so. + ** + ** If scenario (a) caused the error then things are not so safe. The + ** implicit assumption here is that if fstat() fails, things are in + ** such bad shape that dropping a lock or two doesn't matter much. + */ + robust_close(pNew, h, __LINE__); + h = -1; + } + unixLeaveMutex(); + } + +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) + else if( pLockingStyle == &afpIoMethods ){ + /* AFP locking uses the file path so it needs to be included in + ** the afpLockingContext. + */ + afpLockingContext *pCtx; + pNew->lockingContext = pCtx = sqlite3_malloc64( sizeof(*pCtx) ); + if( pCtx==0 ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + /* NB: zFilename exists and remains valid until the file is closed + ** according to requirement F11141. So we do not need to make a + ** copy of the filename. */ + pCtx->dbPath = zFilename; + pCtx->reserved = 0; + srandomdev(); + unixEnterMutex(); + rc = findInodeInfo(pNew, &pNew->pInode); + if( rc!=SQLITE_OK ){ + sqlite3_free(pNew->lockingContext); + robust_close(pNew, h, __LINE__); + h = -1; + } + unixLeaveMutex(); + } + } +#endif + + else if( pLockingStyle == &dotlockIoMethods ){ + /* Dotfile locking uses the file path so it needs to be included in + ** the dotlockLockingContext + */ + char *zLockFile; + int nFilename; + assert( zFilename!=0 ); + nFilename = (int)strlen(zFilename) + 6; + zLockFile = (char *)sqlite3_malloc64(nFilename); + if( zLockFile==0 ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + sqlite3_snprintf(nFilename, zLockFile, "%s" DOTLOCK_SUFFIX, zFilename); + } + pNew->lockingContext = zLockFile; + } + +#if OS_VXWORKS + else if( pLockingStyle == &semIoMethods ){ + /* Named semaphore locking uses the file path so it needs to be + ** included in the semLockingContext + */ + unixEnterMutex(); + rc = findInodeInfo(pNew, &pNew->pInode); + if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){ + char *zSemName = pNew->pInode->aSemName; + int n; + sqlite3_snprintf(MAX_PATHNAME, zSemName, "/%s.sem", + pNew->pId->zCanonicalName); + for( n=1; zSemName[n]; n++ ) + if( zSemName[n]=='/' ) zSemName[n] = '_'; + pNew->pInode->pSem = sem_open(zSemName, O_CREAT, 0666, 1); + if( pNew->pInode->pSem == SEM_FAILED ){ + rc = SQLITE_NOMEM_BKPT; + pNew->pInode->aSemName[0] = '\0'; + } + } + unixLeaveMutex(); + } +#endif + + storeLastErrno(pNew, 0); +#if OS_VXWORKS + if( rc!=SQLITE_OK ){ + if( h>=0 ) robust_close(pNew, h, __LINE__); + h = -1; + osUnlink(zFilename); + pNew->ctrlFlags |= UNIXFILE_DELETE; + } +#endif + if( rc!=SQLITE_OK ){ + if( h>=0 ) robust_close(pNew, h, __LINE__); + }else{ + pId->pMethods = pLockingStyle; + OpenCounter(+1); + verifyDbFile(pNew); + } + return rc; +} + +/* +** Return the name of a directory in which to put temporary files. +** If no suitable temporary file directory can be found, return NULL. +*/ +static const char *unixTempFileDir(void){ + static const char *azDirs[] = { + 0, + 0, + "/var/tmp", + "/usr/tmp", + "/tmp", + "." + }; + unsigned int i = 0; + struct stat buf; + const char *zDir = sqlite3_temp_directory; + + if( !azDirs[0] ) azDirs[0] = getenv("SQLITE_TMPDIR"); + if( !azDirs[1] ) azDirs[1] = getenv("TMPDIR"); + while(1){ + if( zDir!=0 + && osStat(zDir, &buf)==0 + && S_ISDIR(buf.st_mode) + && osAccess(zDir, 03)==0 + ){ + return zDir; + } + if( i>=sizeof(azDirs)/sizeof(azDirs[0]) ) break; + zDir = azDirs[i++]; + } + return 0; +} + +/* +** Create a temporary file name in zBuf. zBuf must be allocated +** by the calling process and must be big enough to hold at least +** pVfs->mxPathname bytes. +*/ +static int unixGetTempname(int nBuf, char *zBuf){ + const char *zDir; + int iLimit = 0; + + /* It's odd to simulate an io-error here, but really this is just + ** using the io-error infrastructure to test that SQLite handles this + ** function failing. + */ + zBuf[0] = 0; + SimulateIOError( return SQLITE_IOERR ); + + zDir = unixTempFileDir(); + if( zDir==0 ) return SQLITE_IOERR_GETTEMPPATH; + do{ + u64 r; + sqlite3_randomness(sizeof(r), &r); + assert( nBuf>2 ); + zBuf[nBuf-2] = 0; + sqlite3_snprintf(nBuf, zBuf, "%s/"SQLITE_TEMP_FILE_PREFIX"%llx%c", + zDir, r, 0); + if( zBuf[nBuf-2]!=0 || (iLimit++)>10 ) return SQLITE_ERROR; + }while( osAccess(zBuf,0)==0 ); + return SQLITE_OK; +} + +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) +/* +** Routine to transform a unixFile into a proxy-locking unixFile. +** Implementation in the proxy-lock division, but used by unixOpen() +** if SQLITE_PREFER_PROXY_LOCKING is defined. +*/ +static int proxyTransformUnixFile(unixFile*, const char*); +#endif + +/* +** Search for an unused file descriptor that was opened on the database +** file (not a journal or super-journal file) identified by pathname +** zPath with SQLITE_OPEN_XXX flags matching those passed as the second +** argument to this function. +** +** Such a file descriptor may exist if a database connection was closed +** but the associated file descriptor could not be closed because some +** other file descriptor open on the same file is holding a file-lock. +** Refer to comments in the unixClose() function and the lengthy comment +** describing "Posix Advisory Locking" at the start of this file for +** further details. Also, ticket #4018. +** +** If a suitable file descriptor is found, then it is returned. If no +** such file descriptor is located, -1 is returned. +*/ +static UnixUnusedFd *findReusableFd(const char *zPath, int flags){ + UnixUnusedFd *pUnused = 0; + + /* Do not search for an unused file descriptor on vxworks. Not because + ** vxworks would not benefit from the change (it might, we're not sure), + ** but because no way to test it is currently available. It is better + ** not to risk breaking vxworks support for the sake of such an obscure + ** feature. */ +#if !OS_VXWORKS + struct stat sStat; /* Results of stat() call */ + + unixEnterMutex(); + + /* A stat() call may fail for various reasons. If this happens, it is + ** almost certain that an open() call on the same path will also fail. + ** For this reason, if an error occurs in the stat() call here, it is + ** ignored and -1 is returned. The caller will try to open a new file + ** descriptor on the same path, fail, and return an error to SQLite. + ** + ** Even if a subsequent open() call does succeed, the consequences of + ** not searching for a reusable file descriptor are not dire. */ + if( inodeList!=0 && 0==osStat(zPath, &sStat) ){ + unixInodeInfo *pInode; + + pInode = inodeList; + while( pInode && (pInode->fileId.dev!=sStat.st_dev + || pInode->fileId.ino!=(u64)sStat.st_ino) ){ + pInode = pInode->pNext; + } + if( pInode ){ + UnixUnusedFd **pp; + assert( sqlite3_mutex_notheld(pInode->pLockMutex) ); + sqlite3_mutex_enter(pInode->pLockMutex); + flags &= (SQLITE_OPEN_READONLY|SQLITE_OPEN_READWRITE); + for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext)); + pUnused = *pp; + if( pUnused ){ + *pp = pUnused->pNext; + } + sqlite3_mutex_leave(pInode->pLockMutex); + } + } + unixLeaveMutex(); +#endif /* if !OS_VXWORKS */ + return pUnused; +} + +/* +** Find the mode, uid and gid of file zFile. +*/ +static int getFileMode( + const char *zFile, /* File name */ + mode_t *pMode, /* OUT: Permissions of zFile */ + uid_t *pUid, /* OUT: uid of zFile. */ + gid_t *pGid /* OUT: gid of zFile. */ +){ + struct stat sStat; /* Output of stat() on database file */ + int rc = SQLITE_OK; + if( 0==osStat(zFile, &sStat) ){ + *pMode = sStat.st_mode & 0777; + *pUid = sStat.st_uid; + *pGid = sStat.st_gid; + }else{ + rc = SQLITE_IOERR_FSTAT; + } + return rc; +} + +/* +** This function is called by unixOpen() to determine the unix permissions +** to create new files with. If no error occurs, then SQLITE_OK is returned +** and a value suitable for passing as the third argument to open(2) is +** written to *pMode. If an IO error occurs, an SQLite error code is +** returned and the value of *pMode is not modified. +** +** In most cases, this routine sets *pMode to 0, which will become +** an indication to robust_open() to create the file using +** SQLITE_DEFAULT_FILE_PERMISSIONS adjusted by the umask. +** But if the file being opened is a WAL or regular journal file, then +** this function queries the file-system for the permissions on the +** corresponding database file and sets *pMode to this value. Whenever +** possible, WAL and journal files are created using the same permissions +** as the associated database file. +** +** If the SQLITE_ENABLE_8_3_NAMES option is enabled, then the +** original filename is unavailable. But 8_3_NAMES is only used for +** FAT filesystems and permissions do not matter there, so just use +** the default permissions. In 8_3_NAMES mode, leave *pMode set to zero. +*/ +static int findCreateFileMode( + const char *zPath, /* Path of file (possibly) being created */ + int flags, /* Flags passed as 4th argument to xOpen() */ + mode_t *pMode, /* OUT: Permissions to open file with */ + uid_t *pUid, /* OUT: uid to set on the file */ + gid_t *pGid /* OUT: gid to set on the file */ +){ + int rc = SQLITE_OK; /* Return Code */ + *pMode = 0; + *pUid = 0; + *pGid = 0; + if( flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL) ){ + char zDb[MAX_PATHNAME+1]; /* Database file path */ + int nDb; /* Number of valid bytes in zDb */ + + /* zPath is a path to a WAL or journal file. The following block derives + ** the path to the associated database file from zPath. This block handles + ** the following naming conventions: + ** + ** "-journal" + ** "-wal" + ** "-journalNN" + ** "-walNN" + ** + ** where NN is a decimal number. The NN naming schemes are + ** used by the test_multiplex.c module. + */ + nDb = sqlite3Strlen30(zPath) - 1; + while( zPath[nDb]!='-' ){ + /* In normal operation, the journal file name will always contain + ** a '-' character. However in 8+3 filename mode, or if a corrupt + ** rollback journal specifies a super-journal with a goofy name, then + ** the '-' might be missing. */ + if( nDb==0 || zPath[nDb]=='.' ) return SQLITE_OK; + nDb--; + } + memcpy(zDb, zPath, nDb); + zDb[nDb] = '\0'; + + rc = getFileMode(zDb, pMode, pUid, pGid); + }else if( flags & SQLITE_OPEN_DELETEONCLOSE ){ + *pMode = 0600; + }else if( flags & SQLITE_OPEN_URI ){ + /* If this is a main database file and the file was opened using a URI + ** filename, check for the "modeof" parameter. If present, interpret + ** its value as a filename and try to copy the mode, uid and gid from + ** that file. */ + const char *z = sqlite3_uri_parameter(zPath, "modeof"); + if( z ){ + rc = getFileMode(z, pMode, pUid, pGid); + } + } + return rc; +} + +/* +** Open the file zPath. +** +** Previously, the SQLite OS layer used three functions in place of this +** one: +** +** sqlite3OsOpenReadWrite(); +** sqlite3OsOpenReadOnly(); +** sqlite3OsOpenExclusive(); +** +** These calls correspond to the following combinations of flags: +** +** ReadWrite() -> (READWRITE | CREATE) +** ReadOnly() -> (READONLY) +** OpenExclusive() -> (READWRITE | CREATE | EXCLUSIVE) +** +** The old OpenExclusive() accepted a boolean argument - "delFlag". If +** true, the file was configured to be automatically deleted when the +** file handle closed. To achieve the same effect using this new +** interface, add the DELETEONCLOSE flag to those specified above for +** OpenExclusive(). +*/ +static int unixOpen( + sqlite3_vfs *pVfs, /* The VFS for which this is the xOpen method */ + const char *zPath, /* Pathname of file to be opened */ + sqlite3_file *pFile, /* The file descriptor to be filled in */ + int flags, /* Input flags to control the opening */ + int *pOutFlags /* Output flags returned to SQLite core */ +){ + unixFile *p = (unixFile *)pFile; + int fd = -1; /* File descriptor returned by open() */ + int openFlags = 0; /* Flags to pass to open() */ + int eType = flags&0x0FFF00; /* Type of file to open */ + int noLock; /* True to omit locking primitives */ + int rc = SQLITE_OK; /* Function Return Code */ + int ctrlFlags = 0; /* UNIXFILE_* flags */ + + int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE); + int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE); + int isCreate = (flags & SQLITE_OPEN_CREATE); + int isReadonly = (flags & SQLITE_OPEN_READONLY); + int isReadWrite = (flags & SQLITE_OPEN_READWRITE); +#if SQLITE_ENABLE_LOCKING_STYLE + int isAutoProxy = (flags & SQLITE_OPEN_AUTOPROXY); +#endif +#if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE + struct statfs fsInfo; +#endif + + /* If creating a super- or main-file journal, this function will open + ** a file-descriptor on the directory too. The first time unixSync() + ** is called the directory file descriptor will be fsync()ed and close()d. + */ + int isNewJrnl = (isCreate && ( + eType==SQLITE_OPEN_SUPER_JOURNAL + || eType==SQLITE_OPEN_MAIN_JOURNAL + || eType==SQLITE_OPEN_WAL + )); + + /* If argument zPath is a NULL pointer, this function is required to open + ** a temporary file. Use this buffer to store the file name in. + */ + char zTmpname[MAX_PATHNAME+2]; + const char *zName = zPath; + + /* Check the following statements are true: + ** + ** (a) Exactly one of the READWRITE and READONLY flags must be set, and + ** (b) if CREATE is set, then READWRITE must also be set, and + ** (c) if EXCLUSIVE is set, then CREATE must also be set. + ** (d) if DELETEONCLOSE is set, then CREATE must also be set. + */ + assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly)); + assert(isCreate==0 || isReadWrite); + assert(isExclusive==0 || isCreate); + assert(isDelete==0 || isCreate); + + /* The main DB, main journal, WAL file and super-journal are never + ** automatically deleted. Nor are they ever temporary files. */ + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_SUPER_JOURNAL ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL ); + + /* Assert that the upper layer has set one of the "file-type" flags. */ + assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB + || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL + || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_SUPER_JOURNAL + || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL + ); + + /* Detect a pid change and reset the PRNG. There is a race condition + ** here such that two or more threads all trying to open databases at + ** the same instant might all reset the PRNG. But multiple resets + ** are harmless. + */ + if( randomnessPid!=osGetpid(0) ){ + randomnessPid = osGetpid(0); + sqlite3_randomness(0,0); + } + memset(p, 0, sizeof(unixFile)); + + if( eType==SQLITE_OPEN_MAIN_DB ){ + UnixUnusedFd *pUnused; + pUnused = findReusableFd(zName, flags); + if( pUnused ){ + fd = pUnused->fd; + }else{ + pUnused = sqlite3_malloc64(sizeof(*pUnused)); + if( !pUnused ){ + return SQLITE_NOMEM_BKPT; + } + } + p->pPreallocatedUnused = pUnused; + + /* Database filenames are double-zero terminated if they are not + ** URIs with parameters. Hence, they can always be passed into + ** sqlite3_uri_parameter(). */ + assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 ); + + }else if( !zName ){ + /* If zName is NULL, the upper layer is requesting a temp file. */ + assert(isDelete && !isNewJrnl); + rc = unixGetTempname(pVfs->mxPathname, zTmpname); + if( rc!=SQLITE_OK ){ + return rc; + } + zName = zTmpname; + + /* Generated temporary filenames are always double-zero terminated + ** for use by sqlite3_uri_parameter(). */ + assert( zName[strlen(zName)+1]==0 ); + } + + /* Determine the value of the flags parameter passed to POSIX function + ** open(). These must be calculated even if open() is not called, as + ** they may be stored as part of the file handle and used by the + ** 'conch file' locking functions later on. */ + if( isReadonly ) openFlags |= O_RDONLY; + if( isReadWrite ) openFlags |= O_RDWR; + if( isCreate ) openFlags |= O_CREAT; + if( isExclusive ) openFlags |= (O_EXCL|O_NOFOLLOW); + openFlags |= (O_LARGEFILE|O_BINARY|O_NOFOLLOW); + + if( fd<0 ){ + mode_t openMode; /* Permissions to create file with */ + uid_t uid; /* Userid for the file */ + gid_t gid; /* Groupid for the file */ + rc = findCreateFileMode(zName, flags, &openMode, &uid, &gid); + if( rc!=SQLITE_OK ){ + assert( !p->pPreallocatedUnused ); + assert( eType==SQLITE_OPEN_WAL || eType==SQLITE_OPEN_MAIN_JOURNAL ); + return rc; + } + fd = robust_open(zName, openFlags, openMode); + OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags)); + assert( !isExclusive || (openFlags & O_CREAT)!=0 ); + if( fd<0 ){ + if( isNewJrnl && errno==EACCES && osAccess(zName, F_OK) ){ + /* If unable to create a journal because the directory is not + ** writable, change the error code to indicate that. */ + rc = SQLITE_READONLY_DIRECTORY; + }else if( errno!=EISDIR && isReadWrite ){ + /* Failed to open the file for read/write access. Try read-only. */ + flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE); + openFlags &= ~(O_RDWR|O_CREAT); + flags |= SQLITE_OPEN_READONLY; + openFlags |= O_RDONLY; + isReadonly = 1; + fd = robust_open(zName, openFlags, openMode); + } + } + if( fd<0 ){ + int rc2 = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName); + if( rc==SQLITE_OK ) rc = rc2; + goto open_finished; + } + + /* The owner of the rollback journal or WAL file should always be the + ** same as the owner of the database file. Try to ensure that this is + ** the case. The chown() system call will be a no-op if the current + ** process lacks root privileges, be we should at least try. Without + ** this step, if a root process opens a database file, it can leave + ** behinds a journal/WAL that is owned by root and hence make the + ** database inaccessible to unprivileged processes. + ** + ** If openMode==0, then that means uid and gid are not set correctly + ** (probably because SQLite is configured to use 8+3 filename mode) and + ** in that case we do not want to attempt the chown(). + */ + if( openMode && (flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL))!=0 ){ + robustFchown(fd, uid, gid); + } + } + assert( fd>=0 ); + if( pOutFlags ){ + *pOutFlags = flags; + } + + if( p->pPreallocatedUnused ){ + p->pPreallocatedUnused->fd = fd; + p->pPreallocatedUnused->flags = + flags & (SQLITE_OPEN_READONLY|SQLITE_OPEN_READWRITE); + } + + if( isDelete ){ +#if OS_VXWORKS + zPath = zName; +#elif defined(SQLITE_UNLINK_AFTER_CLOSE) + zPath = sqlite3_mprintf("%s", zName); + if( zPath==0 ){ + robust_close(p, fd, __LINE__); + return SQLITE_NOMEM_BKPT; + } +#else + osUnlink(zName); +#endif + } +#if SQLITE_ENABLE_LOCKING_STYLE + else{ + p->openFlags = openFlags; + } +#endif + +#if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE + if( fstatfs(fd, &fsInfo) == -1 ){ + storeLastErrno(p, errno); + robust_close(p, fd, __LINE__); + return SQLITE_IOERR_ACCESS; + } + if (0 == strncmp("msdos", fsInfo.f_fstypename, 5)) { + ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS; + } + if (0 == strncmp("exfat", fsInfo.f_fstypename, 5)) { + ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS; + } +#endif + + /* Set up appropriate ctrlFlags */ + if( isDelete ) ctrlFlags |= UNIXFILE_DELETE; + if( isReadonly ) ctrlFlags |= UNIXFILE_RDONLY; + noLock = eType!=SQLITE_OPEN_MAIN_DB; + if( noLock ) ctrlFlags |= UNIXFILE_NOLOCK; + if( isNewJrnl ) ctrlFlags |= UNIXFILE_DIRSYNC; + if( flags & SQLITE_OPEN_URI ) ctrlFlags |= UNIXFILE_URI; + +#if SQLITE_ENABLE_LOCKING_STYLE +#if SQLITE_PREFER_PROXY_LOCKING + isAutoProxy = 1; +#endif + if( isAutoProxy && (zPath!=NULL) && (!noLock) && pVfs->xOpen ){ + char *envforce = getenv("SQLITE_FORCE_PROXY_LOCKING"); + int useProxy = 0; + + /* SQLITE_FORCE_PROXY_LOCKING==1 means force always use proxy, 0 means + ** never use proxy, NULL means use proxy for non-local files only. */ + if( envforce!=NULL ){ + useProxy = atoi(envforce)>0; + }else{ + useProxy = !(fsInfo.f_flags&MNT_LOCAL); + } + if( useProxy ){ + rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags); + if( rc==SQLITE_OK ){ + rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:"); + if( rc!=SQLITE_OK ){ + /* Use unixClose to clean up the resources added in fillInUnixFile + ** and clear all the structure's references. Specifically, + ** pFile->pMethods will be NULL so sqlite3OsClose will be a no-op + */ + unixClose(pFile); + return rc; + } + } + goto open_finished; + } + } +#endif + + assert( zPath==0 || zPath[0]=='/' + || eType==SQLITE_OPEN_SUPER_JOURNAL || eType==SQLITE_OPEN_MAIN_JOURNAL + ); + rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags); + +open_finished: + if( rc!=SQLITE_OK ){ + sqlite3_free(p->pPreallocatedUnused); + } + return rc; +} + + +/* +** Delete the file at zPath. If the dirSync argument is true, fsync() +** the directory after deleting the file. +*/ +static int unixDelete( + sqlite3_vfs *NotUsed, /* VFS containing this as the xDelete method */ + const char *zPath, /* Name of file to be deleted */ + int dirSync /* If true, fsync() directory after deleting file */ +){ + int rc = SQLITE_OK; + UNUSED_PARAMETER(NotUsed); + SimulateIOError(return SQLITE_IOERR_DELETE); + if( osUnlink(zPath)==(-1) ){ + if( errno==ENOENT +#if OS_VXWORKS + || osAccess(zPath,0)!=0 +#endif + ){ + rc = SQLITE_IOERR_DELETE_NOENT; + }else{ + rc = unixLogError(SQLITE_IOERR_DELETE, "unlink", zPath); + } + return rc; + } +#ifndef SQLITE_DISABLE_DIRSYNC + if( (dirSync & 1)!=0 ){ + int fd; + rc = osOpenDirectory(zPath, &fd); + if( rc==SQLITE_OK ){ + if( full_fsync(fd,0,0) ){ + rc = unixLogError(SQLITE_IOERR_DIR_FSYNC, "fsync", zPath); + } + robust_close(0, fd, __LINE__); + }else{ + assert( rc==SQLITE_CANTOPEN ); + rc = SQLITE_OK; + } + } +#endif + return rc; +} + +/* +** Test the existence of or access permissions of file zPath. The +** test performed depends on the value of flags: +** +** SQLITE_ACCESS_EXISTS: Return 1 if the file exists +** SQLITE_ACCESS_READWRITE: Return 1 if the file is read and writable. +** SQLITE_ACCESS_READONLY: Return 1 if the file is readable. +** +** Otherwise return 0. +*/ +static int unixAccess( + sqlite3_vfs *NotUsed, /* The VFS containing this xAccess method */ + const char *zPath, /* Path of the file to examine */ + int flags, /* What do we want to learn about the zPath file? */ + int *pResOut /* Write result boolean here */ +){ + UNUSED_PARAMETER(NotUsed); + SimulateIOError( return SQLITE_IOERR_ACCESS; ); + assert( pResOut!=0 ); + + /* The spec says there are three possible values for flags. But only + ** two of them are actually used */ + assert( flags==SQLITE_ACCESS_EXISTS || flags==SQLITE_ACCESS_READWRITE ); + + if( flags==SQLITE_ACCESS_EXISTS ){ + struct stat buf; + *pResOut = 0==osStat(zPath, &buf) && + (!S_ISREG(buf.st_mode) || buf.st_size>0); + }else{ + *pResOut = osAccess(zPath, W_OK|R_OK)==0; + } + return SQLITE_OK; +} + +/* +** If the last component of the pathname in z[0]..z[j-1] is something +** other than ".." then back it out and return true. If the last +** component is empty or if it is ".." then return false. +*/ +static int unixBackupDir(const char *z, int *pJ){ + int j = *pJ; + int i; + if( j<=0 ) return 0; + for(i=j-1; ALWAYS(i>0) && z[i-1]!='/'; i--){} + if( z[i]=='.' && i==j-2 && z[i+1]=='.' ) return 0; + *pJ = i-1; + return 1; +} + +/* +** Convert a relative pathname into a full pathname. Also +** simplify the pathname as follows: +** +** Remove all instances of /./ +** Remove all isntances of /X/../ for any X +*/ +static int mkFullPathname( + const char *zPath, /* Input path */ + char *zOut, /* Output buffer */ + int nOut /* Allocated size of buffer zOut */ +){ + int nPath = sqlite3Strlen30(zPath); + int iOff = 0; + int i, j; + if( zPath[0]!='/' ){ + if( osGetcwd(zOut, nOut-2)==0 ){ + return unixLogError(SQLITE_CANTOPEN_BKPT, "getcwd", zPath); + } + iOff = sqlite3Strlen30(zOut); + zOut[iOff++] = '/'; + } + if( (iOff+nPath+1)>nOut ){ + /* SQLite assumes that xFullPathname() nul-terminates the output buffer + ** even if it returns an error. */ + zOut[iOff] = '\0'; + return SQLITE_CANTOPEN_BKPT; + } + sqlite3_snprintf(nOut-iOff, &zOut[iOff], "%s", zPath); + + /* Remove duplicate '/' characters. Except, two // at the beginning + ** of a pathname is allowed since this is important on windows. */ + for(i=j=1; zOut[i]; i++){ + zOut[j++] = zOut[i]; + while( zOut[i]=='/' && zOut[i+1]=='/' ) i++; + } + zOut[j] = 0; + + assert( zOut[0]=='/' ); + for(i=j=0; zOut[i]; i++){ + if( zOut[i]=='/' ){ + /* Skip over internal "/." directory components */ + if( zOut[i+1]=='.' && zOut[i+2]=='/' ){ + i += 1; + continue; + } + + /* If this is a "/.." directory component then back out the + ** previous term of the directory if it is something other than "..". + */ + if( zOut[i+1]=='.' + && zOut[i+2]=='.' + && zOut[i+3]=='/' + && unixBackupDir(zOut, &j) + ){ + i += 2; + continue; + } + } + if( ALWAYS(j>=0) ) zOut[j] = zOut[i]; + j++; + } + if( NEVER(j==0) ) zOut[j++] = '/'; + zOut[j] = 0; + return SQLITE_OK; +} + +/* +** Turn a relative pathname into a full pathname. The relative path +** is stored as a nul-terminated string in the buffer pointed to by +** zPath. +** +** zOut points to a buffer of at least sqlite3_vfs.mxPathname bytes +** (in this case, MAX_PATHNAME bytes). The full-path is written to +** this buffer before returning. +*/ +static int unixFullPathname( + sqlite3_vfs *pVfs, /* Pointer to vfs object */ + const char *zPath, /* Possibly relative input path */ + int nOut, /* Size of output buffer in bytes */ + char *zOut /* Output buffer */ +){ +#if !defined(HAVE_READLINK) || !defined(HAVE_LSTAT) + return mkFullPathname(zPath, zOut, nOut); +#else + int rc = SQLITE_OK; + int nByte; + int nLink = 0; /* Number of symbolic links followed so far */ + const char *zIn = zPath; /* Input path for each iteration of loop */ + char *zDel = 0; + + assert( pVfs->mxPathname==MAX_PATHNAME ); + UNUSED_PARAMETER(pVfs); + + /* It's odd to simulate an io-error here, but really this is just + ** using the io-error infrastructure to test that SQLite handles this + ** function failing. This function could fail if, for example, the + ** current working directory has been unlinked. + */ + SimulateIOError( return SQLITE_ERROR ); + + do { + + /* Call stat() on path zIn. Set bLink to true if the path is a symbolic + ** link, or false otherwise. */ + int bLink = 0; + struct stat buf; + if( osLstat(zIn, &buf)!=0 ){ + if( errno!=ENOENT ){ + rc = unixLogError(SQLITE_CANTOPEN_BKPT, "lstat", zIn); + } + }else{ + bLink = S_ISLNK(buf.st_mode); + } + + if( bLink ){ + nLink++; + if( zDel==0 ){ + zDel = sqlite3_malloc(nOut); + if( zDel==0 ) rc = SQLITE_NOMEM_BKPT; + }else if( nLink>=SQLITE_MAX_SYMLINKS ){ + rc = SQLITE_CANTOPEN_BKPT; + } + + if( rc==SQLITE_OK ){ + nByte = osReadlink(zIn, zDel, nOut-1); + if( nByte<0 ){ + rc = unixLogError(SQLITE_CANTOPEN_BKPT, "readlink", zIn); + }else{ + if( zDel[0]!='/' ){ + int n; + for(n = sqlite3Strlen30(zIn); n>0 && zIn[n-1]!='/'; n--); + if( nByte+n+1>nOut ){ + rc = SQLITE_CANTOPEN_BKPT; + }else{ + memmove(&zDel[n], zDel, nByte+1); + memcpy(zDel, zIn, n); + nByte += n; + } + } + zDel[nByte] = '\0'; + } + } + + zIn = zDel; + } + + assert( rc!=SQLITE_OK || zIn!=zOut || zIn[0]=='/' ); + if( rc==SQLITE_OK && zIn!=zOut ){ + rc = mkFullPathname(zIn, zOut, nOut); + } + if( bLink==0 ) break; + zIn = zOut; + }while( rc==SQLITE_OK ); + + sqlite3_free(zDel); + if( rc==SQLITE_OK && nLink ) rc = SQLITE_OK_SYMLINK; + return rc; +#endif /* HAVE_READLINK && HAVE_LSTAT */ +} + + +#ifndef SQLITE_OMIT_LOAD_EXTENSION +/* +** Interfaces for opening a shared library, finding entry points +** within the shared library, and closing the shared library. +*/ +#include +static void *unixDlOpen(sqlite3_vfs *NotUsed, const char *zFilename){ + UNUSED_PARAMETER(NotUsed); + return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL); +} + +/* +** SQLite calls this function immediately after a call to unixDlSym() or +** unixDlOpen() fails (returns a null pointer). If a more detailed error +** message is available, it is written to zBufOut. If no error message +** is available, zBufOut is left unmodified and SQLite uses a default +** error message. +*/ +static void unixDlError(sqlite3_vfs *NotUsed, int nBuf, char *zBufOut){ + const char *zErr; + UNUSED_PARAMETER(NotUsed); + unixEnterMutex(); + zErr = dlerror(); + if( zErr ){ + sqlite3_snprintf(nBuf, zBufOut, "%s", zErr); + } + unixLeaveMutex(); +} +static void (*unixDlSym(sqlite3_vfs *NotUsed, void *p, const char*zSym))(void){ + /* + ** GCC with -pedantic-errors says that C90 does not allow a void* to be + ** cast into a pointer to a function. And yet the library dlsym() routine + ** returns a void* which is really a pointer to a function. So how do we + ** use dlsym() with -pedantic-errors? + ** + ** Variable x below is defined to be a pointer to a function taking + ** parameters void* and const char* and returning a pointer to a function. + ** We initialize x by assigning it a pointer to the dlsym() function. + ** (That assignment requires a cast.) Then we call the function that + ** x points to. + ** + ** This work-around is unlikely to work correctly on any system where + ** you really cannot cast a function pointer into void*. But then, on the + ** other hand, dlsym() will not work on such a system either, so we have + ** not really lost anything. + */ + void (*(*x)(void*,const char*))(void); + UNUSED_PARAMETER(NotUsed); + x = (void(*(*)(void*,const char*))(void))dlsym; + return (*x)(p, zSym); +} +static void unixDlClose(sqlite3_vfs *NotUsed, void *pHandle){ + UNUSED_PARAMETER(NotUsed); + dlclose(pHandle); +} +#else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */ + #define unixDlOpen 0 + #define unixDlError 0 + #define unixDlSym 0 + #define unixDlClose 0 +#endif + +/* +** Write nBuf bytes of random data to the supplied buffer zBuf. +*/ +static int unixRandomness(sqlite3_vfs *NotUsed, int nBuf, char *zBuf){ + UNUSED_PARAMETER(NotUsed); + assert((size_t)nBuf>=(sizeof(time_t)+sizeof(int))); + + /* We have to initialize zBuf to prevent valgrind from reporting + ** errors. The reports issued by valgrind are incorrect - we would + ** prefer that the randomness be increased by making use of the + ** uninitialized space in zBuf - but valgrind errors tend to worry + ** some users. Rather than argue, it seems easier just to initialize + ** the whole array and silence valgrind, even if that means less randomness + ** in the random seed. + ** + ** When testing, initializing zBuf[] to zero is all we do. That means + ** that we always use the same random number sequence. This makes the + ** tests repeatable. + */ + memset(zBuf, 0, nBuf); + randomnessPid = osGetpid(0); +#if !defined(SQLITE_TEST) && !defined(SQLITE_OMIT_RANDOMNESS) + { + int fd, got; + fd = robust_open("/dev/urandom", O_RDONLY, 0); + if( fd<0 ){ + time_t t; + time(&t); + memcpy(zBuf, &t, sizeof(t)); + memcpy(&zBuf[sizeof(t)], &randomnessPid, sizeof(randomnessPid)); + assert( sizeof(t)+sizeof(randomnessPid)<=(size_t)nBuf ); + nBuf = sizeof(t) + sizeof(randomnessPid); + }else{ + do{ got = osRead(fd, zBuf, nBuf); }while( got<0 && errno==EINTR ); + robust_close(0, fd, __LINE__); + } + } +#endif + return nBuf; +} + + +/* +** Sleep for a little while. Return the amount of time slept. +** The argument is the number of microseconds we want to sleep. +** The return value is the number of microseconds of sleep actually +** requested from the underlying operating system, a number which +** might be greater than or equal to the argument, but not less +** than the argument. +*/ +static int unixSleep(sqlite3_vfs *NotUsed, int microseconds){ +#if OS_VXWORKS + struct timespec sp; + + sp.tv_sec = microseconds / 1000000; + sp.tv_nsec = (microseconds % 1000000) * 1000; + nanosleep(&sp, NULL); + UNUSED_PARAMETER(NotUsed); + return microseconds; +#elif defined(HAVE_USLEEP) && HAVE_USLEEP + if( microseconds>=1000000 ) sleep(microseconds/1000000); + if( microseconds%1000000 ) usleep(microseconds%1000000); + UNUSED_PARAMETER(NotUsed); + return microseconds; +#else + int seconds = (microseconds+999999)/1000000; + sleep(seconds); + UNUSED_PARAMETER(NotUsed); + return seconds*1000000; +#endif +} + +/* +** The following variable, if set to a non-zero value, is interpreted as +** the number of seconds since 1970 and is used to set the result of +** sqlite3OsCurrentTime() during testing. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */ +#endif + +/* +** Find the current time (in Universal Coordinated Time). Write into *piNow +** the current time and date as a Julian Day number times 86_400_000. In +** other words, write into *piNow the number of milliseconds since the Julian +** epoch of noon in Greenwich on November 24, 4714 B.C according to the +** proleptic Gregorian calendar. +** +** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date +** cannot be found. +*/ +static int unixCurrentTimeInt64(sqlite3_vfs *NotUsed, sqlite3_int64 *piNow){ + static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000; + int rc = SQLITE_OK; +#if defined(NO_GETTOD) + time_t t; + time(&t); + *piNow = ((sqlite3_int64)t)*1000 + unixEpoch; +#elif OS_VXWORKS + struct timespec sNow; + clock_gettime(CLOCK_REALTIME, &sNow); + *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_nsec/1000000; +#else + struct timeval sNow; + (void)gettimeofday(&sNow, 0); /* Cannot fail given valid arguments */ + *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_usec/1000; +#endif + +#ifdef SQLITE_TEST + if( sqlite3_current_time ){ + *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch; + } +#endif + UNUSED_PARAMETER(NotUsed); + return rc; +} + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Find the current time (in Universal Coordinated Time). Write the +** current time and date as a Julian Day number into *prNow and +** return 0. Return 1 if the time and date cannot be found. +*/ +static int unixCurrentTime(sqlite3_vfs *NotUsed, double *prNow){ + sqlite3_int64 i = 0; + int rc; + UNUSED_PARAMETER(NotUsed); + rc = unixCurrentTimeInt64(0, &i); + *prNow = i/86400000.0; + return rc; +} +#else +# define unixCurrentTime 0 +#endif + +/* +** The xGetLastError() method is designed to return a better +** low-level error message when operating-system problems come up +** during SQLite operation. Only the integer return code is currently +** used. +*/ +static int unixGetLastError(sqlite3_vfs *NotUsed, int NotUsed2, char *NotUsed3){ + UNUSED_PARAMETER(NotUsed); + UNUSED_PARAMETER(NotUsed2); + UNUSED_PARAMETER(NotUsed3); + return errno; +} + + +/* +************************ End of sqlite3_vfs methods *************************** +******************************************************************************/ + +/****************************************************************************** +************************** Begin Proxy Locking ******************************** +** +** Proxy locking is a "uber-locking-method" in this sense: It uses the +** other locking methods on secondary lock files. Proxy locking is a +** meta-layer over top of the primitive locking implemented above. For +** this reason, the division that implements of proxy locking is deferred +** until late in the file (here) after all of the other I/O methods have +** been defined - so that the primitive locking methods are available +** as services to help with the implementation of proxy locking. +** +**** +** +** The default locking schemes in SQLite use byte-range locks on the +** database file to coordinate safe, concurrent access by multiple readers +** and writers [http://sqlite.org/lockingv3.html]. The five file locking +** states (UNLOCKED, PENDING, SHARED, RESERVED, EXCLUSIVE) are implemented +** as POSIX read & write locks over fixed set of locations (via fsctl), +** on AFP and SMB only exclusive byte-range locks are available via fsctl +** with _IOWR('z', 23, struct ByteRangeLockPB2) to track the same 5 states. +** To simulate a F_RDLCK on the shared range, on AFP a randomly selected +** address in the shared range is taken for a SHARED lock, the entire +** shared range is taken for an EXCLUSIVE lock): +** +** PENDING_BYTE 0x40000000 +** RESERVED_BYTE 0x40000001 +** SHARED_RANGE 0x40000002 -> 0x40000200 +** +** This works well on the local file system, but shows a nearly 100x +** slowdown in read performance on AFP because the AFP client disables +** the read cache when byte-range locks are present. Enabling the read +** cache exposes a cache coherency problem that is present on all OS X +** supported network file systems. NFS and AFP both observe the +** close-to-open semantics for ensuring cache coherency +** [http://nfs.sourceforge.net/#faq_a8], which does not effectively +** address the requirements for concurrent database access by multiple +** readers and writers +** [http://www.nabble.com/SQLite-on-NFS-cache-coherency-td15655701.html]. +** +** To address the performance and cache coherency issues, proxy file locking +** changes the way database access is controlled by limiting access to a +** single host at a time and moving file locks off of the database file +** and onto a proxy file on the local file system. +** +** +** Using proxy locks +** ----------------- +** +** C APIs +** +** sqlite3_file_control(db, dbname, SQLITE_FCNTL_SET_LOCKPROXYFILE, +** | ":auto:"); +** sqlite3_file_control(db, dbname, SQLITE_FCNTL_GET_LOCKPROXYFILE, +** &); +** +** +** SQL pragmas +** +** PRAGMA [database.]lock_proxy_file= | :auto: +** PRAGMA [database.]lock_proxy_file +** +** Specifying ":auto:" means that if there is a conch file with a matching +** host ID in it, the proxy path in the conch file will be used, otherwise +** a proxy path based on the user's temp dir +** (via confstr(_CS_DARWIN_USER_TEMP_DIR,...)) will be used and the +** actual proxy file name is generated from the name and path of the +** database file. For example: +** +** For database path "/Users/me/foo.db" +** The lock path will be "/sqliteplocks/_Users_me_foo.db:auto:") +** +** Once a lock proxy is configured for a database connection, it can not +** be removed, however it may be switched to a different proxy path via +** the above APIs (assuming the conch file is not being held by another +** connection or process). +** +** +** How proxy locking works +** ----------------------- +** +** Proxy file locking relies primarily on two new supporting files: +** +** * conch file to limit access to the database file to a single host +** at a time +** +** * proxy file to act as a proxy for the advisory locks normally +** taken on the database +** +** The conch file - to use a proxy file, sqlite must first "hold the conch" +** by taking an sqlite-style shared lock on the conch file, reading the +** contents and comparing the host's unique host ID (see below) and lock +** proxy path against the values stored in the conch. The conch file is +** stored in the same directory as the database file and the file name +** is patterned after the database file name as ".-conch". +** If the conch file does not exist, or its contents do not match the +** host ID and/or proxy path, then the lock is escalated to an exclusive +** lock and the conch file contents is updated with the host ID and proxy +** path and the lock is downgraded to a shared lock again. If the conch +** is held by another process (with a shared lock), the exclusive lock +** will fail and SQLITE_BUSY is returned. +** +** The proxy file - a single-byte file used for all advisory file locks +** normally taken on the database file. This allows for safe sharing +** of the database file for multiple readers and writers on the same +** host (the conch ensures that they all use the same local lock file). +** +** Requesting the lock proxy does not immediately take the conch, it is +** only taken when the first request to lock database file is made. +** This matches the semantics of the traditional locking behavior, where +** opening a connection to a database file does not take a lock on it. +** The shared lock and an open file descriptor are maintained until +** the connection to the database is closed. +** +** The proxy file and the lock file are never deleted so they only need +** to be created the first time they are used. +** +** Configuration options +** --------------------- +** +** SQLITE_PREFER_PROXY_LOCKING +** +** Database files accessed on non-local file systems are +** automatically configured for proxy locking, lock files are +** named automatically using the same logic as +** PRAGMA lock_proxy_file=":auto:" +** +** SQLITE_PROXY_DEBUG +** +** Enables the logging of error messages during host id file +** retrieval and creation +** +** LOCKPROXYDIR +** +** Overrides the default directory used for lock proxy files that +** are named automatically via the ":auto:" setting +** +** SQLITE_DEFAULT_PROXYDIR_PERMISSIONS +** +** Permissions to use when creating a directory for storing the +** lock proxy files, only used when LOCKPROXYDIR is not set. +** +** +** As mentioned above, when compiled with SQLITE_PREFER_PROXY_LOCKING, +** setting the environment variable SQLITE_FORCE_PROXY_LOCKING to 1 will +** force proxy locking to be used for every database file opened, and 0 +** will force automatic proxy locking to be disabled for all database +** files (explicitly calling the SQLITE_FCNTL_SET_LOCKPROXYFILE pragma or +** sqlite_file_control API is not affected by SQLITE_FORCE_PROXY_LOCKING). +*/ + +/* +** Proxy locking is only available on MacOSX +*/ +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE + +/* +** The proxyLockingContext has the path and file structures for the remote +** and local proxy files in it +*/ +typedef struct proxyLockingContext proxyLockingContext; +struct proxyLockingContext { + unixFile *conchFile; /* Open conch file */ + char *conchFilePath; /* Name of the conch file */ + unixFile *lockProxy; /* Open proxy lock file */ + char *lockProxyPath; /* Name of the proxy lock file */ + char *dbPath; /* Name of the open file */ + int conchHeld; /* 1 if the conch is held, -1 if lockless */ + int nFails; /* Number of conch taking failures */ + void *oldLockingContext; /* Original lockingcontext to restore on close */ + sqlite3_io_methods const *pOldMethod; /* Original I/O methods for close */ +}; + +/* +** The proxy lock file path for the database at dbPath is written into lPath, +** which must point to valid, writable memory large enough for a maxLen length +** file path. +*/ +static int proxyGetLockPath(const char *dbPath, char *lPath, size_t maxLen){ + int len; + int dbLen; + int i; + +#ifdef LOCKPROXYDIR + len = strlcpy(lPath, LOCKPROXYDIR, maxLen); +#else +# ifdef _CS_DARWIN_USER_TEMP_DIR + { + if( !confstr(_CS_DARWIN_USER_TEMP_DIR, lPath, maxLen) ){ + OSTRACE(("GETLOCKPATH failed %s errno=%d pid=%d\n", + lPath, errno, osGetpid(0))); + return SQLITE_IOERR_LOCK; + } + len = strlcat(lPath, "sqliteplocks", maxLen); + } +# else + len = strlcpy(lPath, "/tmp/", maxLen); +# endif +#endif + + if( lPath[len-1]!='/' ){ + len = strlcat(lPath, "/", maxLen); + } + + /* transform the db path to a unique cache name */ + dbLen = (int)strlen(dbPath); + for( i=0; i 0) ){ + /* only mkdir if leaf dir != "." or "/" or ".." */ + if( i-start>2 || (i-start==1 && buf[start] != '.' && buf[start] != '/') + || (i-start==2 && buf[start] != '.' && buf[start+1] != '.') ){ + buf[i]='\0'; + if( osMkdir(buf, SQLITE_DEFAULT_PROXYDIR_PERMISSIONS) ){ + int err=errno; + if( err!=EEXIST ) { + OSTRACE(("CREATELOCKPATH FAILED creating %s, " + "'%s' proxy lock path=%s pid=%d\n", + buf, strerror(err), lockPath, osGetpid(0))); + return err; + } + } + } + start=i+1; + } + buf[i] = lockPath[i]; + } + OSTRACE(("CREATELOCKPATH proxy lock path=%s pid=%d\n",lockPath,osGetpid(0))); + return 0; +} + +/* +** Create a new VFS file descriptor (stored in memory obtained from +** sqlite3_malloc) and open the file named "path" in the file descriptor. +** +** The caller is responsible not only for closing the file descriptor +** but also for freeing the memory associated with the file descriptor. +*/ +static int proxyCreateUnixFile( + const char *path, /* path for the new unixFile */ + unixFile **ppFile, /* unixFile created and returned by ref */ + int islockfile /* if non zero missing dirs will be created */ +) { + int fd = -1; + unixFile *pNew; + int rc = SQLITE_OK; + int openFlags = O_RDWR | O_CREAT | O_NOFOLLOW; + sqlite3_vfs dummyVfs; + int terrno = 0; + UnixUnusedFd *pUnused = NULL; + + /* 1. first try to open/create the file + ** 2. if that fails, and this is a lock file (not-conch), try creating + ** the parent directories and then try again. + ** 3. if that fails, try to open the file read-only + ** otherwise return BUSY (if lock file) or CANTOPEN for the conch file + */ + pUnused = findReusableFd(path, openFlags); + if( pUnused ){ + fd = pUnused->fd; + }else{ + pUnused = sqlite3_malloc64(sizeof(*pUnused)); + if( !pUnused ){ + return SQLITE_NOMEM_BKPT; + } + } + if( fd<0 ){ + fd = robust_open(path, openFlags, 0); + terrno = errno; + if( fd<0 && errno==ENOENT && islockfile ){ + if( proxyCreateLockPath(path) == SQLITE_OK ){ + fd = robust_open(path, openFlags, 0); + } + } + } + if( fd<0 ){ + openFlags = O_RDONLY | O_NOFOLLOW; + fd = robust_open(path, openFlags, 0); + terrno = errno; + } + if( fd<0 ){ + if( islockfile ){ + return SQLITE_BUSY; + } + switch (terrno) { + case EACCES: + return SQLITE_PERM; + case EIO: + return SQLITE_IOERR_LOCK; /* even though it is the conch */ + default: + return SQLITE_CANTOPEN_BKPT; + } + } + + pNew = (unixFile *)sqlite3_malloc64(sizeof(*pNew)); + if( pNew==NULL ){ + rc = SQLITE_NOMEM_BKPT; + goto end_create_proxy; + } + memset(pNew, 0, sizeof(unixFile)); + pNew->openFlags = openFlags; + memset(&dummyVfs, 0, sizeof(dummyVfs)); + dummyVfs.pAppData = (void*)&autolockIoFinder; + dummyVfs.zName = "dummy"; + pUnused->fd = fd; + pUnused->flags = openFlags; + pNew->pPreallocatedUnused = pUnused; + + rc = fillInUnixFile(&dummyVfs, fd, (sqlite3_file*)pNew, path, 0); + if( rc==SQLITE_OK ){ + *ppFile = pNew; + return SQLITE_OK; + } +end_create_proxy: + robust_close(pNew, fd, __LINE__); + sqlite3_free(pNew); + sqlite3_free(pUnused); + return rc; +} + +#ifdef SQLITE_TEST +/* simulate multiple hosts by creating unique hostid file paths */ +SQLITE_API int sqlite3_hostid_num = 0; +#endif + +#define PROXY_HOSTIDLEN 16 /* conch file host id length */ + +#if HAVE_GETHOSTUUID +/* Not always defined in the headers as it ought to be */ +extern int gethostuuid(uuid_t id, const struct timespec *wait); +#endif + +/* get the host ID via gethostuuid(), pHostID must point to PROXY_HOSTIDLEN +** bytes of writable memory. +*/ +static int proxyGetHostID(unsigned char *pHostID, int *pError){ + assert(PROXY_HOSTIDLEN == sizeof(uuid_t)); + memset(pHostID, 0, PROXY_HOSTIDLEN); +#if HAVE_GETHOSTUUID + { + struct timespec timeout = {1, 0}; /* 1 sec timeout */ + if( gethostuuid(pHostID, &timeout) ){ + int err = errno; + if( pError ){ + *pError = err; + } + return SQLITE_IOERR; + } + } +#else + UNUSED_PARAMETER(pError); +#endif +#ifdef SQLITE_TEST + /* simulate multiple hosts by creating unique hostid file paths */ + if( sqlite3_hostid_num != 0){ + pHostID[0] = (char)(pHostID[0] + (char)(sqlite3_hostid_num & 0xFF)); + } +#endif + + return SQLITE_OK; +} + +/* The conch file contains the header, host id and lock file path + */ +#define PROXY_CONCHVERSION 2 /* 1-byte header, 16-byte host id, path */ +#define PROXY_HEADERLEN 1 /* conch file header length */ +#define PROXY_PATHINDEX (PROXY_HEADERLEN+PROXY_HOSTIDLEN) +#define PROXY_MAXCONCHLEN (PROXY_HEADERLEN+PROXY_HOSTIDLEN+MAXPATHLEN) + +/* +** Takes an open conch file, copies the contents to a new path and then moves +** it back. The newly created file's file descriptor is assigned to the +** conch file structure and finally the original conch file descriptor is +** closed. Returns zero if successful. +*/ +static int proxyBreakConchLock(unixFile *pFile, uuid_t myHostID){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + unixFile *conchFile = pCtx->conchFile; + char tPath[MAXPATHLEN]; + char buf[PROXY_MAXCONCHLEN]; + char *cPath = pCtx->conchFilePath; + size_t readLen = 0; + size_t pathLen = 0; + char errmsg[64] = ""; + int fd = -1; + int rc = -1; + UNUSED_PARAMETER(myHostID); + + /* create a new path by replace the trailing '-conch' with '-break' */ + pathLen = strlcpy(tPath, cPath, MAXPATHLEN); + if( pathLen>MAXPATHLEN || pathLen<6 || + (strlcpy(&tPath[pathLen-5], "break", 6) != 5) ){ + sqlite3_snprintf(sizeof(errmsg),errmsg,"path error (len %d)",(int)pathLen); + goto end_breaklock; + } + /* read the conch content */ + readLen = osPread(conchFile->h, buf, PROXY_MAXCONCHLEN, 0); + if( readLenh, __LINE__); + conchFile->h = fd; + conchFile->openFlags = O_RDWR | O_CREAT; + +end_breaklock: + if( rc ){ + if( fd>=0 ){ + osUnlink(tPath); + robust_close(pFile, fd, __LINE__); + } + fprintf(stderr, "failed to break stale lock on %s, %s\n", cPath, errmsg); + } + return rc; +} + +/* Take the requested lock on the conch file and break a stale lock if the +** host id matches. +*/ +static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + unixFile *conchFile = pCtx->conchFile; + int rc = SQLITE_OK; + int nTries = 0; + struct timespec conchModTime; + + memset(&conchModTime, 0, sizeof(conchModTime)); + do { + rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, lockType); + nTries ++; + if( rc==SQLITE_BUSY ){ + /* If the lock failed (busy): + * 1st try: get the mod time of the conch, wait 0.5s and try again. + * 2nd try: fail if the mod time changed or host id is different, wait + * 10 sec and try again + * 3rd try: break the lock unless the mod time has changed. + */ + struct stat buf; + if( osFstat(conchFile->h, &buf) ){ + storeLastErrno(pFile, errno); + return SQLITE_IOERR_LOCK; + } + + if( nTries==1 ){ + conchModTime = buf.st_mtimespec; + unixSleep(0,500000); /* wait 0.5 sec and try the lock again*/ + continue; + } + + assert( nTries>1 ); + if( conchModTime.tv_sec != buf.st_mtimespec.tv_sec || + conchModTime.tv_nsec != buf.st_mtimespec.tv_nsec ){ + return SQLITE_BUSY; + } + + if( nTries==2 ){ + char tBuf[PROXY_MAXCONCHLEN]; + int len = osPread(conchFile->h, tBuf, PROXY_MAXCONCHLEN, 0); + if( len<0 ){ + storeLastErrno(pFile, errno); + return SQLITE_IOERR_LOCK; + } + if( len>PROXY_PATHINDEX && tBuf[0]==(char)PROXY_CONCHVERSION){ + /* don't break the lock if the host id doesn't match */ + if( 0!=memcmp(&tBuf[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN) ){ + return SQLITE_BUSY; + } + }else{ + /* don't break the lock on short read or a version mismatch */ + return SQLITE_BUSY; + } + unixSleep(0,10000000); /* wait 10 sec and try the lock again */ + continue; + } + + assert( nTries==3 ); + if( 0==proxyBreakConchLock(pFile, myHostID) ){ + rc = SQLITE_OK; + if( lockType==EXCLUSIVE_LOCK ){ + rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, SHARED_LOCK); + } + if( !rc ){ + rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, lockType); + } + } + } + } while( rc==SQLITE_BUSY && nTries<3 ); + + return rc; +} + +/* Takes the conch by taking a shared lock and read the contents conch, if +** lockPath is non-NULL, the host ID and lock file path must match. A NULL +** lockPath means that the lockPath in the conch file will be used if the +** host IDs match, or a new lock path will be generated automatically +** and written to the conch file. +*/ +static int proxyTakeConch(unixFile *pFile){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + + if( pCtx->conchHeld!=0 ){ + return SQLITE_OK; + }else{ + unixFile *conchFile = pCtx->conchFile; + uuid_t myHostID; + int pError = 0; + char readBuf[PROXY_MAXCONCHLEN]; + char lockPath[MAXPATHLEN]; + char *tempLockPath = NULL; + int rc = SQLITE_OK; + int createConch = 0; + int hostIdMatch = 0; + int readLen = 0; + int tryOldLockPath = 0; + int forceNewLockPath = 0; + + OSTRACE(("TAKECONCH %d for %s pid=%d\n", conchFile->h, + (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"), + osGetpid(0))); + + rc = proxyGetHostID(myHostID, &pError); + if( (rc&0xff)==SQLITE_IOERR ){ + storeLastErrno(pFile, pError); + goto end_takeconch; + } + rc = proxyConchLock(pFile, myHostID, SHARED_LOCK); + if( rc!=SQLITE_OK ){ + goto end_takeconch; + } + /* read the existing conch file */ + readLen = seekAndRead((unixFile*)conchFile, 0, readBuf, PROXY_MAXCONCHLEN); + if( readLen<0 ){ + /* I/O error: lastErrno set by seekAndRead */ + storeLastErrno(pFile, conchFile->lastErrno); + rc = SQLITE_IOERR_READ; + goto end_takeconch; + }else if( readLen<=(PROXY_HEADERLEN+PROXY_HOSTIDLEN) || + readBuf[0]!=(char)PROXY_CONCHVERSION ){ + /* a short read or version format mismatch means we need to create a new + ** conch file. + */ + createConch = 1; + } + /* if the host id matches and the lock path already exists in the conch + ** we'll try to use the path there, if we can't open that path, we'll + ** retry with a new auto-generated path + */ + do { /* in case we need to try again for an :auto: named lock file */ + + if( !createConch && !forceNewLockPath ){ + hostIdMatch = !memcmp(&readBuf[PROXY_HEADERLEN], myHostID, + PROXY_HOSTIDLEN); + /* if the conch has data compare the contents */ + if( !pCtx->lockProxyPath ){ + /* for auto-named local lock file, just check the host ID and we'll + ** use the local lock file path that's already in there + */ + if( hostIdMatch ){ + size_t pathLen = (readLen - PROXY_PATHINDEX); + + if( pathLen>=MAXPATHLEN ){ + pathLen=MAXPATHLEN-1; + } + memcpy(lockPath, &readBuf[PROXY_PATHINDEX], pathLen); + lockPath[pathLen] = 0; + tempLockPath = lockPath; + tryOldLockPath = 1; + /* create a copy of the lock path if the conch is taken */ + goto end_takeconch; + } + }else if( hostIdMatch + && !strncmp(pCtx->lockProxyPath, &readBuf[PROXY_PATHINDEX], + readLen-PROXY_PATHINDEX) + ){ + /* conch host and lock path match */ + goto end_takeconch; + } + } + + /* if the conch isn't writable and doesn't match, we can't take it */ + if( (conchFile->openFlags&O_RDWR) == 0 ){ + rc = SQLITE_BUSY; + goto end_takeconch; + } + + /* either the conch didn't match or we need to create a new one */ + if( !pCtx->lockProxyPath ){ + proxyGetLockPath(pCtx->dbPath, lockPath, MAXPATHLEN); + tempLockPath = lockPath; + /* create a copy of the lock path _only_ if the conch is taken */ + } + + /* update conch with host and path (this will fail if other process + ** has a shared lock already), if the host id matches, use the big + ** stick. + */ + futimes(conchFile->h, NULL); + if( hostIdMatch && !createConch ){ + if( conchFile->pInode && conchFile->pInode->nShared>1 ){ + /* We are trying for an exclusive lock but another thread in this + ** same process is still holding a shared lock. */ + rc = SQLITE_BUSY; + } else { + rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK); + } + }else{ + rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK); + } + if( rc==SQLITE_OK ){ + char writeBuffer[PROXY_MAXCONCHLEN]; + int writeSize = 0; + + writeBuffer[0] = (char)PROXY_CONCHVERSION; + memcpy(&writeBuffer[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN); + if( pCtx->lockProxyPath!=NULL ){ + strlcpy(&writeBuffer[PROXY_PATHINDEX], pCtx->lockProxyPath, + MAXPATHLEN); + }else{ + strlcpy(&writeBuffer[PROXY_PATHINDEX], tempLockPath, MAXPATHLEN); + } + writeSize = PROXY_PATHINDEX + strlen(&writeBuffer[PROXY_PATHINDEX]); + robust_ftruncate(conchFile->h, writeSize); + rc = unixWrite((sqlite3_file *)conchFile, writeBuffer, writeSize, 0); + full_fsync(conchFile->h,0,0); + /* If we created a new conch file (not just updated the contents of a + ** valid conch file), try to match the permissions of the database + */ + if( rc==SQLITE_OK && createConch ){ + struct stat buf; + int err = osFstat(pFile->h, &buf); + if( err==0 ){ + mode_t cmode = buf.st_mode&(S_IRUSR|S_IWUSR | S_IRGRP|S_IWGRP | + S_IROTH|S_IWOTH); + /* try to match the database file R/W permissions, ignore failure */ +#ifndef SQLITE_PROXY_DEBUG + osFchmod(conchFile->h, cmode); +#else + do{ + rc = osFchmod(conchFile->h, cmode); + }while( rc==(-1) && errno==EINTR ); + if( rc!=0 ){ + int code = errno; + fprintf(stderr, "fchmod %o FAILED with %d %s\n", + cmode, code, strerror(code)); + } else { + fprintf(stderr, "fchmod %o SUCCEDED\n",cmode); + } + }else{ + int code = errno; + fprintf(stderr, "STAT FAILED[%d] with %d %s\n", + err, code, strerror(code)); +#endif + } + } + } + conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, SHARED_LOCK); + + end_takeconch: + OSTRACE(("TRANSPROXY: CLOSE %d\n", pFile->h)); + if( rc==SQLITE_OK && pFile->openFlags ){ + int fd; + if( pFile->h>=0 ){ + robust_close(pFile, pFile->h, __LINE__); + } + pFile->h = -1; + fd = robust_open(pCtx->dbPath, pFile->openFlags, 0); + OSTRACE(("TRANSPROXY: OPEN %d\n", fd)); + if( fd>=0 ){ + pFile->h = fd; + }else{ + rc=SQLITE_CANTOPEN_BKPT; /* SQLITE_BUSY? proxyTakeConch called + during locking */ + } + } + if( rc==SQLITE_OK && !pCtx->lockProxy ){ + char *path = tempLockPath ? tempLockPath : pCtx->lockProxyPath; + rc = proxyCreateUnixFile(path, &pCtx->lockProxy, 1); + if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM && tryOldLockPath ){ + /* we couldn't create the proxy lock file with the old lock file path + ** so try again via auto-naming + */ + forceNewLockPath = 1; + tryOldLockPath = 0; + continue; /* go back to the do {} while start point, try again */ + } + } + if( rc==SQLITE_OK ){ + /* Need to make a copy of path if we extracted the value + ** from the conch file or the path was allocated on the stack + */ + if( tempLockPath ){ + pCtx->lockProxyPath = sqlite3DbStrDup(0, tempLockPath); + if( !pCtx->lockProxyPath ){ + rc = SQLITE_NOMEM_BKPT; + } + } + } + if( rc==SQLITE_OK ){ + pCtx->conchHeld = 1; + + if( pCtx->lockProxy->pMethod == &afpIoMethods ){ + afpLockingContext *afpCtx; + afpCtx = (afpLockingContext *)pCtx->lockProxy->lockingContext; + afpCtx->dbPath = pCtx->lockProxyPath; + } + } else { + conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, NO_LOCK); + } + OSTRACE(("TAKECONCH %d %s\n", conchFile->h, + rc==SQLITE_OK?"ok":"failed")); + return rc; + } while (1); /* in case we need to retry the :auto: lock file - + ** we should never get here except via the 'continue' call. */ + } +} + +/* +** If pFile holds a lock on a conch file, then release that lock. +*/ +static int proxyReleaseConch(unixFile *pFile){ + int rc = SQLITE_OK; /* Subroutine return code */ + proxyLockingContext *pCtx; /* The locking context for the proxy lock */ + unixFile *conchFile; /* Name of the conch file */ + + pCtx = (proxyLockingContext *)pFile->lockingContext; + conchFile = pCtx->conchFile; + OSTRACE(("RELEASECONCH %d for %s pid=%d\n", conchFile->h, + (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"), + osGetpid(0))); + if( pCtx->conchHeld>0 ){ + rc = conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, NO_LOCK); + } + pCtx->conchHeld = 0; + OSTRACE(("RELEASECONCH %d %s\n", conchFile->h, + (rc==SQLITE_OK ? "ok" : "failed"))); + return rc; +} + +/* +** Given the name of a database file, compute the name of its conch file. +** Store the conch filename in memory obtained from sqlite3_malloc64(). +** Make *pConchPath point to the new name. Return SQLITE_OK on success +** or SQLITE_NOMEM if unable to obtain memory. +** +** The caller is responsible for ensuring that the allocated memory +** space is eventually freed. +** +** *pConchPath is set to NULL if a memory allocation error occurs. +*/ +static int proxyCreateConchPathname(char *dbPath, char **pConchPath){ + int i; /* Loop counter */ + int len = (int)strlen(dbPath); /* Length of database filename - dbPath */ + char *conchPath; /* buffer in which to construct conch name */ + + /* Allocate space for the conch filename and initialize the name to + ** the name of the original database file. */ + *pConchPath = conchPath = (char *)sqlite3_malloc64(len + 8); + if( conchPath==0 ){ + return SQLITE_NOMEM_BKPT; + } + memcpy(conchPath, dbPath, len+1); + + /* now insert a "." before the last / character */ + for( i=(len-1); i>=0; i-- ){ + if( conchPath[i]=='/' ){ + i++; + break; + } + } + conchPath[i]='.'; + while ( ilockingContext; + char *oldPath = pCtx->lockProxyPath; + int rc = SQLITE_OK; + + if( pFile->eFileLock!=NO_LOCK ){ + return SQLITE_BUSY; + } + + /* nothing to do if the path is NULL, :auto: or matches the existing path */ + if( !path || path[0]=='\0' || !strcmp(path, ":auto:") || + (oldPath && !strncmp(oldPath, path, MAXPATHLEN)) ){ + return SQLITE_OK; + }else{ + unixFile *lockProxy = pCtx->lockProxy; + pCtx->lockProxy=NULL; + pCtx->conchHeld = 0; + if( lockProxy!=NULL ){ + rc=lockProxy->pMethod->xClose((sqlite3_file *)lockProxy); + if( rc ) return rc; + sqlite3_free(lockProxy); + } + sqlite3_free(oldPath); + pCtx->lockProxyPath = sqlite3DbStrDup(0, path); + } + + return rc; +} + +/* +** pFile is a file that has been opened by a prior xOpen call. dbPath +** is a string buffer at least MAXPATHLEN+1 characters in size. +** +** This routine find the filename associated with pFile and writes it +** int dbPath. +*/ +static int proxyGetDbPathForUnixFile(unixFile *pFile, char *dbPath){ +#if defined(__APPLE__) + if( pFile->pMethod == &afpIoMethods ){ + /* afp style keeps a reference to the db path in the filePath field + ** of the struct */ + assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN ); + strlcpy(dbPath, ((afpLockingContext *)pFile->lockingContext)->dbPath, + MAXPATHLEN); + } else +#endif + if( pFile->pMethod == &dotlockIoMethods ){ + /* dot lock style uses the locking context to store the dot lock + ** file path */ + int len = strlen((char *)pFile->lockingContext) - strlen(DOTLOCK_SUFFIX); + memcpy(dbPath, (char *)pFile->lockingContext, len + 1); + }else{ + /* all other styles use the locking context to store the db file path */ + assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN ); + strlcpy(dbPath, (char *)pFile->lockingContext, MAXPATHLEN); + } + return SQLITE_OK; +} + +/* +** Takes an already filled in unix file and alters it so all file locking +** will be performed on the local proxy lock file. The following fields +** are preserved in the locking context so that they can be restored and +** the unix structure properly cleaned up at close time: +** ->lockingContext +** ->pMethod +*/ +static int proxyTransformUnixFile(unixFile *pFile, const char *path) { + proxyLockingContext *pCtx; + char dbPath[MAXPATHLEN+1]; /* Name of the database file */ + char *lockPath=NULL; + int rc = SQLITE_OK; + + if( pFile->eFileLock!=NO_LOCK ){ + return SQLITE_BUSY; + } + proxyGetDbPathForUnixFile(pFile, dbPath); + if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ){ + lockPath=NULL; + }else{ + lockPath=(char *)path; + } + + OSTRACE(("TRANSPROXY %d for %s pid=%d\n", pFile->h, + (lockPath ? lockPath : ":auto:"), osGetpid(0))); + + pCtx = sqlite3_malloc64( sizeof(*pCtx) ); + if( pCtx==0 ){ + return SQLITE_NOMEM_BKPT; + } + memset(pCtx, 0, sizeof(*pCtx)); + + rc = proxyCreateConchPathname(dbPath, &pCtx->conchFilePath); + if( rc==SQLITE_OK ){ + rc = proxyCreateUnixFile(pCtx->conchFilePath, &pCtx->conchFile, 0); + if( rc==SQLITE_CANTOPEN && ((pFile->openFlags&O_RDWR) == 0) ){ + /* if (a) the open flags are not O_RDWR, (b) the conch isn't there, and + ** (c) the file system is read-only, then enable no-locking access. + ** Ugh, since O_RDONLY==0x0000 we test for !O_RDWR since unixOpen asserts + ** that openFlags will have only one of O_RDONLY or O_RDWR. + */ + struct statfs fsInfo; + struct stat conchInfo; + int goLockless = 0; + + if( osStat(pCtx->conchFilePath, &conchInfo) == -1 ) { + int err = errno; + if( (err==ENOENT) && (statfs(dbPath, &fsInfo) != -1) ){ + goLockless = (fsInfo.f_flags&MNT_RDONLY) == MNT_RDONLY; + } + } + if( goLockless ){ + pCtx->conchHeld = -1; /* read only FS/ lockless */ + rc = SQLITE_OK; + } + } + } + if( rc==SQLITE_OK && lockPath ){ + pCtx->lockProxyPath = sqlite3DbStrDup(0, lockPath); + } + + if( rc==SQLITE_OK ){ + pCtx->dbPath = sqlite3DbStrDup(0, dbPath); + if( pCtx->dbPath==NULL ){ + rc = SQLITE_NOMEM_BKPT; + } + } + if( rc==SQLITE_OK ){ + /* all memory is allocated, proxys are created and assigned, + ** switch the locking context and pMethod then return. + */ + pCtx->oldLockingContext = pFile->lockingContext; + pFile->lockingContext = pCtx; + pCtx->pOldMethod = pFile->pMethod; + pFile->pMethod = &proxyIoMethods; + }else{ + if( pCtx->conchFile ){ + pCtx->conchFile->pMethod->xClose((sqlite3_file *)pCtx->conchFile); + sqlite3_free(pCtx->conchFile); + } + sqlite3DbFree(0, pCtx->lockProxyPath); + sqlite3_free(pCtx->conchFilePath); + sqlite3_free(pCtx); + } + OSTRACE(("TRANSPROXY %d %s\n", pFile->h, + (rc==SQLITE_OK ? "ok" : "failed"))); + return rc; +} + + +/* +** This routine handles sqlite3_file_control() calls that are specific +** to proxy locking. +*/ +static int proxyFileControl(sqlite3_file *id, int op, void *pArg){ + switch( op ){ + case SQLITE_FCNTL_GET_LOCKPROXYFILE: { + unixFile *pFile = (unixFile*)id; + if( pFile->pMethod == &proxyIoMethods ){ + proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext; + proxyTakeConch(pFile); + if( pCtx->lockProxyPath ){ + *(const char **)pArg = pCtx->lockProxyPath; + }else{ + *(const char **)pArg = ":auto: (not held)"; + } + } else { + *(const char **)pArg = NULL; + } + return SQLITE_OK; + } + case SQLITE_FCNTL_SET_LOCKPROXYFILE: { + unixFile *pFile = (unixFile*)id; + int rc = SQLITE_OK; + int isProxyStyle = (pFile->pMethod == &proxyIoMethods); + if( pArg==NULL || (const char *)pArg==0 ){ + if( isProxyStyle ){ + /* turn off proxy locking - not supported. If support is added for + ** switching proxy locking mode off then it will need to fail if + ** the journal mode is WAL mode. + */ + rc = SQLITE_ERROR /*SQLITE_PROTOCOL? SQLITE_MISUSE?*/; + }else{ + /* turn off proxy locking - already off - NOOP */ + rc = SQLITE_OK; + } + }else{ + const char *proxyPath = (const char *)pArg; + if( isProxyStyle ){ + proxyLockingContext *pCtx = + (proxyLockingContext*)pFile->lockingContext; + if( !strcmp(pArg, ":auto:") + || (pCtx->lockProxyPath && + !strncmp(pCtx->lockProxyPath, proxyPath, MAXPATHLEN)) + ){ + rc = SQLITE_OK; + }else{ + rc = switchLockProxyPath(pFile, proxyPath); + } + }else{ + /* turn on proxy file locking */ + rc = proxyTransformUnixFile(pFile, proxyPath); + } + } + return rc; + } + default: { + assert( 0 ); /* The call assures that only valid opcodes are sent */ + } + } + /*NOTREACHED*/ assert(0); + return SQLITE_ERROR; +} + +/* +** Within this division (the proxying locking implementation) the procedures +** above this point are all utilities. The lock-related methods of the +** proxy-locking sqlite3_io_method object follow. +*/ + + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +*/ +static int proxyCheckReservedLock(sqlite3_file *id, int *pResOut) { + unixFile *pFile = (unixFile*)id; + int rc = proxyTakeConch(pFile); + if( rc==SQLITE_OK ){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + if( pCtx->conchHeld>0 ){ + unixFile *proxy = pCtx->lockProxy; + return proxy->pMethod->xCheckReservedLock((sqlite3_file*)proxy, pResOut); + }else{ /* conchHeld < 0 is lockless */ + pResOut=0; + } + } + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int proxyLock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + int rc = proxyTakeConch(pFile); + if( rc==SQLITE_OK ){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + if( pCtx->conchHeld>0 ){ + unixFile *proxy = pCtx->lockProxy; + rc = proxy->pMethod->xLock((sqlite3_file*)proxy, eFileLock); + pFile->eFileLock = proxy->eFileLock; + }else{ + /* conchHeld < 0 is lockless */ + } + } + return rc; +} + + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int proxyUnlock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + int rc = proxyTakeConch(pFile); + if( rc==SQLITE_OK ){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + if( pCtx->conchHeld>0 ){ + unixFile *proxy = pCtx->lockProxy; + rc = proxy->pMethod->xUnlock((sqlite3_file*)proxy, eFileLock); + pFile->eFileLock = proxy->eFileLock; + }else{ + /* conchHeld < 0 is lockless */ + } + } + return rc; +} + +/* +** Close a file that uses proxy locks. +*/ +static int proxyClose(sqlite3_file *id) { + if( ALWAYS(id) ){ + unixFile *pFile = (unixFile*)id; + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + unixFile *lockProxy = pCtx->lockProxy; + unixFile *conchFile = pCtx->conchFile; + int rc = SQLITE_OK; + + if( lockProxy ){ + rc = lockProxy->pMethod->xUnlock((sqlite3_file*)lockProxy, NO_LOCK); + if( rc ) return rc; + rc = lockProxy->pMethod->xClose((sqlite3_file*)lockProxy); + if( rc ) return rc; + sqlite3_free(lockProxy); + pCtx->lockProxy = 0; + } + if( conchFile ){ + if( pCtx->conchHeld ){ + rc = proxyReleaseConch(pFile); + if( rc ) return rc; + } + rc = conchFile->pMethod->xClose((sqlite3_file*)conchFile); + if( rc ) return rc; + sqlite3_free(conchFile); + } + sqlite3DbFree(0, pCtx->lockProxyPath); + sqlite3_free(pCtx->conchFilePath); + sqlite3DbFree(0, pCtx->dbPath); + /* restore the original locking context and pMethod then close it */ + pFile->lockingContext = pCtx->oldLockingContext; + pFile->pMethod = pCtx->pOldMethod; + sqlite3_free(pCtx); + return pFile->pMethod->xClose(id); + } + return SQLITE_OK; +} + + + +#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */ +/* +** The proxy locking style is intended for use with AFP filesystems. +** And since AFP is only supported on MacOSX, the proxy locking is also +** restricted to MacOSX. +** +** +******************* End of the proxy lock implementation ********************** +******************************************************************************/ + +/* +** Initialize the operating system interface. +** +** This routine registers all VFS implementations for unix-like operating +** systems. This routine, and the sqlite3_os_end() routine that follows, +** should be the only routines in this file that are visible from other +** files. +** +** This routine is called once during SQLite initialization and by a +** single thread. The memory allocation and mutex subsystems have not +** necessarily been initialized when this routine is called, and so they +** should not be used. +*/ +SQLITE_API int sqlite3_os_init(void){ + /* + ** The following macro defines an initializer for an sqlite3_vfs object. + ** The name of the VFS is NAME. The pAppData is a pointer to a pointer + ** to the "finder" function. (pAppData is a pointer to a pointer because + ** silly C90 rules prohibit a void* from being cast to a function pointer + ** and so we have to go through the intermediate pointer to avoid problems + ** when compiling with -pedantic-errors on GCC.) + ** + ** The FINDER parameter to this macro is the name of the pointer to the + ** finder-function. The finder-function returns a pointer to the + ** sqlite_io_methods object that implements the desired locking + ** behaviors. See the division above that contains the IOMETHODS + ** macro for addition information on finder-functions. + ** + ** Most finders simply return a pointer to a fixed sqlite3_io_methods + ** object. But the "autolockIoFinder" available on MacOSX does a little + ** more than that; it looks at the filesystem type that hosts the + ** database file and tries to choose an locking method appropriate for + ** that filesystem time. + */ + #define UNIXVFS(VFSNAME, FINDER) { \ + 3, /* iVersion */ \ + sizeof(unixFile), /* szOsFile */ \ + MAX_PATHNAME, /* mxPathname */ \ + 0, /* pNext */ \ + VFSNAME, /* zName */ \ + (void*)&FINDER, /* pAppData */ \ + unixOpen, /* xOpen */ \ + unixDelete, /* xDelete */ \ + unixAccess, /* xAccess */ \ + unixFullPathname, /* xFullPathname */ \ + unixDlOpen, /* xDlOpen */ \ + unixDlError, /* xDlError */ \ + unixDlSym, /* xDlSym */ \ + unixDlClose, /* xDlClose */ \ + unixRandomness, /* xRandomness */ \ + unixSleep, /* xSleep */ \ + unixCurrentTime, /* xCurrentTime */ \ + unixGetLastError, /* xGetLastError */ \ + unixCurrentTimeInt64, /* xCurrentTimeInt64 */ \ + unixSetSystemCall, /* xSetSystemCall */ \ + unixGetSystemCall, /* xGetSystemCall */ \ + unixNextSystemCall, /* xNextSystemCall */ \ + } + + /* + ** All default VFSes for unix are contained in the following array. + ** + ** Note that the sqlite3_vfs.pNext field of the VFS object is modified + ** by the SQLite core when the VFS is registered. So the following + ** array cannot be const. + */ + static sqlite3_vfs aVfs[] = { +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) + UNIXVFS("unix", autolockIoFinder ), +#elif OS_VXWORKS + UNIXVFS("unix", vxworksIoFinder ), +#else + UNIXVFS("unix", posixIoFinder ), +#endif + UNIXVFS("unix-none", nolockIoFinder ), + UNIXVFS("unix-dotfile", dotlockIoFinder ), + UNIXVFS("unix-excl", posixIoFinder ), +#if OS_VXWORKS + UNIXVFS("unix-namedsem", semIoFinder ), +#endif +#if SQLITE_ENABLE_LOCKING_STYLE || OS_VXWORKS + UNIXVFS("unix-posix", posixIoFinder ), +#endif +#if SQLITE_ENABLE_LOCKING_STYLE + UNIXVFS("unix-flock", flockIoFinder ), +#endif +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) + UNIXVFS("unix-afp", afpIoFinder ), + UNIXVFS("unix-nfs", nfsIoFinder ), + UNIXVFS("unix-proxy", proxyIoFinder ), +#endif + }; + unsigned int i; /* Loop counter */ + + /* Double-check that the aSyscall[] array has been constructed + ** correctly. See ticket [bb3a86e890c8e96ab] */ + assert( ArraySize(aSyscall)==29 ); + + /* Register all VFSes defined in the aVfs[] array */ + for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){ + sqlite3_vfs_register(&aVfs[i], i==0); + } + unixBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1); + return SQLITE_OK; +} + +/* +** Shutdown the operating system interface. +** +** Some operating systems might need to do some cleanup in this routine, +** to release dynamically allocated objects. But not on unix. +** This routine is a no-op for unix. +*/ +SQLITE_API int sqlite3_os_end(void){ + unixBigLock = 0; + return SQLITE_OK; +} + +#endif /* SQLITE_OS_UNIX */ + +/************** End of os_unix.c *********************************************/ +/************** Begin file os_win.c ******************************************/ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains code that is specific to Windows. +*/ +/* #include "sqliteInt.h" */ +#if SQLITE_OS_WIN /* This file is used for Windows only */ + +/* +** Include code that is common to all os_*.c files +*/ +/************** Include os_common.h in the middle of os_win.c ****************/ +/************** Begin file os_common.h ***************************************/ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains macros and a little bit of code that is common to +** all of the platform-specific files (os_*.c) and is #included into those +** files. +** +** This file should be #included by the os_*.c files only. It is not a +** general purpose header file. +*/ +#ifndef _OS_COMMON_H_ +#define _OS_COMMON_H_ + +/* +** At least two bugs have slipped in because we changed the MEMORY_DEBUG +** macro to SQLITE_DEBUG and some older makefiles have not yet made the +** switch. The following code should catch this problem at compile-time. +*/ +#ifdef MEMORY_DEBUG +# error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead." +#endif + +/* +** Macros for performance tracing. Normally turned off. Only works +** on i486 hardware. +*/ +#ifdef SQLITE_PERFORMANCE_TRACE + +/* +** hwtime.h contains inline assembler code for implementing +** high-performance timing routines. +*/ +/************** Include hwtime.h in the middle of os_common.h ****************/ +/************** Begin file hwtime.h ******************************************/ +/* +** 2008 May 27 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains inline asm code for retrieving "high-performance" +** counters for x86 and x86_64 class CPUs. +*/ +#ifndef SQLITE_HWTIME_H +#define SQLITE_HWTIME_H + +/* +** The following routine only works on pentium-class (or newer) processors. +** It uses the RDTSC opcode to read the cycle count value out of the +** processor and returns that value. This can be used for high-res +** profiling. +*/ +#if !defined(__STRICT_ANSI__) && \ + (defined(__GNUC__) || defined(_MSC_VER)) && \ + (defined(i386) || defined(__i386__) || defined(_M_IX86)) + + #if defined(__GNUC__) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned int lo, hi; + __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); + return (sqlite_uint64)hi << 32 | lo; + } + + #elif defined(_MSC_VER) + + __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){ + __asm { + rdtsc + ret ; return value at EDX:EAX + } + } + + #endif + +#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long val; + __asm__ __volatile__ ("rdtsc" : "=A" (val)); + return val; + } + +#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long long retval; + unsigned long junk; + __asm__ __volatile__ ("\n\ + 1: mftbu %1\n\ + mftb %L0\n\ + mftbu %0\n\ + cmpw %0,%1\n\ + bne 1b" + : "=r" (retval), "=r" (junk)); + return retval; + } + +#else + + /* + ** asm() is needed for hardware timing support. Without asm(), + ** disable the sqlite3Hwtime() routine. + ** + ** sqlite3Hwtime() is only used for some obscure debugging + ** and analysis configurations, not in any deliverable, so this + ** should not be a great loss. + */ +SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); } + +#endif + +#endif /* !defined(SQLITE_HWTIME_H) */ + +/************** End of hwtime.h **********************************************/ +/************** Continuing where we left off in os_common.h ******************/ + +static sqlite_uint64 g_start; +static sqlite_uint64 g_elapsed; +#define TIMER_START g_start=sqlite3Hwtime() +#define TIMER_END g_elapsed=sqlite3Hwtime()-g_start +#define TIMER_ELAPSED g_elapsed +#else +#define TIMER_START +#define TIMER_END +#define TIMER_ELAPSED ((sqlite_uint64)0) +#endif + +/* +** If we compile with the SQLITE_TEST macro set, then the following block +** of code will give us the ability to simulate a disk I/O error. This +** is used for testing the I/O recovery logic. +*/ +#if defined(SQLITE_TEST) +SQLITE_API extern int sqlite3_io_error_hit; +SQLITE_API extern int sqlite3_io_error_hardhit; +SQLITE_API extern int sqlite3_io_error_pending; +SQLITE_API extern int sqlite3_io_error_persist; +SQLITE_API extern int sqlite3_io_error_benign; +SQLITE_API extern int sqlite3_diskfull_pending; +SQLITE_API extern int sqlite3_diskfull; +#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X) +#define SimulateIOError(CODE) \ + if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \ + || sqlite3_io_error_pending-- == 1 ) \ + { local_ioerr(); CODE; } +static void local_ioerr(){ + IOTRACE(("IOERR\n")); + sqlite3_io_error_hit++; + if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++; +} +#define SimulateDiskfullError(CODE) \ + if( sqlite3_diskfull_pending ){ \ + if( sqlite3_diskfull_pending == 1 ){ \ + local_ioerr(); \ + sqlite3_diskfull = 1; \ + sqlite3_io_error_hit = 1; \ + CODE; \ + }else{ \ + sqlite3_diskfull_pending--; \ + } \ + } +#else +#define SimulateIOErrorBenign(X) +#define SimulateIOError(A) +#define SimulateDiskfullError(A) +#endif /* defined(SQLITE_TEST) */ + +/* +** When testing, keep a count of the number of open files. +*/ +#if defined(SQLITE_TEST) +SQLITE_API extern int sqlite3_open_file_count; +#define OpenCounter(X) sqlite3_open_file_count+=(X) +#else +#define OpenCounter(X) +#endif /* defined(SQLITE_TEST) */ + +#endif /* !defined(_OS_COMMON_H_) */ + +/************** End of os_common.h *******************************************/ +/************** Continuing where we left off in os_win.c *********************/ + +/* +** Include the header file for the Windows VFS. +*/ +/* #include "os_win.h" */ + +/* +** Compiling and using WAL mode requires several APIs that are only +** available in Windows platforms based on the NT kernel. +*/ +#if !SQLITE_OS_WINNT && !defined(SQLITE_OMIT_WAL) +# error "WAL mode requires support from the Windows NT kernel, compile\ + with SQLITE_OMIT_WAL." +#endif + +#if !SQLITE_OS_WINNT && SQLITE_MAX_MMAP_SIZE>0 +# error "Memory mapped files require support from the Windows NT kernel,\ + compile with SQLITE_MAX_MMAP_SIZE=0." +#endif + +/* +** Are most of the Win32 ANSI APIs available (i.e. with certain exceptions +** based on the sub-platform)? +*/ +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && !defined(SQLITE_WIN32_NO_ANSI) +# define SQLITE_WIN32_HAS_ANSI +#endif + +/* +** Are most of the Win32 Unicode APIs available (i.e. with certain exceptions +** based on the sub-platform)? +*/ +#if (SQLITE_OS_WINCE || SQLITE_OS_WINNT || SQLITE_OS_WINRT) && \ + !defined(SQLITE_WIN32_NO_WIDE) +# define SQLITE_WIN32_HAS_WIDE +#endif + +/* +** Make sure at least one set of Win32 APIs is available. +*/ +#if !defined(SQLITE_WIN32_HAS_ANSI) && !defined(SQLITE_WIN32_HAS_WIDE) +# error "At least one of SQLITE_WIN32_HAS_ANSI and SQLITE_WIN32_HAS_WIDE\ + must be defined." +#endif + +/* +** Define the required Windows SDK version constants if they are not +** already available. +*/ +#ifndef NTDDI_WIN8 +# define NTDDI_WIN8 0x06020000 +#endif + +#ifndef NTDDI_WINBLUE +# define NTDDI_WINBLUE 0x06030000 +#endif + +#ifndef NTDDI_WINTHRESHOLD +# define NTDDI_WINTHRESHOLD 0x06040000 +#endif + +/* +** Check to see if the GetVersionEx[AW] functions are deprecated on the +** target system. GetVersionEx was first deprecated in Win8.1. +*/ +#ifndef SQLITE_WIN32_GETVERSIONEX +# if defined(NTDDI_VERSION) && NTDDI_VERSION >= NTDDI_WINBLUE +# define SQLITE_WIN32_GETVERSIONEX 0 /* GetVersionEx() is deprecated */ +# else +# define SQLITE_WIN32_GETVERSIONEX 1 /* GetVersionEx() is current */ +# endif +#endif + +/* +** Check to see if the CreateFileMappingA function is supported on the +** target system. It is unavailable when using "mincore.lib" on Win10. +** When compiling for Windows 10, always assume "mincore.lib" is in use. +*/ +#ifndef SQLITE_WIN32_CREATEFILEMAPPINGA +# if defined(NTDDI_VERSION) && NTDDI_VERSION >= NTDDI_WINTHRESHOLD +# define SQLITE_WIN32_CREATEFILEMAPPINGA 0 +# else +# define SQLITE_WIN32_CREATEFILEMAPPINGA 1 +# endif +#endif + +/* +** This constant should already be defined (in the "WinDef.h" SDK file). +*/ +#ifndef MAX_PATH +# define MAX_PATH (260) +#endif + +/* +** Maximum pathname length (in chars) for Win32. This should normally be +** MAX_PATH. +*/ +#ifndef SQLITE_WIN32_MAX_PATH_CHARS +# define SQLITE_WIN32_MAX_PATH_CHARS (MAX_PATH) +#endif + +/* +** This constant should already be defined (in the "WinNT.h" SDK file). +*/ +#ifndef UNICODE_STRING_MAX_CHARS +# define UNICODE_STRING_MAX_CHARS (32767) +#endif + +/* +** Maximum pathname length (in chars) for WinNT. This should normally be +** UNICODE_STRING_MAX_CHARS. +*/ +#ifndef SQLITE_WINNT_MAX_PATH_CHARS +# define SQLITE_WINNT_MAX_PATH_CHARS (UNICODE_STRING_MAX_CHARS) +#endif + +/* +** Maximum pathname length (in bytes) for Win32. The MAX_PATH macro is in +** characters, so we allocate 4 bytes per character assuming worst-case of +** 4-bytes-per-character for UTF8. +*/ +#ifndef SQLITE_WIN32_MAX_PATH_BYTES +# define SQLITE_WIN32_MAX_PATH_BYTES (SQLITE_WIN32_MAX_PATH_CHARS*4) +#endif + +/* +** Maximum pathname length (in bytes) for WinNT. This should normally be +** UNICODE_STRING_MAX_CHARS * sizeof(WCHAR). +*/ +#ifndef SQLITE_WINNT_MAX_PATH_BYTES +# define SQLITE_WINNT_MAX_PATH_BYTES \ + (sizeof(WCHAR) * SQLITE_WINNT_MAX_PATH_CHARS) +#endif + +/* +** Maximum error message length (in chars) for WinRT. +*/ +#ifndef SQLITE_WIN32_MAX_ERRMSG_CHARS +# define SQLITE_WIN32_MAX_ERRMSG_CHARS (1024) +#endif + +/* +** Returns non-zero if the character should be treated as a directory +** separator. +*/ +#ifndef winIsDirSep +# define winIsDirSep(a) (((a) == '/') || ((a) == '\\')) +#endif + +/* +** This macro is used when a local variable is set to a value that is +** [sometimes] not used by the code (e.g. via conditional compilation). +*/ +#ifndef UNUSED_VARIABLE_VALUE +# define UNUSED_VARIABLE_VALUE(x) (void)(x) +#endif + +/* +** Returns the character that should be used as the directory separator. +*/ +#ifndef winGetDirSep +# define winGetDirSep() '\\' +#endif + +/* +** Do we need to manually define the Win32 file mapping APIs for use with WAL +** mode or memory mapped files (e.g. these APIs are available in the Windows +** CE SDK; however, they are not present in the header file)? +*/ +#if SQLITE_WIN32_FILEMAPPING_API && \ + (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) +/* +** Two of the file mapping APIs are different under WinRT. Figure out which +** set we need. +*/ +#if SQLITE_OS_WINRT +WINBASEAPI HANDLE WINAPI CreateFileMappingFromApp(HANDLE, \ + LPSECURITY_ATTRIBUTES, ULONG, ULONG64, LPCWSTR); + +WINBASEAPI LPVOID WINAPI MapViewOfFileFromApp(HANDLE, ULONG, ULONG64, SIZE_T); +#else +#if defined(SQLITE_WIN32_HAS_ANSI) +WINBASEAPI HANDLE WINAPI CreateFileMappingA(HANDLE, LPSECURITY_ATTRIBUTES, \ + DWORD, DWORD, DWORD, LPCSTR); +#endif /* defined(SQLITE_WIN32_HAS_ANSI) */ + +#if defined(SQLITE_WIN32_HAS_WIDE) +WINBASEAPI HANDLE WINAPI CreateFileMappingW(HANDLE, LPSECURITY_ATTRIBUTES, \ + DWORD, DWORD, DWORD, LPCWSTR); +#endif /* defined(SQLITE_WIN32_HAS_WIDE) */ + +WINBASEAPI LPVOID WINAPI MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, SIZE_T); +#endif /* SQLITE_OS_WINRT */ + +/* +** These file mapping APIs are common to both Win32 and WinRT. +*/ + +WINBASEAPI BOOL WINAPI FlushViewOfFile(LPCVOID, SIZE_T); +WINBASEAPI BOOL WINAPI UnmapViewOfFile(LPCVOID); +#endif /* SQLITE_WIN32_FILEMAPPING_API */ + +/* +** Some Microsoft compilers lack this definition. +*/ +#ifndef INVALID_FILE_ATTRIBUTES +# define INVALID_FILE_ATTRIBUTES ((DWORD)-1) +#endif + +#ifndef FILE_FLAG_MASK +# define FILE_FLAG_MASK (0xFF3C0000) +#endif + +#ifndef FILE_ATTRIBUTE_MASK +# define FILE_ATTRIBUTE_MASK (0x0003FFF7) +#endif + +#ifndef SQLITE_OMIT_WAL +/* Forward references to structures used for WAL */ +typedef struct winShm winShm; /* A connection to shared-memory */ +typedef struct winShmNode winShmNode; /* A region of shared-memory */ +#endif + +/* +** WinCE lacks native support for file locking so we have to fake it +** with some code of our own. +*/ +#if SQLITE_OS_WINCE +typedef struct winceLock { + int nReaders; /* Number of reader locks obtained */ + BOOL bPending; /* Indicates a pending lock has been obtained */ + BOOL bReserved; /* Indicates a reserved lock has been obtained */ + BOOL bExclusive; /* Indicates an exclusive lock has been obtained */ +} winceLock; +#endif + +/* +** The winFile structure is a subclass of sqlite3_file* specific to the win32 +** portability layer. +*/ +typedef struct winFile winFile; +struct winFile { + const sqlite3_io_methods *pMethod; /*** Must be first ***/ + sqlite3_vfs *pVfs; /* The VFS used to open this file */ + HANDLE h; /* Handle for accessing the file */ + u8 locktype; /* Type of lock currently held on this file */ + short sharedLockByte; /* Randomly chosen byte used as a shared lock */ + u8 ctrlFlags; /* Flags. See WINFILE_* below */ + DWORD lastErrno; /* The Windows errno from the last I/O error */ +#ifndef SQLITE_OMIT_WAL + winShm *pShm; /* Instance of shared memory on this file */ +#endif + const char *zPath; /* Full pathname of this file */ + int szChunk; /* Chunk size configured by FCNTL_CHUNK_SIZE */ +#if SQLITE_OS_WINCE + LPWSTR zDeleteOnClose; /* Name of file to delete when closing */ + HANDLE hMutex; /* Mutex used to control access to shared lock */ + HANDLE hShared; /* Shared memory segment used for locking */ + winceLock local; /* Locks obtained by this instance of winFile */ + winceLock *shared; /* Global shared lock memory for the file */ +#endif +#if SQLITE_MAX_MMAP_SIZE>0 + int nFetchOut; /* Number of outstanding xFetch references */ + HANDLE hMap; /* Handle for accessing memory mapping */ + void *pMapRegion; /* Area memory mapped */ + sqlite3_int64 mmapSize; /* Size of mapped region */ + sqlite3_int64 mmapSizeMax; /* Configured FCNTL_MMAP_SIZE value */ +#endif +}; + +/* +** The winVfsAppData structure is used for the pAppData member for all of the +** Win32 VFS variants. +*/ +typedef struct winVfsAppData winVfsAppData; +struct winVfsAppData { + const sqlite3_io_methods *pMethod; /* The file I/O methods to use. */ + void *pAppData; /* The extra pAppData, if any. */ + BOOL bNoLock; /* Non-zero if locking is disabled. */ +}; + +/* +** Allowed values for winFile.ctrlFlags +*/ +#define WINFILE_RDONLY 0x02 /* Connection is read only */ +#define WINFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */ +#define WINFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */ + +/* + * The size of the buffer used by sqlite3_win32_write_debug(). + */ +#ifndef SQLITE_WIN32_DBG_BUF_SIZE +# define SQLITE_WIN32_DBG_BUF_SIZE ((int)(4096-sizeof(DWORD))) +#endif + +/* + * If compiled with SQLITE_WIN32_MALLOC on Windows, we will use the + * various Win32 API heap functions instead of our own. + */ +#ifdef SQLITE_WIN32_MALLOC + +/* + * If this is non-zero, an isolated heap will be created by the native Win32 + * allocator subsystem; otherwise, the default process heap will be used. This + * setting has no effect when compiling for WinRT. By default, this is enabled + * and an isolated heap will be created to store all allocated data. + * + ****************************************************************************** + * WARNING: It is important to note that when this setting is non-zero and the + * winMemShutdown function is called (e.g. by the sqlite3_shutdown + * function), all data that was allocated using the isolated heap will + * be freed immediately and any attempt to access any of that freed + * data will almost certainly result in an immediate access violation. + ****************************************************************************** + */ +#ifndef SQLITE_WIN32_HEAP_CREATE +# define SQLITE_WIN32_HEAP_CREATE (TRUE) +#endif + +/* + * This is the maximum possible initial size of the Win32-specific heap, in + * bytes. + */ +#ifndef SQLITE_WIN32_HEAP_MAX_INIT_SIZE +# define SQLITE_WIN32_HEAP_MAX_INIT_SIZE (4294967295U) +#endif + +/* + * This is the extra space for the initial size of the Win32-specific heap, + * in bytes. This value may be zero. + */ +#ifndef SQLITE_WIN32_HEAP_INIT_EXTRA +# define SQLITE_WIN32_HEAP_INIT_EXTRA (4194304) +#endif + +/* + * Calculate the maximum legal cache size, in pages, based on the maximum + * possible initial heap size and the default page size, setting aside the + * needed extra space. + */ +#ifndef SQLITE_WIN32_MAX_CACHE_SIZE +# define SQLITE_WIN32_MAX_CACHE_SIZE (((SQLITE_WIN32_HEAP_MAX_INIT_SIZE) - \ + (SQLITE_WIN32_HEAP_INIT_EXTRA)) / \ + (SQLITE_DEFAULT_PAGE_SIZE)) +#endif + +/* + * This is cache size used in the calculation of the initial size of the + * Win32-specific heap. It cannot be negative. + */ +#ifndef SQLITE_WIN32_CACHE_SIZE +# if SQLITE_DEFAULT_CACHE_SIZE>=0 +# define SQLITE_WIN32_CACHE_SIZE (SQLITE_DEFAULT_CACHE_SIZE) +# else +# define SQLITE_WIN32_CACHE_SIZE (-(SQLITE_DEFAULT_CACHE_SIZE)) +# endif +#endif + +/* + * Make sure that the calculated cache size, in pages, cannot cause the + * initial size of the Win32-specific heap to exceed the maximum amount + * of memory that can be specified in the call to HeapCreate. + */ +#if SQLITE_WIN32_CACHE_SIZE>SQLITE_WIN32_MAX_CACHE_SIZE +# undef SQLITE_WIN32_CACHE_SIZE +# define SQLITE_WIN32_CACHE_SIZE (2000) +#endif + +/* + * The initial size of the Win32-specific heap. This value may be zero. + */ +#ifndef SQLITE_WIN32_HEAP_INIT_SIZE +# define SQLITE_WIN32_HEAP_INIT_SIZE ((SQLITE_WIN32_CACHE_SIZE) * \ + (SQLITE_DEFAULT_PAGE_SIZE) + \ + (SQLITE_WIN32_HEAP_INIT_EXTRA)) +#endif + +/* + * The maximum size of the Win32-specific heap. This value may be zero. + */ +#ifndef SQLITE_WIN32_HEAP_MAX_SIZE +# define SQLITE_WIN32_HEAP_MAX_SIZE (0) +#endif + +/* + * The extra flags to use in calls to the Win32 heap APIs. This value may be + * zero for the default behavior. + */ +#ifndef SQLITE_WIN32_HEAP_FLAGS +# define SQLITE_WIN32_HEAP_FLAGS (0) +#endif + + +/* +** The winMemData structure stores information required by the Win32-specific +** sqlite3_mem_methods implementation. +*/ +typedef struct winMemData winMemData; +struct winMemData { +#ifndef NDEBUG + u32 magic1; /* Magic number to detect structure corruption. */ +#endif + HANDLE hHeap; /* The handle to our heap. */ + BOOL bOwned; /* Do we own the heap (i.e. destroy it on shutdown)? */ +#ifndef NDEBUG + u32 magic2; /* Magic number to detect structure corruption. */ +#endif +}; + +#ifndef NDEBUG +#define WINMEM_MAGIC1 0x42b2830b +#define WINMEM_MAGIC2 0xbd4d7cf4 +#endif + +static struct winMemData win_mem_data = { +#ifndef NDEBUG + WINMEM_MAGIC1, +#endif + NULL, FALSE +#ifndef NDEBUG + ,WINMEM_MAGIC2 +#endif +}; + +#ifndef NDEBUG +#define winMemAssertMagic1() assert( win_mem_data.magic1==WINMEM_MAGIC1 ) +#define winMemAssertMagic2() assert( win_mem_data.magic2==WINMEM_MAGIC2 ) +#define winMemAssertMagic() winMemAssertMagic1(); winMemAssertMagic2(); +#else +#define winMemAssertMagic() +#endif + +#define winMemGetDataPtr() &win_mem_data +#define winMemGetHeap() win_mem_data.hHeap +#define winMemGetOwned() win_mem_data.bOwned + +static void *winMemMalloc(int nBytes); +static void winMemFree(void *pPrior); +static void *winMemRealloc(void *pPrior, int nBytes); +static int winMemSize(void *p); +static int winMemRoundup(int n); +static int winMemInit(void *pAppData); +static void winMemShutdown(void *pAppData); + +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetWin32(void); +#endif /* SQLITE_WIN32_MALLOC */ + +/* +** The following variable is (normally) set once and never changes +** thereafter. It records whether the operating system is Win9x +** or WinNT. +** +** 0: Operating system unknown. +** 1: Operating system is Win9x. +** 2: Operating system is WinNT. +** +** In order to facilitate testing on a WinNT system, the test fixture +** can manually set this value to 1 to emulate Win98 behavior. +*/ +#ifdef SQLITE_TEST +SQLITE_API LONG SQLITE_WIN32_VOLATILE sqlite3_os_type = 0; +#else +static LONG SQLITE_WIN32_VOLATILE sqlite3_os_type = 0; +#endif + +#ifndef SYSCALL +# define SYSCALL sqlite3_syscall_ptr +#endif + +/* +** This function is not available on Windows CE or WinRT. + */ + +#if SQLITE_OS_WINCE || SQLITE_OS_WINRT +# define osAreFileApisANSI() 1 +#endif + +/* +** Many system calls are accessed through pointer-to-functions so that +** they may be overridden at runtime to facilitate fault injection during +** testing and sandboxing. The following array holds the names and pointers +** to all overrideable system calls. +*/ +static struct win_syscall { + const char *zName; /* Name of the system call */ + sqlite3_syscall_ptr pCurrent; /* Current value of the system call */ + sqlite3_syscall_ptr pDefault; /* Default value */ +} aSyscall[] = { +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT + { "AreFileApisANSI", (SYSCALL)AreFileApisANSI, 0 }, +#else + { "AreFileApisANSI", (SYSCALL)0, 0 }, +#endif + +#ifndef osAreFileApisANSI +#define osAreFileApisANSI ((BOOL(WINAPI*)(VOID))aSyscall[0].pCurrent) +#endif + +#if SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE) + { "CharLowerW", (SYSCALL)CharLowerW, 0 }, +#else + { "CharLowerW", (SYSCALL)0, 0 }, +#endif + +#define osCharLowerW ((LPWSTR(WINAPI*)(LPWSTR))aSyscall[1].pCurrent) + +#if SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE) + { "CharUpperW", (SYSCALL)CharUpperW, 0 }, +#else + { "CharUpperW", (SYSCALL)0, 0 }, +#endif + +#define osCharUpperW ((LPWSTR(WINAPI*)(LPWSTR))aSyscall[2].pCurrent) + + { "CloseHandle", (SYSCALL)CloseHandle, 0 }, + +#define osCloseHandle ((BOOL(WINAPI*)(HANDLE))aSyscall[3].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "CreateFileA", (SYSCALL)CreateFileA, 0 }, +#else + { "CreateFileA", (SYSCALL)0, 0 }, +#endif + +#define osCreateFileA ((HANDLE(WINAPI*)(LPCSTR,DWORD,DWORD, \ + LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[4].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "CreateFileW", (SYSCALL)CreateFileW, 0 }, +#else + { "CreateFileW", (SYSCALL)0, 0 }, +#endif + +#define osCreateFileW ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD, \ + LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[5].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_ANSI) && \ + (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) && \ + SQLITE_WIN32_CREATEFILEMAPPINGA + { "CreateFileMappingA", (SYSCALL)CreateFileMappingA, 0 }, +#else + { "CreateFileMappingA", (SYSCALL)0, 0 }, +#endif + +#define osCreateFileMappingA ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \ + DWORD,DWORD,DWORD,LPCSTR))aSyscall[6].pCurrent) + +#if SQLITE_OS_WINCE || (!SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \ + (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0)) + { "CreateFileMappingW", (SYSCALL)CreateFileMappingW, 0 }, +#else + { "CreateFileMappingW", (SYSCALL)0, 0 }, +#endif + +#define osCreateFileMappingW ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \ + DWORD,DWORD,DWORD,LPCWSTR))aSyscall[7].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "CreateMutexW", (SYSCALL)CreateMutexW, 0 }, +#else + { "CreateMutexW", (SYSCALL)0, 0 }, +#endif + +#define osCreateMutexW ((HANDLE(WINAPI*)(LPSECURITY_ATTRIBUTES,BOOL, \ + LPCWSTR))aSyscall[8].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "DeleteFileA", (SYSCALL)DeleteFileA, 0 }, +#else + { "DeleteFileA", (SYSCALL)0, 0 }, +#endif + +#define osDeleteFileA ((BOOL(WINAPI*)(LPCSTR))aSyscall[9].pCurrent) + +#if defined(SQLITE_WIN32_HAS_WIDE) + { "DeleteFileW", (SYSCALL)DeleteFileW, 0 }, +#else + { "DeleteFileW", (SYSCALL)0, 0 }, +#endif + +#define osDeleteFileW ((BOOL(WINAPI*)(LPCWSTR))aSyscall[10].pCurrent) + +#if SQLITE_OS_WINCE + { "FileTimeToLocalFileTime", (SYSCALL)FileTimeToLocalFileTime, 0 }, +#else + { "FileTimeToLocalFileTime", (SYSCALL)0, 0 }, +#endif + +#define osFileTimeToLocalFileTime ((BOOL(WINAPI*)(CONST FILETIME*, \ + LPFILETIME))aSyscall[11].pCurrent) + +#if SQLITE_OS_WINCE + { "FileTimeToSystemTime", (SYSCALL)FileTimeToSystemTime, 0 }, +#else + { "FileTimeToSystemTime", (SYSCALL)0, 0 }, +#endif + +#define osFileTimeToSystemTime ((BOOL(WINAPI*)(CONST FILETIME*, \ + LPSYSTEMTIME))aSyscall[12].pCurrent) + + { "FlushFileBuffers", (SYSCALL)FlushFileBuffers, 0 }, + +#define osFlushFileBuffers ((BOOL(WINAPI*)(HANDLE))aSyscall[13].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "FormatMessageA", (SYSCALL)FormatMessageA, 0 }, +#else + { "FormatMessageA", (SYSCALL)0, 0 }, +#endif + +#define osFormatMessageA ((DWORD(WINAPI*)(DWORD,LPCVOID,DWORD,DWORD,LPSTR, \ + DWORD,va_list*))aSyscall[14].pCurrent) + +#if defined(SQLITE_WIN32_HAS_WIDE) + { "FormatMessageW", (SYSCALL)FormatMessageW, 0 }, +#else + { "FormatMessageW", (SYSCALL)0, 0 }, +#endif + +#define osFormatMessageW ((DWORD(WINAPI*)(DWORD,LPCVOID,DWORD,DWORD,LPWSTR, \ + DWORD,va_list*))aSyscall[15].pCurrent) + +#if !defined(SQLITE_OMIT_LOAD_EXTENSION) + { "FreeLibrary", (SYSCALL)FreeLibrary, 0 }, +#else + { "FreeLibrary", (SYSCALL)0, 0 }, +#endif + +#define osFreeLibrary ((BOOL(WINAPI*)(HMODULE))aSyscall[16].pCurrent) + + { "GetCurrentProcessId", (SYSCALL)GetCurrentProcessId, 0 }, + +#define osGetCurrentProcessId ((DWORD(WINAPI*)(VOID))aSyscall[17].pCurrent) + +#if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_ANSI) + { "GetDiskFreeSpaceA", (SYSCALL)GetDiskFreeSpaceA, 0 }, +#else + { "GetDiskFreeSpaceA", (SYSCALL)0, 0 }, +#endif + +#define osGetDiskFreeSpaceA ((BOOL(WINAPI*)(LPCSTR,LPDWORD,LPDWORD,LPDWORD, \ + LPDWORD))aSyscall[18].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "GetDiskFreeSpaceW", (SYSCALL)GetDiskFreeSpaceW, 0 }, +#else + { "GetDiskFreeSpaceW", (SYSCALL)0, 0 }, +#endif + +#define osGetDiskFreeSpaceW ((BOOL(WINAPI*)(LPCWSTR,LPDWORD,LPDWORD,LPDWORD, \ + LPDWORD))aSyscall[19].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "GetFileAttributesA", (SYSCALL)GetFileAttributesA, 0 }, +#else + { "GetFileAttributesA", (SYSCALL)0, 0 }, +#endif + +#define osGetFileAttributesA ((DWORD(WINAPI*)(LPCSTR))aSyscall[20].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "GetFileAttributesW", (SYSCALL)GetFileAttributesW, 0 }, +#else + { "GetFileAttributesW", (SYSCALL)0, 0 }, +#endif + +#define osGetFileAttributesW ((DWORD(WINAPI*)(LPCWSTR))aSyscall[21].pCurrent) + +#if defined(SQLITE_WIN32_HAS_WIDE) + { "GetFileAttributesExW", (SYSCALL)GetFileAttributesExW, 0 }, +#else + { "GetFileAttributesExW", (SYSCALL)0, 0 }, +#endif + +#define osGetFileAttributesExW ((BOOL(WINAPI*)(LPCWSTR,GET_FILEEX_INFO_LEVELS, \ + LPVOID))aSyscall[22].pCurrent) + +#if !SQLITE_OS_WINRT + { "GetFileSize", (SYSCALL)GetFileSize, 0 }, +#else + { "GetFileSize", (SYSCALL)0, 0 }, +#endif + +#define osGetFileSize ((DWORD(WINAPI*)(HANDLE,LPDWORD))aSyscall[23].pCurrent) + +#if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_ANSI) + { "GetFullPathNameA", (SYSCALL)GetFullPathNameA, 0 }, +#else + { "GetFullPathNameA", (SYSCALL)0, 0 }, +#endif + +#define osGetFullPathNameA ((DWORD(WINAPI*)(LPCSTR,DWORD,LPSTR, \ + LPSTR*))aSyscall[24].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "GetFullPathNameW", (SYSCALL)GetFullPathNameW, 0 }, +#else + { "GetFullPathNameW", (SYSCALL)0, 0 }, +#endif + +#define osGetFullPathNameW ((DWORD(WINAPI*)(LPCWSTR,DWORD,LPWSTR, \ + LPWSTR*))aSyscall[25].pCurrent) + + { "GetLastError", (SYSCALL)GetLastError, 0 }, + +#define osGetLastError ((DWORD(WINAPI*)(VOID))aSyscall[26].pCurrent) + +#if !defined(SQLITE_OMIT_LOAD_EXTENSION) +#if SQLITE_OS_WINCE + /* The GetProcAddressA() routine is only available on Windows CE. */ + { "GetProcAddressA", (SYSCALL)GetProcAddressA, 0 }, +#else + /* All other Windows platforms expect GetProcAddress() to take + ** an ANSI string regardless of the _UNICODE setting */ + { "GetProcAddressA", (SYSCALL)GetProcAddress, 0 }, +#endif +#else + { "GetProcAddressA", (SYSCALL)0, 0 }, +#endif + +#define osGetProcAddressA ((FARPROC(WINAPI*)(HMODULE, \ + LPCSTR))aSyscall[27].pCurrent) + +#if !SQLITE_OS_WINRT + { "GetSystemInfo", (SYSCALL)GetSystemInfo, 0 }, +#else + { "GetSystemInfo", (SYSCALL)0, 0 }, +#endif + +#define osGetSystemInfo ((VOID(WINAPI*)(LPSYSTEM_INFO))aSyscall[28].pCurrent) + + { "GetSystemTime", (SYSCALL)GetSystemTime, 0 }, + +#define osGetSystemTime ((VOID(WINAPI*)(LPSYSTEMTIME))aSyscall[29].pCurrent) + +#if !SQLITE_OS_WINCE + { "GetSystemTimeAsFileTime", (SYSCALL)GetSystemTimeAsFileTime, 0 }, +#else + { "GetSystemTimeAsFileTime", (SYSCALL)0, 0 }, +#endif + +#define osGetSystemTimeAsFileTime ((VOID(WINAPI*)( \ + LPFILETIME))aSyscall[30].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "GetTempPathA", (SYSCALL)GetTempPathA, 0 }, +#else + { "GetTempPathA", (SYSCALL)0, 0 }, +#endif + +#define osGetTempPathA ((DWORD(WINAPI*)(DWORD,LPSTR))aSyscall[31].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "GetTempPathW", (SYSCALL)GetTempPathW, 0 }, +#else + { "GetTempPathW", (SYSCALL)0, 0 }, +#endif + +#define osGetTempPathW ((DWORD(WINAPI*)(DWORD,LPWSTR))aSyscall[32].pCurrent) + +#if !SQLITE_OS_WINRT + { "GetTickCount", (SYSCALL)GetTickCount, 0 }, +#else + { "GetTickCount", (SYSCALL)0, 0 }, +#endif + +#define osGetTickCount ((DWORD(WINAPI*)(VOID))aSyscall[33].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) && SQLITE_WIN32_GETVERSIONEX + { "GetVersionExA", (SYSCALL)GetVersionExA, 0 }, +#else + { "GetVersionExA", (SYSCALL)0, 0 }, +#endif + +#define osGetVersionExA ((BOOL(WINAPI*)( \ + LPOSVERSIONINFOA))aSyscall[34].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \ + SQLITE_WIN32_GETVERSIONEX + { "GetVersionExW", (SYSCALL)GetVersionExW, 0 }, +#else + { "GetVersionExW", (SYSCALL)0, 0 }, +#endif + +#define osGetVersionExW ((BOOL(WINAPI*)( \ + LPOSVERSIONINFOW))aSyscall[35].pCurrent) + + { "HeapAlloc", (SYSCALL)HeapAlloc, 0 }, + +#define osHeapAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD, \ + SIZE_T))aSyscall[36].pCurrent) + +#if !SQLITE_OS_WINRT + { "HeapCreate", (SYSCALL)HeapCreate, 0 }, +#else + { "HeapCreate", (SYSCALL)0, 0 }, +#endif + +#define osHeapCreate ((HANDLE(WINAPI*)(DWORD,SIZE_T, \ + SIZE_T))aSyscall[37].pCurrent) + +#if !SQLITE_OS_WINRT + { "HeapDestroy", (SYSCALL)HeapDestroy, 0 }, +#else + { "HeapDestroy", (SYSCALL)0, 0 }, +#endif + +#define osHeapDestroy ((BOOL(WINAPI*)(HANDLE))aSyscall[38].pCurrent) + + { "HeapFree", (SYSCALL)HeapFree, 0 }, + +#define osHeapFree ((BOOL(WINAPI*)(HANDLE,DWORD,LPVOID))aSyscall[39].pCurrent) + + { "HeapReAlloc", (SYSCALL)HeapReAlloc, 0 }, + +#define osHeapReAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD,LPVOID, \ + SIZE_T))aSyscall[40].pCurrent) + + { "HeapSize", (SYSCALL)HeapSize, 0 }, + +#define osHeapSize ((SIZE_T(WINAPI*)(HANDLE,DWORD, \ + LPCVOID))aSyscall[41].pCurrent) + +#if !SQLITE_OS_WINRT + { "HeapValidate", (SYSCALL)HeapValidate, 0 }, +#else + { "HeapValidate", (SYSCALL)0, 0 }, +#endif + +#define osHeapValidate ((BOOL(WINAPI*)(HANDLE,DWORD, \ + LPCVOID))aSyscall[42].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT + { "HeapCompact", (SYSCALL)HeapCompact, 0 }, +#else + { "HeapCompact", (SYSCALL)0, 0 }, +#endif + +#define osHeapCompact ((UINT(WINAPI*)(HANDLE,DWORD))aSyscall[43].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) && !defined(SQLITE_OMIT_LOAD_EXTENSION) + { "LoadLibraryA", (SYSCALL)LoadLibraryA, 0 }, +#else + { "LoadLibraryA", (SYSCALL)0, 0 }, +#endif + +#define osLoadLibraryA ((HMODULE(WINAPI*)(LPCSTR))aSyscall[44].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \ + !defined(SQLITE_OMIT_LOAD_EXTENSION) + { "LoadLibraryW", (SYSCALL)LoadLibraryW, 0 }, +#else + { "LoadLibraryW", (SYSCALL)0, 0 }, +#endif + +#define osLoadLibraryW ((HMODULE(WINAPI*)(LPCWSTR))aSyscall[45].pCurrent) + +#if !SQLITE_OS_WINRT + { "LocalFree", (SYSCALL)LocalFree, 0 }, +#else + { "LocalFree", (SYSCALL)0, 0 }, +#endif + +#define osLocalFree ((HLOCAL(WINAPI*)(HLOCAL))aSyscall[46].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT + { "LockFile", (SYSCALL)LockFile, 0 }, +#else + { "LockFile", (SYSCALL)0, 0 }, +#endif + +#ifndef osLockFile +#define osLockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \ + DWORD))aSyscall[47].pCurrent) +#endif + +#if !SQLITE_OS_WINCE + { "LockFileEx", (SYSCALL)LockFileEx, 0 }, +#else + { "LockFileEx", (SYSCALL)0, 0 }, +#endif + +#ifndef osLockFileEx +#define osLockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD,DWORD, \ + LPOVERLAPPED))aSyscall[48].pCurrent) +#endif + +#if SQLITE_OS_WINCE || (!SQLITE_OS_WINRT && \ + (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0)) + { "MapViewOfFile", (SYSCALL)MapViewOfFile, 0 }, +#else + { "MapViewOfFile", (SYSCALL)0, 0 }, +#endif + +#define osMapViewOfFile ((LPVOID(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \ + SIZE_T))aSyscall[49].pCurrent) + + { "MultiByteToWideChar", (SYSCALL)MultiByteToWideChar, 0 }, + +#define osMultiByteToWideChar ((int(WINAPI*)(UINT,DWORD,LPCSTR,int,LPWSTR, \ + int))aSyscall[50].pCurrent) + + { "QueryPerformanceCounter", (SYSCALL)QueryPerformanceCounter, 0 }, + +#define osQueryPerformanceCounter ((BOOL(WINAPI*)( \ + LARGE_INTEGER*))aSyscall[51].pCurrent) + + { "ReadFile", (SYSCALL)ReadFile, 0 }, + +#define osReadFile ((BOOL(WINAPI*)(HANDLE,LPVOID,DWORD,LPDWORD, \ + LPOVERLAPPED))aSyscall[52].pCurrent) + + { "SetEndOfFile", (SYSCALL)SetEndOfFile, 0 }, + +#define osSetEndOfFile ((BOOL(WINAPI*)(HANDLE))aSyscall[53].pCurrent) + +#if !SQLITE_OS_WINRT + { "SetFilePointer", (SYSCALL)SetFilePointer, 0 }, +#else + { "SetFilePointer", (SYSCALL)0, 0 }, +#endif + +#define osSetFilePointer ((DWORD(WINAPI*)(HANDLE,LONG,PLONG, \ + DWORD))aSyscall[54].pCurrent) + +#if !SQLITE_OS_WINRT + { "Sleep", (SYSCALL)Sleep, 0 }, +#else + { "Sleep", (SYSCALL)0, 0 }, +#endif + +#define osSleep ((VOID(WINAPI*)(DWORD))aSyscall[55].pCurrent) + + { "SystemTimeToFileTime", (SYSCALL)SystemTimeToFileTime, 0 }, + +#define osSystemTimeToFileTime ((BOOL(WINAPI*)(CONST SYSTEMTIME*, \ + LPFILETIME))aSyscall[56].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT + { "UnlockFile", (SYSCALL)UnlockFile, 0 }, +#else + { "UnlockFile", (SYSCALL)0, 0 }, +#endif + +#ifndef osUnlockFile +#define osUnlockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \ + DWORD))aSyscall[57].pCurrent) +#endif + +#if !SQLITE_OS_WINCE + { "UnlockFileEx", (SYSCALL)UnlockFileEx, 0 }, +#else + { "UnlockFileEx", (SYSCALL)0, 0 }, +#endif + +#define osUnlockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \ + LPOVERLAPPED))aSyscall[58].pCurrent) + +#if SQLITE_OS_WINCE || !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 + { "UnmapViewOfFile", (SYSCALL)UnmapViewOfFile, 0 }, +#else + { "UnmapViewOfFile", (SYSCALL)0, 0 }, +#endif + +#define osUnmapViewOfFile ((BOOL(WINAPI*)(LPCVOID))aSyscall[59].pCurrent) + + { "WideCharToMultiByte", (SYSCALL)WideCharToMultiByte, 0 }, + +#define osWideCharToMultiByte ((int(WINAPI*)(UINT,DWORD,LPCWSTR,int,LPSTR,int, \ + LPCSTR,LPBOOL))aSyscall[60].pCurrent) + + { "WriteFile", (SYSCALL)WriteFile, 0 }, + +#define osWriteFile ((BOOL(WINAPI*)(HANDLE,LPCVOID,DWORD,LPDWORD, \ + LPOVERLAPPED))aSyscall[61].pCurrent) + +#if SQLITE_OS_WINRT + { "CreateEventExW", (SYSCALL)CreateEventExW, 0 }, +#else + { "CreateEventExW", (SYSCALL)0, 0 }, +#endif + +#define osCreateEventExW ((HANDLE(WINAPI*)(LPSECURITY_ATTRIBUTES,LPCWSTR, \ + DWORD,DWORD))aSyscall[62].pCurrent) + +#if !SQLITE_OS_WINRT + { "WaitForSingleObject", (SYSCALL)WaitForSingleObject, 0 }, +#else + { "WaitForSingleObject", (SYSCALL)0, 0 }, +#endif + +#define osWaitForSingleObject ((DWORD(WINAPI*)(HANDLE, \ + DWORD))aSyscall[63].pCurrent) + +#if !SQLITE_OS_WINCE + { "WaitForSingleObjectEx", (SYSCALL)WaitForSingleObjectEx, 0 }, +#else + { "WaitForSingleObjectEx", (SYSCALL)0, 0 }, +#endif + +#define osWaitForSingleObjectEx ((DWORD(WINAPI*)(HANDLE,DWORD, \ + BOOL))aSyscall[64].pCurrent) + +#if SQLITE_OS_WINRT + { "SetFilePointerEx", (SYSCALL)SetFilePointerEx, 0 }, +#else + { "SetFilePointerEx", (SYSCALL)0, 0 }, +#endif + +#define osSetFilePointerEx ((BOOL(WINAPI*)(HANDLE,LARGE_INTEGER, \ + PLARGE_INTEGER,DWORD))aSyscall[65].pCurrent) + +#if SQLITE_OS_WINRT + { "GetFileInformationByHandleEx", (SYSCALL)GetFileInformationByHandleEx, 0 }, +#else + { "GetFileInformationByHandleEx", (SYSCALL)0, 0 }, +#endif + +#define osGetFileInformationByHandleEx ((BOOL(WINAPI*)(HANDLE, \ + FILE_INFO_BY_HANDLE_CLASS,LPVOID,DWORD))aSyscall[66].pCurrent) + +#if SQLITE_OS_WINRT && (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) + { "MapViewOfFileFromApp", (SYSCALL)MapViewOfFileFromApp, 0 }, +#else + { "MapViewOfFileFromApp", (SYSCALL)0, 0 }, +#endif + +#define osMapViewOfFileFromApp ((LPVOID(WINAPI*)(HANDLE,ULONG,ULONG64, \ + SIZE_T))aSyscall[67].pCurrent) + +#if SQLITE_OS_WINRT + { "CreateFile2", (SYSCALL)CreateFile2, 0 }, +#else + { "CreateFile2", (SYSCALL)0, 0 }, +#endif + +#define osCreateFile2 ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD,DWORD, \ + LPCREATEFILE2_EXTENDED_PARAMETERS))aSyscall[68].pCurrent) + +#if SQLITE_OS_WINRT && !defined(SQLITE_OMIT_LOAD_EXTENSION) + { "LoadPackagedLibrary", (SYSCALL)LoadPackagedLibrary, 0 }, +#else + { "LoadPackagedLibrary", (SYSCALL)0, 0 }, +#endif + +#define osLoadPackagedLibrary ((HMODULE(WINAPI*)(LPCWSTR, \ + DWORD))aSyscall[69].pCurrent) + +#if SQLITE_OS_WINRT + { "GetTickCount64", (SYSCALL)GetTickCount64, 0 }, +#else + { "GetTickCount64", (SYSCALL)0, 0 }, +#endif + +#define osGetTickCount64 ((ULONGLONG(WINAPI*)(VOID))aSyscall[70].pCurrent) + +#if SQLITE_OS_WINRT + { "GetNativeSystemInfo", (SYSCALL)GetNativeSystemInfo, 0 }, +#else + { "GetNativeSystemInfo", (SYSCALL)0, 0 }, +#endif + +#define osGetNativeSystemInfo ((VOID(WINAPI*)( \ + LPSYSTEM_INFO))aSyscall[71].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "OutputDebugStringA", (SYSCALL)OutputDebugStringA, 0 }, +#else + { "OutputDebugStringA", (SYSCALL)0, 0 }, +#endif + +#define osOutputDebugStringA ((VOID(WINAPI*)(LPCSTR))aSyscall[72].pCurrent) + +#if defined(SQLITE_WIN32_HAS_WIDE) + { "OutputDebugStringW", (SYSCALL)OutputDebugStringW, 0 }, +#else + { "OutputDebugStringW", (SYSCALL)0, 0 }, +#endif + +#define osOutputDebugStringW ((VOID(WINAPI*)(LPCWSTR))aSyscall[73].pCurrent) + + { "GetProcessHeap", (SYSCALL)GetProcessHeap, 0 }, + +#define osGetProcessHeap ((HANDLE(WINAPI*)(VOID))aSyscall[74].pCurrent) + +#if SQLITE_OS_WINRT && (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) + { "CreateFileMappingFromApp", (SYSCALL)CreateFileMappingFromApp, 0 }, +#else + { "CreateFileMappingFromApp", (SYSCALL)0, 0 }, +#endif + +#define osCreateFileMappingFromApp ((HANDLE(WINAPI*)(HANDLE, \ + LPSECURITY_ATTRIBUTES,ULONG,ULONG64,LPCWSTR))aSyscall[75].pCurrent) + +/* +** NOTE: On some sub-platforms, the InterlockedCompareExchange "function" +** is really just a macro that uses a compiler intrinsic (e.g. x64). +** So do not try to make this is into a redefinable interface. +*/ +#if defined(InterlockedCompareExchange) + { "InterlockedCompareExchange", (SYSCALL)0, 0 }, + +#define osInterlockedCompareExchange InterlockedCompareExchange +#else + { "InterlockedCompareExchange", (SYSCALL)InterlockedCompareExchange, 0 }, + +#define osInterlockedCompareExchange ((LONG(WINAPI*)(LONG \ + SQLITE_WIN32_VOLATILE*, LONG,LONG))aSyscall[76].pCurrent) +#endif /* defined(InterlockedCompareExchange) */ + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_WIN32_USE_UUID + { "UuidCreate", (SYSCALL)UuidCreate, 0 }, +#else + { "UuidCreate", (SYSCALL)0, 0 }, +#endif + +#define osUuidCreate ((RPC_STATUS(RPC_ENTRY*)(UUID*))aSyscall[77].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_WIN32_USE_UUID + { "UuidCreateSequential", (SYSCALL)UuidCreateSequential, 0 }, +#else + { "UuidCreateSequential", (SYSCALL)0, 0 }, +#endif + +#define osUuidCreateSequential \ + ((RPC_STATUS(RPC_ENTRY*)(UUID*))aSyscall[78].pCurrent) + +#if !defined(SQLITE_NO_SYNC) && SQLITE_MAX_MMAP_SIZE>0 + { "FlushViewOfFile", (SYSCALL)FlushViewOfFile, 0 }, +#else + { "FlushViewOfFile", (SYSCALL)0, 0 }, +#endif + +#define osFlushViewOfFile \ + ((BOOL(WINAPI*)(LPCVOID,SIZE_T))aSyscall[79].pCurrent) + +}; /* End of the overrideable system calls */ + +/* +** This is the xSetSystemCall() method of sqlite3_vfs for all of the +** "win32" VFSes. Return SQLITE_OK opon successfully updating the +** system call pointer, or SQLITE_NOTFOUND if there is no configurable +** system call named zName. +*/ +static int winSetSystemCall( + sqlite3_vfs *pNotUsed, /* The VFS pointer. Not used */ + const char *zName, /* Name of system call to override */ + sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */ +){ + unsigned int i; + int rc = SQLITE_NOTFOUND; + + UNUSED_PARAMETER(pNotUsed); + if( zName==0 ){ + /* If no zName is given, restore all system calls to their default + ** settings and return NULL + */ + rc = SQLITE_OK; + for(i=0; i0 ){ + memset(zDbgBuf, 0, SQLITE_WIN32_DBG_BUF_SIZE); + memcpy(zDbgBuf, zBuf, nMin); + osOutputDebugStringA(zDbgBuf); + }else{ + osOutputDebugStringA(zBuf); + } +#elif defined(SQLITE_WIN32_HAS_WIDE) + memset(zDbgBuf, 0, SQLITE_WIN32_DBG_BUF_SIZE); + if ( osMultiByteToWideChar( + osAreFileApisANSI() ? CP_ACP : CP_OEMCP, 0, zBuf, + nMin, (LPWSTR)zDbgBuf, SQLITE_WIN32_DBG_BUF_SIZE/sizeof(WCHAR))<=0 ){ + return; + } + osOutputDebugStringW((LPCWSTR)zDbgBuf); +#else + if( nMin>0 ){ + memset(zDbgBuf, 0, SQLITE_WIN32_DBG_BUF_SIZE); + memcpy(zDbgBuf, zBuf, nMin); + fprintf(stderr, "%s", zDbgBuf); + }else{ + fprintf(stderr, "%s", zBuf); + } +#endif +} + +/* +** The following routine suspends the current thread for at least ms +** milliseconds. This is equivalent to the Win32 Sleep() interface. +*/ +#if SQLITE_OS_WINRT +static HANDLE sleepObj = NULL; +#endif + +SQLITE_API void sqlite3_win32_sleep(DWORD milliseconds){ +#if SQLITE_OS_WINRT + if ( sleepObj==NULL ){ + sleepObj = osCreateEventExW(NULL, NULL, CREATE_EVENT_MANUAL_RESET, + SYNCHRONIZE); + } + assert( sleepObj!=NULL ); + osWaitForSingleObjectEx(sleepObj, milliseconds, FALSE); +#else + osSleep(milliseconds); +#endif +} + +#if SQLITE_MAX_WORKER_THREADS>0 && !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && \ + SQLITE_THREADSAFE>0 +SQLITE_PRIVATE DWORD sqlite3Win32Wait(HANDLE hObject){ + DWORD rc; + while( (rc = osWaitForSingleObjectEx(hObject, INFINITE, + TRUE))==WAIT_IO_COMPLETION ){} + return rc; +} +#endif + +/* +** Return true (non-zero) if we are running under WinNT, Win2K, WinXP, +** or WinCE. Return false (zero) for Win95, Win98, or WinME. +** +** Here is an interesting observation: Win95, Win98, and WinME lack +** the LockFileEx() API. But we can still statically link against that +** API as long as we don't call it when running Win95/98/ME. A call to +** this routine is used to determine if the host is Win95/98/ME or +** WinNT/2K/XP so that we will know whether or not we can safely call +** the LockFileEx() API. +*/ + +#if !SQLITE_WIN32_GETVERSIONEX +# define osIsNT() (1) +#elif SQLITE_OS_WINCE || SQLITE_OS_WINRT || !defined(SQLITE_WIN32_HAS_ANSI) +# define osIsNT() (1) +#elif !defined(SQLITE_WIN32_HAS_WIDE) +# define osIsNT() (0) +#else +# define osIsNT() ((sqlite3_os_type==2) || sqlite3_win32_is_nt()) +#endif + +/* +** This function determines if the machine is running a version of Windows +** based on the NT kernel. +*/ +SQLITE_API int sqlite3_win32_is_nt(void){ +#if SQLITE_OS_WINRT + /* + ** NOTE: The WinRT sub-platform is always assumed to be based on the NT + ** kernel. + */ + return 1; +#elif SQLITE_WIN32_GETVERSIONEX + if( osInterlockedCompareExchange(&sqlite3_os_type, 0, 0)==0 ){ +#if defined(SQLITE_WIN32_HAS_ANSI) + OSVERSIONINFOA sInfo; + sInfo.dwOSVersionInfoSize = sizeof(sInfo); + osGetVersionExA(&sInfo); + osInterlockedCompareExchange(&sqlite3_os_type, + (sInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) ? 2 : 1, 0); +#elif defined(SQLITE_WIN32_HAS_WIDE) + OSVERSIONINFOW sInfo; + sInfo.dwOSVersionInfoSize = sizeof(sInfo); + osGetVersionExW(&sInfo); + osInterlockedCompareExchange(&sqlite3_os_type, + (sInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) ? 2 : 1, 0); +#endif + } + return osInterlockedCompareExchange(&sqlite3_os_type, 2, 2)==2; +#elif SQLITE_TEST + return osInterlockedCompareExchange(&sqlite3_os_type, 2, 2)==2; +#else + /* + ** NOTE: All sub-platforms where the GetVersionEx[AW] functions are + ** deprecated are always assumed to be based on the NT kernel. + */ + return 1; +#endif +} + +#ifdef SQLITE_WIN32_MALLOC +/* +** Allocate nBytes of memory. +*/ +static void *winMemMalloc(int nBytes){ + HANDLE hHeap; + void *p; + + winMemAssertMagic(); + hHeap = winMemGetHeap(); + assert( hHeap!=0 ); + assert( hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) ); +#endif + assert( nBytes>=0 ); + p = osHeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes); + if( !p ){ + sqlite3_log(SQLITE_NOMEM, "failed to HeapAlloc %u bytes (%lu), heap=%p", + nBytes, osGetLastError(), (void*)hHeap); + } + return p; +} + +/* +** Free memory. +*/ +static void winMemFree(void *pPrior){ + HANDLE hHeap; + + winMemAssertMagic(); + hHeap = winMemGetHeap(); + assert( hHeap!=0 ); + assert( hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ); +#endif + if( !pPrior ) return; /* Passing NULL to HeapFree is undefined. */ + if( !osHeapFree(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ){ + sqlite3_log(SQLITE_NOMEM, "failed to HeapFree block %p (%lu), heap=%p", + pPrior, osGetLastError(), (void*)hHeap); + } +} + +/* +** Change the size of an existing memory allocation +*/ +static void *winMemRealloc(void *pPrior, int nBytes){ + HANDLE hHeap; + void *p; + + winMemAssertMagic(); + hHeap = winMemGetHeap(); + assert( hHeap!=0 ); + assert( hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ); +#endif + assert( nBytes>=0 ); + if( !pPrior ){ + p = osHeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes); + }else{ + p = osHeapReAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior, (SIZE_T)nBytes); + } + if( !p ){ + sqlite3_log(SQLITE_NOMEM, "failed to %s %u bytes (%lu), heap=%p", + pPrior ? "HeapReAlloc" : "HeapAlloc", nBytes, osGetLastError(), + (void*)hHeap); + } + return p; +} + +/* +** Return the size of an outstanding allocation, in bytes. +*/ +static int winMemSize(void *p){ + HANDLE hHeap; + SIZE_T n; + + winMemAssertMagic(); + hHeap = winMemGetHeap(); + assert( hHeap!=0 ); + assert( hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, p) ); +#endif + if( !p ) return 0; + n = osHeapSize(hHeap, SQLITE_WIN32_HEAP_FLAGS, p); + if( n==(SIZE_T)-1 ){ + sqlite3_log(SQLITE_NOMEM, "failed to HeapSize block %p (%lu), heap=%p", + p, osGetLastError(), (void*)hHeap); + return 0; + } + return (int)n; +} + +/* +** Round up a request size to the next valid allocation size. +*/ +static int winMemRoundup(int n){ + return n; +} + +/* +** Initialize this module. +*/ +static int winMemInit(void *pAppData){ + winMemData *pWinMemData = (winMemData *)pAppData; + + if( !pWinMemData ) return SQLITE_ERROR; + assert( pWinMemData->magic1==WINMEM_MAGIC1 ); + assert( pWinMemData->magic2==WINMEM_MAGIC2 ); + +#if !SQLITE_OS_WINRT && SQLITE_WIN32_HEAP_CREATE + if( !pWinMemData->hHeap ){ + DWORD dwInitialSize = SQLITE_WIN32_HEAP_INIT_SIZE; + DWORD dwMaximumSize = (DWORD)sqlite3GlobalConfig.nHeap; + if( dwMaximumSize==0 ){ + dwMaximumSize = SQLITE_WIN32_HEAP_MAX_SIZE; + }else if( dwInitialSize>dwMaximumSize ){ + dwInitialSize = dwMaximumSize; + } + pWinMemData->hHeap = osHeapCreate(SQLITE_WIN32_HEAP_FLAGS, + dwInitialSize, dwMaximumSize); + if( !pWinMemData->hHeap ){ + sqlite3_log(SQLITE_NOMEM, + "failed to HeapCreate (%lu), flags=%u, initSize=%lu, maxSize=%lu", + osGetLastError(), SQLITE_WIN32_HEAP_FLAGS, dwInitialSize, + dwMaximumSize); + return SQLITE_NOMEM_BKPT; + } + pWinMemData->bOwned = TRUE; + assert( pWinMemData->bOwned ); + } +#else + pWinMemData->hHeap = osGetProcessHeap(); + if( !pWinMemData->hHeap ){ + sqlite3_log(SQLITE_NOMEM, + "failed to GetProcessHeap (%lu)", osGetLastError()); + return SQLITE_NOMEM_BKPT; + } + pWinMemData->bOwned = FALSE; + assert( !pWinMemData->bOwned ); +#endif + assert( pWinMemData->hHeap!=0 ); + assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) ); +#endif + return SQLITE_OK; +} + +/* +** Deinitialize this module. +*/ +static void winMemShutdown(void *pAppData){ + winMemData *pWinMemData = (winMemData *)pAppData; + + if( !pWinMemData ) return; + assert( pWinMemData->magic1==WINMEM_MAGIC1 ); + assert( pWinMemData->magic2==WINMEM_MAGIC2 ); + + if( pWinMemData->hHeap ){ + assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) ); +#endif + if( pWinMemData->bOwned ){ + if( !osHeapDestroy(pWinMemData->hHeap) ){ + sqlite3_log(SQLITE_NOMEM, "failed to HeapDestroy (%lu), heap=%p", + osGetLastError(), (void*)pWinMemData->hHeap); + } + pWinMemData->bOwned = FALSE; + } + pWinMemData->hHeap = NULL; + } +} + +/* +** Populate the low-level memory allocation function pointers in +** sqlite3GlobalConfig.m with pointers to the routines in this file. The +** arguments specify the block of memory to manage. +** +** This routine is only called by sqlite3_config(), and therefore +** is not required to be threadsafe (it is not). +*/ +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetWin32(void){ + static const sqlite3_mem_methods winMemMethods = { + winMemMalloc, + winMemFree, + winMemRealloc, + winMemSize, + winMemRoundup, + winMemInit, + winMemShutdown, + &win_mem_data + }; + return &winMemMethods; +} + +SQLITE_PRIVATE void sqlite3MemSetDefault(void){ + sqlite3_config(SQLITE_CONFIG_MALLOC, sqlite3MemGetWin32()); +} +#endif /* SQLITE_WIN32_MALLOC */ + +/* +** Convert a UTF-8 string to Microsoft Unicode. +** +** Space to hold the returned string is obtained from sqlite3_malloc(). +*/ +static LPWSTR winUtf8ToUnicode(const char *zText){ + int nChar; + LPWSTR zWideText; + + nChar = osMultiByteToWideChar(CP_UTF8, 0, zText, -1, NULL, 0); + if( nChar==0 ){ + return 0; + } + zWideText = sqlite3MallocZero( nChar*sizeof(WCHAR) ); + if( zWideText==0 ){ + return 0; + } + nChar = osMultiByteToWideChar(CP_UTF8, 0, zText, -1, zWideText, + nChar); + if( nChar==0 ){ + sqlite3_free(zWideText); + zWideText = 0; + } + return zWideText; +} + +/* +** Convert a Microsoft Unicode string to UTF-8. +** +** Space to hold the returned string is obtained from sqlite3_malloc(). +*/ +static char *winUnicodeToUtf8(LPCWSTR zWideText){ + int nByte; + char *zText; + + nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideText, -1, 0, 0, 0, 0); + if( nByte == 0 ){ + return 0; + } + zText = sqlite3MallocZero( nByte ); + if( zText==0 ){ + return 0; + } + nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideText, -1, zText, nByte, + 0, 0); + if( nByte == 0 ){ + sqlite3_free(zText); + zText = 0; + } + return zText; +} + +/* +** Convert an ANSI string to Microsoft Unicode, using the ANSI or OEM +** code page. +** +** Space to hold the returned string is obtained from sqlite3_malloc(). +*/ +static LPWSTR winMbcsToUnicode(const char *zText, int useAnsi){ + int nByte; + LPWSTR zMbcsText; + int codepage = useAnsi ? CP_ACP : CP_OEMCP; + + nByte = osMultiByteToWideChar(codepage, 0, zText, -1, NULL, + 0)*sizeof(WCHAR); + if( nByte==0 ){ + return 0; + } + zMbcsText = sqlite3MallocZero( nByte*sizeof(WCHAR) ); + if( zMbcsText==0 ){ + return 0; + } + nByte = osMultiByteToWideChar(codepage, 0, zText, -1, zMbcsText, + nByte); + if( nByte==0 ){ + sqlite3_free(zMbcsText); + zMbcsText = 0; + } + return zMbcsText; +} + +/* +** Convert a Microsoft Unicode string to a multi-byte character string, +** using the ANSI or OEM code page. +** +** Space to hold the returned string is obtained from sqlite3_malloc(). +*/ +static char *winUnicodeToMbcs(LPCWSTR zWideText, int useAnsi){ + int nByte; + char *zText; + int codepage = useAnsi ? CP_ACP : CP_OEMCP; + + nByte = osWideCharToMultiByte(codepage, 0, zWideText, -1, 0, 0, 0, 0); + if( nByte == 0 ){ + return 0; + } + zText = sqlite3MallocZero( nByte ); + if( zText==0 ){ + return 0; + } + nByte = osWideCharToMultiByte(codepage, 0, zWideText, -1, zText, + nByte, 0, 0); + if( nByte == 0 ){ + sqlite3_free(zText); + zText = 0; + } + return zText; +} + +/* +** Convert a multi-byte character string to UTF-8. +** +** Space to hold the returned string is obtained from sqlite3_malloc(). +*/ +static char *winMbcsToUtf8(const char *zText, int useAnsi){ + char *zTextUtf8; + LPWSTR zTmpWide; + + zTmpWide = winMbcsToUnicode(zText, useAnsi); + if( zTmpWide==0 ){ + return 0; + } + zTextUtf8 = winUnicodeToUtf8(zTmpWide); + sqlite3_free(zTmpWide); + return zTextUtf8; +} + +/* +** Convert a UTF-8 string to a multi-byte character string. +** +** Space to hold the returned string is obtained from sqlite3_malloc(). +*/ +static char *winUtf8ToMbcs(const char *zText, int useAnsi){ + char *zTextMbcs; + LPWSTR zTmpWide; + + zTmpWide = winUtf8ToUnicode(zText); + if( zTmpWide==0 ){ + return 0; + } + zTextMbcs = winUnicodeToMbcs(zTmpWide, useAnsi); + sqlite3_free(zTmpWide); + return zTextMbcs; +} + +/* +** This is a public wrapper for the winUtf8ToUnicode() function. +*/ +SQLITE_API LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !zText ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return winUtf8ToUnicode(zText); +} + +/* +** This is a public wrapper for the winUnicodeToUtf8() function. +*/ +SQLITE_API char *sqlite3_win32_unicode_to_utf8(LPCWSTR zWideText){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !zWideText ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return winUnicodeToUtf8(zWideText); +} + +/* +** This is a public wrapper for the winMbcsToUtf8() function. +*/ +SQLITE_API char *sqlite3_win32_mbcs_to_utf8(const char *zText){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !zText ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return winMbcsToUtf8(zText, osAreFileApisANSI()); +} + +/* +** This is a public wrapper for the winMbcsToUtf8() function. +*/ +SQLITE_API char *sqlite3_win32_mbcs_to_utf8_v2(const char *zText, int useAnsi){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !zText ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return winMbcsToUtf8(zText, useAnsi); +} + +/* +** This is a public wrapper for the winUtf8ToMbcs() function. +*/ +SQLITE_API char *sqlite3_win32_utf8_to_mbcs(const char *zText){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !zText ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return winUtf8ToMbcs(zText, osAreFileApisANSI()); +} + +/* +** This is a public wrapper for the winUtf8ToMbcs() function. +*/ +SQLITE_API char *sqlite3_win32_utf8_to_mbcs_v2(const char *zText, int useAnsi){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !zText ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return winUtf8ToMbcs(zText, useAnsi); +} + +/* +** This function is the same as sqlite3_win32_set_directory (below); however, +** it accepts a UTF-8 string. +*/ +SQLITE_API int sqlite3_win32_set_directory8( + unsigned long type, /* Identifier for directory being set or reset */ + const char *zValue /* New value for directory being set or reset */ +){ + char **ppDirectory = 0; +#ifndef SQLITE_OMIT_AUTOINIT + int rc = sqlite3_initialize(); + if( rc ) return rc; +#endif + if( type==SQLITE_WIN32_DATA_DIRECTORY_TYPE ){ + ppDirectory = &sqlite3_data_directory; + }else if( type==SQLITE_WIN32_TEMP_DIRECTORY_TYPE ){ + ppDirectory = &sqlite3_temp_directory; + } + assert( !ppDirectory || type==SQLITE_WIN32_DATA_DIRECTORY_TYPE + || type==SQLITE_WIN32_TEMP_DIRECTORY_TYPE + ); + assert( !ppDirectory || sqlite3MemdebugHasType(*ppDirectory, MEMTYPE_HEAP) ); + if( ppDirectory ){ + char *zCopy = 0; + if( zValue && zValue[0] ){ + zCopy = sqlite3_mprintf("%s", zValue); + if ( zCopy==0 ){ + return SQLITE_NOMEM_BKPT; + } + } + sqlite3_free(*ppDirectory); + *ppDirectory = zCopy; + return SQLITE_OK; + } + return SQLITE_ERROR; +} + +/* +** This function is the same as sqlite3_win32_set_directory (below); however, +** it accepts a UTF-16 string. +*/ +SQLITE_API int sqlite3_win32_set_directory16( + unsigned long type, /* Identifier for directory being set or reset */ + const void *zValue /* New value for directory being set or reset */ +){ + int rc; + char *zUtf8 = 0; + if( zValue ){ + zUtf8 = sqlite3_win32_unicode_to_utf8(zValue); + if( zUtf8==0 ) return SQLITE_NOMEM_BKPT; + } + rc = sqlite3_win32_set_directory8(type, zUtf8); + if( zUtf8 ) sqlite3_free(zUtf8); + return rc; +} + +/* +** This function sets the data directory or the temporary directory based on +** the provided arguments. The type argument must be 1 in order to set the +** data directory or 2 in order to set the temporary directory. The zValue +** argument is the name of the directory to use. The return value will be +** SQLITE_OK if successful. +*/ +SQLITE_API int sqlite3_win32_set_directory( + unsigned long type, /* Identifier for directory being set or reset */ + void *zValue /* New value for directory being set or reset */ +){ + return sqlite3_win32_set_directory16(type, zValue); +} + +/* +** The return value of winGetLastErrorMsg +** is zero if the error message fits in the buffer, or non-zero +** otherwise (if the message was truncated). +*/ +static int winGetLastErrorMsg(DWORD lastErrno, int nBuf, char *zBuf){ + /* FormatMessage returns 0 on failure. Otherwise it + ** returns the number of TCHARs written to the output + ** buffer, excluding the terminating null char. + */ + DWORD dwLen = 0; + char *zOut = 0; + + if( osIsNT() ){ +#if SQLITE_OS_WINRT + WCHAR zTempWide[SQLITE_WIN32_MAX_ERRMSG_CHARS+1]; + dwLen = osFormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + lastErrno, + 0, + zTempWide, + SQLITE_WIN32_MAX_ERRMSG_CHARS, + 0); +#else + LPWSTR zTempWide = NULL; + dwLen = osFormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + lastErrno, + 0, + (LPWSTR) &zTempWide, + 0, + 0); +#endif + if( dwLen > 0 ){ + /* allocate a buffer and convert to UTF8 */ + sqlite3BeginBenignMalloc(); + zOut = winUnicodeToUtf8(zTempWide); + sqlite3EndBenignMalloc(); +#if !SQLITE_OS_WINRT + /* free the system buffer allocated by FormatMessage */ + osLocalFree(zTempWide); +#endif + } + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + char *zTemp = NULL; + dwLen = osFormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + lastErrno, + 0, + (LPSTR) &zTemp, + 0, + 0); + if( dwLen > 0 ){ + /* allocate a buffer and convert to UTF8 */ + sqlite3BeginBenignMalloc(); + zOut = winMbcsToUtf8(zTemp, osAreFileApisANSI()); + sqlite3EndBenignMalloc(); + /* free the system buffer allocated by FormatMessage */ + osLocalFree(zTemp); + } + } +#endif + if( 0 == dwLen ){ + sqlite3_snprintf(nBuf, zBuf, "OsError 0x%lx (%lu)", lastErrno, lastErrno); + }else{ + /* copy a maximum of nBuf chars to output buffer */ + sqlite3_snprintf(nBuf, zBuf, "%s", zOut); + /* free the UTF8 buffer */ + sqlite3_free(zOut); + } + return 0; +} + +/* +** +** This function - winLogErrorAtLine() - is only ever called via the macro +** winLogError(). +** +** This routine is invoked after an error occurs in an OS function. +** It logs a message using sqlite3_log() containing the current value of +** error code and, if possible, the human-readable equivalent from +** FormatMessage. +** +** The first argument passed to the macro should be the error code that +** will be returned to SQLite (e.g. SQLITE_IOERR_DELETE, SQLITE_CANTOPEN). +** The two subsequent arguments should be the name of the OS function that +** failed and the associated file-system path, if any. +*/ +#define winLogError(a,b,c,d) winLogErrorAtLine(a,b,c,d,__LINE__) +static int winLogErrorAtLine( + int errcode, /* SQLite error code */ + DWORD lastErrno, /* Win32 last error */ + const char *zFunc, /* Name of OS function that failed */ + const char *zPath, /* File path associated with error */ + int iLine /* Source line number where error occurred */ +){ + char zMsg[500]; /* Human readable error text */ + int i; /* Loop counter */ + + zMsg[0] = 0; + winGetLastErrorMsg(lastErrno, sizeof(zMsg), zMsg); + assert( errcode!=SQLITE_OK ); + if( zPath==0 ) zPath = ""; + for(i=0; zMsg[i] && zMsg[i]!='\r' && zMsg[i]!='\n'; i++){} + zMsg[i] = 0; + sqlite3_log(errcode, + "os_win.c:%d: (%lu) %s(%s) - %s", + iLine, lastErrno, zFunc, zPath, zMsg + ); + + return errcode; +} + +/* +** The number of times that a ReadFile(), WriteFile(), and DeleteFile() +** will be retried following a locking error - probably caused by +** antivirus software. Also the initial delay before the first retry. +** The delay increases linearly with each retry. +*/ +#ifndef SQLITE_WIN32_IOERR_RETRY +# define SQLITE_WIN32_IOERR_RETRY 10 +#endif +#ifndef SQLITE_WIN32_IOERR_RETRY_DELAY +# define SQLITE_WIN32_IOERR_RETRY_DELAY 25 +#endif +static int winIoerrRetry = SQLITE_WIN32_IOERR_RETRY; +static int winIoerrRetryDelay = SQLITE_WIN32_IOERR_RETRY_DELAY; + +/* +** The "winIoerrCanRetry1" macro is used to determine if a particular I/O +** error code obtained via GetLastError() is eligible to be retried. It +** must accept the error code DWORD as its only argument and should return +** non-zero if the error code is transient in nature and the operation +** responsible for generating the original error might succeed upon being +** retried. The argument to this macro should be a variable. +** +** Additionally, a macro named "winIoerrCanRetry2" may be defined. If it +** is defined, it will be consulted only when the macro "winIoerrCanRetry1" +** returns zero. The "winIoerrCanRetry2" macro is completely optional and +** may be used to include additional error codes in the set that should +** result in the failing I/O operation being retried by the caller. If +** defined, the "winIoerrCanRetry2" macro must exhibit external semantics +** identical to those of the "winIoerrCanRetry1" macro. +*/ +#if !defined(winIoerrCanRetry1) +#define winIoerrCanRetry1(a) (((a)==ERROR_ACCESS_DENIED) || \ + ((a)==ERROR_SHARING_VIOLATION) || \ + ((a)==ERROR_LOCK_VIOLATION) || \ + ((a)==ERROR_DEV_NOT_EXIST) || \ + ((a)==ERROR_NETNAME_DELETED) || \ + ((a)==ERROR_SEM_TIMEOUT) || \ + ((a)==ERROR_NETWORK_UNREACHABLE)) +#endif + +/* +** If a ReadFile() or WriteFile() error occurs, invoke this routine +** to see if it should be retried. Return TRUE to retry. Return FALSE +** to give up with an error. +*/ +static int winRetryIoerr(int *pnRetry, DWORD *pError){ + DWORD e = osGetLastError(); + if( *pnRetry>=winIoerrRetry ){ + if( pError ){ + *pError = e; + } + return 0; + } + if( winIoerrCanRetry1(e) ){ + sqlite3_win32_sleep(winIoerrRetryDelay*(1+*pnRetry)); + ++*pnRetry; + return 1; + } +#if defined(winIoerrCanRetry2) + else if( winIoerrCanRetry2(e) ){ + sqlite3_win32_sleep(winIoerrRetryDelay*(1+*pnRetry)); + ++*pnRetry; + return 1; + } +#endif + if( pError ){ + *pError = e; + } + return 0; +} + +/* +** Log a I/O error retry episode. +*/ +static void winLogIoerr(int nRetry, int lineno){ + if( nRetry ){ + sqlite3_log(SQLITE_NOTICE, + "delayed %dms for lock/sharing conflict at line %d", + winIoerrRetryDelay*nRetry*(nRetry+1)/2, lineno + ); + } +} + +/* +** This #if does not rely on the SQLITE_OS_WINCE define because the +** corresponding section in "date.c" cannot use it. +*/ +#if !defined(SQLITE_OMIT_LOCALTIME) && defined(_WIN32_WCE) && \ + (!defined(SQLITE_MSVC_LOCALTIME_API) || !SQLITE_MSVC_LOCALTIME_API) +/* +** The MSVC CRT on Windows CE may not have a localtime() function. +** So define a substitute. +*/ +/* # include */ +struct tm *__cdecl localtime(const time_t *t) +{ + static struct tm y; + FILETIME uTm, lTm; + SYSTEMTIME pTm; + sqlite3_int64 t64; + t64 = *t; + t64 = (t64 + 11644473600)*10000000; + uTm.dwLowDateTime = (DWORD)(t64 & 0xFFFFFFFF); + uTm.dwHighDateTime= (DWORD)(t64 >> 32); + osFileTimeToLocalFileTime(&uTm,&lTm); + osFileTimeToSystemTime(&lTm,&pTm); + y.tm_year = pTm.wYear - 1900; + y.tm_mon = pTm.wMonth - 1; + y.tm_wday = pTm.wDayOfWeek; + y.tm_mday = pTm.wDay; + y.tm_hour = pTm.wHour; + y.tm_min = pTm.wMinute; + y.tm_sec = pTm.wSecond; + return &y; +} +#endif + +#if SQLITE_OS_WINCE +/************************************************************************* +** This section contains code for WinCE only. +*/ +#define HANDLE_TO_WINFILE(a) (winFile*)&((char*)a)[-(int)offsetof(winFile,h)] + +/* +** Acquire a lock on the handle h +*/ +static void winceMutexAcquire(HANDLE h){ + DWORD dwErr; + do { + dwErr = osWaitForSingleObject(h, INFINITE); + } while (dwErr != WAIT_OBJECT_0 && dwErr != WAIT_ABANDONED); +} +/* +** Release a lock acquired by winceMutexAcquire() +*/ +#define winceMutexRelease(h) ReleaseMutex(h) + +/* +** Create the mutex and shared memory used for locking in the file +** descriptor pFile +*/ +static int winceCreateLock(const char *zFilename, winFile *pFile){ + LPWSTR zTok; + LPWSTR zName; + DWORD lastErrno; + BOOL bLogged = FALSE; + BOOL bInit = TRUE; + + zName = winUtf8ToUnicode(zFilename); + if( zName==0 ){ + /* out of memory */ + return SQLITE_IOERR_NOMEM_BKPT; + } + + /* Initialize the local lockdata */ + memset(&pFile->local, 0, sizeof(pFile->local)); + + /* Replace the backslashes from the filename and lowercase it + ** to derive a mutex name. */ + zTok = osCharLowerW(zName); + for (;*zTok;zTok++){ + if (*zTok == '\\') *zTok = '_'; + } + + /* Create/open the named mutex */ + pFile->hMutex = osCreateMutexW(NULL, FALSE, zName); + if (!pFile->hMutex){ + pFile->lastErrno = osGetLastError(); + sqlite3_free(zName); + return winLogError(SQLITE_IOERR, pFile->lastErrno, + "winceCreateLock1", zFilename); + } + + /* Acquire the mutex before continuing */ + winceMutexAcquire(pFile->hMutex); + + /* Since the names of named mutexes, semaphores, file mappings etc are + ** case-sensitive, take advantage of that by uppercasing the mutex name + ** and using that as the shared filemapping name. + */ + osCharUpperW(zName); + pFile->hShared = osCreateFileMappingW(INVALID_HANDLE_VALUE, NULL, + PAGE_READWRITE, 0, sizeof(winceLock), + zName); + + /* Set a flag that indicates we're the first to create the memory so it + ** must be zero-initialized */ + lastErrno = osGetLastError(); + if (lastErrno == ERROR_ALREADY_EXISTS){ + bInit = FALSE; + } + + sqlite3_free(zName); + + /* If we succeeded in making the shared memory handle, map it. */ + if( pFile->hShared ){ + pFile->shared = (winceLock*)osMapViewOfFile(pFile->hShared, + FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, sizeof(winceLock)); + /* If mapping failed, close the shared memory handle and erase it */ + if( !pFile->shared ){ + pFile->lastErrno = osGetLastError(); + winLogError(SQLITE_IOERR, pFile->lastErrno, + "winceCreateLock2", zFilename); + bLogged = TRUE; + osCloseHandle(pFile->hShared); + pFile->hShared = NULL; + } + } + + /* If shared memory could not be created, then close the mutex and fail */ + if( pFile->hShared==NULL ){ + if( !bLogged ){ + pFile->lastErrno = lastErrno; + winLogError(SQLITE_IOERR, pFile->lastErrno, + "winceCreateLock3", zFilename); + bLogged = TRUE; + } + winceMutexRelease(pFile->hMutex); + osCloseHandle(pFile->hMutex); + pFile->hMutex = NULL; + return SQLITE_IOERR; + } + + /* Initialize the shared memory if we're supposed to */ + if( bInit ){ + memset(pFile->shared, 0, sizeof(winceLock)); + } + + winceMutexRelease(pFile->hMutex); + return SQLITE_OK; +} + +/* +** Destroy the part of winFile that deals with wince locks +*/ +static void winceDestroyLock(winFile *pFile){ + if (pFile->hMutex){ + /* Acquire the mutex */ + winceMutexAcquire(pFile->hMutex); + + /* The following blocks should probably assert in debug mode, but they + are to cleanup in case any locks remained open */ + if (pFile->local.nReaders){ + pFile->shared->nReaders --; + } + if (pFile->local.bReserved){ + pFile->shared->bReserved = FALSE; + } + if (pFile->local.bPending){ + pFile->shared->bPending = FALSE; + } + if (pFile->local.bExclusive){ + pFile->shared->bExclusive = FALSE; + } + + /* De-reference and close our copy of the shared memory handle */ + osUnmapViewOfFile(pFile->shared); + osCloseHandle(pFile->hShared); + + /* Done with the mutex */ + winceMutexRelease(pFile->hMutex); + osCloseHandle(pFile->hMutex); + pFile->hMutex = NULL; + } +} + +/* +** An implementation of the LockFile() API of Windows for CE +*/ +static BOOL winceLockFile( + LPHANDLE phFile, + DWORD dwFileOffsetLow, + DWORD dwFileOffsetHigh, + DWORD nNumberOfBytesToLockLow, + DWORD nNumberOfBytesToLockHigh +){ + winFile *pFile = HANDLE_TO_WINFILE(phFile); + BOOL bReturn = FALSE; + + UNUSED_PARAMETER(dwFileOffsetHigh); + UNUSED_PARAMETER(nNumberOfBytesToLockHigh); + + if (!pFile->hMutex) return TRUE; + winceMutexAcquire(pFile->hMutex); + + /* Wanting an exclusive lock? */ + if (dwFileOffsetLow == (DWORD)SHARED_FIRST + && nNumberOfBytesToLockLow == (DWORD)SHARED_SIZE){ + if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){ + pFile->shared->bExclusive = TRUE; + pFile->local.bExclusive = TRUE; + bReturn = TRUE; + } + } + + /* Want a read-only lock? */ + else if (dwFileOffsetLow == (DWORD)SHARED_FIRST && + nNumberOfBytesToLockLow == 1){ + if (pFile->shared->bExclusive == 0){ + pFile->local.nReaders ++; + if (pFile->local.nReaders == 1){ + pFile->shared->nReaders ++; + } + bReturn = TRUE; + } + } + + /* Want a pending lock? */ + else if (dwFileOffsetLow == (DWORD)PENDING_BYTE + && nNumberOfBytesToLockLow == 1){ + /* If no pending lock has been acquired, then acquire it */ + if (pFile->shared->bPending == 0) { + pFile->shared->bPending = TRUE; + pFile->local.bPending = TRUE; + bReturn = TRUE; + } + } + + /* Want a reserved lock? */ + else if (dwFileOffsetLow == (DWORD)RESERVED_BYTE + && nNumberOfBytesToLockLow == 1){ + if (pFile->shared->bReserved == 0) { + pFile->shared->bReserved = TRUE; + pFile->local.bReserved = TRUE; + bReturn = TRUE; + } + } + + winceMutexRelease(pFile->hMutex); + return bReturn; +} + +/* +** An implementation of the UnlockFile API of Windows for CE +*/ +static BOOL winceUnlockFile( + LPHANDLE phFile, + DWORD dwFileOffsetLow, + DWORD dwFileOffsetHigh, + DWORD nNumberOfBytesToUnlockLow, + DWORD nNumberOfBytesToUnlockHigh +){ + winFile *pFile = HANDLE_TO_WINFILE(phFile); + BOOL bReturn = FALSE; + + UNUSED_PARAMETER(dwFileOffsetHigh); + UNUSED_PARAMETER(nNumberOfBytesToUnlockHigh); + + if (!pFile->hMutex) return TRUE; + winceMutexAcquire(pFile->hMutex); + + /* Releasing a reader lock or an exclusive lock */ + if (dwFileOffsetLow == (DWORD)SHARED_FIRST){ + /* Did we have an exclusive lock? */ + if (pFile->local.bExclusive){ + assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE); + pFile->local.bExclusive = FALSE; + pFile->shared->bExclusive = FALSE; + bReturn = TRUE; + } + + /* Did we just have a reader lock? */ + else if (pFile->local.nReaders){ + assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE + || nNumberOfBytesToUnlockLow == 1); + pFile->local.nReaders --; + if (pFile->local.nReaders == 0) + { + pFile->shared->nReaders --; + } + bReturn = TRUE; + } + } + + /* Releasing a pending lock */ + else if (dwFileOffsetLow == (DWORD)PENDING_BYTE + && nNumberOfBytesToUnlockLow == 1){ + if (pFile->local.bPending){ + pFile->local.bPending = FALSE; + pFile->shared->bPending = FALSE; + bReturn = TRUE; + } + } + /* Releasing a reserved lock */ + else if (dwFileOffsetLow == (DWORD)RESERVED_BYTE + && nNumberOfBytesToUnlockLow == 1){ + if (pFile->local.bReserved) { + pFile->local.bReserved = FALSE; + pFile->shared->bReserved = FALSE; + bReturn = TRUE; + } + } + + winceMutexRelease(pFile->hMutex); + return bReturn; +} +/* +** End of the special code for wince +*****************************************************************************/ +#endif /* SQLITE_OS_WINCE */ + +/* +** Lock a file region. +*/ +static BOOL winLockFile( + LPHANDLE phFile, + DWORD flags, + DWORD offsetLow, + DWORD offsetHigh, + DWORD numBytesLow, + DWORD numBytesHigh +){ +#if SQLITE_OS_WINCE + /* + ** NOTE: Windows CE is handled differently here due its lack of the Win32 + ** API LockFile. + */ + return winceLockFile(phFile, offsetLow, offsetHigh, + numBytesLow, numBytesHigh); +#else + if( osIsNT() ){ + OVERLAPPED ovlp; + memset(&ovlp, 0, sizeof(OVERLAPPED)); + ovlp.Offset = offsetLow; + ovlp.OffsetHigh = offsetHigh; + return osLockFileEx(*phFile, flags, 0, numBytesLow, numBytesHigh, &ovlp); + }else{ + return osLockFile(*phFile, offsetLow, offsetHigh, numBytesLow, + numBytesHigh); + } +#endif +} + +/* +** Unlock a file region. + */ +static BOOL winUnlockFile( + LPHANDLE phFile, + DWORD offsetLow, + DWORD offsetHigh, + DWORD numBytesLow, + DWORD numBytesHigh +){ +#if SQLITE_OS_WINCE + /* + ** NOTE: Windows CE is handled differently here due its lack of the Win32 + ** API UnlockFile. + */ + return winceUnlockFile(phFile, offsetLow, offsetHigh, + numBytesLow, numBytesHigh); +#else + if( osIsNT() ){ + OVERLAPPED ovlp; + memset(&ovlp, 0, sizeof(OVERLAPPED)); + ovlp.Offset = offsetLow; + ovlp.OffsetHigh = offsetHigh; + return osUnlockFileEx(*phFile, 0, numBytesLow, numBytesHigh, &ovlp); + }else{ + return osUnlockFile(*phFile, offsetLow, offsetHigh, numBytesLow, + numBytesHigh); + } +#endif +} + +/***************************************************************************** +** The next group of routines implement the I/O methods specified +** by the sqlite3_io_methods object. +******************************************************************************/ + +/* +** Some Microsoft compilers lack this definition. +*/ +#ifndef INVALID_SET_FILE_POINTER +# define INVALID_SET_FILE_POINTER ((DWORD)-1) +#endif + +/* +** Move the current position of the file handle passed as the first +** argument to offset iOffset within the file. If successful, return 0. +** Otherwise, set pFile->lastErrno and return non-zero. +*/ +static int winSeekFile(winFile *pFile, sqlite3_int64 iOffset){ +#if !SQLITE_OS_WINRT + LONG upperBits; /* Most sig. 32 bits of new offset */ + LONG lowerBits; /* Least sig. 32 bits of new offset */ + DWORD dwRet; /* Value returned by SetFilePointer() */ + DWORD lastErrno; /* Value returned by GetLastError() */ + + OSTRACE(("SEEK file=%p, offset=%lld\n", pFile->h, iOffset)); + + upperBits = (LONG)((iOffset>>32) & 0x7fffffff); + lowerBits = (LONG)(iOffset & 0xffffffff); + + /* API oddity: If successful, SetFilePointer() returns a dword + ** containing the lower 32-bits of the new file-offset. Or, if it fails, + ** it returns INVALID_SET_FILE_POINTER. However according to MSDN, + ** INVALID_SET_FILE_POINTER may also be a valid new offset. So to determine + ** whether an error has actually occurred, it is also necessary to call + ** GetLastError(). + */ + dwRet = osSetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN); + + if( (dwRet==INVALID_SET_FILE_POINTER + && ((lastErrno = osGetLastError())!=NO_ERROR)) ){ + pFile->lastErrno = lastErrno; + winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno, + "winSeekFile", pFile->zPath); + OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h)); + return 1; + } + + OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h)); + return 0; +#else + /* + ** Same as above, except that this implementation works for WinRT. + */ + + LARGE_INTEGER x; /* The new offset */ + BOOL bRet; /* Value returned by SetFilePointerEx() */ + + x.QuadPart = iOffset; + bRet = osSetFilePointerEx(pFile->h, x, 0, FILE_BEGIN); + + if(!bRet){ + pFile->lastErrno = osGetLastError(); + winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno, + "winSeekFile", pFile->zPath); + OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h)); + return 1; + } + + OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h)); + return 0; +#endif +} + +#if SQLITE_MAX_MMAP_SIZE>0 +/* Forward references to VFS helper methods used for memory mapped files */ +static int winMapfile(winFile*, sqlite3_int64); +static int winUnmapfile(winFile*); +#endif + +/* +** Close a file. +** +** It is reported that an attempt to close a handle might sometimes +** fail. This is a very unreasonable result, but Windows is notorious +** for being unreasonable so I do not doubt that it might happen. If +** the close fails, we pause for 100 milliseconds and try again. As +** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before +** giving up and returning an error. +*/ +#define MX_CLOSE_ATTEMPT 3 +static int winClose(sqlite3_file *id){ + int rc, cnt = 0; + winFile *pFile = (winFile*)id; + + assert( id!=0 ); +#ifndef SQLITE_OMIT_WAL + assert( pFile->pShm==0 ); +#endif + assert( pFile->h!=NULL && pFile->h!=INVALID_HANDLE_VALUE ); + OSTRACE(("CLOSE pid=%lu, pFile=%p, file=%p\n", + osGetCurrentProcessId(), pFile, pFile->h)); + +#if SQLITE_MAX_MMAP_SIZE>0 + winUnmapfile(pFile); +#endif + + do{ + rc = osCloseHandle(pFile->h); + /* SimulateIOError( rc=0; cnt=MX_CLOSE_ATTEMPT; ); */ + }while( rc==0 && ++cnt < MX_CLOSE_ATTEMPT && (sqlite3_win32_sleep(100), 1) ); +#if SQLITE_OS_WINCE +#define WINCE_DELETION_ATTEMPTS 3 + { + winVfsAppData *pAppData = (winVfsAppData*)pFile->pVfs->pAppData; + if( pAppData==NULL || !pAppData->bNoLock ){ + winceDestroyLock(pFile); + } + } + if( pFile->zDeleteOnClose ){ + int cnt = 0; + while( + osDeleteFileW(pFile->zDeleteOnClose)==0 + && osGetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff + && cnt++ < WINCE_DELETION_ATTEMPTS + ){ + sqlite3_win32_sleep(100); /* Wait a little before trying again */ + } + sqlite3_free(pFile->zDeleteOnClose); + } +#endif + if( rc ){ + pFile->h = NULL; + } + OpenCounter(-1); + OSTRACE(("CLOSE pid=%lu, pFile=%p, file=%p, rc=%s\n", + osGetCurrentProcessId(), pFile, pFile->h, rc ? "ok" : "failed")); + return rc ? SQLITE_OK + : winLogError(SQLITE_IOERR_CLOSE, osGetLastError(), + "winClose", pFile->zPath); +} + +/* +** Read data from a file into a buffer. Return SQLITE_OK if all +** bytes were read successfully and SQLITE_IOERR if anything goes +** wrong. +*/ +static int winRead( + sqlite3_file *id, /* File to read from */ + void *pBuf, /* Write content into this buffer */ + int amt, /* Number of bytes to read */ + sqlite3_int64 offset /* Begin reading at this offset */ +){ +#if !SQLITE_OS_WINCE && !defined(SQLITE_WIN32_NO_OVERLAPPED) + OVERLAPPED overlapped; /* The offset for ReadFile. */ +#endif + winFile *pFile = (winFile*)id; /* file handle */ + DWORD nRead; /* Number of bytes actually read from file */ + int nRetry = 0; /* Number of retrys */ + + assert( id!=0 ); + assert( amt>0 ); + assert( offset>=0 ); + SimulateIOError(return SQLITE_IOERR_READ); + OSTRACE(("READ pid=%lu, pFile=%p, file=%p, buffer=%p, amount=%d, " + "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile, + pFile->h, pBuf, amt, offset, pFile->locktype)); + +#if SQLITE_MAX_MMAP_SIZE>0 + /* Deal with as much of this read request as possible by transfering + ** data from the memory mapping using memcpy(). */ + if( offsetmmapSize ){ + if( offset+amt <= pFile->mmapSize ){ + memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt); + OSTRACE(("READ-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; + }else{ + int nCopy = (int)(pFile->mmapSize - offset); + memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy); + pBuf = &((u8 *)pBuf)[nCopy]; + amt -= nCopy; + offset += nCopy; + } + } +#endif + +#if SQLITE_OS_WINCE || defined(SQLITE_WIN32_NO_OVERLAPPED) + if( winSeekFile(pFile, offset) ){ + OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_FULL\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_FULL; + } + while( !osReadFile(pFile->h, pBuf, amt, &nRead, 0) ){ +#else + memset(&overlapped, 0, sizeof(OVERLAPPED)); + overlapped.Offset = (LONG)(offset & 0xffffffff); + overlapped.OffsetHigh = (LONG)((offset>>32) & 0x7fffffff); + while( !osReadFile(pFile->h, pBuf, amt, &nRead, &overlapped) && + osGetLastError()!=ERROR_HANDLE_EOF ){ +#endif + DWORD lastErrno; + if( winRetryIoerr(&nRetry, &lastErrno) ) continue; + pFile->lastErrno = lastErrno; + OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_READ\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return winLogError(SQLITE_IOERR_READ, pFile->lastErrno, + "winRead", pFile->zPath); + } + winLogIoerr(nRetry, __LINE__); + if( nRead<(DWORD)amt ){ + /* Unread parts of the buffer must be zero-filled */ + memset(&((char*)pBuf)[nRead], 0, amt-nRead); + OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_SHORT_READ\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_IOERR_SHORT_READ; + } + + OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; +} + +/* +** Write data from a buffer into a file. Return SQLITE_OK on success +** or some other error code on failure. +*/ +static int winWrite( + sqlite3_file *id, /* File to write into */ + const void *pBuf, /* The bytes to be written */ + int amt, /* Number of bytes to write */ + sqlite3_int64 offset /* Offset into the file to begin writing at */ +){ + int rc = 0; /* True if error has occurred, else false */ + winFile *pFile = (winFile*)id; /* File handle */ + int nRetry = 0; /* Number of retries */ + + assert( amt>0 ); + assert( pFile ); + SimulateIOError(return SQLITE_IOERR_WRITE); + SimulateDiskfullError(return SQLITE_FULL); + + OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, buffer=%p, amount=%d, " + "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile, + pFile->h, pBuf, amt, offset, pFile->locktype)); + +#if defined(SQLITE_MMAP_READWRITE) && SQLITE_MAX_MMAP_SIZE>0 + /* Deal with as much of this write request as possible by transfering + ** data from the memory mapping using memcpy(). */ + if( offsetmmapSize ){ + if( offset+amt <= pFile->mmapSize ){ + memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt); + OSTRACE(("WRITE-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; + }else{ + int nCopy = (int)(pFile->mmapSize - offset); + memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy); + pBuf = &((u8 *)pBuf)[nCopy]; + amt -= nCopy; + offset += nCopy; + } + } +#endif + +#if SQLITE_OS_WINCE || defined(SQLITE_WIN32_NO_OVERLAPPED) + rc = winSeekFile(pFile, offset); + if( rc==0 ){ +#else + { +#endif +#if !SQLITE_OS_WINCE && !defined(SQLITE_WIN32_NO_OVERLAPPED) + OVERLAPPED overlapped; /* The offset for WriteFile. */ +#endif + u8 *aRem = (u8 *)pBuf; /* Data yet to be written */ + int nRem = amt; /* Number of bytes yet to be written */ + DWORD nWrite; /* Bytes written by each WriteFile() call */ + DWORD lastErrno = NO_ERROR; /* Value returned by GetLastError() */ + +#if !SQLITE_OS_WINCE && !defined(SQLITE_WIN32_NO_OVERLAPPED) + memset(&overlapped, 0, sizeof(OVERLAPPED)); + overlapped.Offset = (LONG)(offset & 0xffffffff); + overlapped.OffsetHigh = (LONG)((offset>>32) & 0x7fffffff); +#endif + + while( nRem>0 ){ +#if SQLITE_OS_WINCE || defined(SQLITE_WIN32_NO_OVERLAPPED) + if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, 0) ){ +#else + if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, &overlapped) ){ +#endif + if( winRetryIoerr(&nRetry, &lastErrno) ) continue; + break; + } + assert( nWrite==0 || nWrite<=(DWORD)nRem ); + if( nWrite==0 || nWrite>(DWORD)nRem ){ + lastErrno = osGetLastError(); + break; + } +#if !SQLITE_OS_WINCE && !defined(SQLITE_WIN32_NO_OVERLAPPED) + offset += nWrite; + overlapped.Offset = (LONG)(offset & 0xffffffff); + overlapped.OffsetHigh = (LONG)((offset>>32) & 0x7fffffff); +#endif + aRem += nWrite; + nRem -= nWrite; + } + if( nRem>0 ){ + pFile->lastErrno = lastErrno; + rc = 1; + } + } + + if( rc ){ + if( ( pFile->lastErrno==ERROR_HANDLE_DISK_FULL ) + || ( pFile->lastErrno==ERROR_DISK_FULL )){ + OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_FULL\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return winLogError(SQLITE_FULL, pFile->lastErrno, + "winWrite1", pFile->zPath); + } + OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_WRITE\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return winLogError(SQLITE_IOERR_WRITE, pFile->lastErrno, + "winWrite2", pFile->zPath); + }else{ + winLogIoerr(nRetry, __LINE__); + } + OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; +} + +/* +** Truncate an open file to a specified size +*/ +static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){ + winFile *pFile = (winFile*)id; /* File handle object */ + int rc = SQLITE_OK; /* Return code for this function */ + DWORD lastErrno; +#if SQLITE_MAX_MMAP_SIZE>0 + sqlite3_int64 oldMmapSize; + if( pFile->nFetchOut>0 ){ + /* File truncation is a no-op if there are outstanding memory mapped + ** pages. This is because truncating the file means temporarily unmapping + ** the file, and that might delete memory out from under existing cursors. + ** + ** This can result in incremental vacuum not truncating the file, + ** if there is an active read cursor when the incremental vacuum occurs. + ** No real harm comes of this - the database file is not corrupted, + ** though some folks might complain that the file is bigger than it + ** needs to be. + ** + ** The only feasible work-around is to defer the truncation until after + ** all references to memory-mapped content are closed. That is doable, + ** but involves adding a few branches in the common write code path which + ** could slow down normal operations slightly. Hence, we have decided for + ** now to simply make trancations a no-op if there are pending reads. We + ** can maybe revisit this decision in the future. + */ + return SQLITE_OK; + } +#endif + + assert( pFile ); + SimulateIOError(return SQLITE_IOERR_TRUNCATE); + OSTRACE(("TRUNCATE pid=%lu, pFile=%p, file=%p, size=%lld, lock=%d\n", + osGetCurrentProcessId(), pFile, pFile->h, nByte, pFile->locktype)); + + /* If the user has configured a chunk-size for this file, truncate the + ** file so that it consists of an integer number of chunks (i.e. the + ** actual file size after the operation may be larger than the requested + ** size). + */ + if( pFile->szChunk>0 ){ + nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk; + } + +#if SQLITE_MAX_MMAP_SIZE>0 + if( pFile->pMapRegion ){ + oldMmapSize = pFile->mmapSize; + }else{ + oldMmapSize = 0; + } + winUnmapfile(pFile); +#endif + + /* SetEndOfFile() returns non-zero when successful, or zero when it fails. */ + if( winSeekFile(pFile, nByte) ){ + rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno, + "winTruncate1", pFile->zPath); + }else if( 0==osSetEndOfFile(pFile->h) && + ((lastErrno = osGetLastError())!=ERROR_USER_MAPPED_FILE) ){ + pFile->lastErrno = lastErrno; + rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno, + "winTruncate2", pFile->zPath); + } + +#if SQLITE_MAX_MMAP_SIZE>0 + if( rc==SQLITE_OK && oldMmapSize>0 ){ + if( oldMmapSize>nByte ){ + winMapfile(pFile, -1); + }else{ + winMapfile(pFile, oldMmapSize); + } + } +#endif + + OSTRACE(("TRUNCATE pid=%lu, pFile=%p, file=%p, rc=%s\n", + osGetCurrentProcessId(), pFile, pFile->h, sqlite3ErrName(rc))); + return rc; +} + +#ifdef SQLITE_TEST +/* +** Count the number of fullsyncs and normal syncs. This is used to test +** that syncs and fullsyncs are occuring at the right times. +*/ +SQLITE_API int sqlite3_sync_count = 0; +SQLITE_API int sqlite3_fullsync_count = 0; +#endif + +/* +** Make sure all writes to a particular file are committed to disk. +*/ +static int winSync(sqlite3_file *id, int flags){ +#ifndef SQLITE_NO_SYNC + /* + ** Used only when SQLITE_NO_SYNC is not defined. + */ + BOOL rc; +#endif +#if !defined(NDEBUG) || !defined(SQLITE_NO_SYNC) || \ + defined(SQLITE_HAVE_OS_TRACE) + /* + ** Used when SQLITE_NO_SYNC is not defined and by the assert() and/or + ** OSTRACE() macros. + */ + winFile *pFile = (winFile*)id; +#else + UNUSED_PARAMETER(id); +#endif + + assert( pFile ); + /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */ + assert((flags&0x0F)==SQLITE_SYNC_NORMAL + || (flags&0x0F)==SQLITE_SYNC_FULL + ); + + /* Unix cannot, but some systems may return SQLITE_FULL from here. This + ** line is to test that doing so does not cause any problems. + */ + SimulateDiskfullError( return SQLITE_FULL ); + + OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, flags=%x, lock=%d\n", + osGetCurrentProcessId(), pFile, pFile->h, flags, + pFile->locktype)); + +#ifndef SQLITE_TEST + UNUSED_PARAMETER(flags); +#else + if( (flags&0x0F)==SQLITE_SYNC_FULL ){ + sqlite3_fullsync_count++; + } + sqlite3_sync_count++; +#endif + + /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a + ** no-op + */ +#ifdef SQLITE_NO_SYNC + OSTRACE(("SYNC-NOP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; +#else +#if SQLITE_MAX_MMAP_SIZE>0 + if( pFile->pMapRegion ){ + if( osFlushViewOfFile(pFile->pMapRegion, 0) ){ + OSTRACE(("SYNC-MMAP pid=%lu, pFile=%p, pMapRegion=%p, " + "rc=SQLITE_OK\n", osGetCurrentProcessId(), + pFile, pFile->pMapRegion)); + }else{ + pFile->lastErrno = osGetLastError(); + OSTRACE(("SYNC-MMAP pid=%lu, pFile=%p, pMapRegion=%p, " + "rc=SQLITE_IOERR_MMAP\n", osGetCurrentProcessId(), + pFile, pFile->pMapRegion)); + return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno, + "winSync1", pFile->zPath); + } + } +#endif + rc = osFlushFileBuffers(pFile->h); + SimulateIOError( rc=FALSE ); + if( rc ){ + OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; + }else{ + pFile->lastErrno = osGetLastError(); + OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_FSYNC\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return winLogError(SQLITE_IOERR_FSYNC, pFile->lastErrno, + "winSync2", pFile->zPath); + } +#endif +} + +/* +** Determine the current size of a file in bytes +*/ +static int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize){ + winFile *pFile = (winFile*)id; + int rc = SQLITE_OK; + + assert( id!=0 ); + assert( pSize!=0 ); + SimulateIOError(return SQLITE_IOERR_FSTAT); + OSTRACE(("SIZE file=%p, pSize=%p\n", pFile->h, pSize)); + +#if SQLITE_OS_WINRT + { + FILE_STANDARD_INFO info; + if( osGetFileInformationByHandleEx(pFile->h, FileStandardInfo, + &info, sizeof(info)) ){ + *pSize = info.EndOfFile.QuadPart; + }else{ + pFile->lastErrno = osGetLastError(); + rc = winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno, + "winFileSize", pFile->zPath); + } + } +#else + { + DWORD upperBits; + DWORD lowerBits; + DWORD lastErrno; + + lowerBits = osGetFileSize(pFile->h, &upperBits); + *pSize = (((sqlite3_int64)upperBits)<<32) + lowerBits; + if( (lowerBits == INVALID_FILE_SIZE) + && ((lastErrno = osGetLastError())!=NO_ERROR) ){ + pFile->lastErrno = lastErrno; + rc = winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno, + "winFileSize", pFile->zPath); + } + } +#endif + OSTRACE(("SIZE file=%p, pSize=%p, *pSize=%lld, rc=%s\n", + pFile->h, pSize, *pSize, sqlite3ErrName(rc))); + return rc; +} + +/* +** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems. +*/ +#ifndef LOCKFILE_FAIL_IMMEDIATELY +# define LOCKFILE_FAIL_IMMEDIATELY 1 +#endif + +#ifndef LOCKFILE_EXCLUSIVE_LOCK +# define LOCKFILE_EXCLUSIVE_LOCK 2 +#endif + +/* +** Historically, SQLite has used both the LockFile and LockFileEx functions. +** When the LockFile function was used, it was always expected to fail +** immediately if the lock could not be obtained. Also, it always expected to +** obtain an exclusive lock. These flags are used with the LockFileEx function +** and reflect those expectations; therefore, they should not be changed. +*/ +#ifndef SQLITE_LOCKFILE_FLAGS +# define SQLITE_LOCKFILE_FLAGS (LOCKFILE_FAIL_IMMEDIATELY | \ + LOCKFILE_EXCLUSIVE_LOCK) +#endif + +/* +** Currently, SQLite never calls the LockFileEx function without wanting the +** call to fail immediately if the lock cannot be obtained. +*/ +#ifndef SQLITE_LOCKFILEEX_FLAGS +# define SQLITE_LOCKFILEEX_FLAGS (LOCKFILE_FAIL_IMMEDIATELY) +#endif + +/* +** Acquire a reader lock. +** Different API routines are called depending on whether or not this +** is Win9x or WinNT. +*/ +static int winGetReadLock(winFile *pFile){ + int res; + OSTRACE(("READ-LOCK file=%p, lock=%d\n", pFile->h, pFile->locktype)); + if( osIsNT() ){ +#if SQLITE_OS_WINCE + /* + ** NOTE: Windows CE is handled differently here due its lack of the Win32 + ** API LockFileEx. + */ + res = winceLockFile(&pFile->h, SHARED_FIRST, 0, 1, 0); +#else + res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS, SHARED_FIRST, 0, + SHARED_SIZE, 0); +#endif + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + int lk; + sqlite3_randomness(sizeof(lk), &lk); + pFile->sharedLockByte = (short)((lk & 0x7fffffff)%(SHARED_SIZE - 1)); + res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, + SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0); + } +#endif + if( res == 0 ){ + pFile->lastErrno = osGetLastError(); + /* No need to log a failure to lock */ + } + OSTRACE(("READ-LOCK file=%p, result=%d\n", pFile->h, res)); + return res; +} + +/* +** Undo a readlock +*/ +static int winUnlockReadLock(winFile *pFile){ + int res; + DWORD lastErrno; + OSTRACE(("READ-UNLOCK file=%p, lock=%d\n", pFile->h, pFile->locktype)); + if( osIsNT() ){ + res = winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0); + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + res = winUnlockFile(&pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0); + } +#endif + if( res==0 && ((lastErrno = osGetLastError())!=ERROR_NOT_LOCKED) ){ + pFile->lastErrno = lastErrno; + winLogError(SQLITE_IOERR_UNLOCK, pFile->lastErrno, + "winUnlockReadLock", pFile->zPath); + } + OSTRACE(("READ-UNLOCK file=%p, result=%d\n", pFile->h, res)); + return res; +} + +/* +** Lock the file with the lock specified by parameter locktype - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. The winUnlock() routine +** erases all locks at once and returns us immediately to locking level 0. +** It is not possible to lower the locking level one step at a time. You +** must go straight to locking level 0. +*/ +static int winLock(sqlite3_file *id, int locktype){ + int rc = SQLITE_OK; /* Return code from subroutines */ + int res = 1; /* Result of a Windows lock call */ + int newLocktype; /* Set pFile->locktype to this value before exiting */ + int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */ + winFile *pFile = (winFile*)id; + DWORD lastErrno = NO_ERROR; + + assert( id!=0 ); + OSTRACE(("LOCK file=%p, oldLock=%d(%d), newLock=%d\n", + pFile->h, pFile->locktype, pFile->sharedLockByte, locktype)); + + /* If there is already a lock of this type or more restrictive on the + ** OsFile, do nothing. Don't use the end_lock: exit path, as + ** sqlite3OsEnterMutex() hasn't been called yet. + */ + if( pFile->locktype>=locktype ){ + OSTRACE(("LOCK-HELD file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + + /* Do not allow any kind of write-lock on a read-only database + */ + if( (pFile->ctrlFlags & WINFILE_RDONLY)!=0 && locktype>=RESERVED_LOCK ){ + return SQLITE_IOERR_LOCK; + } + + /* Make sure the locking sequence is correct + */ + assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK ); + assert( locktype!=PENDING_LOCK ); + assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK ); + + /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or + ** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of + ** the PENDING_LOCK byte is temporary. + */ + newLocktype = pFile->locktype; + if( pFile->locktype==NO_LOCK + || (locktype==EXCLUSIVE_LOCK && pFile->locktype<=RESERVED_LOCK) + ){ + int cnt = 3; + while( cnt-->0 && (res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, + PENDING_BYTE, 0, 1, 0))==0 ){ + /* Try 3 times to get the pending lock. This is needed to work + ** around problems caused by indexing and/or anti-virus software on + ** Windows systems. + ** If you are using this code as a model for alternative VFSes, do not + ** copy this retry logic. It is a hack intended for Windows only. + */ + lastErrno = osGetLastError(); + OSTRACE(("LOCK-PENDING-FAIL file=%p, count=%d, result=%d\n", + pFile->h, cnt, res)); + if( lastErrno==ERROR_INVALID_HANDLE ){ + pFile->lastErrno = lastErrno; + rc = SQLITE_IOERR_LOCK; + OSTRACE(("LOCK-FAIL file=%p, count=%d, rc=%s\n", + pFile->h, cnt, sqlite3ErrName(rc))); + return rc; + } + if( cnt ) sqlite3_win32_sleep(1); + } + gotPendingLock = res; + if( !res ){ + lastErrno = osGetLastError(); + } + } + + /* Acquire a shared lock + */ + if( locktype==SHARED_LOCK && res ){ + assert( pFile->locktype==NO_LOCK ); + res = winGetReadLock(pFile); + if( res ){ + newLocktype = SHARED_LOCK; + }else{ + lastErrno = osGetLastError(); + } + } + + /* Acquire a RESERVED lock + */ + if( locktype==RESERVED_LOCK && res ){ + assert( pFile->locktype==SHARED_LOCK ); + res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, RESERVED_BYTE, 0, 1, 0); + if( res ){ + newLocktype = RESERVED_LOCK; + }else{ + lastErrno = osGetLastError(); + } + } + + /* Acquire a PENDING lock + */ + if( locktype==EXCLUSIVE_LOCK && res ){ + newLocktype = PENDING_LOCK; + gotPendingLock = 0; + } + + /* Acquire an EXCLUSIVE lock + */ + if( locktype==EXCLUSIVE_LOCK && res ){ + assert( pFile->locktype>=SHARED_LOCK ); + res = winUnlockReadLock(pFile); + res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, SHARED_FIRST, 0, + SHARED_SIZE, 0); + if( res ){ + newLocktype = EXCLUSIVE_LOCK; + }else{ + lastErrno = osGetLastError(); + winGetReadLock(pFile); + } + } + + /* If we are holding a PENDING lock that ought to be released, then + ** release it now. + */ + if( gotPendingLock && locktype==SHARED_LOCK ){ + winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0); + } + + /* Update the state of the lock has held in the file descriptor then + ** return the appropriate result code. + */ + if( res ){ + rc = SQLITE_OK; + }else{ + pFile->lastErrno = lastErrno; + rc = SQLITE_BUSY; + OSTRACE(("LOCK-FAIL file=%p, wanted=%d, got=%d\n", + pFile->h, locktype, newLocktype)); + } + pFile->locktype = (u8)newLocktype; + OSTRACE(("LOCK file=%p, lock=%d, rc=%s\n", + pFile->h, pFile->locktype, sqlite3ErrName(rc))); + return rc; +} + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, return +** non-zero, otherwise zero. +*/ +static int winCheckReservedLock(sqlite3_file *id, int *pResOut){ + int res; + winFile *pFile = (winFile*)id; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p\n", pFile->h, pResOut)); + + assert( id!=0 ); + if( pFile->locktype>=RESERVED_LOCK ){ + res = 1; + OSTRACE(("TEST-WR-LOCK file=%p, result=%d (local)\n", pFile->h, res)); + }else{ + res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS,RESERVED_BYTE,0,1,0); + if( res ){ + winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0); + } + res = !res; + OSTRACE(("TEST-WR-LOCK file=%p, result=%d (remote)\n", pFile->h, res)); + } + *pResOut = res; + OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n", + pFile->h, pResOut, *pResOut)); + return SQLITE_OK; +} + +/* +** Lower the locking level on file descriptor id to locktype. locktype +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +** +** It is not possible for this routine to fail if the second argument +** is NO_LOCK. If the second argument is SHARED_LOCK then this routine +** might return SQLITE_IOERR; +*/ +static int winUnlock(sqlite3_file *id, int locktype){ + int type; + winFile *pFile = (winFile*)id; + int rc = SQLITE_OK; + assert( pFile!=0 ); + assert( locktype<=SHARED_LOCK ); + OSTRACE(("UNLOCK file=%p, oldLock=%d(%d), newLock=%d\n", + pFile->h, pFile->locktype, pFile->sharedLockByte, locktype)); + type = pFile->locktype; + if( type>=EXCLUSIVE_LOCK ){ + winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0); + if( locktype==SHARED_LOCK && !winGetReadLock(pFile) ){ + /* This should never happen. We should always be able to + ** reacquire the read lock */ + rc = winLogError(SQLITE_IOERR_UNLOCK, osGetLastError(), + "winUnlock", pFile->zPath); + } + } + if( type>=RESERVED_LOCK ){ + winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0); + } + if( locktype==NO_LOCK && type>=SHARED_LOCK ){ + winUnlockReadLock(pFile); + } + if( type>=PENDING_LOCK ){ + winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0); + } + pFile->locktype = (u8)locktype; + OSTRACE(("UNLOCK file=%p, lock=%d, rc=%s\n", + pFile->h, pFile->locktype, sqlite3ErrName(rc))); + return rc; +} + +/****************************************************************************** +****************************** No-op Locking ********************************** +** +** Of the various locking implementations available, this is by far the +** simplest: locking is ignored. No attempt is made to lock the database +** file for reading or writing. +** +** This locking mode is appropriate for use on read-only databases +** (ex: databases that are burned into CD-ROM, for example.) It can +** also be used if the application employs some external mechanism to +** prevent simultaneous access of the same database by two or more +** database connections. But there is a serious risk of database +** corruption if this locking mode is used in situations where multiple +** database connections are accessing the same database file at the same +** time and one or more of those connections are writing. +*/ + +static int winNolockLock(sqlite3_file *id, int locktype){ + UNUSED_PARAMETER(id); + UNUSED_PARAMETER(locktype); + return SQLITE_OK; +} + +static int winNolockCheckReservedLock(sqlite3_file *id, int *pResOut){ + UNUSED_PARAMETER(id); + UNUSED_PARAMETER(pResOut); + return SQLITE_OK; +} + +static int winNolockUnlock(sqlite3_file *id, int locktype){ + UNUSED_PARAMETER(id); + UNUSED_PARAMETER(locktype); + return SQLITE_OK; +} + +/******************* End of the no-op lock implementation ********************* +******************************************************************************/ + +/* +** If *pArg is initially negative then this is a query. Set *pArg to +** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set. +** +** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags. +*/ +static void winModeBit(winFile *pFile, unsigned char mask, int *pArg){ + if( *pArg<0 ){ + *pArg = (pFile->ctrlFlags & mask)!=0; + }else if( (*pArg)==0 ){ + pFile->ctrlFlags &= ~mask; + }else{ + pFile->ctrlFlags |= mask; + } +} + +/* Forward references to VFS helper methods used for temporary files */ +static int winGetTempname(sqlite3_vfs *, char **); +static int winIsDir(const void *); +static BOOL winIsLongPathPrefix(const char *); +static BOOL winIsDriveLetterAndColon(const char *); + +/* +** Control and query of the open file handle. +*/ +static int winFileControl(sqlite3_file *id, int op, void *pArg){ + winFile *pFile = (winFile*)id; + OSTRACE(("FCNTL file=%p, op=%d, pArg=%p\n", pFile->h, op, pArg)); + switch( op ){ + case SQLITE_FCNTL_LOCKSTATE: { + *(int*)pArg = pFile->locktype; + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_LAST_ERRNO: { + *(int*)pArg = (int)pFile->lastErrno; + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_CHUNK_SIZE: { + pFile->szChunk = *(int *)pArg; + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_SIZE_HINT: { + if( pFile->szChunk>0 ){ + sqlite3_int64 oldSz; + int rc = winFileSize(id, &oldSz); + if( rc==SQLITE_OK ){ + sqlite3_int64 newSz = *(sqlite3_int64*)pArg; + if( newSz>oldSz ){ + SimulateIOErrorBenign(1); + rc = winTruncate(id, newSz); + SimulateIOErrorBenign(0); + } + } + OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc))); + return rc; + } + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_PERSIST_WAL: { + winModeBit(pFile, WINFILE_PERSIST_WAL, (int*)pArg); + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_POWERSAFE_OVERWRITE: { + winModeBit(pFile, WINFILE_PSOW, (int*)pArg); + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_VFSNAME: { + *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName); + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_WIN32_AV_RETRY: { + int *a = (int*)pArg; + if( a[0]>0 ){ + winIoerrRetry = a[0]; + }else{ + a[0] = winIoerrRetry; + } + if( a[1]>0 ){ + winIoerrRetryDelay = a[1]; + }else{ + a[1] = winIoerrRetryDelay; + } + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_WIN32_GET_HANDLE: { + LPHANDLE phFile = (LPHANDLE)pArg; + *phFile = pFile->h; + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } +#ifdef SQLITE_TEST + case SQLITE_FCNTL_WIN32_SET_HANDLE: { + LPHANDLE phFile = (LPHANDLE)pArg; + HANDLE hOldFile = pFile->h; + pFile->h = *phFile; + *phFile = hOldFile; + OSTRACE(("FCNTL oldFile=%p, newFile=%p, rc=SQLITE_OK\n", + hOldFile, pFile->h)); + return SQLITE_OK; + } +#endif + case SQLITE_FCNTL_TEMPFILENAME: { + char *zTFile = 0; + int rc = winGetTempname(pFile->pVfs, &zTFile); + if( rc==SQLITE_OK ){ + *(char**)pArg = zTFile; + } + OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc))); + return rc; + } +#if SQLITE_MAX_MMAP_SIZE>0 + case SQLITE_FCNTL_MMAP_SIZE: { + i64 newLimit = *(i64*)pArg; + int rc = SQLITE_OK; + if( newLimit>sqlite3GlobalConfig.mxMmap ){ + newLimit = sqlite3GlobalConfig.mxMmap; + } + + /* The value of newLimit may be eventually cast to (SIZE_T) and passed + ** to MapViewOfFile(). Restrict its value to 2GB if (SIZE_T) is not at + ** least a 64-bit type. */ + if( newLimit>0 && sizeof(SIZE_T)<8 ){ + newLimit = (newLimit & 0x7FFFFFFF); + } + + *(i64*)pArg = pFile->mmapSizeMax; + if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){ + pFile->mmapSizeMax = newLimit; + if( pFile->mmapSize>0 ){ + winUnmapfile(pFile); + rc = winMapfile(pFile, -1); + } + } + OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc))); + return rc; + } +#endif + } + OSTRACE(("FCNTL file=%p, rc=SQLITE_NOTFOUND\n", pFile->h)); + return SQLITE_NOTFOUND; +} + +/* +** Return the sector size in bytes of the underlying block device for +** the specified file. This is almost always 512 bytes, but may be +** larger for some devices. +** +** SQLite code assumes this function cannot fail. It also assumes that +** if two files are created in the same file-system directory (i.e. +** a database and its journal file) that the sector size will be the +** same for both. +*/ +static int winSectorSize(sqlite3_file *id){ + (void)id; + return SQLITE_DEFAULT_SECTOR_SIZE; +} + +/* +** Return a vector of device characteristics. +*/ +static int winDeviceCharacteristics(sqlite3_file *id){ + winFile *p = (winFile*)id; + return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN | + ((p->ctrlFlags & WINFILE_PSOW)?SQLITE_IOCAP_POWERSAFE_OVERWRITE:0); +} + +/* +** Windows will only let you create file view mappings +** on allocation size granularity boundaries. +** During sqlite3_os_init() we do a GetSystemInfo() +** to get the granularity size. +*/ +static SYSTEM_INFO winSysInfo; + +#ifndef SQLITE_OMIT_WAL + +/* +** Helper functions to obtain and relinquish the global mutex. The +** global mutex is used to protect the winLockInfo objects used by +** this file, all of which may be shared by multiple threads. +** +** Function winShmMutexHeld() is used to assert() that the global mutex +** is held when required. This function is only used as part of assert() +** statements. e.g. +** +** winShmEnterMutex() +** assert( winShmMutexHeld() ); +** winShmLeaveMutex() +*/ +static sqlite3_mutex *winBigLock = 0; +static void winShmEnterMutex(void){ + sqlite3_mutex_enter(winBigLock); +} +static void winShmLeaveMutex(void){ + sqlite3_mutex_leave(winBigLock); +} +#ifndef NDEBUG +static int winShmMutexHeld(void) { + return sqlite3_mutex_held(winBigLock); +} +#endif + +/* +** Object used to represent a single file opened and mmapped to provide +** shared memory. When multiple threads all reference the same +** log-summary, each thread has its own winFile object, but they all +** point to a single instance of this object. In other words, each +** log-summary is opened only once per process. +** +** winShmMutexHeld() must be true when creating or destroying +** this object or while reading or writing the following fields: +** +** nRef +** pNext +** +** The following fields are read-only after the object is created: +** +** fid +** zFilename +** +** Either winShmNode.mutex must be held or winShmNode.nRef==0 and +** winShmMutexHeld() is true when reading or writing any other field +** in this structure. +** +*/ +struct winShmNode { + sqlite3_mutex *mutex; /* Mutex to access this object */ + char *zFilename; /* Name of the file */ + winFile hFile; /* File handle from winOpen */ + + int szRegion; /* Size of shared-memory regions */ + int nRegion; /* Size of array apRegion */ + u8 isReadonly; /* True if read-only */ + u8 isUnlocked; /* True if no DMS lock held */ + + struct ShmRegion { + HANDLE hMap; /* File handle from CreateFileMapping */ + void *pMap; + } *aRegion; + DWORD lastErrno; /* The Windows errno from the last I/O error */ + + int nRef; /* Number of winShm objects pointing to this */ + winShm *pFirst; /* All winShm objects pointing to this */ + winShmNode *pNext; /* Next in list of all winShmNode objects */ +#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) + u8 nextShmId; /* Next available winShm.id value */ +#endif +}; + +/* +** A global array of all winShmNode objects. +** +** The winShmMutexHeld() must be true while reading or writing this list. +*/ +static winShmNode *winShmNodeList = 0; + +/* +** Structure used internally by this VFS to record the state of an +** open shared memory connection. +** +** The following fields are initialized when this object is created and +** are read-only thereafter: +** +** winShm.pShmNode +** winShm.id +** +** All other fields are read/write. The winShm.pShmNode->mutex must be held +** while accessing any read/write fields. +*/ +struct winShm { + winShmNode *pShmNode; /* The underlying winShmNode object */ + winShm *pNext; /* Next winShm with the same winShmNode */ + u8 hasMutex; /* True if holding the winShmNode mutex */ + u16 sharedMask; /* Mask of shared locks held */ + u16 exclMask; /* Mask of exclusive locks held */ +#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) + u8 id; /* Id of this connection with its winShmNode */ +#endif +}; + +/* +** Constants used for locking +*/ +#define WIN_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */ +#define WIN_SHM_DMS (WIN_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */ + +/* +** Apply advisory locks for all n bytes beginning at ofst. +*/ +#define WINSHM_UNLCK 1 +#define WINSHM_RDLCK 2 +#define WINSHM_WRLCK 3 +static int winShmSystemLock( + winShmNode *pFile, /* Apply locks to this open shared-memory segment */ + int lockType, /* WINSHM_UNLCK, WINSHM_RDLCK, or WINSHM_WRLCK */ + int ofst, /* Offset to first byte to be locked/unlocked */ + int nByte /* Number of bytes to lock or unlock */ +){ + int rc = 0; /* Result code form Lock/UnlockFileEx() */ + + /* Access to the winShmNode object is serialized by the caller */ + assert( pFile->nRef==0 || sqlite3_mutex_held(pFile->mutex) ); + + OSTRACE(("SHM-LOCK file=%p, lock=%d, offset=%d, size=%d\n", + pFile->hFile.h, lockType, ofst, nByte)); + + /* Release/Acquire the system-level lock */ + if( lockType==WINSHM_UNLCK ){ + rc = winUnlockFile(&pFile->hFile.h, ofst, 0, nByte, 0); + }else{ + /* Initialize the locking parameters */ + DWORD dwFlags = LOCKFILE_FAIL_IMMEDIATELY; + if( lockType == WINSHM_WRLCK ) dwFlags |= LOCKFILE_EXCLUSIVE_LOCK; + rc = winLockFile(&pFile->hFile.h, dwFlags, ofst, 0, nByte, 0); + } + + if( rc!= 0 ){ + rc = SQLITE_OK; + }else{ + pFile->lastErrno = osGetLastError(); + rc = SQLITE_BUSY; + } + + OSTRACE(("SHM-LOCK file=%p, func=%s, errno=%lu, rc=%s\n", + pFile->hFile.h, (lockType == WINSHM_UNLCK) ? "winUnlockFile" : + "winLockFile", pFile->lastErrno, sqlite3ErrName(rc))); + + return rc; +} + +/* Forward references to VFS methods */ +static int winOpen(sqlite3_vfs*,const char*,sqlite3_file*,int,int*); +static int winDelete(sqlite3_vfs *,const char*,int); + +/* +** Purge the winShmNodeList list of all entries with winShmNode.nRef==0. +** +** This is not a VFS shared-memory method; it is a utility function called +** by VFS shared-memory methods. +*/ +static void winShmPurge(sqlite3_vfs *pVfs, int deleteFlag){ + winShmNode **pp; + winShmNode *p; + assert( winShmMutexHeld() ); + OSTRACE(("SHM-PURGE pid=%lu, deleteFlag=%d\n", + osGetCurrentProcessId(), deleteFlag)); + pp = &winShmNodeList; + while( (p = *pp)!=0 ){ + if( p->nRef==0 ){ + int i; + if( p->mutex ){ sqlite3_mutex_free(p->mutex); } + for(i=0; inRegion; i++){ + BOOL bRc = osUnmapViewOfFile(p->aRegion[i].pMap); + OSTRACE(("SHM-PURGE-UNMAP pid=%lu, region=%d, rc=%s\n", + osGetCurrentProcessId(), i, bRc ? "ok" : "failed")); + UNUSED_VARIABLE_VALUE(bRc); + bRc = osCloseHandle(p->aRegion[i].hMap); + OSTRACE(("SHM-PURGE-CLOSE pid=%lu, region=%d, rc=%s\n", + osGetCurrentProcessId(), i, bRc ? "ok" : "failed")); + UNUSED_VARIABLE_VALUE(bRc); + } + if( p->hFile.h!=NULL && p->hFile.h!=INVALID_HANDLE_VALUE ){ + SimulateIOErrorBenign(1); + winClose((sqlite3_file *)&p->hFile); + SimulateIOErrorBenign(0); + } + if( deleteFlag ){ + SimulateIOErrorBenign(1); + sqlite3BeginBenignMalloc(); + winDelete(pVfs, p->zFilename, 0); + sqlite3EndBenignMalloc(); + SimulateIOErrorBenign(0); + } + *pp = p->pNext; + sqlite3_free(p->aRegion); + sqlite3_free(p); + }else{ + pp = &p->pNext; + } + } +} + +/* +** The DMS lock has not yet been taken on shm file pShmNode. Attempt to +** take it now. Return SQLITE_OK if successful, or an SQLite error +** code otherwise. +** +** If the DMS cannot be locked because this is a readonly_shm=1 +** connection and no other process already holds a lock, return +** SQLITE_READONLY_CANTINIT and set pShmNode->isUnlocked=1. +*/ +static int winLockSharedMemory(winShmNode *pShmNode){ + int rc = winShmSystemLock(pShmNode, WINSHM_WRLCK, WIN_SHM_DMS, 1); + + if( rc==SQLITE_OK ){ + if( pShmNode->isReadonly ){ + pShmNode->isUnlocked = 1; + winShmSystemLock(pShmNode, WINSHM_UNLCK, WIN_SHM_DMS, 1); + return SQLITE_READONLY_CANTINIT; + }else if( winTruncate((sqlite3_file*)&pShmNode->hFile, 0) ){ + winShmSystemLock(pShmNode, WINSHM_UNLCK, WIN_SHM_DMS, 1); + return winLogError(SQLITE_IOERR_SHMOPEN, osGetLastError(), + "winLockSharedMemory", pShmNode->zFilename); + } + } + + if( rc==SQLITE_OK ){ + winShmSystemLock(pShmNode, WINSHM_UNLCK, WIN_SHM_DMS, 1); + } + + return winShmSystemLock(pShmNode, WINSHM_RDLCK, WIN_SHM_DMS, 1); +} + +/* +** Open the shared-memory area associated with database file pDbFd. +** +** When opening a new shared-memory file, if no other instances of that +** file are currently open, in this process or in other processes, then +** the file must be truncated to zero length or have its header cleared. +*/ +static int winOpenSharedMemory(winFile *pDbFd){ + struct winShm *p; /* The connection to be opened */ + winShmNode *pShmNode = 0; /* The underlying mmapped file */ + int rc = SQLITE_OK; /* Result code */ + winShmNode *pNew; /* Newly allocated winShmNode */ + int nName; /* Size of zName in bytes */ + + assert( pDbFd->pShm==0 ); /* Not previously opened */ + + /* Allocate space for the new sqlite3_shm object. Also speculatively + ** allocate space for a new winShmNode and filename. + */ + p = sqlite3MallocZero( sizeof(*p) ); + if( p==0 ) return SQLITE_IOERR_NOMEM_BKPT; + nName = sqlite3Strlen30(pDbFd->zPath); + pNew = sqlite3MallocZero( sizeof(*pShmNode) + nName + 17 ); + if( pNew==0 ){ + sqlite3_free(p); + return SQLITE_IOERR_NOMEM_BKPT; + } + pNew->zFilename = (char*)&pNew[1]; + sqlite3_snprintf(nName+15, pNew->zFilename, "%s-shm", pDbFd->zPath); + sqlite3FileSuffix3(pDbFd->zPath, pNew->zFilename); + + /* Look to see if there is an existing winShmNode that can be used. + ** If no matching winShmNode currently exists, create a new one. + */ + winShmEnterMutex(); + for(pShmNode = winShmNodeList; pShmNode; pShmNode=pShmNode->pNext){ + /* TBD need to come up with better match here. Perhaps + ** use FILE_ID_BOTH_DIR_INFO Structure. + */ + if( sqlite3StrICmp(pShmNode->zFilename, pNew->zFilename)==0 ) break; + } + if( pShmNode ){ + sqlite3_free(pNew); + }else{ + int inFlags = SQLITE_OPEN_WAL; + int outFlags = 0; + + pShmNode = pNew; + pNew = 0; + ((winFile*)(&pShmNode->hFile))->h = INVALID_HANDLE_VALUE; + pShmNode->pNext = winShmNodeList; + winShmNodeList = pShmNode; + + if( sqlite3GlobalConfig.bCoreMutex ){ + pShmNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); + if( pShmNode->mutex==0 ){ + rc = SQLITE_IOERR_NOMEM_BKPT; + goto shm_open_err; + } + } + + if( 0==sqlite3_uri_boolean(pDbFd->zPath, "readonly_shm", 0) ){ + inFlags |= SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE; + }else{ + inFlags |= SQLITE_OPEN_READONLY; + } + rc = winOpen(pDbFd->pVfs, pShmNode->zFilename, + (sqlite3_file*)&pShmNode->hFile, + inFlags, &outFlags); + if( rc!=SQLITE_OK ){ + rc = winLogError(rc, osGetLastError(), "winOpenShm", + pShmNode->zFilename); + goto shm_open_err; + } + if( outFlags==SQLITE_OPEN_READONLY ) pShmNode->isReadonly = 1; + + rc = winLockSharedMemory(pShmNode); + if( rc!=SQLITE_OK && rc!=SQLITE_READONLY_CANTINIT ) goto shm_open_err; + } + + /* Make the new connection a child of the winShmNode */ + p->pShmNode = pShmNode; +#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) + p->id = pShmNode->nextShmId++; +#endif + pShmNode->nRef++; + pDbFd->pShm = p; + winShmLeaveMutex(); + + /* The reference count on pShmNode has already been incremented under + ** the cover of the winShmEnterMutex() mutex and the pointer from the + ** new (struct winShm) object to the pShmNode has been set. All that is + ** left to do is to link the new object into the linked list starting + ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex + ** mutex. + */ + sqlite3_mutex_enter(pShmNode->mutex); + p->pNext = pShmNode->pFirst; + pShmNode->pFirst = p; + sqlite3_mutex_leave(pShmNode->mutex); + return rc; + + /* Jump here on any error */ +shm_open_err: + winShmSystemLock(pShmNode, WINSHM_UNLCK, WIN_SHM_DMS, 1); + winShmPurge(pDbFd->pVfs, 0); /* This call frees pShmNode if required */ + sqlite3_free(p); + sqlite3_free(pNew); + winShmLeaveMutex(); + return rc; +} + +/* +** Close a connection to shared-memory. Delete the underlying +** storage if deleteFlag is true. +*/ +static int winShmUnmap( + sqlite3_file *fd, /* Database holding shared memory */ + int deleteFlag /* Delete after closing if true */ +){ + winFile *pDbFd; /* Database holding shared-memory */ + winShm *p; /* The connection to be closed */ + winShmNode *pShmNode; /* The underlying shared-memory file */ + winShm **pp; /* For looping over sibling connections */ + + pDbFd = (winFile*)fd; + p = pDbFd->pShm; + if( p==0 ) return SQLITE_OK; + pShmNode = p->pShmNode; + + /* Remove connection p from the set of connections associated + ** with pShmNode */ + sqlite3_mutex_enter(pShmNode->mutex); + for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){} + *pp = p->pNext; + + /* Free the connection p */ + sqlite3_free(p); + pDbFd->pShm = 0; + sqlite3_mutex_leave(pShmNode->mutex); + + /* If pShmNode->nRef has reached 0, then close the underlying + ** shared-memory file, too */ + winShmEnterMutex(); + assert( pShmNode->nRef>0 ); + pShmNode->nRef--; + if( pShmNode->nRef==0 ){ + winShmPurge(pDbFd->pVfs, deleteFlag); + } + winShmLeaveMutex(); + + return SQLITE_OK; +} + +/* +** Change the lock state for a shared-memory segment. +*/ +static int winShmLock( + sqlite3_file *fd, /* Database file holding the shared memory */ + int ofst, /* First lock to acquire or release */ + int n, /* Number of locks to acquire or release */ + int flags /* What to do with the lock */ +){ + winFile *pDbFd = (winFile*)fd; /* Connection holding shared memory */ + winShm *p = pDbFd->pShm; /* The shared memory being locked */ + winShm *pX; /* For looping over all siblings */ + winShmNode *pShmNode = p->pShmNode; + int rc = SQLITE_OK; /* Result code */ + u16 mask; /* Mask of locks to take or release */ + + assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK ); + assert( n>=1 ); + assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED) + || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE) + || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED) + || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) ); + assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 ); + + mask = (u16)((1U<<(ofst+n)) - (1U<1 || mask==(1<mutex); + if( flags & SQLITE_SHM_UNLOCK ){ + u16 allMask = 0; /* Mask of locks held by siblings */ + + /* See if any siblings hold this same lock */ + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){ + if( pX==p ) continue; + assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 ); + allMask |= pX->sharedMask; + } + + /* Unlock the system-level locks */ + if( (mask & allMask)==0 ){ + rc = winShmSystemLock(pShmNode, WINSHM_UNLCK, ofst+WIN_SHM_BASE, n); + }else{ + rc = SQLITE_OK; + } + + /* Undo the local locks */ + if( rc==SQLITE_OK ){ + p->exclMask &= ~mask; + p->sharedMask &= ~mask; + } + }else if( flags & SQLITE_SHM_SHARED ){ + u16 allShared = 0; /* Union of locks held by connections other than "p" */ + + /* Find out which shared locks are already held by sibling connections. + ** If any sibling already holds an exclusive lock, go ahead and return + ** SQLITE_BUSY. + */ + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){ + if( (pX->exclMask & mask)!=0 ){ + rc = SQLITE_BUSY; + break; + } + allShared |= pX->sharedMask; + } + + /* Get shared locks at the system level, if necessary */ + if( rc==SQLITE_OK ){ + if( (allShared & mask)==0 ){ + rc = winShmSystemLock(pShmNode, WINSHM_RDLCK, ofst+WIN_SHM_BASE, n); + }else{ + rc = SQLITE_OK; + } + } + + /* Get the local shared locks */ + if( rc==SQLITE_OK ){ + p->sharedMask |= mask; + } + }else{ + /* Make sure no sibling connections hold locks that will block this + ** lock. If any do, return SQLITE_BUSY right away. + */ + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){ + if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){ + rc = SQLITE_BUSY; + break; + } + } + + /* Get the exclusive locks at the system level. Then if successful + ** also mark the local connection as being locked. + */ + if( rc==SQLITE_OK ){ + rc = winShmSystemLock(pShmNode, WINSHM_WRLCK, ofst+WIN_SHM_BASE, n); + if( rc==SQLITE_OK ){ + assert( (p->sharedMask & mask)==0 ); + p->exclMask |= mask; + } + } + } + sqlite3_mutex_leave(pShmNode->mutex); + OSTRACE(("SHM-LOCK pid=%lu, id=%d, sharedMask=%03x, exclMask=%03x, rc=%s\n", + osGetCurrentProcessId(), p->id, p->sharedMask, p->exclMask, + sqlite3ErrName(rc))); + return rc; +} + +/* +** Implement a memory barrier or memory fence on shared memory. +** +** All loads and stores begun before the barrier must complete before +** any load or store begun after the barrier. +*/ +static void winShmBarrier( + sqlite3_file *fd /* Database holding the shared memory */ +){ + UNUSED_PARAMETER(fd); + sqlite3MemoryBarrier(); /* compiler-defined memory barrier */ + winShmEnterMutex(); /* Also mutex, for redundancy */ + winShmLeaveMutex(); +} + +/* +** This function is called to obtain a pointer to region iRegion of the +** shared-memory associated with the database file fd. Shared-memory regions +** are numbered starting from zero. Each shared-memory region is szRegion +** bytes in size. +** +** If an error occurs, an error code is returned and *pp is set to NULL. +** +** Otherwise, if the isWrite parameter is 0 and the requested shared-memory +** region has not been allocated (by any client, including one running in a +** separate process), then *pp is set to NULL and SQLITE_OK returned. If +** isWrite is non-zero and the requested shared-memory region has not yet +** been allocated, it is allocated by this function. +** +** If the shared-memory region has already been allocated or is allocated by +** this call as described above, then it is mapped into this processes +** address space (if it is not already), *pp is set to point to the mapped +** memory and SQLITE_OK returned. +*/ +static int winShmMap( + sqlite3_file *fd, /* Handle open on database file */ + int iRegion, /* Region to retrieve */ + int szRegion, /* Size of regions */ + int isWrite, /* True to extend file if necessary */ + void volatile **pp /* OUT: Mapped memory */ +){ + winFile *pDbFd = (winFile*)fd; + winShm *pShm = pDbFd->pShm; + winShmNode *pShmNode; + DWORD protect = PAGE_READWRITE; + DWORD flags = FILE_MAP_WRITE | FILE_MAP_READ; + int rc = SQLITE_OK; + + if( !pShm ){ + rc = winOpenSharedMemory(pDbFd); + if( rc!=SQLITE_OK ) return rc; + pShm = pDbFd->pShm; + assert( pShm!=0 ); + } + pShmNode = pShm->pShmNode; + + sqlite3_mutex_enter(pShmNode->mutex); + if( pShmNode->isUnlocked ){ + rc = winLockSharedMemory(pShmNode); + if( rc!=SQLITE_OK ) goto shmpage_out; + pShmNode->isUnlocked = 0; + } + assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 ); + + if( pShmNode->nRegion<=iRegion ){ + struct ShmRegion *apNew; /* New aRegion[] array */ + int nByte = (iRegion+1)*szRegion; /* Minimum required file size */ + sqlite3_int64 sz; /* Current size of wal-index file */ + + pShmNode->szRegion = szRegion; + + /* The requested region is not mapped into this processes address space. + ** Check to see if it has been allocated (i.e. if the wal-index file is + ** large enough to contain the requested region). + */ + rc = winFileSize((sqlite3_file *)&pShmNode->hFile, &sz); + if( rc!=SQLITE_OK ){ + rc = winLogError(SQLITE_IOERR_SHMSIZE, osGetLastError(), + "winShmMap1", pDbFd->zPath); + goto shmpage_out; + } + + if( szhFile, nByte); + if( rc!=SQLITE_OK ){ + rc = winLogError(SQLITE_IOERR_SHMSIZE, osGetLastError(), + "winShmMap2", pDbFd->zPath); + goto shmpage_out; + } + } + + /* Map the requested memory region into this processes address space. */ + apNew = (struct ShmRegion *)sqlite3_realloc64( + pShmNode->aRegion, (iRegion+1)*sizeof(apNew[0]) + ); + if( !apNew ){ + rc = SQLITE_IOERR_NOMEM_BKPT; + goto shmpage_out; + } + pShmNode->aRegion = apNew; + + if( pShmNode->isReadonly ){ + protect = PAGE_READONLY; + flags = FILE_MAP_READ; + } + + while( pShmNode->nRegion<=iRegion ){ + HANDLE hMap = NULL; /* file-mapping handle */ + void *pMap = 0; /* Mapped memory region */ + +#if SQLITE_OS_WINRT + hMap = osCreateFileMappingFromApp(pShmNode->hFile.h, + NULL, protect, nByte, NULL + ); +#elif defined(SQLITE_WIN32_HAS_WIDE) + hMap = osCreateFileMappingW(pShmNode->hFile.h, + NULL, protect, 0, nByte, NULL + ); +#elif defined(SQLITE_WIN32_HAS_ANSI) && SQLITE_WIN32_CREATEFILEMAPPINGA + hMap = osCreateFileMappingA(pShmNode->hFile.h, + NULL, protect, 0, nByte, NULL + ); +#endif + OSTRACE(("SHM-MAP-CREATE pid=%lu, region=%d, size=%d, rc=%s\n", + osGetCurrentProcessId(), pShmNode->nRegion, nByte, + hMap ? "ok" : "failed")); + if( hMap ){ + int iOffset = pShmNode->nRegion*szRegion; + int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity; +#if SQLITE_OS_WINRT + pMap = osMapViewOfFileFromApp(hMap, flags, + iOffset - iOffsetShift, szRegion + iOffsetShift + ); +#else + pMap = osMapViewOfFile(hMap, flags, + 0, iOffset - iOffsetShift, szRegion + iOffsetShift + ); +#endif + OSTRACE(("SHM-MAP-MAP pid=%lu, region=%d, offset=%d, size=%d, rc=%s\n", + osGetCurrentProcessId(), pShmNode->nRegion, iOffset, + szRegion, pMap ? "ok" : "failed")); + } + if( !pMap ){ + pShmNode->lastErrno = osGetLastError(); + rc = winLogError(SQLITE_IOERR_SHMMAP, pShmNode->lastErrno, + "winShmMap3", pDbFd->zPath); + if( hMap ) osCloseHandle(hMap); + goto shmpage_out; + } + + pShmNode->aRegion[pShmNode->nRegion].pMap = pMap; + pShmNode->aRegion[pShmNode->nRegion].hMap = hMap; + pShmNode->nRegion++; + } + } + +shmpage_out: + if( pShmNode->nRegion>iRegion ){ + int iOffset = iRegion*szRegion; + int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity; + char *p = (char *)pShmNode->aRegion[iRegion].pMap; + *pp = (void *)&p[iOffsetShift]; + }else{ + *pp = 0; + } + if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY; + sqlite3_mutex_leave(pShmNode->mutex); + return rc; +} + +#else +# define winShmMap 0 +# define winShmLock 0 +# define winShmBarrier 0 +# define winShmUnmap 0 +#endif /* #ifndef SQLITE_OMIT_WAL */ + +/* +** Cleans up the mapped region of the specified file, if any. +*/ +#if SQLITE_MAX_MMAP_SIZE>0 +static int winUnmapfile(winFile *pFile){ + assert( pFile!=0 ); + OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, hMap=%p, pMapRegion=%p, " + "mmapSize=%lld, mmapSizeMax=%lld\n", + osGetCurrentProcessId(), pFile, pFile->hMap, pFile->pMapRegion, + pFile->mmapSize, pFile->mmapSizeMax)); + if( pFile->pMapRegion ){ + if( !osUnmapViewOfFile(pFile->pMapRegion) ){ + pFile->lastErrno = osGetLastError(); + OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, pMapRegion=%p, " + "rc=SQLITE_IOERR_MMAP\n", osGetCurrentProcessId(), pFile, + pFile->pMapRegion)); + return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno, + "winUnmapfile1", pFile->zPath); + } + pFile->pMapRegion = 0; + pFile->mmapSize = 0; + } + if( pFile->hMap!=NULL ){ + if( !osCloseHandle(pFile->hMap) ){ + pFile->lastErrno = osGetLastError(); + OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, hMap=%p, rc=SQLITE_IOERR_MMAP\n", + osGetCurrentProcessId(), pFile, pFile->hMap)); + return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno, + "winUnmapfile2", pFile->zPath); + } + pFile->hMap = NULL; + } + OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile)); + return SQLITE_OK; +} + +/* +** Memory map or remap the file opened by file-descriptor pFd (if the file +** is already mapped, the existing mapping is replaced by the new). Or, if +** there already exists a mapping for this file, and there are still +** outstanding xFetch() references to it, this function is a no-op. +** +** If parameter nByte is non-negative, then it is the requested size of +** the mapping to create. Otherwise, if nByte is less than zero, then the +** requested size is the size of the file on disk. The actual size of the +** created mapping is either the requested size or the value configured +** using SQLITE_FCNTL_MMAP_SIZE, whichever is smaller. +** +** SQLITE_OK is returned if no error occurs (even if the mapping is not +** recreated as a result of outstanding references) or an SQLite error +** code otherwise. +*/ +static int winMapfile(winFile *pFd, sqlite3_int64 nByte){ + sqlite3_int64 nMap = nByte; + int rc; + + assert( nMap>=0 || pFd->nFetchOut==0 ); + OSTRACE(("MAP-FILE pid=%lu, pFile=%p, size=%lld\n", + osGetCurrentProcessId(), pFd, nByte)); + + if( pFd->nFetchOut>0 ) return SQLITE_OK; + + if( nMap<0 ){ + rc = winFileSize((sqlite3_file*)pFd, &nMap); + if( rc ){ + OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_IOERR_FSTAT\n", + osGetCurrentProcessId(), pFd)); + return SQLITE_IOERR_FSTAT; + } + } + if( nMap>pFd->mmapSizeMax ){ + nMap = pFd->mmapSizeMax; + } + nMap &= ~(sqlite3_int64)(winSysInfo.dwPageSize - 1); + + if( nMap==0 && pFd->mmapSize>0 ){ + winUnmapfile(pFd); + } + if( nMap!=pFd->mmapSize ){ + void *pNew = 0; + DWORD protect = PAGE_READONLY; + DWORD flags = FILE_MAP_READ; + + winUnmapfile(pFd); +#ifdef SQLITE_MMAP_READWRITE + if( (pFd->ctrlFlags & WINFILE_RDONLY)==0 ){ + protect = PAGE_READWRITE; + flags |= FILE_MAP_WRITE; + } +#endif +#if SQLITE_OS_WINRT + pFd->hMap = osCreateFileMappingFromApp(pFd->h, NULL, protect, nMap, NULL); +#elif defined(SQLITE_WIN32_HAS_WIDE) + pFd->hMap = osCreateFileMappingW(pFd->h, NULL, protect, + (DWORD)((nMap>>32) & 0xffffffff), + (DWORD)(nMap & 0xffffffff), NULL); +#elif defined(SQLITE_WIN32_HAS_ANSI) && SQLITE_WIN32_CREATEFILEMAPPINGA + pFd->hMap = osCreateFileMappingA(pFd->h, NULL, protect, + (DWORD)((nMap>>32) & 0xffffffff), + (DWORD)(nMap & 0xffffffff), NULL); +#endif + if( pFd->hMap==NULL ){ + pFd->lastErrno = osGetLastError(); + rc = winLogError(SQLITE_IOERR_MMAP, pFd->lastErrno, + "winMapfile1", pFd->zPath); + /* Log the error, but continue normal operation using xRead/xWrite */ + OSTRACE(("MAP-FILE-CREATE pid=%lu, pFile=%p, rc=%s\n", + osGetCurrentProcessId(), pFd, sqlite3ErrName(rc))); + return SQLITE_OK; + } + assert( (nMap % winSysInfo.dwPageSize)==0 ); + assert( sizeof(SIZE_T)==sizeof(sqlite3_int64) || nMap<=0xffffffff ); +#if SQLITE_OS_WINRT + pNew = osMapViewOfFileFromApp(pFd->hMap, flags, 0, (SIZE_T)nMap); +#else + pNew = osMapViewOfFile(pFd->hMap, flags, 0, 0, (SIZE_T)nMap); +#endif + if( pNew==NULL ){ + osCloseHandle(pFd->hMap); + pFd->hMap = NULL; + pFd->lastErrno = osGetLastError(); + rc = winLogError(SQLITE_IOERR_MMAP, pFd->lastErrno, + "winMapfile2", pFd->zPath); + /* Log the error, but continue normal operation using xRead/xWrite */ + OSTRACE(("MAP-FILE-MAP pid=%lu, pFile=%p, rc=%s\n", + osGetCurrentProcessId(), pFd, sqlite3ErrName(rc))); + return SQLITE_OK; + } + pFd->pMapRegion = pNew; + pFd->mmapSize = nMap; + } + + OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFd)); + return SQLITE_OK; +} +#endif /* SQLITE_MAX_MMAP_SIZE>0 */ + +/* +** If possible, return a pointer to a mapping of file fd starting at offset +** iOff. The mapping must be valid for at least nAmt bytes. +** +** If such a pointer can be obtained, store it in *pp and return SQLITE_OK. +** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK. +** Finally, if an error does occur, return an SQLite error code. The final +** value of *pp is undefined in this case. +** +** If this function does return a pointer, the caller must eventually +** release the reference by calling winUnfetch(). +*/ +static int winFetch(sqlite3_file *fd, i64 iOff, int nAmt, void **pp){ +#if SQLITE_MAX_MMAP_SIZE>0 + winFile *pFd = (winFile*)fd; /* The underlying database file */ +#endif + *pp = 0; + + OSTRACE(("FETCH pid=%lu, pFile=%p, offset=%lld, amount=%d, pp=%p\n", + osGetCurrentProcessId(), fd, iOff, nAmt, pp)); + +#if SQLITE_MAX_MMAP_SIZE>0 + if( pFd->mmapSizeMax>0 ){ + if( pFd->pMapRegion==0 ){ + int rc = winMapfile(pFd, -1); + if( rc!=SQLITE_OK ){ + OSTRACE(("FETCH pid=%lu, pFile=%p, rc=%s\n", + osGetCurrentProcessId(), pFd, sqlite3ErrName(rc))); + return rc; + } + } + if( pFd->mmapSize >= iOff+nAmt ){ + assert( pFd->pMapRegion!=0 ); + *pp = &((u8 *)pFd->pMapRegion)[iOff]; + pFd->nFetchOut++; + } + } +#endif + + OSTRACE(("FETCH pid=%lu, pFile=%p, pp=%p, *pp=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), fd, pp, *pp)); + return SQLITE_OK; +} + +/* +** If the third argument is non-NULL, then this function releases a +** reference obtained by an earlier call to winFetch(). The second +** argument passed to this function must be the same as the corresponding +** argument that was passed to the winFetch() invocation. +** +** Or, if the third argument is NULL, then this function is being called +** to inform the VFS layer that, according to POSIX, any existing mapping +** may now be invalid and should be unmapped. +*/ +static int winUnfetch(sqlite3_file *fd, i64 iOff, void *p){ +#if SQLITE_MAX_MMAP_SIZE>0 + winFile *pFd = (winFile*)fd; /* The underlying database file */ + + /* If p==0 (unmap the entire file) then there must be no outstanding + ** xFetch references. Or, if p!=0 (meaning it is an xFetch reference), + ** then there must be at least one outstanding. */ + assert( (p==0)==(pFd->nFetchOut==0) ); + + /* If p!=0, it must match the iOff value. */ + assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] ); + + OSTRACE(("UNFETCH pid=%lu, pFile=%p, offset=%lld, p=%p\n", + osGetCurrentProcessId(), pFd, iOff, p)); + + if( p ){ + pFd->nFetchOut--; + }else{ + /* FIXME: If Windows truly always prevents truncating or deleting a + ** file while a mapping is held, then the following winUnmapfile() call + ** is unnecessary can be omitted - potentially improving + ** performance. */ + winUnmapfile(pFd); + } + + assert( pFd->nFetchOut>=0 ); +#endif + + OSTRACE(("UNFETCH pid=%lu, pFile=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), fd)); + return SQLITE_OK; +} + +/* +** Here ends the implementation of all sqlite3_file methods. +** +********************** End sqlite3_file Methods ******************************* +******************************************************************************/ + +/* +** This vector defines all the methods that can operate on an +** sqlite3_file for win32. +*/ +static const sqlite3_io_methods winIoMethod = { + 3, /* iVersion */ + winClose, /* xClose */ + winRead, /* xRead */ + winWrite, /* xWrite */ + winTruncate, /* xTruncate */ + winSync, /* xSync */ + winFileSize, /* xFileSize */ + winLock, /* xLock */ + winUnlock, /* xUnlock */ + winCheckReservedLock, /* xCheckReservedLock */ + winFileControl, /* xFileControl */ + winSectorSize, /* xSectorSize */ + winDeviceCharacteristics, /* xDeviceCharacteristics */ + winShmMap, /* xShmMap */ + winShmLock, /* xShmLock */ + winShmBarrier, /* xShmBarrier */ + winShmUnmap, /* xShmUnmap */ + winFetch, /* xFetch */ + winUnfetch /* xUnfetch */ +}; + +/* +** This vector defines all the methods that can operate on an +** sqlite3_file for win32 without performing any locking. +*/ +static const sqlite3_io_methods winIoNolockMethod = { + 3, /* iVersion */ + winClose, /* xClose */ + winRead, /* xRead */ + winWrite, /* xWrite */ + winTruncate, /* xTruncate */ + winSync, /* xSync */ + winFileSize, /* xFileSize */ + winNolockLock, /* xLock */ + winNolockUnlock, /* xUnlock */ + winNolockCheckReservedLock, /* xCheckReservedLock */ + winFileControl, /* xFileControl */ + winSectorSize, /* xSectorSize */ + winDeviceCharacteristics, /* xDeviceCharacteristics */ + winShmMap, /* xShmMap */ + winShmLock, /* xShmLock */ + winShmBarrier, /* xShmBarrier */ + winShmUnmap, /* xShmUnmap */ + winFetch, /* xFetch */ + winUnfetch /* xUnfetch */ +}; + +static winVfsAppData winAppData = { + &winIoMethod, /* pMethod */ + 0, /* pAppData */ + 0 /* bNoLock */ +}; + +static winVfsAppData winNolockAppData = { + &winIoNolockMethod, /* pMethod */ + 0, /* pAppData */ + 1 /* bNoLock */ +}; + +/**************************************************************************** +**************************** sqlite3_vfs methods **************************** +** +** This division contains the implementation of methods on the +** sqlite3_vfs object. +*/ + +#if defined(__CYGWIN__) +/* +** Convert a filename from whatever the underlying operating system +** supports for filenames into UTF-8. Space to hold the result is +** obtained from malloc and must be freed by the calling function. +*/ +static char *winConvertToUtf8Filename(const void *zFilename){ + char *zConverted = 0; + if( osIsNT() ){ + zConverted = winUnicodeToUtf8(zFilename); + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + zConverted = winMbcsToUtf8(zFilename, osAreFileApisANSI()); + } +#endif + /* caller will handle out of memory */ + return zConverted; +} +#endif + +/* +** Convert a UTF-8 filename into whatever form the underlying +** operating system wants filenames in. Space to hold the result +** is obtained from malloc and must be freed by the calling +** function. +*/ +static void *winConvertFromUtf8Filename(const char *zFilename){ + void *zConverted = 0; + if( osIsNT() ){ + zConverted = winUtf8ToUnicode(zFilename); + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + zConverted = winUtf8ToMbcs(zFilename, osAreFileApisANSI()); + } +#endif + /* caller will handle out of memory */ + return zConverted; +} + +/* +** This function returns non-zero if the specified UTF-8 string buffer +** ends with a directory separator character or one was successfully +** added to it. +*/ +static int winMakeEndInDirSep(int nBuf, char *zBuf){ + if( zBuf ){ + int nLen = sqlite3Strlen30(zBuf); + if( nLen>0 ){ + if( winIsDirSep(zBuf[nLen-1]) ){ + return 1; + }else if( nLen+1mxPathname; nBuf = nMax + 2; + zBuf = sqlite3MallocZero( nBuf ); + if( !zBuf ){ + OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n")); + return SQLITE_IOERR_NOMEM_BKPT; + } + + /* Figure out the effective temporary directory. First, check if one + ** has been explicitly set by the application; otherwise, use the one + ** configured by the operating system. + */ + nDir = nMax - (nPre + 15); + assert( nDir>0 ); + if( sqlite3_temp_directory ){ + int nDirLen = sqlite3Strlen30(sqlite3_temp_directory); + if( nDirLen>0 ){ + if( !winIsDirSep(sqlite3_temp_directory[nDirLen-1]) ){ + nDirLen++; + } + if( nDirLen>nDir ){ + sqlite3_free(zBuf); + OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n")); + return winLogError(SQLITE_ERROR, 0, "winGetTempname1", 0); + } + sqlite3_snprintf(nMax, zBuf, "%s", sqlite3_temp_directory); + } + } +#if defined(__CYGWIN__) + else{ + static const char *azDirs[] = { + 0, /* getenv("SQLITE_TMPDIR") */ + 0, /* getenv("TMPDIR") */ + 0, /* getenv("TMP") */ + 0, /* getenv("TEMP") */ + 0, /* getenv("USERPROFILE") */ + "/var/tmp", + "/usr/tmp", + "/tmp", + ".", + 0 /* List terminator */ + }; + unsigned int i; + const char *zDir = 0; + + if( !azDirs[0] ) azDirs[0] = getenv("SQLITE_TMPDIR"); + if( !azDirs[1] ) azDirs[1] = getenv("TMPDIR"); + if( !azDirs[2] ) azDirs[2] = getenv("TMP"); + if( !azDirs[3] ) azDirs[3] = getenv("TEMP"); + if( !azDirs[4] ) azDirs[4] = getenv("USERPROFILE"); + for(i=0; i/etilqs_XXXXXXXXXXXXXXX\0\0" + ** + ** If not, return SQLITE_ERROR. The number 17 is used here in order to + ** account for the space used by the 15 character random suffix and the + ** two trailing NUL characters. The final directory separator character + ** has already added if it was not already present. + */ + nLen = sqlite3Strlen30(zBuf); + if( (nLen + nPre + 17) > nBuf ){ + sqlite3_free(zBuf); + OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n")); + return winLogError(SQLITE_ERROR, 0, "winGetTempname5", 0); + } + + sqlite3_snprintf(nBuf-16-nLen, zBuf+nLen, SQLITE_TEMP_FILE_PREFIX); + + j = sqlite3Strlen30(zBuf); + sqlite3_randomness(15, &zBuf[j]); + for(i=0; i<15; i++, j++){ + zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; + } + zBuf[j] = 0; + zBuf[j+1] = 0; + *pzBuf = zBuf; + + OSTRACE(("TEMP-FILENAME name=%s, rc=SQLITE_OK\n", zBuf)); + return SQLITE_OK; +} + +/* +** Return TRUE if the named file is really a directory. Return false if +** it is something other than a directory, or if there is any kind of memory +** allocation failure. +*/ +static int winIsDir(const void *zConverted){ + DWORD attr; + int rc = 0; + DWORD lastErrno; + + if( osIsNT() ){ + int cnt = 0; + WIN32_FILE_ATTRIBUTE_DATA sAttrData; + memset(&sAttrData, 0, sizeof(sAttrData)); + while( !(rc = osGetFileAttributesExW((LPCWSTR)zConverted, + GetFileExInfoStandard, + &sAttrData)) && winRetryIoerr(&cnt, &lastErrno) ){} + if( !rc ){ + return 0; /* Invalid name? */ + } + attr = sAttrData.dwFileAttributes; +#if SQLITE_OS_WINCE==0 + }else{ + attr = osGetFileAttributesA((char*)zConverted); +#endif + } + return (attr!=INVALID_FILE_ATTRIBUTES) && (attr&FILE_ATTRIBUTE_DIRECTORY); +} + +/* forward reference */ +static int winAccess( + sqlite3_vfs *pVfs, /* Not used on win32 */ + const char *zFilename, /* Name of file to check */ + int flags, /* Type of test to make on this file */ + int *pResOut /* OUT: Result */ +); + +/* +** Open a file. +*/ +static int winOpen( + sqlite3_vfs *pVfs, /* Used to get maximum path length and AppData */ + const char *zName, /* Name of the file (UTF-8) */ + sqlite3_file *id, /* Write the SQLite file handle here */ + int flags, /* Open mode flags */ + int *pOutFlags /* Status return flags */ +){ + HANDLE h; + DWORD lastErrno = 0; + DWORD dwDesiredAccess; + DWORD dwShareMode; + DWORD dwCreationDisposition; + DWORD dwFlagsAndAttributes = 0; +#if SQLITE_OS_WINCE + int isTemp = 0; +#endif + winVfsAppData *pAppData; + winFile *pFile = (winFile*)id; + void *zConverted; /* Filename in OS encoding */ + const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */ + int cnt = 0; + + /* If argument zPath is a NULL pointer, this function is required to open + ** a temporary file. Use this buffer to store the file name in. + */ + char *zTmpname = 0; /* For temporary filename, if necessary. */ + + int rc = SQLITE_OK; /* Function Return Code */ +#if !defined(NDEBUG) || SQLITE_OS_WINCE + int eType = flags&0xFFFFFF00; /* Type of file to open */ +#endif + + int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE); + int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE); + int isCreate = (flags & SQLITE_OPEN_CREATE); + int isReadonly = (flags & SQLITE_OPEN_READONLY); + int isReadWrite = (flags & SQLITE_OPEN_READWRITE); + +#ifndef NDEBUG + int isOpenJournal = (isCreate && ( + eType==SQLITE_OPEN_SUPER_JOURNAL + || eType==SQLITE_OPEN_MAIN_JOURNAL + || eType==SQLITE_OPEN_WAL + )); +#endif + + OSTRACE(("OPEN name=%s, pFile=%p, flags=%x, pOutFlags=%p\n", + zUtf8Name, id, flags, pOutFlags)); + + /* Check the following statements are true: + ** + ** (a) Exactly one of the READWRITE and READONLY flags must be set, and + ** (b) if CREATE is set, then READWRITE must also be set, and + ** (c) if EXCLUSIVE is set, then CREATE must also be set. + ** (d) if DELETEONCLOSE is set, then CREATE must also be set. + */ + assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly)); + assert(isCreate==0 || isReadWrite); + assert(isExclusive==0 || isCreate); + assert(isDelete==0 || isCreate); + + /* The main DB, main journal, WAL file and super-journal are never + ** automatically deleted. Nor are they ever temporary files. */ + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_SUPER_JOURNAL ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL ); + + /* Assert that the upper layer has set one of the "file-type" flags. */ + assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB + || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL + || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_SUPER_JOURNAL + || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL + ); + + assert( pFile!=0 ); + memset(pFile, 0, sizeof(winFile)); + pFile->h = INVALID_HANDLE_VALUE; + +#if SQLITE_OS_WINRT + if( !zUtf8Name && !sqlite3_temp_directory ){ + sqlite3_log(SQLITE_ERROR, + "sqlite3_temp_directory variable should be set for WinRT"); + } +#endif + + /* If the second argument to this function is NULL, generate a + ** temporary file name to use + */ + if( !zUtf8Name ){ + assert( isDelete && !isOpenJournal ); + rc = winGetTempname(pVfs, &zTmpname); + if( rc!=SQLITE_OK ){ + OSTRACE(("OPEN name=%s, rc=%s", zUtf8Name, sqlite3ErrName(rc))); + return rc; + } + zUtf8Name = zTmpname; + } + + /* Database filenames are double-zero terminated if they are not + ** URIs with parameters. Hence, they can always be passed into + ** sqlite3_uri_parameter(). + */ + assert( (eType!=SQLITE_OPEN_MAIN_DB) || (flags & SQLITE_OPEN_URI) || + zUtf8Name[sqlite3Strlen30(zUtf8Name)+1]==0 ); + + /* Convert the filename to the system encoding. */ + zConverted = winConvertFromUtf8Filename(zUtf8Name); + if( zConverted==0 ){ + sqlite3_free(zTmpname); + OSTRACE(("OPEN name=%s, rc=SQLITE_IOERR_NOMEM", zUtf8Name)); + return SQLITE_IOERR_NOMEM_BKPT; + } + + if( winIsDir(zConverted) ){ + sqlite3_free(zConverted); + sqlite3_free(zTmpname); + OSTRACE(("OPEN name=%s, rc=SQLITE_CANTOPEN_ISDIR", zUtf8Name)); + return SQLITE_CANTOPEN_ISDIR; + } + + if( isReadWrite ){ + dwDesiredAccess = GENERIC_READ | GENERIC_WRITE; + }else{ + dwDesiredAccess = GENERIC_READ; + } + + /* SQLITE_OPEN_EXCLUSIVE is used to make sure that a new file is + ** created. SQLite doesn't use it to indicate "exclusive access" + ** as it is usually understood. + */ + if( isExclusive ){ + /* Creates a new file, only if it does not already exist. */ + /* If the file exists, it fails. */ + dwCreationDisposition = CREATE_NEW; + }else if( isCreate ){ + /* Open existing file, or create if it doesn't exist */ + dwCreationDisposition = OPEN_ALWAYS; + }else{ + /* Opens a file, only if it exists. */ + dwCreationDisposition = OPEN_EXISTING; + } + + if( 0==sqlite3_uri_boolean(zName, "exclusive", 0) ){ + dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE; + }else{ + dwShareMode = 0; + } + + if( isDelete ){ +#if SQLITE_OS_WINCE + dwFlagsAndAttributes = FILE_ATTRIBUTE_HIDDEN; + isTemp = 1; +#else + dwFlagsAndAttributes = FILE_ATTRIBUTE_TEMPORARY + | FILE_ATTRIBUTE_HIDDEN + | FILE_FLAG_DELETE_ON_CLOSE; +#endif + }else{ + dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL; + } + /* Reports from the internet are that performance is always + ** better if FILE_FLAG_RANDOM_ACCESS is used. Ticket #2699. */ +#if SQLITE_OS_WINCE + dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS; +#endif + + if( osIsNT() ){ +#if SQLITE_OS_WINRT + CREATEFILE2_EXTENDED_PARAMETERS extendedParameters; + extendedParameters.dwSize = sizeof(CREATEFILE2_EXTENDED_PARAMETERS); + extendedParameters.dwFileAttributes = + dwFlagsAndAttributes & FILE_ATTRIBUTE_MASK; + extendedParameters.dwFileFlags = dwFlagsAndAttributes & FILE_FLAG_MASK; + extendedParameters.dwSecurityQosFlags = SECURITY_ANONYMOUS; + extendedParameters.lpSecurityAttributes = NULL; + extendedParameters.hTemplateFile = NULL; + do{ + h = osCreateFile2((LPCWSTR)zConverted, + dwDesiredAccess, + dwShareMode, + dwCreationDisposition, + &extendedParameters); + if( h!=INVALID_HANDLE_VALUE ) break; + if( isReadWrite ){ + int rc2, isRO = 0; + sqlite3BeginBenignMalloc(); + rc2 = winAccess(pVfs, zName, SQLITE_ACCESS_READ, &isRO); + sqlite3EndBenignMalloc(); + if( rc2==SQLITE_OK && isRO ) break; + } + }while( winRetryIoerr(&cnt, &lastErrno) ); +#else + do{ + h = osCreateFileW((LPCWSTR)zConverted, + dwDesiredAccess, + dwShareMode, NULL, + dwCreationDisposition, + dwFlagsAndAttributes, + NULL); + if( h!=INVALID_HANDLE_VALUE ) break; + if( isReadWrite ){ + int rc2, isRO = 0; + sqlite3BeginBenignMalloc(); + rc2 = winAccess(pVfs, zName, SQLITE_ACCESS_READ, &isRO); + sqlite3EndBenignMalloc(); + if( rc2==SQLITE_OK && isRO ) break; + } + }while( winRetryIoerr(&cnt, &lastErrno) ); +#endif + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + do{ + h = osCreateFileA((LPCSTR)zConverted, + dwDesiredAccess, + dwShareMode, NULL, + dwCreationDisposition, + dwFlagsAndAttributes, + NULL); + if( h!=INVALID_HANDLE_VALUE ) break; + if( isReadWrite ){ + int rc2, isRO = 0; + sqlite3BeginBenignMalloc(); + rc2 = winAccess(pVfs, zName, SQLITE_ACCESS_READ, &isRO); + sqlite3EndBenignMalloc(); + if( rc2==SQLITE_OK && isRO ) break; + } + }while( winRetryIoerr(&cnt, &lastErrno) ); + } +#endif + winLogIoerr(cnt, __LINE__); + + OSTRACE(("OPEN file=%p, name=%s, access=%lx, rc=%s\n", h, zUtf8Name, + dwDesiredAccess, (h==INVALID_HANDLE_VALUE) ? "failed" : "ok")); + + if( h==INVALID_HANDLE_VALUE ){ + sqlite3_free(zConverted); + sqlite3_free(zTmpname); + if( isReadWrite && !isExclusive ){ + return winOpen(pVfs, zName, id, + ((flags|SQLITE_OPEN_READONLY) & + ~(SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE)), + pOutFlags); + }else{ + pFile->lastErrno = lastErrno; + winLogError(SQLITE_CANTOPEN, pFile->lastErrno, "winOpen", zUtf8Name); + return SQLITE_CANTOPEN_BKPT; + } + } + + if( pOutFlags ){ + if( isReadWrite ){ + *pOutFlags = SQLITE_OPEN_READWRITE; + }else{ + *pOutFlags = SQLITE_OPEN_READONLY; + } + } + + OSTRACE(("OPEN file=%p, name=%s, access=%lx, pOutFlags=%p, *pOutFlags=%d, " + "rc=%s\n", h, zUtf8Name, dwDesiredAccess, pOutFlags, pOutFlags ? + *pOutFlags : 0, (h==INVALID_HANDLE_VALUE) ? "failed" : "ok")); + + pAppData = (winVfsAppData*)pVfs->pAppData; + +#if SQLITE_OS_WINCE + { + if( isReadWrite && eType==SQLITE_OPEN_MAIN_DB + && ((pAppData==NULL) || !pAppData->bNoLock) + && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK + ){ + osCloseHandle(h); + sqlite3_free(zConverted); + sqlite3_free(zTmpname); + OSTRACE(("OPEN-CE-LOCK name=%s, rc=%s\n", zName, sqlite3ErrName(rc))); + return rc; + } + } + if( isTemp ){ + pFile->zDeleteOnClose = zConverted; + }else +#endif + { + sqlite3_free(zConverted); + } + + sqlite3_free(zTmpname); + id->pMethods = pAppData ? pAppData->pMethod : &winIoMethod; + pFile->pVfs = pVfs; + pFile->h = h; + if( isReadonly ){ + pFile->ctrlFlags |= WINFILE_RDONLY; + } + if( (flags & SQLITE_OPEN_MAIN_DB) + && sqlite3_uri_boolean(zName, "psow", SQLITE_POWERSAFE_OVERWRITE) + ){ + pFile->ctrlFlags |= WINFILE_PSOW; + } + pFile->lastErrno = NO_ERROR; + pFile->zPath = zName; +#if SQLITE_MAX_MMAP_SIZE>0 + pFile->hMap = NULL; + pFile->pMapRegion = 0; + pFile->mmapSize = 0; + pFile->mmapSizeMax = sqlite3GlobalConfig.szMmap; +#endif + + OpenCounter(+1); + return rc; +} + +/* +** Delete the named file. +** +** Note that Windows does not allow a file to be deleted if some other +** process has it open. Sometimes a virus scanner or indexing program +** will open a journal file shortly after it is created in order to do +** whatever it does. While this other process is holding the +** file open, we will be unable to delete it. To work around this +** problem, we delay 100 milliseconds and try to delete again. Up +** to MX_DELETION_ATTEMPTs deletion attempts are run before giving +** up and returning an error. +*/ +static int winDelete( + sqlite3_vfs *pVfs, /* Not used on win32 */ + const char *zFilename, /* Name of file to delete */ + int syncDir /* Not used on win32 */ +){ + int cnt = 0; + int rc; + DWORD attr; + DWORD lastErrno = 0; + void *zConverted; + UNUSED_PARAMETER(pVfs); + UNUSED_PARAMETER(syncDir); + + SimulateIOError(return SQLITE_IOERR_DELETE); + OSTRACE(("DELETE name=%s, syncDir=%d\n", zFilename, syncDir)); + + zConverted = winConvertFromUtf8Filename(zFilename); + if( zConverted==0 ){ + OSTRACE(("DELETE name=%s, rc=SQLITE_IOERR_NOMEM\n", zFilename)); + return SQLITE_IOERR_NOMEM_BKPT; + } + if( osIsNT() ){ + do { +#if SQLITE_OS_WINRT + WIN32_FILE_ATTRIBUTE_DATA sAttrData; + memset(&sAttrData, 0, sizeof(sAttrData)); + if ( osGetFileAttributesExW(zConverted, GetFileExInfoStandard, + &sAttrData) ){ + attr = sAttrData.dwFileAttributes; + }else{ + lastErrno = osGetLastError(); + if( lastErrno==ERROR_FILE_NOT_FOUND + || lastErrno==ERROR_PATH_NOT_FOUND ){ + rc = SQLITE_IOERR_DELETE_NOENT; /* Already gone? */ + }else{ + rc = SQLITE_ERROR; + } + break; + } +#else + attr = osGetFileAttributesW(zConverted); +#endif + if ( attr==INVALID_FILE_ATTRIBUTES ){ + lastErrno = osGetLastError(); + if( lastErrno==ERROR_FILE_NOT_FOUND + || lastErrno==ERROR_PATH_NOT_FOUND ){ + rc = SQLITE_IOERR_DELETE_NOENT; /* Already gone? */ + }else{ + rc = SQLITE_ERROR; + } + break; + } + if ( attr&FILE_ATTRIBUTE_DIRECTORY ){ + rc = SQLITE_ERROR; /* Files only. */ + break; + } + if ( osDeleteFileW(zConverted) ){ + rc = SQLITE_OK; /* Deleted OK. */ + break; + } + if ( !winRetryIoerr(&cnt, &lastErrno) ){ + rc = SQLITE_ERROR; /* No more retries. */ + break; + } + } while(1); + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + do { + attr = osGetFileAttributesA(zConverted); + if ( attr==INVALID_FILE_ATTRIBUTES ){ + lastErrno = osGetLastError(); + if( lastErrno==ERROR_FILE_NOT_FOUND + || lastErrno==ERROR_PATH_NOT_FOUND ){ + rc = SQLITE_IOERR_DELETE_NOENT; /* Already gone? */ + }else{ + rc = SQLITE_ERROR; + } + break; + } + if ( attr&FILE_ATTRIBUTE_DIRECTORY ){ + rc = SQLITE_ERROR; /* Files only. */ + break; + } + if ( osDeleteFileA(zConverted) ){ + rc = SQLITE_OK; /* Deleted OK. */ + break; + } + if ( !winRetryIoerr(&cnt, &lastErrno) ){ + rc = SQLITE_ERROR; /* No more retries. */ + break; + } + } while(1); + } +#endif + if( rc && rc!=SQLITE_IOERR_DELETE_NOENT ){ + rc = winLogError(SQLITE_IOERR_DELETE, lastErrno, "winDelete", zFilename); + }else{ + winLogIoerr(cnt, __LINE__); + } + sqlite3_free(zConverted); + OSTRACE(("DELETE name=%s, rc=%s\n", zFilename, sqlite3ErrName(rc))); + return rc; +} + +/* +** Check the existence and status of a file. +*/ +static int winAccess( + sqlite3_vfs *pVfs, /* Not used on win32 */ + const char *zFilename, /* Name of file to check */ + int flags, /* Type of test to make on this file */ + int *pResOut /* OUT: Result */ +){ + DWORD attr; + int rc = 0; + DWORD lastErrno = 0; + void *zConverted; + UNUSED_PARAMETER(pVfs); + + SimulateIOError( return SQLITE_IOERR_ACCESS; ); + OSTRACE(("ACCESS name=%s, flags=%x, pResOut=%p\n", + zFilename, flags, pResOut)); + + zConverted = winConvertFromUtf8Filename(zFilename); + if( zConverted==0 ){ + OSTRACE(("ACCESS name=%s, rc=SQLITE_IOERR_NOMEM\n", zFilename)); + return SQLITE_IOERR_NOMEM_BKPT; + } + if( osIsNT() ){ + int cnt = 0; + WIN32_FILE_ATTRIBUTE_DATA sAttrData; + memset(&sAttrData, 0, sizeof(sAttrData)); + while( !(rc = osGetFileAttributesExW((LPCWSTR)zConverted, + GetFileExInfoStandard, + &sAttrData)) && winRetryIoerr(&cnt, &lastErrno) ){} + if( rc ){ + /* For an SQLITE_ACCESS_EXISTS query, treat a zero-length file + ** as if it does not exist. + */ + if( flags==SQLITE_ACCESS_EXISTS + && sAttrData.nFileSizeHigh==0 + && sAttrData.nFileSizeLow==0 ){ + attr = INVALID_FILE_ATTRIBUTES; + }else{ + attr = sAttrData.dwFileAttributes; + } + }else{ + winLogIoerr(cnt, __LINE__); + if( lastErrno!=ERROR_FILE_NOT_FOUND && lastErrno!=ERROR_PATH_NOT_FOUND ){ + sqlite3_free(zConverted); + return winLogError(SQLITE_IOERR_ACCESS, lastErrno, "winAccess", + zFilename); + }else{ + attr = INVALID_FILE_ATTRIBUTES; + } + } + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + attr = osGetFileAttributesA((char*)zConverted); + } +#endif + sqlite3_free(zConverted); + switch( flags ){ + case SQLITE_ACCESS_READ: + case SQLITE_ACCESS_EXISTS: + rc = attr!=INVALID_FILE_ATTRIBUTES; + break; + case SQLITE_ACCESS_READWRITE: + rc = attr!=INVALID_FILE_ATTRIBUTES && + (attr & FILE_ATTRIBUTE_READONLY)==0; + break; + default: + assert(!"Invalid flags argument"); + } + *pResOut = rc; + OSTRACE(("ACCESS name=%s, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n", + zFilename, pResOut, *pResOut)); + return SQLITE_OK; +} + +/* +** Returns non-zero if the specified path name starts with the "long path" +** prefix. +*/ +static BOOL winIsLongPathPrefix( + const char *zPathname +){ + return ( zPathname[0]=='\\' && zPathname[1]=='\\' + && zPathname[2]=='?' && zPathname[3]=='\\' ); +} + +/* +** Returns non-zero if the specified path name starts with a drive letter +** followed by a colon character. +*/ +static BOOL winIsDriveLetterAndColon( + const char *zPathname +){ + return ( sqlite3Isalpha(zPathname[0]) && zPathname[1]==':' ); +} + +/* +** Returns non-zero if the specified path name should be used verbatim. If +** non-zero is returned from this function, the calling function must simply +** use the provided path name verbatim -OR- resolve it into a full path name +** using the GetFullPathName Win32 API function (if available). +*/ +static BOOL winIsVerbatimPathname( + const char *zPathname +){ + /* + ** If the path name starts with a forward slash or a backslash, it is either + ** a legal UNC name, a volume relative path, or an absolute path name in the + ** "Unix" format on Windows. There is no easy way to differentiate between + ** the final two cases; therefore, we return the safer return value of TRUE + ** so that callers of this function will simply use it verbatim. + */ + if ( winIsDirSep(zPathname[0]) ){ + return TRUE; + } + + /* + ** If the path name starts with a letter and a colon it is either a volume + ** relative path or an absolute path. Callers of this function must not + ** attempt to treat it as a relative path name (i.e. they should simply use + ** it verbatim). + */ + if ( winIsDriveLetterAndColon(zPathname) ){ + return TRUE; + } + + /* + ** If we get to this point, the path name should almost certainly be a purely + ** relative one (i.e. not a UNC name, not absolute, and not volume relative). + */ + return FALSE; +} + +/* +** Turn a relative pathname into a full pathname. Write the full +** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname +** bytes in size. +*/ +static int winFullPathname( + sqlite3_vfs *pVfs, /* Pointer to vfs object */ + const char *zRelative, /* Possibly relative input path */ + int nFull, /* Size of output buffer in bytes */ + char *zFull /* Output buffer */ +){ +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && !defined(__CYGWIN__) + DWORD nByte; + void *zConverted; + char *zOut; +#endif + + /* If this path name begins with "/X:" or "\\?\", where "X" is any + ** alphabetic character, discard the initial "/" from the pathname. + */ + if( zRelative[0]=='/' && (winIsDriveLetterAndColon(zRelative+1) + || winIsLongPathPrefix(zRelative+1)) ){ + zRelative++; + } + +#if defined(__CYGWIN__) + SimulateIOError( return SQLITE_ERROR ); + UNUSED_PARAMETER(nFull); + assert( nFull>=pVfs->mxPathname ); + if ( sqlite3_data_directory && !winIsVerbatimPathname(zRelative) ){ + /* + ** NOTE: We are dealing with a relative path name and the data + ** directory has been set. Therefore, use it as the basis + ** for converting the relative path name to an absolute + ** one by prepending the data directory and a slash. + */ + char *zOut = sqlite3MallocZero( pVfs->mxPathname+1 ); + if( !zOut ){ + return SQLITE_IOERR_NOMEM_BKPT; + } + if( cygwin_conv_path( + (osIsNT() ? CCP_POSIX_TO_WIN_W : CCP_POSIX_TO_WIN_A) | + CCP_RELATIVE, zRelative, zOut, pVfs->mxPathname+1)<0 ){ + sqlite3_free(zOut); + return winLogError(SQLITE_CANTOPEN_CONVPATH, (DWORD)errno, + "winFullPathname1", zRelative); + }else{ + char *zUtf8 = winConvertToUtf8Filename(zOut); + if( !zUtf8 ){ + sqlite3_free(zOut); + return SQLITE_IOERR_NOMEM_BKPT; + } + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s", + sqlite3_data_directory, winGetDirSep(), zUtf8); + sqlite3_free(zUtf8); + sqlite3_free(zOut); + } + }else{ + char *zOut = sqlite3MallocZero( pVfs->mxPathname+1 ); + if( !zOut ){ + return SQLITE_IOERR_NOMEM_BKPT; + } + if( cygwin_conv_path( + (osIsNT() ? CCP_POSIX_TO_WIN_W : CCP_POSIX_TO_WIN_A), + zRelative, zOut, pVfs->mxPathname+1)<0 ){ + sqlite3_free(zOut); + return winLogError(SQLITE_CANTOPEN_CONVPATH, (DWORD)errno, + "winFullPathname2", zRelative); + }else{ + char *zUtf8 = winConvertToUtf8Filename(zOut); + if( !zUtf8 ){ + sqlite3_free(zOut); + return SQLITE_IOERR_NOMEM_BKPT; + } + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zUtf8); + sqlite3_free(zUtf8); + sqlite3_free(zOut); + } + } + return SQLITE_OK; +#endif + +#if (SQLITE_OS_WINCE || SQLITE_OS_WINRT) && !defined(__CYGWIN__) + SimulateIOError( return SQLITE_ERROR ); + /* WinCE has no concept of a relative pathname, or so I am told. */ + /* WinRT has no way to convert a relative path to an absolute one. */ + if ( sqlite3_data_directory && !winIsVerbatimPathname(zRelative) ){ + /* + ** NOTE: We are dealing with a relative path name and the data + ** directory has been set. Therefore, use it as the basis + ** for converting the relative path name to an absolute + ** one by prepending the data directory and a backslash. + */ + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s", + sqlite3_data_directory, winGetDirSep(), zRelative); + }else{ + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zRelative); + } + return SQLITE_OK; +#endif + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && !defined(__CYGWIN__) + /* It's odd to simulate an io-error here, but really this is just + ** using the io-error infrastructure to test that SQLite handles this + ** function failing. This function could fail if, for example, the + ** current working directory has been unlinked. + */ + SimulateIOError( return SQLITE_ERROR ); + if ( sqlite3_data_directory && !winIsVerbatimPathname(zRelative) ){ + /* + ** NOTE: We are dealing with a relative path name and the data + ** directory has been set. Therefore, use it as the basis + ** for converting the relative path name to an absolute + ** one by prepending the data directory and a backslash. + */ + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s", + sqlite3_data_directory, winGetDirSep(), zRelative); + return SQLITE_OK; + } + zConverted = winConvertFromUtf8Filename(zRelative); + if( zConverted==0 ){ + return SQLITE_IOERR_NOMEM_BKPT; + } + if( osIsNT() ){ + LPWSTR zTemp; + nByte = osGetFullPathNameW((LPCWSTR)zConverted, 0, 0, 0); + if( nByte==0 ){ + sqlite3_free(zConverted); + return winLogError(SQLITE_CANTOPEN_FULLPATH, osGetLastError(), + "winFullPathname1", zRelative); + } + nByte += 3; + zTemp = sqlite3MallocZero( nByte*sizeof(zTemp[0]) ); + if( zTemp==0 ){ + sqlite3_free(zConverted); + return SQLITE_IOERR_NOMEM_BKPT; + } + nByte = osGetFullPathNameW((LPCWSTR)zConverted, nByte, zTemp, 0); + if( nByte==0 ){ + sqlite3_free(zConverted); + sqlite3_free(zTemp); + return winLogError(SQLITE_CANTOPEN_FULLPATH, osGetLastError(), + "winFullPathname2", zRelative); + } + sqlite3_free(zConverted); + zOut = winUnicodeToUtf8(zTemp); + sqlite3_free(zTemp); + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + char *zTemp; + nByte = osGetFullPathNameA((char*)zConverted, 0, 0, 0); + if( nByte==0 ){ + sqlite3_free(zConverted); + return winLogError(SQLITE_CANTOPEN_FULLPATH, osGetLastError(), + "winFullPathname3", zRelative); + } + nByte += 3; + zTemp = sqlite3MallocZero( nByte*sizeof(zTemp[0]) ); + if( zTemp==0 ){ + sqlite3_free(zConverted); + return SQLITE_IOERR_NOMEM_BKPT; + } + nByte = osGetFullPathNameA((char*)zConverted, nByte, zTemp, 0); + if( nByte==0 ){ + sqlite3_free(zConverted); + sqlite3_free(zTemp); + return winLogError(SQLITE_CANTOPEN_FULLPATH, osGetLastError(), + "winFullPathname4", zRelative); + } + sqlite3_free(zConverted); + zOut = winMbcsToUtf8(zTemp, osAreFileApisANSI()); + sqlite3_free(zTemp); + } +#endif + if( zOut ){ + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zOut); + sqlite3_free(zOut); + return SQLITE_OK; + }else{ + return SQLITE_IOERR_NOMEM_BKPT; + } +#endif +} + +#ifndef SQLITE_OMIT_LOAD_EXTENSION +/* +** Interfaces for opening a shared library, finding entry points +** within the shared library, and closing the shared library. +*/ +static void *winDlOpen(sqlite3_vfs *pVfs, const char *zFilename){ + HANDLE h; +#if defined(__CYGWIN__) + int nFull = pVfs->mxPathname+1; + char *zFull = sqlite3MallocZero( nFull ); + void *zConverted = 0; + if( zFull==0 ){ + OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0)); + return 0; + } + if( winFullPathname(pVfs, zFilename, nFull, zFull)!=SQLITE_OK ){ + sqlite3_free(zFull); + OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0)); + return 0; + } + zConverted = winConvertFromUtf8Filename(zFull); + sqlite3_free(zFull); +#else + void *zConverted = winConvertFromUtf8Filename(zFilename); + UNUSED_PARAMETER(pVfs); +#endif + if( zConverted==0 ){ + OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0)); + return 0; + } + if( osIsNT() ){ +#if SQLITE_OS_WINRT + h = osLoadPackagedLibrary((LPCWSTR)zConverted, 0); +#else + h = osLoadLibraryW((LPCWSTR)zConverted); +#endif + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + h = osLoadLibraryA((char*)zConverted); + } +#endif + OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)h)); + sqlite3_free(zConverted); + return (void*)h; +} +static void winDlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){ + UNUSED_PARAMETER(pVfs); + winGetLastErrorMsg(osGetLastError(), nBuf, zBufOut); +} +static void (*winDlSym(sqlite3_vfs *pVfs,void *pH,const char *zSym))(void){ + FARPROC proc; + UNUSED_PARAMETER(pVfs); + proc = osGetProcAddressA((HANDLE)pH, zSym); + OSTRACE(("DLSYM handle=%p, symbol=%s, address=%p\n", + (void*)pH, zSym, (void*)proc)); + return (void(*)(void))proc; +} +static void winDlClose(sqlite3_vfs *pVfs, void *pHandle){ + UNUSED_PARAMETER(pVfs); + osFreeLibrary((HANDLE)pHandle); + OSTRACE(("DLCLOSE handle=%p\n", (void*)pHandle)); +} +#else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */ + #define winDlOpen 0 + #define winDlError 0 + #define winDlSym 0 + #define winDlClose 0 +#endif + +/* State information for the randomness gatherer. */ +typedef struct EntropyGatherer EntropyGatherer; +struct EntropyGatherer { + unsigned char *a; /* Gather entropy into this buffer */ + int na; /* Size of a[] in bytes */ + int i; /* XOR next input into a[i] */ + int nXor; /* Number of XOR operations done */ +}; + +#if !defined(SQLITE_TEST) && !defined(SQLITE_OMIT_RANDOMNESS) +/* Mix sz bytes of entropy into p. */ +static void xorMemory(EntropyGatherer *p, unsigned char *x, int sz){ + int j, k; + for(j=0, k=p->i; ja[k++] ^= x[j]; + if( k>=p->na ) k = 0; + } + p->i = k; + p->nXor += sz; +} +#endif /* !defined(SQLITE_TEST) && !defined(SQLITE_OMIT_RANDOMNESS) */ + +/* +** Write up to nBuf bytes of randomness into zBuf. +*/ +static int winRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf){ +#if defined(SQLITE_TEST) || defined(SQLITE_OMIT_RANDOMNESS) + UNUSED_PARAMETER(pVfs); + memset(zBuf, 0, nBuf); + return nBuf; +#else + EntropyGatherer e; + UNUSED_PARAMETER(pVfs); + memset(zBuf, 0, nBuf); + e.a = (unsigned char*)zBuf; + e.na = nBuf; + e.nXor = 0; + e.i = 0; + { + SYSTEMTIME x; + osGetSystemTime(&x); + xorMemory(&e, (unsigned char*)&x, sizeof(SYSTEMTIME)); + } + { + DWORD pid = osGetCurrentProcessId(); + xorMemory(&e, (unsigned char*)&pid, sizeof(DWORD)); + } +#if SQLITE_OS_WINRT + { + ULONGLONG cnt = osGetTickCount64(); + xorMemory(&e, (unsigned char*)&cnt, sizeof(ULONGLONG)); + } +#else + { + DWORD cnt = osGetTickCount(); + xorMemory(&e, (unsigned char*)&cnt, sizeof(DWORD)); + } +#endif /* SQLITE_OS_WINRT */ + { + LARGE_INTEGER i; + osQueryPerformanceCounter(&i); + xorMemory(&e, (unsigned char*)&i, sizeof(LARGE_INTEGER)); + } +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_WIN32_USE_UUID + { + UUID id; + memset(&id, 0, sizeof(UUID)); + osUuidCreate(&id); + xorMemory(&e, (unsigned char*)&id, sizeof(UUID)); + memset(&id, 0, sizeof(UUID)); + osUuidCreateSequential(&id); + xorMemory(&e, (unsigned char*)&id, sizeof(UUID)); + } +#endif /* !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_WIN32_USE_UUID */ + return e.nXor>nBuf ? nBuf : e.nXor; +#endif /* defined(SQLITE_TEST) || defined(SQLITE_OMIT_RANDOMNESS) */ +} + + +/* +** Sleep for a little while. Return the amount of time slept. +*/ +static int winSleep(sqlite3_vfs *pVfs, int microsec){ + sqlite3_win32_sleep((microsec+999)/1000); + UNUSED_PARAMETER(pVfs); + return ((microsec+999)/1000)*1000; +} + +/* +** The following variable, if set to a non-zero value, is interpreted as +** the number of seconds since 1970 and is used to set the result of +** sqlite3OsCurrentTime() during testing. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */ +#endif + +/* +** Find the current time (in Universal Coordinated Time). Write into *piNow +** the current time and date as a Julian Day number times 86_400_000. In +** other words, write into *piNow the number of milliseconds since the Julian +** epoch of noon in Greenwich on November 24, 4714 B.C according to the +** proleptic Gregorian calendar. +** +** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date +** cannot be found. +*/ +static int winCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *piNow){ + /* FILETIME structure is a 64-bit value representing the number of + 100-nanosecond intervals since January 1, 1601 (= JD 2305813.5). + */ + FILETIME ft; + static const sqlite3_int64 winFiletimeEpoch = 23058135*(sqlite3_int64)8640000; +#ifdef SQLITE_TEST + static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000; +#endif + /* 2^32 - to avoid use of LL and warnings in gcc */ + static const sqlite3_int64 max32BitValue = + (sqlite3_int64)2000000000 + (sqlite3_int64)2000000000 + + (sqlite3_int64)294967296; + +#if SQLITE_OS_WINCE + SYSTEMTIME time; + osGetSystemTime(&time); + /* if SystemTimeToFileTime() fails, it returns zero. */ + if (!osSystemTimeToFileTime(&time,&ft)){ + return SQLITE_ERROR; + } +#else + osGetSystemTimeAsFileTime( &ft ); +#endif + + *piNow = winFiletimeEpoch + + ((((sqlite3_int64)ft.dwHighDateTime)*max32BitValue) + + (sqlite3_int64)ft.dwLowDateTime)/(sqlite3_int64)10000; + +#ifdef SQLITE_TEST + if( sqlite3_current_time ){ + *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch; + } +#endif + UNUSED_PARAMETER(pVfs); + return SQLITE_OK; +} + +/* +** Find the current time (in Universal Coordinated Time). Write the +** current time and date as a Julian Day number into *prNow and +** return 0. Return 1 if the time and date cannot be found. +*/ +static int winCurrentTime(sqlite3_vfs *pVfs, double *prNow){ + int rc; + sqlite3_int64 i; + rc = winCurrentTimeInt64(pVfs, &i); + if( !rc ){ + *prNow = i/86400000.0; + } + return rc; +} + +/* +** The idea is that this function works like a combination of +** GetLastError() and FormatMessage() on Windows (or errno and +** strerror_r() on Unix). After an error is returned by an OS +** function, SQLite calls this function with zBuf pointing to +** a buffer of nBuf bytes. The OS layer should populate the +** buffer with a nul-terminated UTF-8 encoded error message +** describing the last IO error to have occurred within the calling +** thread. +** +** If the error message is too large for the supplied buffer, +** it should be truncated. The return value of xGetLastError +** is zero if the error message fits in the buffer, or non-zero +** otherwise (if the message was truncated). If non-zero is returned, +** then it is not necessary to include the nul-terminator character +** in the output buffer. +** +** Not supplying an error message will have no adverse effect +** on SQLite. It is fine to have an implementation that never +** returns an error message: +** +** int xGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){ +** assert(zBuf[0]=='\0'); +** return 0; +** } +** +** However if an error message is supplied, it will be incorporated +** by sqlite into the error message available to the user using +** sqlite3_errmsg(), possibly making IO errors easier to debug. +*/ +static int winGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){ + DWORD e = osGetLastError(); + UNUSED_PARAMETER(pVfs); + if( nBuf>0 ) winGetLastErrorMsg(e, nBuf, zBuf); + return e; +} + +/* +** Initialize and deinitialize the operating system interface. +*/ +SQLITE_API int sqlite3_os_init(void){ + static sqlite3_vfs winVfs = { + 3, /* iVersion */ + sizeof(winFile), /* szOsFile */ + SQLITE_WIN32_MAX_PATH_BYTES, /* mxPathname */ + 0, /* pNext */ + "win32", /* zName */ + &winAppData, /* pAppData */ + winOpen, /* xOpen */ + winDelete, /* xDelete */ + winAccess, /* xAccess */ + winFullPathname, /* xFullPathname */ + winDlOpen, /* xDlOpen */ + winDlError, /* xDlError */ + winDlSym, /* xDlSym */ + winDlClose, /* xDlClose */ + winRandomness, /* xRandomness */ + winSleep, /* xSleep */ + winCurrentTime, /* xCurrentTime */ + winGetLastError, /* xGetLastError */ + winCurrentTimeInt64, /* xCurrentTimeInt64 */ + winSetSystemCall, /* xSetSystemCall */ + winGetSystemCall, /* xGetSystemCall */ + winNextSystemCall, /* xNextSystemCall */ + }; +#if defined(SQLITE_WIN32_HAS_WIDE) + static sqlite3_vfs winLongPathVfs = { + 3, /* iVersion */ + sizeof(winFile), /* szOsFile */ + SQLITE_WINNT_MAX_PATH_BYTES, /* mxPathname */ + 0, /* pNext */ + "win32-longpath", /* zName */ + &winAppData, /* pAppData */ + winOpen, /* xOpen */ + winDelete, /* xDelete */ + winAccess, /* xAccess */ + winFullPathname, /* xFullPathname */ + winDlOpen, /* xDlOpen */ + winDlError, /* xDlError */ + winDlSym, /* xDlSym */ + winDlClose, /* xDlClose */ + winRandomness, /* xRandomness */ + winSleep, /* xSleep */ + winCurrentTime, /* xCurrentTime */ + winGetLastError, /* xGetLastError */ + winCurrentTimeInt64, /* xCurrentTimeInt64 */ + winSetSystemCall, /* xSetSystemCall */ + winGetSystemCall, /* xGetSystemCall */ + winNextSystemCall, /* xNextSystemCall */ + }; +#endif + static sqlite3_vfs winNolockVfs = { + 3, /* iVersion */ + sizeof(winFile), /* szOsFile */ + SQLITE_WIN32_MAX_PATH_BYTES, /* mxPathname */ + 0, /* pNext */ + "win32-none", /* zName */ + &winNolockAppData, /* pAppData */ + winOpen, /* xOpen */ + winDelete, /* xDelete */ + winAccess, /* xAccess */ + winFullPathname, /* xFullPathname */ + winDlOpen, /* xDlOpen */ + winDlError, /* xDlError */ + winDlSym, /* xDlSym */ + winDlClose, /* xDlClose */ + winRandomness, /* xRandomness */ + winSleep, /* xSleep */ + winCurrentTime, /* xCurrentTime */ + winGetLastError, /* xGetLastError */ + winCurrentTimeInt64, /* xCurrentTimeInt64 */ + winSetSystemCall, /* xSetSystemCall */ + winGetSystemCall, /* xGetSystemCall */ + winNextSystemCall, /* xNextSystemCall */ + }; +#if defined(SQLITE_WIN32_HAS_WIDE) + static sqlite3_vfs winLongPathNolockVfs = { + 3, /* iVersion */ + sizeof(winFile), /* szOsFile */ + SQLITE_WINNT_MAX_PATH_BYTES, /* mxPathname */ + 0, /* pNext */ + "win32-longpath-none", /* zName */ + &winNolockAppData, /* pAppData */ + winOpen, /* xOpen */ + winDelete, /* xDelete */ + winAccess, /* xAccess */ + winFullPathname, /* xFullPathname */ + winDlOpen, /* xDlOpen */ + winDlError, /* xDlError */ + winDlSym, /* xDlSym */ + winDlClose, /* xDlClose */ + winRandomness, /* xRandomness */ + winSleep, /* xSleep */ + winCurrentTime, /* xCurrentTime */ + winGetLastError, /* xGetLastError */ + winCurrentTimeInt64, /* xCurrentTimeInt64 */ + winSetSystemCall, /* xSetSystemCall */ + winGetSystemCall, /* xGetSystemCall */ + winNextSystemCall, /* xNextSystemCall */ + }; +#endif + + /* Double-check that the aSyscall[] array has been constructed + ** correctly. See ticket [bb3a86e890c8e96ab] */ + assert( ArraySize(aSyscall)==80 ); + + /* get memory map allocation granularity */ + memset(&winSysInfo, 0, sizeof(SYSTEM_INFO)); +#if SQLITE_OS_WINRT + osGetNativeSystemInfo(&winSysInfo); +#else + osGetSystemInfo(&winSysInfo); +#endif + assert( winSysInfo.dwAllocationGranularity>0 ); + assert( winSysInfo.dwPageSize>0 ); + + sqlite3_vfs_register(&winVfs, 1); + +#if defined(SQLITE_WIN32_HAS_WIDE) + sqlite3_vfs_register(&winLongPathVfs, 0); +#endif + + sqlite3_vfs_register(&winNolockVfs, 0); + +#if defined(SQLITE_WIN32_HAS_WIDE) + sqlite3_vfs_register(&winLongPathNolockVfs, 0); +#endif + +#ifndef SQLITE_OMIT_WAL + winBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1); +#endif + + return SQLITE_OK; +} + +SQLITE_API int sqlite3_os_end(void){ +#if SQLITE_OS_WINRT + if( sleepObj!=NULL ){ + osCloseHandle(sleepObj); + sleepObj = NULL; + } +#endif + +#ifndef SQLITE_OMIT_WAL + winBigLock = 0; +#endif + + return SQLITE_OK; +} + +#endif /* SQLITE_OS_WIN */ + +/************** End of os_win.c **********************************************/ +/************** Begin file memdb.c *******************************************/ +/* +** 2016-09-07 +** +** 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 an in-memory VFS. A database is held as a contiguous +** block of memory. +** +** This file also implements interface sqlite3_serialize() and +** sqlite3_deserialize(). +*/ +/* #include "sqliteInt.h" */ +#ifdef SQLITE_ENABLE_DESERIALIZE + +/* +** Forward declaration of objects used by this utility +*/ +typedef struct sqlite3_vfs MemVfs; +typedef struct MemFile MemFile; + +/* Access to a lower-level VFS that (might) implement dynamic loading, +** access to randomness, etc. +*/ +#define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData)) + +/* An open file */ +struct MemFile { + sqlite3_file base; /* IO methods */ + sqlite3_int64 sz; /* Size of the file */ + sqlite3_int64 szAlloc; /* Space allocated to aData */ + sqlite3_int64 szMax; /* Maximum allowed size of the file */ + unsigned char *aData; /* content of the file */ + int nMmap; /* Number of memory mapped pages */ + unsigned mFlags; /* Flags */ + int eLock; /* Most recent lock against this file */ +}; + +/* +** Methods for MemFile +*/ +static int memdbClose(sqlite3_file*); +static int memdbRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); +static int memdbWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst); +static int memdbTruncate(sqlite3_file*, sqlite3_int64 size); +static int memdbSync(sqlite3_file*, int flags); +static int memdbFileSize(sqlite3_file*, sqlite3_int64 *pSize); +static int memdbLock(sqlite3_file*, int); +/* static int memdbCheckReservedLock(sqlite3_file*, int *pResOut);// not used */ +static int memdbFileControl(sqlite3_file*, int op, void *pArg); +/* static int memdbSectorSize(sqlite3_file*); // not used */ +static int memdbDeviceCharacteristics(sqlite3_file*); +static int memdbFetch(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp); +static int memdbUnfetch(sqlite3_file*, sqlite3_int64 iOfst, void *p); + +/* +** Methods for MemVfs +*/ +static int memdbOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *); +/* static int memdbDelete(sqlite3_vfs*, const char *zName, int syncDir); */ +static int memdbAccess(sqlite3_vfs*, const char *zName, int flags, int *); +static int memdbFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut); +static void *memdbDlOpen(sqlite3_vfs*, const char *zFilename); +static void memdbDlError(sqlite3_vfs*, int nByte, char *zErrMsg); +static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void); +static void memdbDlClose(sqlite3_vfs*, void*); +static int memdbRandomness(sqlite3_vfs*, int nByte, char *zOut); +static int memdbSleep(sqlite3_vfs*, int microseconds); +/* static int memdbCurrentTime(sqlite3_vfs*, double*); */ +static int memdbGetLastError(sqlite3_vfs*, int, char *); +static int memdbCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*); + +static sqlite3_vfs memdb_vfs = { + 2, /* iVersion */ + 0, /* szOsFile (set when registered) */ + 1024, /* mxPathname */ + 0, /* pNext */ + "memdb", /* zName */ + 0, /* pAppData (set when registered) */ + memdbOpen, /* xOpen */ + 0, /* memdbDelete, */ /* xDelete */ + memdbAccess, /* xAccess */ + memdbFullPathname, /* xFullPathname */ + memdbDlOpen, /* xDlOpen */ + memdbDlError, /* xDlError */ + memdbDlSym, /* xDlSym */ + memdbDlClose, /* xDlClose */ + memdbRandomness, /* xRandomness */ + memdbSleep, /* xSleep */ + 0, /* memdbCurrentTime, */ /* xCurrentTime */ + memdbGetLastError, /* xGetLastError */ + memdbCurrentTimeInt64 /* xCurrentTimeInt64 */ +}; + +static const sqlite3_io_methods memdb_io_methods = { + 3, /* iVersion */ + memdbClose, /* xClose */ + memdbRead, /* xRead */ + memdbWrite, /* xWrite */ + memdbTruncate, /* xTruncate */ + memdbSync, /* xSync */ + memdbFileSize, /* xFileSize */ + memdbLock, /* xLock */ + memdbLock, /* xUnlock - same as xLock in this case */ + 0, /* memdbCheckReservedLock, */ /* xCheckReservedLock */ + memdbFileControl, /* xFileControl */ + 0, /* memdbSectorSize,*/ /* xSectorSize */ + memdbDeviceCharacteristics, /* xDeviceCharacteristics */ + 0, /* xShmMap */ + 0, /* xShmLock */ + 0, /* xShmBarrier */ + 0, /* xShmUnmap */ + memdbFetch, /* xFetch */ + memdbUnfetch /* xUnfetch */ +}; + + + +/* +** Close an memdb-file. +** +** The pData pointer is owned by the application, so there is nothing +** to free. Unless the SQLITE_DESERIALIZE_FREEONCLOSE flag is set, +** in which case we own the pData pointer and need to free it. +*/ +static int memdbClose(sqlite3_file *pFile){ + MemFile *p = (MemFile *)pFile; + if( p->mFlags & SQLITE_DESERIALIZE_FREEONCLOSE ){ + sqlite3_free(p->aData); + } + return SQLITE_OK; +} + +/* +** Read data from an memdb-file. +*/ +static int memdbRead( + sqlite3_file *pFile, + void *zBuf, + int iAmt, + sqlite_int64 iOfst +){ + MemFile *p = (MemFile *)pFile; + if( iOfst+iAmt>p->sz ){ + memset(zBuf, 0, iAmt); + if( iOfstsz ) memcpy(zBuf, p->aData+iOfst, p->sz - iOfst); + return SQLITE_IOERR_SHORT_READ; + } + memcpy(zBuf, p->aData+iOfst, iAmt); + return SQLITE_OK; +} + +/* +** Try to enlarge the memory allocation to hold at least sz bytes +*/ +static int memdbEnlarge(MemFile *p, sqlite3_int64 newSz){ + unsigned char *pNew; + if( (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)==0 || p->nMmap>0 ){ + return SQLITE_FULL; + } + if( newSz>p->szMax ){ + return SQLITE_FULL; + } + newSz *= 2; + if( newSz>p->szMax ) newSz = p->szMax; + pNew = sqlite3Realloc(p->aData, newSz); + if( pNew==0 ) return SQLITE_NOMEM; + p->aData = pNew; + p->szAlloc = newSz; + return SQLITE_OK; +} + +/* +** Write data to an memdb-file. +*/ +static int memdbWrite( + sqlite3_file *pFile, + const void *z, + int iAmt, + sqlite_int64 iOfst +){ + MemFile *p = (MemFile *)pFile; + if( NEVER(p->mFlags & SQLITE_DESERIALIZE_READONLY) ) return SQLITE_READONLY; + if( iOfst+iAmt>p->sz ){ + int rc; + if( iOfst+iAmt>p->szAlloc + && (rc = memdbEnlarge(p, iOfst+iAmt))!=SQLITE_OK + ){ + return rc; + } + if( iOfst>p->sz ) memset(p->aData+p->sz, 0, iOfst-p->sz); + p->sz = iOfst+iAmt; + } + memcpy(p->aData+iOfst, z, iAmt); + return SQLITE_OK; +} + +/* +** Truncate an memdb-file. +** +** In rollback mode (which is always the case for memdb, as it does not +** support WAL mode) the truncate() method is only used to reduce +** the size of a file, never to increase the size. +*/ +static int memdbTruncate(sqlite3_file *pFile, sqlite_int64 size){ + MemFile *p = (MemFile *)pFile; + if( NEVER(size>p->sz) ) return SQLITE_FULL; + p->sz = size; + return SQLITE_OK; +} + +/* +** Sync an memdb-file. +*/ +static int memdbSync(sqlite3_file *pFile, int flags){ + return SQLITE_OK; +} + +/* +** Return the current file-size of an memdb-file. +*/ +static int memdbFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ + MemFile *p = (MemFile *)pFile; + *pSize = p->sz; + return SQLITE_OK; +} + +/* +** Lock an memdb-file. +*/ +static int memdbLock(sqlite3_file *pFile, int eLock){ + MemFile *p = (MemFile *)pFile; + if( eLock>SQLITE_LOCK_SHARED + && (p->mFlags & SQLITE_DESERIALIZE_READONLY)!=0 + ){ + return SQLITE_READONLY; + } + p->eLock = eLock; + return SQLITE_OK; +} + +#if 0 /* Never used because memdbAccess() always returns false */ +/* +** Check if another file-handle holds a RESERVED lock on an memdb-file. +*/ +static int memdbCheckReservedLock(sqlite3_file *pFile, int *pResOut){ + *pResOut = 0; + return SQLITE_OK; +} +#endif + +/* +** File control method. For custom operations on an memdb-file. +*/ +static int memdbFileControl(sqlite3_file *pFile, int op, void *pArg){ + MemFile *p = (MemFile *)pFile; + int rc = SQLITE_NOTFOUND; + if( op==SQLITE_FCNTL_VFSNAME ){ + *(char**)pArg = sqlite3_mprintf("memdb(%p,%lld)", p->aData, p->sz); + rc = SQLITE_OK; + } + if( op==SQLITE_FCNTL_SIZE_LIMIT ){ + sqlite3_int64 iLimit = *(sqlite3_int64*)pArg; + if( iLimitsz ){ + if( iLimit<0 ){ + iLimit = p->szMax; + }else{ + iLimit = p->sz; + } + } + p->szMax = iLimit; + *(sqlite3_int64*)pArg = iLimit; + rc = SQLITE_OK; + } + return rc; +} + +#if 0 /* Not used because of SQLITE_IOCAP_POWERSAFE_OVERWRITE */ +/* +** Return the sector-size in bytes for an memdb-file. +*/ +static int memdbSectorSize(sqlite3_file *pFile){ + return 1024; +} +#endif + +/* +** Return the device characteristic flags supported by an memdb-file. +*/ +static int memdbDeviceCharacteristics(sqlite3_file *pFile){ + return SQLITE_IOCAP_ATOMIC | + SQLITE_IOCAP_POWERSAFE_OVERWRITE | + SQLITE_IOCAP_SAFE_APPEND | + SQLITE_IOCAP_SEQUENTIAL; +} + +/* Fetch a page of a memory-mapped file */ +static int memdbFetch( + sqlite3_file *pFile, + sqlite3_int64 iOfst, + int iAmt, + void **pp +){ + MemFile *p = (MemFile *)pFile; + if( iOfst+iAmt>p->sz ){ + *pp = 0; + }else{ + p->nMmap++; + *pp = (void*)(p->aData + iOfst); + } + return SQLITE_OK; +} + +/* Release a memory-mapped page */ +static int memdbUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){ + MemFile *p = (MemFile *)pFile; + p->nMmap--; + return SQLITE_OK; +} + +/* +** Open an mem file handle. +*/ +static int memdbOpen( + sqlite3_vfs *pVfs, + const char *zName, + sqlite3_file *pFile, + int flags, + int *pOutFlags +){ + MemFile *p = (MemFile*)pFile; + if( (flags & SQLITE_OPEN_MAIN_DB)==0 ){ + return ORIGVFS(pVfs)->xOpen(ORIGVFS(pVfs), zName, pFile, flags, pOutFlags); + } + memset(p, 0, sizeof(*p)); + p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE | SQLITE_DESERIALIZE_FREEONCLOSE; + assert( pOutFlags!=0 ); /* True because flags==SQLITE_OPEN_MAIN_DB */ + *pOutFlags = flags | SQLITE_OPEN_MEMORY; + pFile->pMethods = &memdb_io_methods; + p->szMax = sqlite3GlobalConfig.mxMemdbSize; + return SQLITE_OK; +} + +#if 0 /* Only used to delete rollback journals, super-journals, and WAL + ** files, none of which exist in memdb. So this routine is never used */ +/* +** Delete the file located at zPath. If the dirSync argument is true, +** ensure the file-system modifications are synced to disk before +** returning. +*/ +static int memdbDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ + return SQLITE_IOERR_DELETE; +} +#endif + +/* +** Test for access permissions. Return true if the requested permission +** is available, or false otherwise. +** +** With memdb, no files ever exist on disk. So always return false. +*/ +static int memdbAccess( + sqlite3_vfs *pVfs, + const char *zPath, + int flags, + int *pResOut +){ + *pResOut = 0; + return SQLITE_OK; +} + +/* +** Populate buffer zOut with the full canonical pathname corresponding +** to the pathname in zPath. zOut is guaranteed to point to a buffer +** of at least (INST_MAX_PATHNAME+1) bytes. +*/ +static int memdbFullPathname( + sqlite3_vfs *pVfs, + const char *zPath, + int nOut, + char *zOut +){ + sqlite3_snprintf(nOut, zOut, "%s", zPath); + return SQLITE_OK; +} + +/* +** Open the dynamic library located at zPath and return a handle. +*/ +static void *memdbDlOpen(sqlite3_vfs *pVfs, const char *zPath){ + return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath); +} + +/* +** Populate the buffer zErrMsg (size nByte bytes) with a human readable +** utf-8 string describing the most recent error encountered associated +** with dynamic libraries. +*/ +static void memdbDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){ + ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg); +} + +/* +** Return a pointer to the symbol zSymbol in the dynamic library pHandle. +*/ +static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){ + return ORIGVFS(pVfs)->xDlSym(ORIGVFS(pVfs), p, zSym); +} + +/* +** Close the dynamic library handle pHandle. +*/ +static void memdbDlClose(sqlite3_vfs *pVfs, void *pHandle){ + ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle); +} + +/* +** Populate the buffer pointed to by zBufOut with nByte bytes of +** random data. +*/ +static int memdbRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ + return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut); +} + +/* +** Sleep for nMicro microseconds. Return the number of microseconds +** actually slept. +*/ +static int memdbSleep(sqlite3_vfs *pVfs, int nMicro){ + return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro); +} + +#if 0 /* Never used. Modern cores only call xCurrentTimeInt64() */ +/* +** Return the current time as a Julian Day number in *pTimeOut. +*/ +static int memdbCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ + return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut); +} +#endif + +static int memdbGetLastError(sqlite3_vfs *pVfs, int a, char *b){ + return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b); +} +static int memdbCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){ + return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p); +} + +/* +** Translate a database connection pointer and schema name into a +** MemFile pointer. +*/ +static MemFile *memdbFromDbSchema(sqlite3 *db, const char *zSchema){ + MemFile *p = 0; + int rc = sqlite3_file_control(db, zSchema, SQLITE_FCNTL_FILE_POINTER, &p); + if( rc ) return 0; + if( p->base.pMethods!=&memdb_io_methods ) return 0; + return p; +} + +/* +** Return the serialization of a database +*/ +SQLITE_API unsigned char *sqlite3_serialize( + sqlite3 *db, /* The database connection */ + const char *zSchema, /* Which database within the connection */ + sqlite3_int64 *piSize, /* Write size here, if not NULL */ + unsigned int mFlags /* Maybe SQLITE_SERIALIZE_NOCOPY */ +){ + MemFile *p; + int iDb; + Btree *pBt; + sqlite3_int64 sz; + int szPage = 0; + sqlite3_stmt *pStmt = 0; + unsigned char *pOut; + char *zSql; + int rc; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + + if( zSchema==0 ) zSchema = db->aDb[0].zDbSName; + p = memdbFromDbSchema(db, zSchema); + iDb = sqlite3FindDbName(db, zSchema); + if( piSize ) *piSize = -1; + if( iDb<0 ) return 0; + if( p ){ + if( piSize ) *piSize = p->sz; + if( mFlags & SQLITE_SERIALIZE_NOCOPY ){ + pOut = p->aData; + }else{ + pOut = sqlite3_malloc64( p->sz ); + if( pOut ) memcpy(pOut, p->aData, p->sz); + } + return pOut; + } + pBt = db->aDb[iDb].pBt; + if( pBt==0 ) return 0; + szPage = sqlite3BtreeGetPageSize(pBt); + zSql = sqlite3_mprintf("PRAGMA \"%w\".page_count", zSchema); + rc = zSql ? sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0) : SQLITE_NOMEM; + sqlite3_free(zSql); + if( rc ) return 0; + rc = sqlite3_step(pStmt); + if( rc!=SQLITE_ROW ){ + pOut = 0; + }else{ + sz = sqlite3_column_int64(pStmt, 0)*szPage; + if( piSize ) *piSize = sz; + if( mFlags & SQLITE_SERIALIZE_NOCOPY ){ + pOut = 0; + }else{ + pOut = sqlite3_malloc64( sz ); + if( pOut ){ + int nPage = sqlite3_column_int(pStmt, 0); + Pager *pPager = sqlite3BtreePager(pBt); + int pgno; + for(pgno=1; pgno<=nPage; pgno++){ + DbPage *pPage = 0; + unsigned char *pTo = pOut + szPage*(sqlite3_int64)(pgno-1); + rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pPage, 0); + if( rc==SQLITE_OK ){ + memcpy(pTo, sqlite3PagerGetData(pPage), szPage); + }else{ + memset(pTo, 0, szPage); + } + sqlite3PagerUnref(pPage); + } + } + } + } + sqlite3_finalize(pStmt); + return pOut; +} + +/* Convert zSchema to a MemDB and initialize its content. +*/ +SQLITE_API int sqlite3_deserialize( + sqlite3 *db, /* The database connection */ + const char *zSchema, /* Which DB to reopen with the deserialization */ + unsigned char *pData, /* The serialized database content */ + sqlite3_int64 szDb, /* Number bytes in the deserialization */ + sqlite3_int64 szBuf, /* Total size of buffer pData[] */ + unsigned mFlags /* Zero or more SQLITE_DESERIALIZE_* flags */ +){ + MemFile *p; + char *zSql; + sqlite3_stmt *pStmt = 0; + int rc; + int iDb; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + return SQLITE_MISUSE_BKPT; + } + if( szDb<0 ) return SQLITE_MISUSE_BKPT; + if( szBuf<0 ) return SQLITE_MISUSE_BKPT; +#endif + + sqlite3_mutex_enter(db->mutex); + if( zSchema==0 ) zSchema = db->aDb[0].zDbSName; + iDb = sqlite3FindDbName(db, zSchema); + if( iDb<0 ){ + rc = SQLITE_ERROR; + goto end_deserialize; + } + zSql = sqlite3_mprintf("ATTACH x AS %Q", zSchema); + if( zSql==0 ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); + sqlite3_free(zSql); + } + if( rc ) goto end_deserialize; + db->init.iDb = (u8)iDb; + db->init.reopenMemdb = 1; + rc = sqlite3_step(pStmt); + db->init.reopenMemdb = 0; + if( rc!=SQLITE_DONE ){ + rc = SQLITE_ERROR; + goto end_deserialize; + } + p = memdbFromDbSchema(db, zSchema); + if( p==0 ){ + rc = SQLITE_ERROR; + }else{ + p->aData = pData; + pData = 0; + p->sz = szDb; + p->szAlloc = szBuf; + p->szMax = szBuf; + if( p->szMaxszMax = sqlite3GlobalConfig.mxMemdbSize; + } + p->mFlags = mFlags; + rc = SQLITE_OK; + } + +end_deserialize: + sqlite3_finalize(pStmt); + if( pData && (mFlags & SQLITE_DESERIALIZE_FREEONCLOSE)!=0 ){ + sqlite3_free(pData); + } + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** This routine is called when the extension is loaded. +** Register the new VFS. +*/ +SQLITE_PRIVATE int sqlite3MemdbInit(void){ + sqlite3_vfs *pLower = sqlite3_vfs_find(0); + int sz = pLower->szOsFile; + memdb_vfs.pAppData = pLower; + /* The following conditional can only be true when compiled for + ** Windows x86 and SQLITE_MAX_MMAP_SIZE=0. We always leave + ** it in, to be safe, but it is marked as NO_TEST since there + ** is no way to reach it under most builds. */ + if( szBITVEC_NBIT and iDivisor==0 then Bitvec.u.aHash[] is +** a hash table that will hold up to BITVEC_MXHASH distinct values. +** +** Otherwise, the value i is redirected into one of BITVEC_NPTR +** sub-bitmaps pointed to by Bitvec.u.apSub[]. Each subbitmap +** handles up to iDivisor separate values of i. apSub[0] holds +** values between 1 and iDivisor. apSub[1] holds values between +** iDivisor+1 and 2*iDivisor. apSub[N] holds values between +** N*iDivisor+1 and (N+1)*iDivisor. Each subbitmap is normalized +** to hold deal with values between 1 and iDivisor. +*/ +struct Bitvec { + u32 iSize; /* Maximum bit index. Max iSize is 4,294,967,296. */ + u32 nSet; /* Number of bits that are set - only valid for aHash + ** element. Max is BITVEC_NINT. For BITVEC_SZ of 512, + ** this would be 125. */ + u32 iDivisor; /* Number of bits handled by each apSub[] entry. */ + /* Should >=0 for apSub element. */ + /* Max iDivisor is max(u32) / BITVEC_NPTR + 1. */ + /* For a BITVEC_SZ of 512, this would be 34,359,739. */ + union { + BITVEC_TELEM aBitmap[BITVEC_NELEM]; /* Bitmap representation */ + u32 aHash[BITVEC_NINT]; /* Hash table representation */ + Bitvec *apSub[BITVEC_NPTR]; /* Recursive representation */ + } u; +}; + +/* +** Create a new bitmap object able to handle bits between 0 and iSize, +** inclusive. Return a pointer to the new object. Return NULL if +** malloc fails. +*/ +SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32 iSize){ + Bitvec *p; + assert( sizeof(*p)==BITVEC_SZ ); + p = sqlite3MallocZero( sizeof(*p) ); + if( p ){ + p->iSize = iSize; + } + return p; +} + +/* +** Check to see if the i-th bit is set. Return true or false. +** If p is NULL (if the bitmap has not been created) or if +** i is out of range, then return false. +*/ +SQLITE_PRIVATE int sqlite3BitvecTestNotNull(Bitvec *p, u32 i){ + assert( p!=0 ); + i--; + if( i>=p->iSize ) return 0; + while( p->iDivisor ){ + u32 bin = i/p->iDivisor; + i = i%p->iDivisor; + p = p->u.apSub[bin]; + if (!p) { + return 0; + } + } + if( p->iSize<=BITVEC_NBIT ){ + return (p->u.aBitmap[i/BITVEC_SZELEM] & (1<<(i&(BITVEC_SZELEM-1))))!=0; + } else{ + u32 h = BITVEC_HASH(i++); + while( p->u.aHash[h] ){ + if( p->u.aHash[h]==i ) return 1; + h = (h+1) % BITVEC_NINT; + } + return 0; + } +} +SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec *p, u32 i){ + return p!=0 && sqlite3BitvecTestNotNull(p,i); +} + +/* +** Set the i-th bit. Return 0 on success and an error code if +** anything goes wrong. +** +** This routine might cause sub-bitmaps to be allocated. Failing +** to get the memory needed to hold the sub-bitmap is the only +** that can go wrong with an insert, assuming p and i are valid. +** +** The calling function must ensure that p is a valid Bitvec object +** and that the value for "i" is within range of the Bitvec object. +** Otherwise the behavior is undefined. +*/ +SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec *p, u32 i){ + u32 h; + if( p==0 ) return SQLITE_OK; + assert( i>0 ); + assert( i<=p->iSize ); + i--; + while((p->iSize > BITVEC_NBIT) && p->iDivisor) { + u32 bin = i/p->iDivisor; + i = i%p->iDivisor; + if( p->u.apSub[bin]==0 ){ + p->u.apSub[bin] = sqlite3BitvecCreate( p->iDivisor ); + if( p->u.apSub[bin]==0 ) return SQLITE_NOMEM_BKPT; + } + p = p->u.apSub[bin]; + } + if( p->iSize<=BITVEC_NBIT ){ + p->u.aBitmap[i/BITVEC_SZELEM] |= 1 << (i&(BITVEC_SZELEM-1)); + return SQLITE_OK; + } + h = BITVEC_HASH(i++); + /* if there wasn't a hash collision, and this doesn't */ + /* completely fill the hash, then just add it without */ + /* worring about sub-dividing and re-hashing. */ + if( !p->u.aHash[h] ){ + if (p->nSet<(BITVEC_NINT-1)) { + goto bitvec_set_end; + } else { + goto bitvec_set_rehash; + } + } + /* there was a collision, check to see if it's already */ + /* in hash, if not, try to find a spot for it */ + do { + if( p->u.aHash[h]==i ) return SQLITE_OK; + h++; + if( h>=BITVEC_NINT ) h = 0; + } while( p->u.aHash[h] ); + /* we didn't find it in the hash. h points to the first */ + /* available free spot. check to see if this is going to */ + /* make our hash too "full". */ +bitvec_set_rehash: + if( p->nSet>=BITVEC_MXHASH ){ + unsigned int j; + int rc; + u32 *aiValues = sqlite3StackAllocRaw(0, sizeof(p->u.aHash)); + if( aiValues==0 ){ + return SQLITE_NOMEM_BKPT; + }else{ + memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash)); + memset(p->u.apSub, 0, sizeof(p->u.apSub)); + p->iDivisor = (p->iSize + BITVEC_NPTR - 1)/BITVEC_NPTR; + rc = sqlite3BitvecSet(p, i); + for(j=0; jnSet++; + p->u.aHash[h] = i; + return SQLITE_OK; +} + +/* +** Clear the i-th bit. +** +** pBuf must be a pointer to at least BITVEC_SZ bytes of temporary storage +** that BitvecClear can use to rebuilt its hash table. +*/ +SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec *p, u32 i, void *pBuf){ + if( p==0 ) return; + assert( i>0 ); + i--; + while( p->iDivisor ){ + u32 bin = i/p->iDivisor; + i = i%p->iDivisor; + p = p->u.apSub[bin]; + if (!p) { + return; + } + } + if( p->iSize<=BITVEC_NBIT ){ + p->u.aBitmap[i/BITVEC_SZELEM] &= ~(1 << (i&(BITVEC_SZELEM-1))); + }else{ + unsigned int j; + u32 *aiValues = pBuf; + memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash)); + memset(p->u.aHash, 0, sizeof(p->u.aHash)); + p->nSet = 0; + for(j=0; jnSet++; + while( p->u.aHash[h] ){ + h++; + if( h>=BITVEC_NINT ) h = 0; + } + p->u.aHash[h] = aiValues[j]; + } + } + } +} + +/* +** Destroy a bitmap object. Reclaim all memory used. +*/ +SQLITE_PRIVATE void sqlite3BitvecDestroy(Bitvec *p){ + if( p==0 ) return; + if( p->iDivisor ){ + unsigned int i; + for(i=0; iu.apSub[i]); + } + } + sqlite3_free(p); +} + +/* +** Return the value of the iSize parameter specified when Bitvec *p +** was created. +*/ +SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec *p){ + return p->iSize; +} + +#ifndef SQLITE_UNTESTABLE +/* +** Let V[] be an array of unsigned characters sufficient to hold +** up to N bits. Let I be an integer between 0 and N. 0<=I>3] |= (1<<(I&7)) +#define CLEARBIT(V,I) V[I>>3] &= ~(1<<(I&7)) +#define TESTBIT(V,I) (V[I>>3]&(1<<(I&7)))!=0 + +/* +** This routine runs an extensive test of the Bitvec code. +** +** The input is an array of integers that acts as a program +** to test the Bitvec. The integers are opcodes followed +** by 0, 1, or 3 operands, depending on the opcode. Another +** opcode follows immediately after the last operand. +** +** There are 6 opcodes numbered from 0 through 5. 0 is the +** "halt" opcode and causes the test to end. +** +** 0 Halt and return the number of errors +** 1 N S X Set N bits beginning with S and incrementing by X +** 2 N S X Clear N bits beginning with S and incrementing by X +** 3 N Set N randomly chosen bits +** 4 N Clear N randomly chosen bits +** 5 N S X Set N bits from S increment X in array only, not in bitvec +** +** The opcodes 1 through 4 perform set and clear operations are performed +** on both a Bitvec object and on a linear array of bits obtained from malloc. +** Opcode 5 works on the linear array only, not on the Bitvec. +** Opcode 5 is used to deliberately induce a fault in order to +** confirm that error detection works. +** +** At the conclusion of the test the linear array is compared +** against the Bitvec object. If there are any differences, +** an error is returned. If they are the same, zero is returned. +** +** If a memory allocation error occurs, return -1. +*/ +SQLITE_PRIVATE int sqlite3BitvecBuiltinTest(int sz, int *aOp){ + Bitvec *pBitvec = 0; + unsigned char *pV = 0; + int rc = -1; + int i, nx, pc, op; + void *pTmpSpace; + + /* Allocate the Bitvec to be tested and a linear array of + ** bits to act as the reference */ + pBitvec = sqlite3BitvecCreate( sz ); + pV = sqlite3MallocZero( (sz+7)/8 + 1 ); + pTmpSpace = sqlite3_malloc64(BITVEC_SZ); + if( pBitvec==0 || pV==0 || pTmpSpace==0 ) goto bitvec_end; + + /* NULL pBitvec tests */ + sqlite3BitvecSet(0, 1); + sqlite3BitvecClear(0, 1, pTmpSpace); + + /* Run the program */ + pc = 0; + while( (op = aOp[pc])!=0 ){ + switch( op ){ + case 1: + case 2: + case 5: { + nx = 4; + i = aOp[pc+2] - 1; + aOp[pc+2] += aOp[pc+3]; + break; + } + case 3: + case 4: + default: { + nx = 2; + sqlite3_randomness(sizeof(i), &i); + break; + } + } + if( (--aOp[pc+1]) > 0 ) nx = 0; + pc += nx; + i = (i & 0x7fffffff)%sz; + if( (op & 1)!=0 ){ + SETBIT(pV, (i+1)); + if( op!=5 ){ + if( sqlite3BitvecSet(pBitvec, i+1) ) goto bitvec_end; + } + }else{ + CLEARBIT(pV, (i+1)); + sqlite3BitvecClear(pBitvec, i+1, pTmpSpace); + } + } + + /* Test to make sure the linear array exactly matches the + ** Bitvec object. Start with the assumption that they do + ** match (rc==0). Change rc to non-zero if a discrepancy + ** is found. + */ + rc = sqlite3BitvecTest(0,0) + sqlite3BitvecTest(pBitvec, sz+1) + + sqlite3BitvecTest(pBitvec, 0) + + (sqlite3BitvecSize(pBitvec) - sz); + for(i=1; i<=sz; i++){ + if( (TESTBIT(pV,i))!=sqlite3BitvecTest(pBitvec,i) ){ + rc = i; + break; + } + } + + /* Free allocated structure */ +bitvec_end: + sqlite3_free(pTmpSpace); + sqlite3_free(pV); + sqlite3BitvecDestroy(pBitvec); + return rc; +} +#endif /* SQLITE_UNTESTABLE */ + +/************** End of bitvec.c **********************************************/ +/************** Begin file pcache.c ******************************************/ +/* +** 2008 August 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 that page cache. +*/ +/* #include "sqliteInt.h" */ + +/* +** A complete page cache is an instance of this structure. Every +** entry in the cache holds a single page of the database file. The +** btree layer only operates on the cached copy of the database pages. +** +** A page cache entry is "clean" if it exactly matches what is currently +** on disk. A page is "dirty" if it has been modified and needs to be +** persisted to disk. +** +** pDirty, pDirtyTail, pSynced: +** All dirty pages are linked into the doubly linked list using +** PgHdr.pDirtyNext and pDirtyPrev. The list is maintained in LRU order +** such that p was added to the list more recently than p->pDirtyNext. +** PCache.pDirty points to the first (newest) element in the list and +** pDirtyTail to the last (oldest). +** +** The PCache.pSynced variable is used to optimize searching for a dirty +** page to eject from the cache mid-transaction. It is better to eject +** a page that does not require a journal sync than one that does. +** Therefore, pSynced is maintained so that it *almost* always points +** to either the oldest page in the pDirty/pDirtyTail list that has a +** clear PGHDR_NEED_SYNC flag or to a page that is older than this one +** (so that the right page to eject can be found by following pDirtyPrev +** pointers). +*/ +struct PCache { + PgHdr *pDirty, *pDirtyTail; /* List of dirty pages in LRU order */ + PgHdr *pSynced; /* Last synced page in dirty page list */ + int nRefSum; /* Sum of ref counts over all pages */ + int szCache; /* Configured cache size */ + int szSpill; /* Size before spilling occurs */ + int szPage; /* Size of every page in this cache */ + int szExtra; /* Size of extra space for each page */ + u8 bPurgeable; /* True if pages are on backing store */ + u8 eCreate; /* eCreate value for for xFetch() */ + int (*xStress)(void*,PgHdr*); /* Call to try make a page clean */ + void *pStress; /* Argument to xStress */ + sqlite3_pcache *pCache; /* Pluggable cache module */ +}; + +/********************************** Test and Debug Logic **********************/ +/* +** Debug tracing macros. Enable by by changing the "0" to "1" and +** recompiling. +** +** When sqlite3PcacheTrace is 1, single line trace messages are issued. +** When sqlite3PcacheTrace is 2, a dump of the pcache showing all cache entries +** is displayed for many operations, resulting in a lot of output. +*/ +#if defined(SQLITE_DEBUG) && 0 + int sqlite3PcacheTrace = 2; /* 0: off 1: simple 2: cache dumps */ + int sqlite3PcacheMxDump = 9999; /* Max cache entries for pcacheDump() */ +# define pcacheTrace(X) if(sqlite3PcacheTrace){sqlite3DebugPrintf X;} + void pcacheDump(PCache *pCache){ + int N; + int i, j; + sqlite3_pcache_page *pLower; + PgHdr *pPg; + unsigned char *a; + + if( sqlite3PcacheTrace<2 ) return; + if( pCache->pCache==0 ) return; + N = sqlite3PcachePagecount(pCache); + if( N>sqlite3PcacheMxDump ) N = sqlite3PcacheMxDump; + for(i=1; i<=N; i++){ + pLower = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, i, 0); + if( pLower==0 ) continue; + pPg = (PgHdr*)pLower->pExtra; + printf("%3d: nRef %2d flgs %02x data ", i, pPg->nRef, pPg->flags); + a = (unsigned char *)pLower->pBuf; + for(j=0; j<12; j++) printf("%02x", a[j]); + printf("\n"); + if( pPg->pPage==0 ){ + sqlite3GlobalConfig.pcache2.xUnpin(pCache->pCache, pLower, 0); + } + } + } + #else +# define pcacheTrace(X) +# define pcacheDump(X) +#endif + +/* +** Check invariants on a PgHdr entry. Return true if everything is OK. +** Return false if any invariant is violated. +** +** This routine is for use inside of assert() statements only. For +** example: +** +** assert( sqlite3PcachePageSanity(pPg) ); +*/ +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3PcachePageSanity(PgHdr *pPg){ + PCache *pCache; + assert( pPg!=0 ); + assert( pPg->pgno>0 || pPg->pPager==0 ); /* Page number is 1 or more */ + pCache = pPg->pCache; + assert( pCache!=0 ); /* Every page has an associated PCache */ + if( pPg->flags & PGHDR_CLEAN ){ + assert( (pPg->flags & PGHDR_DIRTY)==0 );/* Cannot be both CLEAN and DIRTY */ + assert( pCache->pDirty!=pPg ); /* CLEAN pages not on dirty list */ + assert( pCache->pDirtyTail!=pPg ); + } + /* WRITEABLE pages must also be DIRTY */ + if( pPg->flags & PGHDR_WRITEABLE ){ + assert( pPg->flags & PGHDR_DIRTY ); /* WRITEABLE implies DIRTY */ + } + /* NEED_SYNC can be set independently of WRITEABLE. This can happen, + ** for example, when using the sqlite3PagerDontWrite() optimization: + ** (1) Page X is journalled, and gets WRITEABLE and NEED_SEEK. + ** (2) Page X moved to freelist, WRITEABLE is cleared + ** (3) Page X reused, WRITEABLE is set again + ** If NEED_SYNC had been cleared in step 2, then it would not be reset + ** in step 3, and page might be written into the database without first + ** syncing the rollback journal, which might cause corruption on a power + ** loss. + ** + ** Another example is when the database page size is smaller than the + ** disk sector size. When any page of a sector is journalled, all pages + ** in that sector are marked NEED_SYNC even if they are still CLEAN, just + ** in case they are later modified, since all pages in the same sector + ** must be journalled and synced before any of those pages can be safely + ** written. + */ + return 1; +} +#endif /* SQLITE_DEBUG */ + + +/********************************** Linked List Management ********************/ + +/* Allowed values for second argument to pcacheManageDirtyList() */ +#define PCACHE_DIRTYLIST_REMOVE 1 /* Remove pPage from dirty list */ +#define PCACHE_DIRTYLIST_ADD 2 /* Add pPage to the dirty list */ +#define PCACHE_DIRTYLIST_FRONT 3 /* Move pPage to the front of the list */ + +/* +** Manage pPage's participation on the dirty list. Bits of the addRemove +** argument determines what operation to do. The 0x01 bit means first +** remove pPage from the dirty list. The 0x02 means add pPage back to +** the dirty list. Doing both moves pPage to the front of the dirty list. +*/ +static void pcacheManageDirtyList(PgHdr *pPage, u8 addRemove){ + PCache *p = pPage->pCache; + + pcacheTrace(("%p.DIRTYLIST.%s %d\n", p, + addRemove==1 ? "REMOVE" : addRemove==2 ? "ADD" : "FRONT", + pPage->pgno)); + if( addRemove & PCACHE_DIRTYLIST_REMOVE ){ + assert( pPage->pDirtyNext || pPage==p->pDirtyTail ); + assert( pPage->pDirtyPrev || pPage==p->pDirty ); + + /* Update the PCache1.pSynced variable if necessary. */ + if( p->pSynced==pPage ){ + p->pSynced = pPage->pDirtyPrev; + } + + if( pPage->pDirtyNext ){ + pPage->pDirtyNext->pDirtyPrev = pPage->pDirtyPrev; + }else{ + assert( pPage==p->pDirtyTail ); + p->pDirtyTail = pPage->pDirtyPrev; + } + if( pPage->pDirtyPrev ){ + pPage->pDirtyPrev->pDirtyNext = pPage->pDirtyNext; + }else{ + /* If there are now no dirty pages in the cache, set eCreate to 2. + ** This is an optimization that allows sqlite3PcacheFetch() to skip + ** searching for a dirty page to eject from the cache when it might + ** otherwise have to. */ + assert( pPage==p->pDirty ); + p->pDirty = pPage->pDirtyNext; + assert( p->bPurgeable || p->eCreate==2 ); + if( p->pDirty==0 ){ /*OPTIMIZATION-IF-TRUE*/ + assert( p->bPurgeable==0 || p->eCreate==1 ); + p->eCreate = 2; + } + } + } + if( addRemove & PCACHE_DIRTYLIST_ADD ){ + pPage->pDirtyPrev = 0; + pPage->pDirtyNext = p->pDirty; + if( pPage->pDirtyNext ){ + assert( pPage->pDirtyNext->pDirtyPrev==0 ); + pPage->pDirtyNext->pDirtyPrev = pPage; + }else{ + p->pDirtyTail = pPage; + if( p->bPurgeable ){ + assert( p->eCreate==2 ); + p->eCreate = 1; + } + } + p->pDirty = pPage; + + /* If pSynced is NULL and this page has a clear NEED_SYNC flag, set + ** pSynced to point to it. Checking the NEED_SYNC flag is an + ** optimization, as if pSynced points to a page with the NEED_SYNC + ** flag set sqlite3PcacheFetchStress() searches through all newer + ** entries of the dirty-list for a page with NEED_SYNC clear anyway. */ + if( !p->pSynced + && 0==(pPage->flags&PGHDR_NEED_SYNC) /*OPTIMIZATION-IF-FALSE*/ + ){ + p->pSynced = pPage; + } + } + pcacheDump(p); +} + +/* +** Wrapper around the pluggable caches xUnpin method. If the cache is +** being used for an in-memory database, this function is a no-op. +*/ +static void pcacheUnpin(PgHdr *p){ + if( p->pCache->bPurgeable ){ + pcacheTrace(("%p.UNPIN %d\n", p->pCache, p->pgno)); + sqlite3GlobalConfig.pcache2.xUnpin(p->pCache->pCache, p->pPage, 0); + pcacheDump(p->pCache); + } +} + +/* +** Compute the number of pages of cache requested. p->szCache is the +** cache size requested by the "PRAGMA cache_size" statement. +*/ +static int numberOfCachePages(PCache *p){ + if( p->szCache>=0 ){ + /* IMPLEMENTATION-OF: R-42059-47211 If the argument N is positive then the + ** suggested cache size is set to N. */ + return p->szCache; + }else{ + /* IMPLEMANTATION-OF: R-59858-46238 If the argument N is negative, then the + ** number of cache pages is adjusted to be a number of pages that would + ** use approximately abs(N*1024) bytes of memory based on the current + ** page size. */ + return (int)((-1024*(i64)p->szCache)/(p->szPage+p->szExtra)); + } +} + +/*************************************************** General Interfaces ****** +** +** Initialize and shutdown the page cache subsystem. Neither of these +** functions are threadsafe. +*/ +SQLITE_PRIVATE int sqlite3PcacheInitialize(void){ + if( sqlite3GlobalConfig.pcache2.xInit==0 ){ + /* IMPLEMENTATION-OF: R-26801-64137 If the xInit() method is NULL, then the + ** built-in default page cache is used instead of the application defined + ** page cache. */ + sqlite3PCacheSetDefault(); + assert( sqlite3GlobalConfig.pcache2.xInit!=0 ); + } + return sqlite3GlobalConfig.pcache2.xInit(sqlite3GlobalConfig.pcache2.pArg); +} +SQLITE_PRIVATE void sqlite3PcacheShutdown(void){ + if( sqlite3GlobalConfig.pcache2.xShutdown ){ + /* IMPLEMENTATION-OF: R-26000-56589 The xShutdown() method may be NULL. */ + sqlite3GlobalConfig.pcache2.xShutdown(sqlite3GlobalConfig.pcache2.pArg); + } +} + +/* +** Return the size in bytes of a PCache object. +*/ +SQLITE_PRIVATE int sqlite3PcacheSize(void){ return sizeof(PCache); } + +/* +** Create a new PCache object. Storage space to hold the object +** has already been allocated and is passed in as the p pointer. +** The caller discovers how much space needs to be allocated by +** calling sqlite3PcacheSize(). +** +** szExtra is some extra space allocated for each page. The first +** 8 bytes of the extra space will be zeroed as the page is allocated, +** but remaining content will be uninitialized. Though it is opaque +** to this module, the extra space really ends up being the MemPage +** structure in the pager. +*/ +SQLITE_PRIVATE int sqlite3PcacheOpen( + int szPage, /* Size of every page */ + int szExtra, /* Extra space associated with each page */ + int bPurgeable, /* True if pages are on backing store */ + int (*xStress)(void*,PgHdr*),/* Call to try to make pages clean */ + void *pStress, /* Argument to xStress */ + PCache *p /* Preallocated space for the PCache */ +){ + memset(p, 0, sizeof(PCache)); + p->szPage = 1; + p->szExtra = szExtra; + assert( szExtra>=8 ); /* First 8 bytes will be zeroed */ + p->bPurgeable = bPurgeable; + p->eCreate = 2; + p->xStress = xStress; + p->pStress = pStress; + p->szCache = 100; + p->szSpill = 1; + pcacheTrace(("%p.OPEN szPage %d bPurgeable %d\n",p,szPage,bPurgeable)); + return sqlite3PcacheSetPageSize(p, szPage); +} + +/* +** Change the page size for PCache object. The caller must ensure that there +** are no outstanding page references when this function is called. +*/ +SQLITE_PRIVATE int sqlite3PcacheSetPageSize(PCache *pCache, int szPage){ + assert( pCache->nRefSum==0 && pCache->pDirty==0 ); + if( pCache->szPage ){ + sqlite3_pcache *pNew; + pNew = sqlite3GlobalConfig.pcache2.xCreate( + szPage, pCache->szExtra + ROUND8(sizeof(PgHdr)), + pCache->bPurgeable + ); + if( pNew==0 ) return SQLITE_NOMEM_BKPT; + sqlite3GlobalConfig.pcache2.xCachesize(pNew, numberOfCachePages(pCache)); + if( pCache->pCache ){ + sqlite3GlobalConfig.pcache2.xDestroy(pCache->pCache); + } + pCache->pCache = pNew; + pCache->szPage = szPage; + pcacheTrace(("%p.PAGESIZE %d\n",pCache,szPage)); + } + return SQLITE_OK; +} + +/* +** Try to obtain a page from the cache. +** +** This routine returns a pointer to an sqlite3_pcache_page object if +** such an object is already in cache, or if a new one is created. +** This routine returns a NULL pointer if the object was not in cache +** and could not be created. +** +** The createFlags should be 0 to check for existing pages and should +** be 3 (not 1, but 3) to try to create a new page. +** +** If the createFlag is 0, then NULL is always returned if the page +** is not already in the cache. If createFlag is 1, then a new page +** is created only if that can be done without spilling dirty pages +** and without exceeding the cache size limit. +** +** The caller needs to invoke sqlite3PcacheFetchFinish() to properly +** initialize the sqlite3_pcache_page object and convert it into a +** PgHdr object. The sqlite3PcacheFetch() and sqlite3PcacheFetchFinish() +** routines are split this way for performance reasons. When separated +** they can both (usually) operate without having to push values to +** the stack on entry and pop them back off on exit, which saves a +** lot of pushing and popping. +*/ +SQLITE_PRIVATE sqlite3_pcache_page *sqlite3PcacheFetch( + PCache *pCache, /* Obtain the page from this cache */ + Pgno pgno, /* Page number to obtain */ + int createFlag /* If true, create page if it does not exist already */ +){ + int eCreate; + sqlite3_pcache_page *pRes; + + assert( pCache!=0 ); + assert( pCache->pCache!=0 ); + assert( createFlag==3 || createFlag==0 ); + assert( pCache->eCreate==((pCache->bPurgeable && pCache->pDirty) ? 1 : 2) ); + + /* eCreate defines what to do if the page does not exist. + ** 0 Do not allocate a new page. (createFlag==0) + ** 1 Allocate a new page if doing so is inexpensive. + ** (createFlag==1 AND bPurgeable AND pDirty) + ** 2 Allocate a new page even it doing so is difficult. + ** (createFlag==1 AND !(bPurgeable AND pDirty) + */ + eCreate = createFlag & pCache->eCreate; + assert( eCreate==0 || eCreate==1 || eCreate==2 ); + assert( createFlag==0 || pCache->eCreate==eCreate ); + assert( createFlag==0 || eCreate==1+(!pCache->bPurgeable||!pCache->pDirty) ); + pRes = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, eCreate); + pcacheTrace(("%p.FETCH %d%s (result: %p)\n",pCache,pgno, + createFlag?" create":"",pRes)); + return pRes; +} + +/* +** If the sqlite3PcacheFetch() routine is unable to allocate a new +** page because no clean pages are available for reuse and the cache +** size limit has been reached, then this routine can be invoked to +** try harder to allocate a page. This routine might invoke the stress +** callback to spill dirty pages to the journal. It will then try to +** allocate the new page and will only fail to allocate a new page on +** an OOM error. +** +** This routine should be invoked only after sqlite3PcacheFetch() fails. +*/ +SQLITE_PRIVATE int sqlite3PcacheFetchStress( + PCache *pCache, /* Obtain the page from this cache */ + Pgno pgno, /* Page number to obtain */ + sqlite3_pcache_page **ppPage /* Write result here */ +){ + PgHdr *pPg; + if( pCache->eCreate==2 ) return 0; + + if( sqlite3PcachePagecount(pCache)>pCache->szSpill ){ + /* Find a dirty page to write-out and recycle. First try to find a + ** page that does not require a journal-sync (one with PGHDR_NEED_SYNC + ** cleared), but if that is not possible settle for any other + ** unreferenced dirty page. + ** + ** If the LRU page in the dirty list that has a clear PGHDR_NEED_SYNC + ** flag is currently referenced, then the following may leave pSynced + ** set incorrectly (pointing to other than the LRU page with NEED_SYNC + ** cleared). This is Ok, as pSynced is just an optimization. */ + for(pPg=pCache->pSynced; + pPg && (pPg->nRef || (pPg->flags&PGHDR_NEED_SYNC)); + pPg=pPg->pDirtyPrev + ); + pCache->pSynced = pPg; + if( !pPg ){ + for(pPg=pCache->pDirtyTail; pPg && pPg->nRef; pPg=pPg->pDirtyPrev); + } + if( pPg ){ + int rc; +#ifdef SQLITE_LOG_CACHE_SPILL + sqlite3_log(SQLITE_FULL, + "spill page %d making room for %d - cache used: %d/%d", + pPg->pgno, pgno, + sqlite3GlobalConfig.pcache2.xPagecount(pCache->pCache), + numberOfCachePages(pCache)); +#endif + pcacheTrace(("%p.SPILL %d\n",pCache,pPg->pgno)); + rc = pCache->xStress(pCache->pStress, pPg); + pcacheDump(pCache); + if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){ + return rc; + } + } + } + *ppPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, 2); + return *ppPage==0 ? SQLITE_NOMEM_BKPT : SQLITE_OK; +} + +/* +** This is a helper routine for sqlite3PcacheFetchFinish() +** +** In the uncommon case where the page being fetched has not been +** initialized, this routine is invoked to do the initialization. +** This routine is broken out into a separate function since it +** requires extra stack manipulation that can be avoided in the common +** case. +*/ +static SQLITE_NOINLINE PgHdr *pcacheFetchFinishWithInit( + PCache *pCache, /* Obtain the page from this cache */ + Pgno pgno, /* Page number obtained */ + sqlite3_pcache_page *pPage /* Page obtained by prior PcacheFetch() call */ +){ + PgHdr *pPgHdr; + assert( pPage!=0 ); + pPgHdr = (PgHdr*)pPage->pExtra; + assert( pPgHdr->pPage==0 ); + memset(&pPgHdr->pDirty, 0, sizeof(PgHdr) - offsetof(PgHdr,pDirty)); + pPgHdr->pPage = pPage; + pPgHdr->pData = pPage->pBuf; + pPgHdr->pExtra = (void *)&pPgHdr[1]; + memset(pPgHdr->pExtra, 0, 8); + pPgHdr->pCache = pCache; + pPgHdr->pgno = pgno; + pPgHdr->flags = PGHDR_CLEAN; + return sqlite3PcacheFetchFinish(pCache,pgno,pPage); +} + +/* +** This routine converts the sqlite3_pcache_page object returned by +** sqlite3PcacheFetch() into an initialized PgHdr object. This routine +** must be called after sqlite3PcacheFetch() in order to get a usable +** result. +*/ +SQLITE_PRIVATE PgHdr *sqlite3PcacheFetchFinish( + PCache *pCache, /* Obtain the page from this cache */ + Pgno pgno, /* Page number obtained */ + sqlite3_pcache_page *pPage /* Page obtained by prior PcacheFetch() call */ +){ + PgHdr *pPgHdr; + + assert( pPage!=0 ); + pPgHdr = (PgHdr *)pPage->pExtra; + + if( !pPgHdr->pPage ){ + return pcacheFetchFinishWithInit(pCache, pgno, pPage); + } + pCache->nRefSum++; + pPgHdr->nRef++; + assert( sqlite3PcachePageSanity(pPgHdr) ); + return pPgHdr; +} + +/* +** Decrement the reference count on a page. If the page is clean and the +** reference count drops to 0, then it is made eligible for recycling. +*/ +SQLITE_PRIVATE void SQLITE_NOINLINE sqlite3PcacheRelease(PgHdr *p){ + assert( p->nRef>0 ); + p->pCache->nRefSum--; + if( (--p->nRef)==0 ){ + if( p->flags&PGHDR_CLEAN ){ + pcacheUnpin(p); + }else{ + pcacheManageDirtyList(p, PCACHE_DIRTYLIST_FRONT); + } + } +} + +/* +** Increase the reference count of a supplied page by 1. +*/ +SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr *p){ + assert(p->nRef>0); + assert( sqlite3PcachePageSanity(p) ); + p->nRef++; + p->pCache->nRefSum++; +} + +/* +** Drop a page from the cache. There must be exactly one reference to the +** page. This function deletes that reference, so after it returns the +** page pointed to by p is invalid. +*/ +SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr *p){ + assert( p->nRef==1 ); + assert( sqlite3PcachePageSanity(p) ); + if( p->flags&PGHDR_DIRTY ){ + pcacheManageDirtyList(p, PCACHE_DIRTYLIST_REMOVE); + } + p->pCache->nRefSum--; + sqlite3GlobalConfig.pcache2.xUnpin(p->pCache->pCache, p->pPage, 1); +} + +/* +** Make sure the page is marked as dirty. If it isn't dirty already, +** make it so. +*/ +SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr *p){ + assert( p->nRef>0 ); + assert( sqlite3PcachePageSanity(p) ); + if( p->flags & (PGHDR_CLEAN|PGHDR_DONT_WRITE) ){ /*OPTIMIZATION-IF-FALSE*/ + p->flags &= ~PGHDR_DONT_WRITE; + if( p->flags & PGHDR_CLEAN ){ + p->flags ^= (PGHDR_DIRTY|PGHDR_CLEAN); + pcacheTrace(("%p.DIRTY %d\n",p->pCache,p->pgno)); + assert( (p->flags & (PGHDR_DIRTY|PGHDR_CLEAN))==PGHDR_DIRTY ); + pcacheManageDirtyList(p, PCACHE_DIRTYLIST_ADD); + } + assert( sqlite3PcachePageSanity(p) ); + } +} + +/* +** Make sure the page is marked as clean. If it isn't clean already, +** make it so. +*/ +SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr *p){ + assert( sqlite3PcachePageSanity(p) ); + assert( (p->flags & PGHDR_DIRTY)!=0 ); + assert( (p->flags & PGHDR_CLEAN)==0 ); + pcacheManageDirtyList(p, PCACHE_DIRTYLIST_REMOVE); + p->flags &= ~(PGHDR_DIRTY|PGHDR_NEED_SYNC|PGHDR_WRITEABLE); + p->flags |= PGHDR_CLEAN; + pcacheTrace(("%p.CLEAN %d\n",p->pCache,p->pgno)); + assert( sqlite3PcachePageSanity(p) ); + if( p->nRef==0 ){ + pcacheUnpin(p); + } +} + +/* +** Make every page in the cache clean. +*/ +SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache *pCache){ + PgHdr *p; + pcacheTrace(("%p.CLEAN-ALL\n",pCache)); + while( (p = pCache->pDirty)!=0 ){ + sqlite3PcacheMakeClean(p); + } +} + +/* +** Clear the PGHDR_NEED_SYNC and PGHDR_WRITEABLE flag from all dirty pages. +*/ +SQLITE_PRIVATE void sqlite3PcacheClearWritable(PCache *pCache){ + PgHdr *p; + pcacheTrace(("%p.CLEAR-WRITEABLE\n",pCache)); + for(p=pCache->pDirty; p; p=p->pDirtyNext){ + p->flags &= ~(PGHDR_NEED_SYNC|PGHDR_WRITEABLE); + } + pCache->pSynced = pCache->pDirtyTail; +} + +/* +** Clear the PGHDR_NEED_SYNC flag from all dirty pages. +*/ +SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *pCache){ + PgHdr *p; + for(p=pCache->pDirty; p; p=p->pDirtyNext){ + p->flags &= ~PGHDR_NEED_SYNC; + } + pCache->pSynced = pCache->pDirtyTail; +} + +/* +** Change the page number of page p to newPgno. +*/ +SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){ + PCache *pCache = p->pCache; + assert( p->nRef>0 ); + assert( newPgno>0 ); + assert( sqlite3PcachePageSanity(p) ); + pcacheTrace(("%p.MOVE %d -> %d\n",pCache,p->pgno,newPgno)); + sqlite3GlobalConfig.pcache2.xRekey(pCache->pCache, p->pPage, p->pgno,newPgno); + p->pgno = newPgno; + if( (p->flags&PGHDR_DIRTY) && (p->flags&PGHDR_NEED_SYNC) ){ + pcacheManageDirtyList(p, PCACHE_DIRTYLIST_FRONT); + } +} + +/* +** Drop every cache entry whose page number is greater than "pgno". The +** caller must ensure that there are no outstanding references to any pages +** other than page 1 with a page number greater than pgno. +** +** If there is a reference to page 1 and the pgno parameter passed to this +** function is 0, then the data area associated with page 1 is zeroed, but +** the page object is not dropped. +*/ +SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache *pCache, Pgno pgno){ + if( pCache->pCache ){ + PgHdr *p; + PgHdr *pNext; + pcacheTrace(("%p.TRUNCATE %d\n",pCache,pgno)); + for(p=pCache->pDirty; p; p=pNext){ + pNext = p->pDirtyNext; + /* This routine never gets call with a positive pgno except right + ** after sqlite3PcacheCleanAll(). So if there are dirty pages, + ** it must be that pgno==0. + */ + assert( p->pgno>0 ); + if( p->pgno>pgno ){ + assert( p->flags&PGHDR_DIRTY ); + sqlite3PcacheMakeClean(p); + } + } + if( pgno==0 && pCache->nRefSum ){ + sqlite3_pcache_page *pPage1; + pPage1 = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache,1,0); + if( ALWAYS(pPage1) ){ /* Page 1 is always available in cache, because + ** pCache->nRefSum>0 */ + memset(pPage1->pBuf, 0, pCache->szPage); + pgno = 1; + } + } + sqlite3GlobalConfig.pcache2.xTruncate(pCache->pCache, pgno+1); + } +} + +/* +** Close a cache. +*/ +SQLITE_PRIVATE void sqlite3PcacheClose(PCache *pCache){ + assert( pCache->pCache!=0 ); + pcacheTrace(("%p.CLOSE\n",pCache)); + sqlite3GlobalConfig.pcache2.xDestroy(pCache->pCache); +} + +/* +** Discard the contents of the cache. +*/ +SQLITE_PRIVATE void sqlite3PcacheClear(PCache *pCache){ + sqlite3PcacheTruncate(pCache, 0); +} + +/* +** Merge two lists of pages connected by pDirty and in pgno order. +** Do not bother fixing the pDirtyPrev pointers. +*/ +static PgHdr *pcacheMergeDirtyList(PgHdr *pA, PgHdr *pB){ + PgHdr result, *pTail; + pTail = &result; + assert( pA!=0 && pB!=0 ); + for(;;){ + if( pA->pgnopgno ){ + pTail->pDirty = pA; + pTail = pA; + pA = pA->pDirty; + if( pA==0 ){ + pTail->pDirty = pB; + break; + } + }else{ + pTail->pDirty = pB; + pTail = pB; + pB = pB->pDirty; + if( pB==0 ){ + pTail->pDirty = pA; + break; + } + } + } + return result.pDirty; +} + +/* +** Sort the list of pages in accending order by pgno. Pages are +** connected by pDirty pointers. The pDirtyPrev pointers are +** corrupted by this sort. +** +** Since there cannot be more than 2^31 distinct pages in a database, +** there cannot be more than 31 buckets required by the merge sorter. +** One extra bucket is added to catch overflow in case something +** ever changes to make the previous sentence incorrect. +*/ +#define N_SORT_BUCKET 32 +static PgHdr *pcacheSortDirtyList(PgHdr *pIn){ + PgHdr *a[N_SORT_BUCKET], *p; + int i; + memset(a, 0, sizeof(a)); + while( pIn ){ + p = pIn; + pIn = p->pDirty; + p->pDirty = 0; + for(i=0; ALWAYS(ipDirty; p; p=p->pDirtyNext){ + p->pDirty = p->pDirtyNext; + } + return pcacheSortDirtyList(pCache->pDirty); +} + +/* +** Return the total number of references to all pages held by the cache. +** +** This is not the total number of pages referenced, but the sum of the +** reference count for all pages. +*/ +SQLITE_PRIVATE int sqlite3PcacheRefCount(PCache *pCache){ + return pCache->nRefSum; +} + +/* +** Return the number of references to the page supplied as an argument. +*/ +SQLITE_PRIVATE int sqlite3PcachePageRefcount(PgHdr *p){ + return p->nRef; +} + +/* +** Return the total number of pages in the cache. +*/ +SQLITE_PRIVATE int sqlite3PcachePagecount(PCache *pCache){ + assert( pCache->pCache!=0 ); + return sqlite3GlobalConfig.pcache2.xPagecount(pCache->pCache); +} + +#ifdef SQLITE_TEST +/* +** Get the suggested cache-size value. +*/ +SQLITE_PRIVATE int sqlite3PcacheGetCachesize(PCache *pCache){ + return numberOfCachePages(pCache); +} +#endif + +/* +** Set the suggested cache-size value. +*/ +SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *pCache, int mxPage){ + assert( pCache->pCache!=0 ); + pCache->szCache = mxPage; + sqlite3GlobalConfig.pcache2.xCachesize(pCache->pCache, + numberOfCachePages(pCache)); +} + +/* +** Set the suggested cache-spill value. Make no changes if if the +** argument is zero. Return the effective cache-spill size, which will +** be the larger of the szSpill and szCache. +*/ +SQLITE_PRIVATE int sqlite3PcacheSetSpillsize(PCache *p, int mxPage){ + int res; + assert( p->pCache!=0 ); + if( mxPage ){ + if( mxPage<0 ){ + mxPage = (int)((-1024*(i64)mxPage)/(p->szPage+p->szExtra)); + } + p->szSpill = mxPage; + } + res = numberOfCachePages(p); + if( resszSpill ) res = p->szSpill; + return res; +} + +/* +** Free up as much memory as possible from the page cache. +*/ +SQLITE_PRIVATE void sqlite3PcacheShrink(PCache *pCache){ + assert( pCache->pCache!=0 ); + sqlite3GlobalConfig.pcache2.xShrink(pCache->pCache); +} + +/* +** Return the size of the header added by this middleware layer +** in the page-cache hierarchy. +*/ +SQLITE_PRIVATE int sqlite3HeaderSizePcache(void){ return ROUND8(sizeof(PgHdr)); } + +/* +** Return the number of dirty pages currently in the cache, as a percentage +** of the configured cache size. +*/ +SQLITE_PRIVATE int sqlite3PCachePercentDirty(PCache *pCache){ + PgHdr *pDirty; + int nDirty = 0; + int nCache = numberOfCachePages(pCache); + for(pDirty=pCache->pDirty; pDirty; pDirty=pDirty->pDirtyNext) nDirty++; + return nCache ? (int)(((i64)nDirty * 100) / nCache) : 0; +} + +#ifdef SQLITE_DIRECT_OVERFLOW_READ +/* +** Return true if there are one or more dirty pages in the cache. Else false. +*/ +SQLITE_PRIVATE int sqlite3PCacheIsDirty(PCache *pCache){ + return (pCache->pDirty!=0); +} +#endif + +#if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG) +/* +** For all dirty pages currently in the cache, invoke the specified +** callback. This is only used if the SQLITE_CHECK_PAGES macro is +** defined. +*/ +SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *)){ + PgHdr *pDirty; + for(pDirty=pCache->pDirty; pDirty; pDirty=pDirty->pDirtyNext){ + xIter(pDirty); + } +} +#endif + +/************** End of pcache.c **********************************************/ +/************** Begin file pcache1.c *****************************************/ +/* +** 2008 November 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 the default page cache implementation (the +** sqlite3_pcache interface). It also contains part of the implementation +** of the SQLITE_CONFIG_PAGECACHE and sqlite3_release_memory() features. +** If the default page cache implementation is overridden, then neither of +** these two features are available. +** +** A Page cache line looks like this: +** +** ------------------------------------------------------------- +** | database page content | PgHdr1 | MemPage | PgHdr | +** ------------------------------------------------------------- +** +** The database page content is up front (so that buffer overreads tend to +** flow harmlessly into the PgHdr1, MemPage, and PgHdr extensions). MemPage +** is the extension added by the btree.c module containing information such +** as the database page number and how that database page is used. PgHdr +** is added by the pcache.c layer and contains information used to keep track +** of which pages are "dirty". PgHdr1 is an extension added by this +** module (pcache1.c). The PgHdr1 header is a subclass of sqlite3_pcache_page. +** PgHdr1 contains information needed to look up a page by its page number. +** The superclass sqlite3_pcache_page.pBuf points to the start of the +** database page content and sqlite3_pcache_page.pExtra points to PgHdr. +** +** The size of the extension (MemPage+PgHdr+PgHdr1) can be determined at +** runtime using sqlite3_config(SQLITE_CONFIG_PCACHE_HDRSZ, &size). The +** sizes of the extensions sum to 272 bytes on x64 for 3.8.10, but this +** size can vary according to architecture, compile-time options, and +** SQLite library version number. +** +** If SQLITE_PCACHE_SEPARATE_HEADER is defined, then the extension is obtained +** using a separate memory allocation from the database page content. This +** seeks to overcome the "clownshoe" problem (also called "internal +** fragmentation" in academic literature) of allocating a few bytes more +** than a power of two with the memory allocator rounding up to the next +** power of two, and leaving the rounded-up space unused. +** +** This module tracks pointers to PgHdr1 objects. Only pcache.c communicates +** with this module. Information is passed back and forth as PgHdr1 pointers. +** +** The pcache.c and pager.c modules deal pointers to PgHdr objects. +** The btree.c module deals with pointers to MemPage objects. +** +** SOURCE OF PAGE CACHE MEMORY: +** +** Memory for a page might come from any of three sources: +** +** (1) The general-purpose memory allocator - sqlite3Malloc() +** (2) Global page-cache memory provided using sqlite3_config() with +** SQLITE_CONFIG_PAGECACHE. +** (3) PCache-local bulk allocation. +** +** The third case is a chunk of heap memory (defaulting to 100 pages worth) +** that is allocated when the page cache is created. The size of the local +** bulk allocation can be adjusted using +** +** sqlite3_config(SQLITE_CONFIG_PAGECACHE, (void*)0, 0, N). +** +** If N is positive, then N pages worth of memory are allocated using a single +** sqlite3Malloc() call and that memory is used for the first N pages allocated. +** Or if N is negative, then -1024*N bytes of memory are allocated and used +** for as many pages as can be accomodated. +** +** Only one of (2) or (3) can be used. Once the memory available to (2) or +** (3) is exhausted, subsequent allocations fail over to the general-purpose +** memory allocator (1). +** +** Earlier versions of SQLite used only methods (1) and (2). But experiments +** show that method (3) with N==100 provides about a 5% performance boost for +** common workloads. +*/ +/* #include "sqliteInt.h" */ + +typedef struct PCache1 PCache1; +typedef struct PgHdr1 PgHdr1; +typedef struct PgFreeslot PgFreeslot; +typedef struct PGroup PGroup; + +/* +** Each cache entry is represented by an instance of the following +** structure. Unless SQLITE_PCACHE_SEPARATE_HEADER is defined, a buffer of +** PgHdr1.pCache->szPage bytes is allocated directly before this structure +** in memory. +** +** Note: Variables isBulkLocal and isAnchor were once type "u8". That works, +** but causes a 2-byte gap in the structure for most architectures (since +** pointers must be either 4 or 8-byte aligned). As this structure is located +** in memory directly after the associated page data, if the database is +** corrupt, code at the b-tree layer may overread the page buffer and +** read part of this structure before the corruption is detected. This +** can cause a valgrind error if the unitialized gap is accessed. Using u16 +** ensures there is no such gap, and therefore no bytes of unitialized memory +** in the structure. +*/ +struct PgHdr1 { + sqlite3_pcache_page page; /* Base class. Must be first. pBuf & pExtra */ + unsigned int iKey; /* Key value (page number) */ + u16 isBulkLocal; /* This page from bulk local storage */ + u16 isAnchor; /* This is the PGroup.lru element */ + PgHdr1 *pNext; /* Next in hash table chain */ + PCache1 *pCache; /* Cache that currently owns this page */ + PgHdr1 *pLruNext; /* Next in LRU list of unpinned pages */ + PgHdr1 *pLruPrev; /* Previous in LRU list of unpinned pages */ + /* NB: pLruPrev is only valid if pLruNext!=0 */ +}; + +/* +** A page is pinned if it is not on the LRU list. To be "pinned" means +** that the page is in active use and must not be deallocated. +*/ +#define PAGE_IS_PINNED(p) ((p)->pLruNext==0) +#define PAGE_IS_UNPINNED(p) ((p)->pLruNext!=0) + +/* Each page cache (or PCache) belongs to a PGroup. A PGroup is a set +** of one or more PCaches that are able to recycle each other's unpinned +** pages when they are under memory pressure. A PGroup is an instance of +** the following object. +** +** This page cache implementation works in one of two modes: +** +** (1) Every PCache is the sole member of its own PGroup. There is +** one PGroup per PCache. +** +** (2) There is a single global PGroup that all PCaches are a member +** of. +** +** Mode 1 uses more memory (since PCache instances are not able to rob +** unused pages from other PCaches) but it also operates without a mutex, +** and is therefore often faster. Mode 2 requires a mutex in order to be +** threadsafe, but recycles pages more efficiently. +** +** For mode (1), PGroup.mutex is NULL. For mode (2) there is only a single +** PGroup which is the pcache1.grp global variable and its mutex is +** SQLITE_MUTEX_STATIC_LRU. +*/ +struct PGroup { + sqlite3_mutex *mutex; /* MUTEX_STATIC_LRU or NULL */ + unsigned int nMaxPage; /* Sum of nMax for purgeable caches */ + unsigned int nMinPage; /* Sum of nMin for purgeable caches */ + unsigned int mxPinned; /* nMaxpage + 10 - nMinPage */ + unsigned int nPurgeable; /* Number of purgeable pages allocated */ + PgHdr1 lru; /* The beginning and end of the LRU list */ +}; + +/* Each page cache is an instance of the following object. Every +** open database file (including each in-memory database and each +** temporary or transient database) has a single page cache which +** is an instance of this object. +** +** Pointers to structures of this type are cast and returned as +** opaque sqlite3_pcache* handles. +*/ +struct PCache1 { + /* Cache configuration parameters. Page size (szPage) and the purgeable + ** flag (bPurgeable) and the pnPurgeable pointer are all set when the + ** cache is created and are never changed thereafter. nMax may be + ** modified at any time by a call to the pcache1Cachesize() method. + ** The PGroup mutex must be held when accessing nMax. + */ + PGroup *pGroup; /* PGroup this cache belongs to */ + unsigned int *pnPurgeable; /* Pointer to pGroup->nPurgeable */ + int szPage; /* Size of database content section */ + int szExtra; /* sizeof(MemPage)+sizeof(PgHdr) */ + int szAlloc; /* Total size of one pcache line */ + int bPurgeable; /* True if cache is purgeable */ + unsigned int nMin; /* Minimum number of pages reserved */ + unsigned int nMax; /* Configured "cache_size" value */ + unsigned int n90pct; /* nMax*9/10 */ + unsigned int iMaxKey; /* Largest key seen since xTruncate() */ + unsigned int nPurgeableDummy; /* pnPurgeable points here when not used*/ + + /* Hash table of all pages. The following variables may only be accessed + ** when the accessor is holding the PGroup mutex. + */ + unsigned int nRecyclable; /* Number of pages in the LRU list */ + unsigned int nPage; /* Total number of pages in apHash */ + unsigned int nHash; /* Number of slots in apHash[] */ + PgHdr1 **apHash; /* Hash table for fast lookup by key */ + PgHdr1 *pFree; /* List of unused pcache-local pages */ + void *pBulk; /* Bulk memory used by pcache-local */ +}; + +/* +** Free slots in the allocator used to divide up the global page cache +** buffer provided using the SQLITE_CONFIG_PAGECACHE mechanism. +*/ +struct PgFreeslot { + PgFreeslot *pNext; /* Next free slot */ +}; + +/* +** Global data used by this cache. +*/ +static SQLITE_WSD struct PCacheGlobal { + PGroup grp; /* The global PGroup for mode (2) */ + + /* Variables related to SQLITE_CONFIG_PAGECACHE settings. The + ** szSlot, nSlot, pStart, pEnd, nReserve, and isInit values are all + ** fixed at sqlite3_initialize() time and do not require mutex protection. + ** The nFreeSlot and pFree values do require mutex protection. + */ + int isInit; /* True if initialized */ + int separateCache; /* Use a new PGroup for each PCache */ + int nInitPage; /* Initial bulk allocation size */ + int szSlot; /* Size of each free slot */ + int nSlot; /* The number of pcache slots */ + int nReserve; /* Try to keep nFreeSlot above this */ + void *pStart, *pEnd; /* Bounds of global page cache memory */ + /* Above requires no mutex. Use mutex below for variable that follow. */ + sqlite3_mutex *mutex; /* Mutex for accessing the following: */ + PgFreeslot *pFree; /* Free page blocks */ + int nFreeSlot; /* Number of unused pcache slots */ + /* The following value requires a mutex to change. We skip the mutex on + ** reading because (1) most platforms read a 32-bit integer atomically and + ** (2) even if an incorrect value is read, no great harm is done since this + ** is really just an optimization. */ + int bUnderPressure; /* True if low on PAGECACHE memory */ +} pcache1_g; + +/* +** All code in this file should access the global structure above via the +** alias "pcache1". This ensures that the WSD emulation is used when +** compiling for systems that do not support real WSD. +*/ +#define pcache1 (GLOBAL(struct PCacheGlobal, pcache1_g)) + +/* +** Macros to enter and leave the PCache LRU mutex. +*/ +#if !defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) || SQLITE_THREADSAFE==0 +# define pcache1EnterMutex(X) assert((X)->mutex==0) +# define pcache1LeaveMutex(X) assert((X)->mutex==0) +# define PCACHE1_MIGHT_USE_GROUP_MUTEX 0 +#else +# define pcache1EnterMutex(X) sqlite3_mutex_enter((X)->mutex) +# define pcache1LeaveMutex(X) sqlite3_mutex_leave((X)->mutex) +# define PCACHE1_MIGHT_USE_GROUP_MUTEX 1 +#endif + +/******************************************************************************/ +/******** Page Allocation/SQLITE_CONFIG_PCACHE Related Functions **************/ + + +/* +** This function is called during initialization if a static buffer is +** supplied to use for the page-cache by passing the SQLITE_CONFIG_PAGECACHE +** verb to sqlite3_config(). Parameter pBuf points to an allocation large +** enough to contain 'n' buffers of 'sz' bytes each. +** +** This routine is called from sqlite3_initialize() and so it is guaranteed +** to be serialized already. There is no need for further mutexing. +*/ +SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *pBuf, int sz, int n){ + if( pcache1.isInit ){ + PgFreeslot *p; + if( pBuf==0 ) sz = n = 0; + if( n==0 ) sz = 0; + sz = ROUNDDOWN8(sz); + pcache1.szSlot = sz; + pcache1.nSlot = pcache1.nFreeSlot = n; + pcache1.nReserve = n>90 ? 10 : (n/10 + 1); + pcache1.pStart = pBuf; + pcache1.pFree = 0; + pcache1.bUnderPressure = 0; + while( n-- ){ + p = (PgFreeslot*)pBuf; + p->pNext = pcache1.pFree; + pcache1.pFree = p; + pBuf = (void*)&((char*)pBuf)[sz]; + } + pcache1.pEnd = pBuf; + } +} + +/* +** Try to initialize the pCache->pFree and pCache->pBulk fields. Return +** true if pCache->pFree ends up containing one or more free pages. +*/ +static int pcache1InitBulk(PCache1 *pCache){ + i64 szBulk; + char *zBulk; + if( pcache1.nInitPage==0 ) return 0; + /* Do not bother with a bulk allocation if the cache size very small */ + if( pCache->nMax<3 ) return 0; + sqlite3BeginBenignMalloc(); + if( pcache1.nInitPage>0 ){ + szBulk = pCache->szAlloc * (i64)pcache1.nInitPage; + }else{ + szBulk = -1024 * (i64)pcache1.nInitPage; + } + if( szBulk > pCache->szAlloc*(i64)pCache->nMax ){ + szBulk = pCache->szAlloc*(i64)pCache->nMax; + } + zBulk = pCache->pBulk = sqlite3Malloc( szBulk ); + sqlite3EndBenignMalloc(); + if( zBulk ){ + int nBulk = sqlite3MallocSize(zBulk)/pCache->szAlloc; + do{ + PgHdr1 *pX = (PgHdr1*)&zBulk[pCache->szPage]; + pX->page.pBuf = zBulk; + pX->page.pExtra = &pX[1]; + pX->isBulkLocal = 1; + pX->isAnchor = 0; + pX->pNext = pCache->pFree; + pX->pLruPrev = 0; /* Initializing this saves a valgrind error */ + pCache->pFree = pX; + zBulk += pCache->szAlloc; + }while( --nBulk ); + } + return pCache->pFree!=0; +} + +/* +** Malloc function used within this file to allocate space from the buffer +** configured using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option. If no +** such buffer exists or there is no space left in it, this function falls +** back to sqlite3Malloc(). +** +** Multiple threads can run this routine at the same time. Global variables +** in pcache1 need to be protected via mutex. +*/ +static void *pcache1Alloc(int nByte){ + void *p = 0; + assert( sqlite3_mutex_notheld(pcache1.grp.mutex) ); + if( nByte<=pcache1.szSlot ){ + sqlite3_mutex_enter(pcache1.mutex); + p = (PgHdr1 *)pcache1.pFree; + if( p ){ + pcache1.pFree = pcache1.pFree->pNext; + pcache1.nFreeSlot--; + pcache1.bUnderPressure = pcache1.nFreeSlot=0 ); + sqlite3StatusHighwater(SQLITE_STATUS_PAGECACHE_SIZE, nByte); + sqlite3StatusUp(SQLITE_STATUS_PAGECACHE_USED, 1); + } + sqlite3_mutex_leave(pcache1.mutex); + } + if( p==0 ){ + /* Memory is not available in the SQLITE_CONFIG_PAGECACHE pool. Get + ** it from sqlite3Malloc instead. + */ + p = sqlite3Malloc(nByte); +#ifndef SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS + if( p ){ + int sz = sqlite3MallocSize(p); + sqlite3_mutex_enter(pcache1.mutex); + sqlite3StatusHighwater(SQLITE_STATUS_PAGECACHE_SIZE, nByte); + sqlite3StatusUp(SQLITE_STATUS_PAGECACHE_OVERFLOW, sz); + sqlite3_mutex_leave(pcache1.mutex); + } +#endif + sqlite3MemdebugSetType(p, MEMTYPE_PCACHE); + } + return p; +} + +/* +** Free an allocated buffer obtained from pcache1Alloc(). +*/ +static void pcache1Free(void *p){ + if( p==0 ) return; + if( SQLITE_WITHIN(p, pcache1.pStart, pcache1.pEnd) ){ + PgFreeslot *pSlot; + sqlite3_mutex_enter(pcache1.mutex); + sqlite3StatusDown(SQLITE_STATUS_PAGECACHE_USED, 1); + pSlot = (PgFreeslot*)p; + pSlot->pNext = pcache1.pFree; + pcache1.pFree = pSlot; + pcache1.nFreeSlot++; + pcache1.bUnderPressure = pcache1.nFreeSlot=pcache1.pStart && ppGroup->mutex) ); + if( pCache->pFree || (pCache->nPage==0 && pcache1InitBulk(pCache)) ){ + assert( pCache->pFree!=0 ); + p = pCache->pFree; + pCache->pFree = p->pNext; + p->pNext = 0; + }else{ +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + /* The group mutex must be released before pcache1Alloc() is called. This + ** is because it might call sqlite3_release_memory(), which assumes that + ** this mutex is not held. */ + assert( pcache1.separateCache==0 ); + assert( pCache->pGroup==&pcache1.grp ); + pcache1LeaveMutex(pCache->pGroup); +#endif + if( benignMalloc ){ sqlite3BeginBenignMalloc(); } +#ifdef SQLITE_PCACHE_SEPARATE_HEADER + pPg = pcache1Alloc(pCache->szPage); + p = sqlite3Malloc(sizeof(PgHdr1) + pCache->szExtra); + if( !pPg || !p ){ + pcache1Free(pPg); + sqlite3_free(p); + pPg = 0; + } +#else + pPg = pcache1Alloc(pCache->szAlloc); +#endif + if( benignMalloc ){ sqlite3EndBenignMalloc(); } +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + pcache1EnterMutex(pCache->pGroup); +#endif + if( pPg==0 ) return 0; +#ifndef SQLITE_PCACHE_SEPARATE_HEADER + p = (PgHdr1 *)&((u8 *)pPg)[pCache->szPage]; +#endif + p->page.pBuf = pPg; + p->page.pExtra = &p[1]; + p->isBulkLocal = 0; + p->isAnchor = 0; + } + (*pCache->pnPurgeable)++; + return p; +} + +/* +** Free a page object allocated by pcache1AllocPage(). +*/ +static void pcache1FreePage(PgHdr1 *p){ + PCache1 *pCache; + assert( p!=0 ); + pCache = p->pCache; + assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) ); + if( p->isBulkLocal ){ + p->pNext = pCache->pFree; + pCache->pFree = p; + }else{ + pcache1Free(p->page.pBuf); +#ifdef SQLITE_PCACHE_SEPARATE_HEADER + sqlite3_free(p); +#endif + } + (*pCache->pnPurgeable)--; +} + +/* +** Malloc function used by SQLite to obtain space from the buffer configured +** using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option. If no such buffer +** exists, this function falls back to sqlite3Malloc(). +*/ +SQLITE_PRIVATE void *sqlite3PageMalloc(int sz){ + assert( sz<=65536+8 ); /* These allocations are never very large */ + return pcache1Alloc(sz); +} + +/* +** Free an allocated buffer obtained from sqlite3PageMalloc(). +*/ +SQLITE_PRIVATE void sqlite3PageFree(void *p){ + pcache1Free(p); +} + + +/* +** Return true if it desirable to avoid allocating a new page cache +** entry. +** +** If memory was allocated specifically to the page cache using +** SQLITE_CONFIG_PAGECACHE but that memory has all been used, then +** it is desirable to avoid allocating a new page cache entry because +** presumably SQLITE_CONFIG_PAGECACHE was suppose to be sufficient +** for all page cache needs and we should not need to spill the +** allocation onto the heap. +** +** Or, the heap is used for all page cache memory but the heap is +** under memory pressure, then again it is desirable to avoid +** allocating a new page cache entry in order to avoid stressing +** the heap even further. +*/ +static int pcache1UnderMemoryPressure(PCache1 *pCache){ + if( pcache1.nSlot && (pCache->szPage+pCache->szExtra)<=pcache1.szSlot ){ + return pcache1.bUnderPressure; + }else{ + return sqlite3HeapNearlyFull(); + } +} + +/******************************************************************************/ +/******** General Implementation Functions ************************************/ + +/* +** This function is used to resize the hash table used by the cache passed +** as the first argument. +** +** The PCache mutex must be held when this function is called. +*/ +static void pcache1ResizeHash(PCache1 *p){ + PgHdr1 **apNew; + unsigned int nNew; + unsigned int i; + + assert( sqlite3_mutex_held(p->pGroup->mutex) ); + + nNew = p->nHash*2; + if( nNew<256 ){ + nNew = 256; + } + + pcache1LeaveMutex(p->pGroup); + if( p->nHash ){ sqlite3BeginBenignMalloc(); } + apNew = (PgHdr1 **)sqlite3MallocZero(sizeof(PgHdr1 *)*nNew); + if( p->nHash ){ sqlite3EndBenignMalloc(); } + pcache1EnterMutex(p->pGroup); + if( apNew ){ + for(i=0; inHash; i++){ + PgHdr1 *pPage; + PgHdr1 *pNext = p->apHash[i]; + while( (pPage = pNext)!=0 ){ + unsigned int h = pPage->iKey % nNew; + pNext = pPage->pNext; + pPage->pNext = apNew[h]; + apNew[h] = pPage; + } + } + sqlite3_free(p->apHash); + p->apHash = apNew; + p->nHash = nNew; + } +} + +/* +** This function is used internally to remove the page pPage from the +** PGroup LRU list, if is part of it. If pPage is not part of the PGroup +** LRU list, then this function is a no-op. +** +** The PGroup mutex must be held when this function is called. +*/ +static PgHdr1 *pcache1PinPage(PgHdr1 *pPage){ + assert( pPage!=0 ); + assert( PAGE_IS_UNPINNED(pPage) ); + assert( pPage->pLruNext ); + assert( pPage->pLruPrev ); + assert( sqlite3_mutex_held(pPage->pCache->pGroup->mutex) ); + pPage->pLruPrev->pLruNext = pPage->pLruNext; + pPage->pLruNext->pLruPrev = pPage->pLruPrev; + pPage->pLruNext = 0; + /* pPage->pLruPrev = 0; + ** No need to clear pLruPrev as it is never accessed if pLruNext is 0 */ + assert( pPage->isAnchor==0 ); + assert( pPage->pCache->pGroup->lru.isAnchor==1 ); + pPage->pCache->nRecyclable--; + return pPage; +} + + +/* +** Remove the page supplied as an argument from the hash table +** (PCache1.apHash structure) that it is currently stored in. +** Also free the page if freePage is true. +** +** The PGroup mutex must be held when this function is called. +*/ +static void pcache1RemoveFromHash(PgHdr1 *pPage, int freeFlag){ + unsigned int h; + PCache1 *pCache = pPage->pCache; + PgHdr1 **pp; + + assert( sqlite3_mutex_held(pCache->pGroup->mutex) ); + h = pPage->iKey % pCache->nHash; + for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext); + *pp = (*pp)->pNext; + + pCache->nPage--; + if( freeFlag ) pcache1FreePage(pPage); +} + +/* +** If there are currently more than nMaxPage pages allocated, try +** to recycle pages to reduce the number allocated to nMaxPage. +*/ +static void pcache1EnforceMaxPage(PCache1 *pCache){ + PGroup *pGroup = pCache->pGroup; + PgHdr1 *p; + assert( sqlite3_mutex_held(pGroup->mutex) ); + while( pGroup->nPurgeable>pGroup->nMaxPage + && (p=pGroup->lru.pLruPrev)->isAnchor==0 + ){ + assert( p->pCache->pGroup==pGroup ); + assert( PAGE_IS_UNPINNED(p) ); + pcache1PinPage(p); + pcache1RemoveFromHash(p, 1); + } + if( pCache->nPage==0 && pCache->pBulk ){ + sqlite3_free(pCache->pBulk); + pCache->pBulk = pCache->pFree = 0; + } +} + +/* +** Discard all pages from cache pCache with a page number (key value) +** greater than or equal to iLimit. Any pinned pages that meet this +** criteria are unpinned before they are discarded. +** +** The PCache mutex must be held when this function is called. +*/ +static void pcache1TruncateUnsafe( + PCache1 *pCache, /* The cache to truncate */ + unsigned int iLimit /* Drop pages with this pgno or larger */ +){ + TESTONLY( int nPage = 0; ) /* To assert pCache->nPage is correct */ + unsigned int h, iStop; + assert( sqlite3_mutex_held(pCache->pGroup->mutex) ); + assert( pCache->iMaxKey >= iLimit ); + assert( pCache->nHash > 0 ); + if( pCache->iMaxKey - iLimit < pCache->nHash ){ + /* If we are just shaving the last few pages off the end of the + ** cache, then there is no point in scanning the entire hash table. + ** Only scan those hash slots that might contain pages that need to + ** be removed. */ + h = iLimit % pCache->nHash; + iStop = pCache->iMaxKey % pCache->nHash; + TESTONLY( nPage = -10; ) /* Disable the pCache->nPage validity check */ + }else{ + /* This is the general case where many pages are being removed. + ** It is necessary to scan the entire hash table */ + h = pCache->nHash/2; + iStop = h - 1; + } + for(;;){ + PgHdr1 **pp; + PgHdr1 *pPage; + assert( hnHash ); + pp = &pCache->apHash[h]; + while( (pPage = *pp)!=0 ){ + if( pPage->iKey>=iLimit ){ + pCache->nPage--; + *pp = pPage->pNext; + if( PAGE_IS_UNPINNED(pPage) ) pcache1PinPage(pPage); + pcache1FreePage(pPage); + }else{ + pp = &pPage->pNext; + TESTONLY( if( nPage>=0 ) nPage++; ) + } + } + if( h==iStop ) break; + h = (h+1) % pCache->nHash; + } + assert( nPage<0 || pCache->nPage==(unsigned)nPage ); +} + +/******************************************************************************/ +/******** sqlite3_pcache Methods **********************************************/ + +/* +** Implementation of the sqlite3_pcache.xInit method. +*/ +static int pcache1Init(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + assert( pcache1.isInit==0 ); + memset(&pcache1, 0, sizeof(pcache1)); + + + /* + ** The pcache1.separateCache variable is true if each PCache has its own + ** private PGroup (mode-1). pcache1.separateCache is false if the single + ** PGroup in pcache1.grp is used for all page caches (mode-2). + ** + ** * Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT + ** + ** * Use a unified cache in single-threaded applications that have + ** configured a start-time buffer for use as page-cache memory using + ** sqlite3_config(SQLITE_CONFIG_PAGECACHE, pBuf, sz, N) with non-NULL + ** pBuf argument. + ** + ** * Otherwise use separate caches (mode-1) + */ +#if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) + pcache1.separateCache = 0; +#elif SQLITE_THREADSAFE + pcache1.separateCache = sqlite3GlobalConfig.pPage==0 + || sqlite3GlobalConfig.bCoreMutex>0; +#else + pcache1.separateCache = sqlite3GlobalConfig.pPage==0; +#endif + +#if SQLITE_THREADSAFE + if( sqlite3GlobalConfig.bCoreMutex ){ + pcache1.grp.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU); + pcache1.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PMEM); + } +#endif + if( pcache1.separateCache + && sqlite3GlobalConfig.nPage!=0 + && sqlite3GlobalConfig.pPage==0 + ){ + pcache1.nInitPage = sqlite3GlobalConfig.nPage; + }else{ + pcache1.nInitPage = 0; + } + pcache1.grp.mxPinned = 10; + pcache1.isInit = 1; + return SQLITE_OK; +} + +/* +** Implementation of the sqlite3_pcache.xShutdown method. +** Note that the static mutex allocated in xInit does +** not need to be freed. +*/ +static void pcache1Shutdown(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + assert( pcache1.isInit!=0 ); + memset(&pcache1, 0, sizeof(pcache1)); +} + +/* forward declaration */ +static void pcache1Destroy(sqlite3_pcache *p); + +/* +** Implementation of the sqlite3_pcache.xCreate method. +** +** Allocate a new cache. +*/ +static sqlite3_pcache *pcache1Create(int szPage, int szExtra, int bPurgeable){ + PCache1 *pCache; /* The newly created page cache */ + PGroup *pGroup; /* The group the new page cache will belong to */ + int sz; /* Bytes of memory required to allocate the new cache */ + + assert( (szPage & (szPage-1))==0 && szPage>=512 && szPage<=65536 ); + assert( szExtra < 300 ); + + sz = sizeof(PCache1) + sizeof(PGroup)*pcache1.separateCache; + pCache = (PCache1 *)sqlite3MallocZero(sz); + if( pCache ){ + if( pcache1.separateCache ){ + pGroup = (PGroup*)&pCache[1]; + pGroup->mxPinned = 10; + }else{ + pGroup = &pcache1.grp; + } + pcache1EnterMutex(pGroup); + if( pGroup->lru.isAnchor==0 ){ + pGroup->lru.isAnchor = 1; + pGroup->lru.pLruPrev = pGroup->lru.pLruNext = &pGroup->lru; + } + pCache->pGroup = pGroup; + pCache->szPage = szPage; + pCache->szExtra = szExtra; + pCache->szAlloc = szPage + szExtra + ROUND8(sizeof(PgHdr1)); + pCache->bPurgeable = (bPurgeable ? 1 : 0); + pcache1ResizeHash(pCache); + if( bPurgeable ){ + pCache->nMin = 10; + pGroup->nMinPage += pCache->nMin; + pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage; + pCache->pnPurgeable = &pGroup->nPurgeable; + }else{ + pCache->pnPurgeable = &pCache->nPurgeableDummy; + } + pcache1LeaveMutex(pGroup); + if( pCache->nHash==0 ){ + pcache1Destroy((sqlite3_pcache*)pCache); + pCache = 0; + } + } + return (sqlite3_pcache *)pCache; +} + +/* +** Implementation of the sqlite3_pcache.xCachesize method. +** +** Configure the cache_size limit for a cache. +*/ +static void pcache1Cachesize(sqlite3_pcache *p, int nMax){ + PCache1 *pCache = (PCache1 *)p; + if( pCache->bPurgeable ){ + PGroup *pGroup = pCache->pGroup; + pcache1EnterMutex(pGroup); + pGroup->nMaxPage += (nMax - pCache->nMax); + pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage; + pCache->nMax = nMax; + pCache->n90pct = pCache->nMax*9/10; + pcache1EnforceMaxPage(pCache); + pcache1LeaveMutex(pGroup); + } +} + +/* +** Implementation of the sqlite3_pcache.xShrink method. +** +** Free up as much memory as possible. +*/ +static void pcache1Shrink(sqlite3_pcache *p){ + PCache1 *pCache = (PCache1*)p; + if( pCache->bPurgeable ){ + PGroup *pGroup = pCache->pGroup; + int savedMaxPage; + pcache1EnterMutex(pGroup); + savedMaxPage = pGroup->nMaxPage; + pGroup->nMaxPage = 0; + pcache1EnforceMaxPage(pCache); + pGroup->nMaxPage = savedMaxPage; + pcache1LeaveMutex(pGroup); + } +} + +/* +** Implementation of the sqlite3_pcache.xPagecount method. +*/ +static int pcache1Pagecount(sqlite3_pcache *p){ + int n; + PCache1 *pCache = (PCache1*)p; + pcache1EnterMutex(pCache->pGroup); + n = pCache->nPage; + pcache1LeaveMutex(pCache->pGroup); + return n; +} + + +/* +** Implement steps 3, 4, and 5 of the pcache1Fetch() algorithm described +** in the header of the pcache1Fetch() procedure. +** +** This steps are broken out into a separate procedure because they are +** usually not needed, and by avoiding the stack initialization required +** for these steps, the main pcache1Fetch() procedure can run faster. +*/ +static SQLITE_NOINLINE PgHdr1 *pcache1FetchStage2( + PCache1 *pCache, + unsigned int iKey, + int createFlag +){ + unsigned int nPinned; + PGroup *pGroup = pCache->pGroup; + PgHdr1 *pPage = 0; + + /* Step 3: Abort if createFlag is 1 but the cache is nearly full */ + assert( pCache->nPage >= pCache->nRecyclable ); + nPinned = pCache->nPage - pCache->nRecyclable; + assert( pGroup->mxPinned == pGroup->nMaxPage + 10 - pGroup->nMinPage ); + assert( pCache->n90pct == pCache->nMax*9/10 ); + if( createFlag==1 && ( + nPinned>=pGroup->mxPinned + || nPinned>=pCache->n90pct + || (pcache1UnderMemoryPressure(pCache) && pCache->nRecyclablenPage>=pCache->nHash ) pcache1ResizeHash(pCache); + assert( pCache->nHash>0 && pCache->apHash ); + + /* Step 4. Try to recycle a page. */ + if( pCache->bPurgeable + && !pGroup->lru.pLruPrev->isAnchor + && ((pCache->nPage+1>=pCache->nMax) || pcache1UnderMemoryPressure(pCache)) + ){ + PCache1 *pOther; + pPage = pGroup->lru.pLruPrev; + assert( PAGE_IS_UNPINNED(pPage) ); + pcache1RemoveFromHash(pPage, 0); + pcache1PinPage(pPage); + pOther = pPage->pCache; + if( pOther->szAlloc != pCache->szAlloc ){ + pcache1FreePage(pPage); + pPage = 0; + }else{ + pGroup->nPurgeable -= (pOther->bPurgeable - pCache->bPurgeable); + } + } + + /* Step 5. If a usable page buffer has still not been found, + ** attempt to allocate a new one. + */ + if( !pPage ){ + pPage = pcache1AllocPage(pCache, createFlag==1); + } + + if( pPage ){ + unsigned int h = iKey % pCache->nHash; + pCache->nPage++; + pPage->iKey = iKey; + pPage->pNext = pCache->apHash[h]; + pPage->pCache = pCache; + pPage->pLruNext = 0; + /* pPage->pLruPrev = 0; + ** No need to clear pLruPrev since it is not accessed when pLruNext==0 */ + *(void **)pPage->page.pExtra = 0; + pCache->apHash[h] = pPage; + if( iKey>pCache->iMaxKey ){ + pCache->iMaxKey = iKey; + } + } + return pPage; +} + +/* +** Implementation of the sqlite3_pcache.xFetch method. +** +** Fetch a page by key value. +** +** Whether or not a new page may be allocated by this function depends on +** the value of the createFlag argument. 0 means do not allocate a new +** page. 1 means allocate a new page if space is easily available. 2 +** means to try really hard to allocate a new page. +** +** For a non-purgeable cache (a cache used as the storage for an in-memory +** database) there is really no difference between createFlag 1 and 2. So +** the calling function (pcache.c) will never have a createFlag of 1 on +** a non-purgeable cache. +** +** There are three different approaches to obtaining space for a page, +** depending on the value of parameter createFlag (which may be 0, 1 or 2). +** +** 1. Regardless of the value of createFlag, the cache is searched for a +** copy of the requested page. If one is found, it is returned. +** +** 2. If createFlag==0 and the page is not already in the cache, NULL is +** returned. +** +** 3. If createFlag is 1, and the page is not already in the cache, then +** return NULL (do not allocate a new page) if any of the following +** conditions are true: +** +** (a) the number of pages pinned by the cache is greater than +** PCache1.nMax, or +** +** (b) the number of pages pinned by the cache is greater than +** the sum of nMax for all purgeable caches, less the sum of +** nMin for all other purgeable caches, or +** +** 4. If none of the first three conditions apply and the cache is marked +** as purgeable, and if one of the following is true: +** +** (a) The number of pages allocated for the cache is already +** PCache1.nMax, or +** +** (b) The number of pages allocated for all purgeable caches is +** already equal to or greater than the sum of nMax for all +** purgeable caches, +** +** (c) The system is under memory pressure and wants to avoid +** unnecessary pages cache entry allocations +** +** then attempt to recycle a page from the LRU list. If it is the right +** size, return the recycled buffer. Otherwise, free the buffer and +** proceed to step 5. +** +** 5. Otherwise, allocate and return a new page buffer. +** +** There are two versions of this routine. pcache1FetchWithMutex() is +** the general case. pcache1FetchNoMutex() is a faster implementation for +** the common case where pGroup->mutex is NULL. The pcache1Fetch() wrapper +** invokes the appropriate routine. +*/ +static PgHdr1 *pcache1FetchNoMutex( + sqlite3_pcache *p, + unsigned int iKey, + int createFlag +){ + PCache1 *pCache = (PCache1 *)p; + PgHdr1 *pPage = 0; + + /* Step 1: Search the hash table for an existing entry. */ + pPage = pCache->apHash[iKey % pCache->nHash]; + while( pPage && pPage->iKey!=iKey ){ pPage = pPage->pNext; } + + /* Step 2: If the page was found in the hash table, then return it. + ** If the page was not in the hash table and createFlag is 0, abort. + ** Otherwise (page not in hash and createFlag!=0) continue with + ** subsequent steps to try to create the page. */ + if( pPage ){ + if( PAGE_IS_UNPINNED(pPage) ){ + return pcache1PinPage(pPage); + }else{ + return pPage; + } + }else if( createFlag ){ + /* Steps 3, 4, and 5 implemented by this subroutine */ + return pcache1FetchStage2(pCache, iKey, createFlag); + }else{ + return 0; + } +} +#if PCACHE1_MIGHT_USE_GROUP_MUTEX +static PgHdr1 *pcache1FetchWithMutex( + sqlite3_pcache *p, + unsigned int iKey, + int createFlag +){ + PCache1 *pCache = (PCache1 *)p; + PgHdr1 *pPage; + + pcache1EnterMutex(pCache->pGroup); + pPage = pcache1FetchNoMutex(p, iKey, createFlag); + assert( pPage==0 || pCache->iMaxKey>=iKey ); + pcache1LeaveMutex(pCache->pGroup); + return pPage; +} +#endif +static sqlite3_pcache_page *pcache1Fetch( + sqlite3_pcache *p, + unsigned int iKey, + int createFlag +){ +#if PCACHE1_MIGHT_USE_GROUP_MUTEX || defined(SQLITE_DEBUG) + PCache1 *pCache = (PCache1 *)p; +#endif + + assert( offsetof(PgHdr1,page)==0 ); + assert( pCache->bPurgeable || createFlag!=1 ); + assert( pCache->bPurgeable || pCache->nMin==0 ); + assert( pCache->bPurgeable==0 || pCache->nMin==10 ); + assert( pCache->nMin==0 || pCache->bPurgeable ); + assert( pCache->nHash>0 ); +#if PCACHE1_MIGHT_USE_GROUP_MUTEX + if( pCache->pGroup->mutex ){ + return (sqlite3_pcache_page*)pcache1FetchWithMutex(p, iKey, createFlag); + }else +#endif + { + return (sqlite3_pcache_page*)pcache1FetchNoMutex(p, iKey, createFlag); + } +} + + +/* +** Implementation of the sqlite3_pcache.xUnpin method. +** +** Mark a page as unpinned (eligible for asynchronous recycling). +*/ +static void pcache1Unpin( + sqlite3_pcache *p, + sqlite3_pcache_page *pPg, + int reuseUnlikely +){ + PCache1 *pCache = (PCache1 *)p; + PgHdr1 *pPage = (PgHdr1 *)pPg; + PGroup *pGroup = pCache->pGroup; + + assert( pPage->pCache==pCache ); + pcache1EnterMutex(pGroup); + + /* It is an error to call this function if the page is already + ** part of the PGroup LRU list. + */ + assert( pPage->pLruNext==0 ); + assert( PAGE_IS_PINNED(pPage) ); + + if( reuseUnlikely || pGroup->nPurgeable>pGroup->nMaxPage ){ + pcache1RemoveFromHash(pPage, 1); + }else{ + /* Add the page to the PGroup LRU list. */ + PgHdr1 **ppFirst = &pGroup->lru.pLruNext; + pPage->pLruPrev = &pGroup->lru; + (pPage->pLruNext = *ppFirst)->pLruPrev = pPage; + *ppFirst = pPage; + pCache->nRecyclable++; + } + + pcache1LeaveMutex(pCache->pGroup); +} + +/* +** Implementation of the sqlite3_pcache.xRekey method. +*/ +static void pcache1Rekey( + sqlite3_pcache *p, + sqlite3_pcache_page *pPg, + unsigned int iOld, + unsigned int iNew +){ + PCache1 *pCache = (PCache1 *)p; + PgHdr1 *pPage = (PgHdr1 *)pPg; + PgHdr1 **pp; + unsigned int h; + assert( pPage->iKey==iOld ); + assert( pPage->pCache==pCache ); + + pcache1EnterMutex(pCache->pGroup); + + h = iOld%pCache->nHash; + pp = &pCache->apHash[h]; + while( (*pp)!=pPage ){ + pp = &(*pp)->pNext; + } + *pp = pPage->pNext; + + h = iNew%pCache->nHash; + pPage->iKey = iNew; + pPage->pNext = pCache->apHash[h]; + pCache->apHash[h] = pPage; + if( iNew>pCache->iMaxKey ){ + pCache->iMaxKey = iNew; + } + + pcache1LeaveMutex(pCache->pGroup); +} + +/* +** Implementation of the sqlite3_pcache.xTruncate method. +** +** Discard all unpinned pages in the cache with a page number equal to +** or greater than parameter iLimit. Any pinned pages with a page number +** equal to or greater than iLimit are implicitly unpinned. +*/ +static void pcache1Truncate(sqlite3_pcache *p, unsigned int iLimit){ + PCache1 *pCache = (PCache1 *)p; + pcache1EnterMutex(pCache->pGroup); + if( iLimit<=pCache->iMaxKey ){ + pcache1TruncateUnsafe(pCache, iLimit); + pCache->iMaxKey = iLimit-1; + } + pcache1LeaveMutex(pCache->pGroup); +} + +/* +** Implementation of the sqlite3_pcache.xDestroy method. +** +** Destroy a cache allocated using pcache1Create(). +*/ +static void pcache1Destroy(sqlite3_pcache *p){ + PCache1 *pCache = (PCache1 *)p; + PGroup *pGroup = pCache->pGroup; + assert( pCache->bPurgeable || (pCache->nMax==0 && pCache->nMin==0) ); + pcache1EnterMutex(pGroup); + if( pCache->nPage ) pcache1TruncateUnsafe(pCache, 0); + assert( pGroup->nMaxPage >= pCache->nMax ); + pGroup->nMaxPage -= pCache->nMax; + assert( pGroup->nMinPage >= pCache->nMin ); + pGroup->nMinPage -= pCache->nMin; + pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage; + pcache1EnforceMaxPage(pCache); + pcache1LeaveMutex(pGroup); + sqlite3_free(pCache->pBulk); + sqlite3_free(pCache->apHash); + sqlite3_free(pCache); +} + +/* +** This function is called during initialization (sqlite3_initialize()) to +** install the default pluggable cache module, assuming the user has not +** already provided an alternative. +*/ +SQLITE_PRIVATE void sqlite3PCacheSetDefault(void){ + static const sqlite3_pcache_methods2 defaultMethods = { + 1, /* iVersion */ + 0, /* pArg */ + pcache1Init, /* xInit */ + pcache1Shutdown, /* xShutdown */ + pcache1Create, /* xCreate */ + pcache1Cachesize, /* xCachesize */ + pcache1Pagecount, /* xPagecount */ + pcache1Fetch, /* xFetch */ + pcache1Unpin, /* xUnpin */ + pcache1Rekey, /* xRekey */ + pcache1Truncate, /* xTruncate */ + pcache1Destroy, /* xDestroy */ + pcache1Shrink /* xShrink */ + }; + sqlite3_config(SQLITE_CONFIG_PCACHE2, &defaultMethods); +} + +/* +** Return the size of the header on each page of this PCACHE implementation. +*/ +SQLITE_PRIVATE int sqlite3HeaderSizePcache1(void){ return ROUND8(sizeof(PgHdr1)); } + +/* +** Return the global mutex used by this PCACHE implementation. The +** sqlite3_status() routine needs access to this mutex. +*/ +SQLITE_PRIVATE sqlite3_mutex *sqlite3Pcache1Mutex(void){ + return pcache1.mutex; +} + +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT +/* +** This function is called to free superfluous dynamically allocated memory +** held by the pager system. Memory in use by any SQLite pager allocated +** by the current thread may be sqlite3_free()ed. +** +** nReq is the number of bytes of memory required. Once this much has +** been released, the function returns. The return value is the total number +** of bytes of memory released. +*/ +SQLITE_PRIVATE int sqlite3PcacheReleaseMemory(int nReq){ + int nFree = 0; + assert( sqlite3_mutex_notheld(pcache1.grp.mutex) ); + assert( sqlite3_mutex_notheld(pcache1.mutex) ); + if( sqlite3GlobalConfig.pPage==0 ){ + PgHdr1 *p; + pcache1EnterMutex(&pcache1.grp); + while( (nReq<0 || nFreeisAnchor==0 + ){ + nFree += pcache1MemSize(p->page.pBuf); +#ifdef SQLITE_PCACHE_SEPARATE_HEADER + nFree += sqlite3MemSize(p); +#endif + assert( PAGE_IS_UNPINNED(p) ); + pcache1PinPage(p); + pcache1RemoveFromHash(p, 1); + } + pcache1LeaveMutex(&pcache1.grp); + } + return nFree; +} +#endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */ + +#ifdef SQLITE_TEST +/* +** This function is used by test procedures to inspect the internal state +** of the global cache. +*/ +SQLITE_PRIVATE void sqlite3PcacheStats( + int *pnCurrent, /* OUT: Total number of pages cached */ + int *pnMax, /* OUT: Global maximum cache size */ + int *pnMin, /* OUT: Sum of PCache1.nMin for purgeable caches */ + int *pnRecyclable /* OUT: Total number of pages available for recycling */ +){ + PgHdr1 *p; + int nRecyclable = 0; + for(p=pcache1.grp.lru.pLruNext; p && !p->isAnchor; p=p->pLruNext){ + assert( PAGE_IS_UNPINNED(p) ); + nRecyclable++; + } + *pnCurrent = pcache1.grp.nPurgeable; + *pnMax = (int)pcache1.grp.nMaxPage; + *pnMin = (int)pcache1.grp.nMinPage; + *pnRecyclable = nRecyclable; +} +#endif + +/************** End of pcache1.c *********************************************/ +/************** Begin file rowset.c ******************************************/ +/* +** 2008 December 3 +** +** 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 module implements an object we call a "RowSet". +** +** The RowSet object is a collection of rowids. Rowids +** are inserted into the RowSet in an arbitrary order. Inserts +** can be intermixed with tests to see if a given rowid has been +** previously inserted into the RowSet. +** +** After all inserts are finished, it is possible to extract the +** elements of the RowSet in sorted order. Once this extraction +** process has started, no new elements may be inserted. +** +** Hence, the primitive operations for a RowSet are: +** +** CREATE +** INSERT +** TEST +** SMALLEST +** DESTROY +** +** The CREATE and DESTROY primitives are the constructor and destructor, +** obviously. The INSERT primitive adds a new element to the RowSet. +** TEST checks to see if an element is already in the RowSet. SMALLEST +** extracts the least value from the RowSet. +** +** The INSERT primitive might allocate additional memory. Memory is +** allocated in chunks so most INSERTs do no allocation. There is an +** upper bound on the size of allocated memory. No memory is freed +** until DESTROY. +** +** The TEST primitive includes a "batch" number. The TEST primitive +** will only see elements that were inserted before the last change +** in the batch number. In other words, if an INSERT occurs between +** two TESTs where the TESTs have the same batch nubmer, then the +** value added by the INSERT will not be visible to the second TEST. +** The initial batch number is zero, so if the very first TEST contains +** a non-zero batch number, it will see all prior INSERTs. +** +** No INSERTs may occurs after a SMALLEST. An assertion will fail if +** that is attempted. +** +** The cost of an INSERT is roughly constant. (Sometimes new memory +** has to be allocated on an INSERT.) The cost of a TEST with a new +** batch number is O(NlogN) where N is the number of elements in the RowSet. +** The cost of a TEST using the same batch number is O(logN). The cost +** of the first SMALLEST is O(NlogN). Second and subsequent SMALLEST +** primitives are constant time. The cost of DESTROY is O(N). +** +** TEST and SMALLEST may not be used by the same RowSet. This used to +** be possible, but the feature was not used, so it was removed in order +** to simplify the code. +*/ +/* #include "sqliteInt.h" */ + + +/* +** Target size for allocation chunks. +*/ +#define ROWSET_ALLOCATION_SIZE 1024 + +/* +** The number of rowset entries per allocation chunk. +*/ +#define ROWSET_ENTRY_PER_CHUNK \ + ((ROWSET_ALLOCATION_SIZE-8)/sizeof(struct RowSetEntry)) + +/* +** Each entry in a RowSet is an instance of the following object. +** +** This same object is reused to store a linked list of trees of RowSetEntry +** objects. In that alternative use, pRight points to the next entry +** in the list, pLeft points to the tree, and v is unused. The +** RowSet.pForest value points to the head of this forest list. +*/ +struct RowSetEntry { + i64 v; /* ROWID value for this entry */ + struct RowSetEntry *pRight; /* Right subtree (larger entries) or list */ + struct RowSetEntry *pLeft; /* Left subtree (smaller entries) */ +}; + +/* +** RowSetEntry objects are allocated in large chunks (instances of the +** following structure) to reduce memory allocation overhead. The +** chunks are kept on a linked list so that they can be deallocated +** when the RowSet is destroyed. +*/ +struct RowSetChunk { + struct RowSetChunk *pNextChunk; /* Next chunk on list of them all */ + struct RowSetEntry aEntry[ROWSET_ENTRY_PER_CHUNK]; /* Allocated entries */ +}; + +/* +** A RowSet in an instance of the following structure. +** +** A typedef of this structure if found in sqliteInt.h. +*/ +struct RowSet { + struct RowSetChunk *pChunk; /* List of all chunk allocations */ + sqlite3 *db; /* The database connection */ + struct RowSetEntry *pEntry; /* List of entries using pRight */ + struct RowSetEntry *pLast; /* Last entry on the pEntry list */ + struct RowSetEntry *pFresh; /* Source of new entry objects */ + struct RowSetEntry *pForest; /* List of binary trees of entries */ + u16 nFresh; /* Number of objects on pFresh */ + u16 rsFlags; /* Various flags */ + int iBatch; /* Current insert batch */ +}; + +/* +** Allowed values for RowSet.rsFlags +*/ +#define ROWSET_SORTED 0x01 /* True if RowSet.pEntry is sorted */ +#define ROWSET_NEXT 0x02 /* True if sqlite3RowSetNext() has been called */ + +/* +** Allocate a RowSet object. Return NULL if a memory allocation +** error occurs. +*/ +SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3 *db){ + RowSet *p = sqlite3DbMallocRawNN(db, sizeof(*p)); + if( p ){ + int N = sqlite3DbMallocSize(db, p); + p->pChunk = 0; + p->db = db; + p->pEntry = 0; + p->pLast = 0; + p->pForest = 0; + p->pFresh = (struct RowSetEntry*)(ROUND8(sizeof(*p)) + (char*)p); + p->nFresh = (u16)((N - ROUND8(sizeof(*p)))/sizeof(struct RowSetEntry)); + p->rsFlags = ROWSET_SORTED; + p->iBatch = 0; + } + return p; +} + +/* +** Deallocate all chunks from a RowSet. This frees all memory that +** the RowSet has allocated over its lifetime. This routine is +** the destructor for the RowSet. +*/ +SQLITE_PRIVATE void sqlite3RowSetClear(void *pArg){ + RowSet *p = (RowSet*)pArg; + struct RowSetChunk *pChunk, *pNextChunk; + for(pChunk=p->pChunk; pChunk; pChunk = pNextChunk){ + pNextChunk = pChunk->pNextChunk; + sqlite3DbFree(p->db, pChunk); + } + p->pChunk = 0; + p->nFresh = 0; + p->pEntry = 0; + p->pLast = 0; + p->pForest = 0; + p->rsFlags = ROWSET_SORTED; +} + +/* +** Deallocate all chunks from a RowSet. This frees all memory that +** the RowSet has allocated over its lifetime. This routine is +** the destructor for the RowSet. +*/ +SQLITE_PRIVATE void sqlite3RowSetDelete(void *pArg){ + sqlite3RowSetClear(pArg); + sqlite3DbFree(((RowSet*)pArg)->db, pArg); +} + +/* +** Allocate a new RowSetEntry object that is associated with the +** given RowSet. Return a pointer to the new and completely uninitialized +** object. +** +** In an OOM situation, the RowSet.db->mallocFailed flag is set and this +** routine returns NULL. +*/ +static struct RowSetEntry *rowSetEntryAlloc(RowSet *p){ + assert( p!=0 ); + if( p->nFresh==0 ){ /*OPTIMIZATION-IF-FALSE*/ + /* We could allocate a fresh RowSetEntry each time one is needed, but it + ** is more efficient to pull a preallocated entry from the pool */ + struct RowSetChunk *pNew; + pNew = sqlite3DbMallocRawNN(p->db, sizeof(*pNew)); + if( pNew==0 ){ + return 0; + } + pNew->pNextChunk = p->pChunk; + p->pChunk = pNew; + p->pFresh = pNew->aEntry; + p->nFresh = ROWSET_ENTRY_PER_CHUNK; + } + p->nFresh--; + return p->pFresh++; +} + +/* +** Insert a new value into a RowSet. +** +** The mallocFailed flag of the database connection is set if a +** memory allocation fails. +*/ +SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet *p, i64 rowid){ + struct RowSetEntry *pEntry; /* The new entry */ + struct RowSetEntry *pLast; /* The last prior entry */ + + /* This routine is never called after sqlite3RowSetNext() */ + assert( p!=0 && (p->rsFlags & ROWSET_NEXT)==0 ); + + pEntry = rowSetEntryAlloc(p); + if( pEntry==0 ) return; + pEntry->v = rowid; + pEntry->pRight = 0; + pLast = p->pLast; + if( pLast ){ + if( rowid<=pLast->v ){ /*OPTIMIZATION-IF-FALSE*/ + /* Avoid unnecessary sorts by preserving the ROWSET_SORTED flags + ** where possible */ + p->rsFlags &= ~ROWSET_SORTED; + } + pLast->pRight = pEntry; + }else{ + p->pEntry = pEntry; + } + p->pLast = pEntry; +} + +/* +** Merge two lists of RowSetEntry objects. Remove duplicates. +** +** The input lists are connected via pRight pointers and are +** assumed to each already be in sorted order. +*/ +static struct RowSetEntry *rowSetEntryMerge( + struct RowSetEntry *pA, /* First sorted list to be merged */ + struct RowSetEntry *pB /* Second sorted list to be merged */ +){ + struct RowSetEntry head; + struct RowSetEntry *pTail; + + pTail = &head; + assert( pA!=0 && pB!=0 ); + for(;;){ + assert( pA->pRight==0 || pA->v<=pA->pRight->v ); + assert( pB->pRight==0 || pB->v<=pB->pRight->v ); + if( pA->v<=pB->v ){ + if( pA->vv ) pTail = pTail->pRight = pA; + pA = pA->pRight; + if( pA==0 ){ + pTail->pRight = pB; + break; + } + }else{ + pTail = pTail->pRight = pB; + pB = pB->pRight; + if( pB==0 ){ + pTail->pRight = pA; + break; + } + } + } + return head.pRight; +} + +/* +** Sort all elements on the list of RowSetEntry objects into order of +** increasing v. +*/ +static struct RowSetEntry *rowSetEntrySort(struct RowSetEntry *pIn){ + unsigned int i; + struct RowSetEntry *pNext, *aBucket[40]; + + memset(aBucket, 0, sizeof(aBucket)); + while( pIn ){ + pNext = pIn->pRight; + pIn->pRight = 0; + for(i=0; aBucket[i]; i++){ + pIn = rowSetEntryMerge(aBucket[i], pIn); + aBucket[i] = 0; + } + aBucket[i] = pIn; + pIn = pNext; + } + pIn = aBucket[0]; + for(i=1; ipLeft ){ + struct RowSetEntry *p; + rowSetTreeToList(pIn->pLeft, ppFirst, &p); + p->pRight = pIn; + }else{ + *ppFirst = pIn; + } + if( pIn->pRight ){ + rowSetTreeToList(pIn->pRight, &pIn->pRight, ppLast); + }else{ + *ppLast = pIn; + } + assert( (*ppLast)->pRight==0 ); +} + + +/* +** Convert a sorted list of elements (connected by pRight) into a binary +** tree with depth of iDepth. A depth of 1 means the tree contains a single +** node taken from the head of *ppList. A depth of 2 means a tree with +** three nodes. And so forth. +** +** Use as many entries from the input list as required and update the +** *ppList to point to the unused elements of the list. If the input +** list contains too few elements, then construct an incomplete tree +** and leave *ppList set to NULL. +** +** Return a pointer to the root of the constructed binary tree. +*/ +static struct RowSetEntry *rowSetNDeepTree( + struct RowSetEntry **ppList, + int iDepth +){ + struct RowSetEntry *p; /* Root of the new tree */ + struct RowSetEntry *pLeft; /* Left subtree */ + if( *ppList==0 ){ /*OPTIMIZATION-IF-TRUE*/ + /* Prevent unnecessary deep recursion when we run out of entries */ + return 0; + } + if( iDepth>1 ){ /*OPTIMIZATION-IF-TRUE*/ + /* This branch causes a *balanced* tree to be generated. A valid tree + ** is still generated without this branch, but the tree is wildly + ** unbalanced and inefficient. */ + pLeft = rowSetNDeepTree(ppList, iDepth-1); + p = *ppList; + if( p==0 ){ /*OPTIMIZATION-IF-FALSE*/ + /* It is safe to always return here, but the resulting tree + ** would be unbalanced */ + return pLeft; + } + p->pLeft = pLeft; + *ppList = p->pRight; + p->pRight = rowSetNDeepTree(ppList, iDepth-1); + }else{ + p = *ppList; + *ppList = p->pRight; + p->pLeft = p->pRight = 0; + } + return p; +} + +/* +** Convert a sorted list of elements into a binary tree. Make the tree +** as deep as it needs to be in order to contain the entire list. +*/ +static struct RowSetEntry *rowSetListToTree(struct RowSetEntry *pList){ + int iDepth; /* Depth of the tree so far */ + struct RowSetEntry *p; /* Current tree root */ + struct RowSetEntry *pLeft; /* Left subtree */ + + assert( pList!=0 ); + p = pList; + pList = p->pRight; + p->pLeft = p->pRight = 0; + for(iDepth=1; pList; iDepth++){ + pLeft = p; + p = pList; + pList = p->pRight; + p->pLeft = pLeft; + p->pRight = rowSetNDeepTree(&pList, iDepth); + } + return p; +} + +/* +** Extract the smallest element from the RowSet. +** Write the element into *pRowid. Return 1 on success. Return +** 0 if the RowSet is already empty. +** +** After this routine has been called, the sqlite3RowSetInsert() +** routine may not be called again. +** +** This routine may not be called after sqlite3RowSetTest() has +** been used. Older versions of RowSet allowed that, but as the +** capability was not used by the code generator, it was removed +** for code economy. +*/ +SQLITE_PRIVATE int sqlite3RowSetNext(RowSet *p, i64 *pRowid){ + assert( p!=0 ); + assert( p->pForest==0 ); /* Cannot be used with sqlite3RowSetText() */ + + /* Merge the forest into a single sorted list on first call */ + if( (p->rsFlags & ROWSET_NEXT)==0 ){ /*OPTIMIZATION-IF-FALSE*/ + if( (p->rsFlags & ROWSET_SORTED)==0 ){ /*OPTIMIZATION-IF-FALSE*/ + p->pEntry = rowSetEntrySort(p->pEntry); + } + p->rsFlags |= ROWSET_SORTED|ROWSET_NEXT; + } + + /* Return the next entry on the list */ + if( p->pEntry ){ + *pRowid = p->pEntry->v; + p->pEntry = p->pEntry->pRight; + if( p->pEntry==0 ){ /*OPTIMIZATION-IF-TRUE*/ + /* Free memory immediately, rather than waiting on sqlite3_finalize() */ + sqlite3RowSetClear(p); + } + return 1; + }else{ + return 0; + } +} + +/* +** Check to see if element iRowid was inserted into the rowset as +** part of any insert batch prior to iBatch. Return 1 or 0. +** +** If this is the first test of a new batch and if there exist entries +** on pRowSet->pEntry, then sort those entries into the forest at +** pRowSet->pForest so that they can be tested. +*/ +SQLITE_PRIVATE int sqlite3RowSetTest(RowSet *pRowSet, int iBatch, sqlite3_int64 iRowid){ + struct RowSetEntry *p, *pTree; + + /* This routine is never called after sqlite3RowSetNext() */ + assert( pRowSet!=0 && (pRowSet->rsFlags & ROWSET_NEXT)==0 ); + + /* Sort entries into the forest on the first test of a new batch. + ** To save unnecessary work, only do this when the batch number changes. + */ + if( iBatch!=pRowSet->iBatch ){ /*OPTIMIZATION-IF-FALSE*/ + p = pRowSet->pEntry; + if( p ){ + struct RowSetEntry **ppPrevTree = &pRowSet->pForest; + if( (pRowSet->rsFlags & ROWSET_SORTED)==0 ){ /*OPTIMIZATION-IF-FALSE*/ + /* Only sort the current set of entries if they need it */ + p = rowSetEntrySort(p); + } + for(pTree = pRowSet->pForest; pTree; pTree=pTree->pRight){ + ppPrevTree = &pTree->pRight; + if( pTree->pLeft==0 ){ + pTree->pLeft = rowSetListToTree(p); + break; + }else{ + struct RowSetEntry *pAux, *pTail; + rowSetTreeToList(pTree->pLeft, &pAux, &pTail); + pTree->pLeft = 0; + p = rowSetEntryMerge(pAux, p); + } + } + if( pTree==0 ){ + *ppPrevTree = pTree = rowSetEntryAlloc(pRowSet); + if( pTree ){ + pTree->v = 0; + pTree->pRight = 0; + pTree->pLeft = rowSetListToTree(p); + } + } + pRowSet->pEntry = 0; + pRowSet->pLast = 0; + pRowSet->rsFlags |= ROWSET_SORTED; + } + pRowSet->iBatch = iBatch; + } + + /* Test to see if the iRowid value appears anywhere in the forest. + ** Return 1 if it does and 0 if not. + */ + for(pTree = pRowSet->pForest; pTree; pTree=pTree->pRight){ + p = pTree->pLeft; + while( p ){ + if( p->vpRight; + }else if( p->v>iRowid ){ + p = p->pLeft; + }else{ + return 1; + } + } + } + return 0; +} + +/************** End of rowset.c **********************************************/ +/************** Begin file pager.c *******************************************/ +/* +** 2001 September 15 +** +** 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 is the implementation of the page cache subsystem or "pager". +** +** The pager is used to access a database disk file. It implements +** atomic commit and rollback through the use of a journal file that +** is separate from the database file. The pager also implements file +** locking to prevent two processes from writing the same database +** file simultaneously, or one process from reading the database while +** another is writing. +*/ +#ifndef SQLITE_OMIT_DISKIO +/* #include "sqliteInt.h" */ +/************** Include wal.h in the middle of pager.c ***********************/ +/************** Begin file wal.h *********************************************/ +/* +** 2010 February 1 +** +** 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 header file defines the interface to the write-ahead logging +** system. Refer to the comments below and the header comment attached to +** the implementation of each function in log.c for further details. +*/ + +#ifndef SQLITE_WAL_H +#define SQLITE_WAL_H + +/* #include "sqliteInt.h" */ + +/* Macros for extracting appropriate sync flags for either transaction +** commits (WAL_SYNC_FLAGS(X)) or for checkpoint ops (CKPT_SYNC_FLAGS(X)): +*/ +#define WAL_SYNC_FLAGS(X) ((X)&0x03) +#define CKPT_SYNC_FLAGS(X) (((X)>>2)&0x03) + +#ifdef SQLITE_OMIT_WAL +# define sqlite3WalOpen(x,y,z) 0 +# define sqlite3WalLimit(x,y) +# define sqlite3WalClose(v,w,x,y,z) 0 +# define sqlite3WalBeginReadTransaction(y,z) 0 +# define sqlite3WalEndReadTransaction(z) +# define sqlite3WalDbsize(y) 0 +# define sqlite3WalBeginWriteTransaction(y) 0 +# define sqlite3WalEndWriteTransaction(x) 0 +# define sqlite3WalUndo(x,y,z) 0 +# define sqlite3WalSavepoint(y,z) +# define sqlite3WalSavepointUndo(y,z) 0 +# define sqlite3WalFrames(u,v,w,x,y,z) 0 +# define sqlite3WalCheckpoint(q,r,s,t,u,v,w,x,y,z) 0 +# define sqlite3WalCallback(z) 0 +# define sqlite3WalExclusiveMode(y,z) 0 +# define sqlite3WalHeapMemory(z) 0 +# define sqlite3WalFramesize(z) 0 +# define sqlite3WalFindFrame(x,y,z) 0 +# define sqlite3WalFile(x) 0 +#else + +#define WAL_SAVEPOINT_NDATA 4 + +/* Connection to a write-ahead log (WAL) file. +** There is one object of this type for each pager. +*/ +typedef struct Wal Wal; + +/* Open and close a connection to a write-ahead log. */ +SQLITE_PRIVATE int sqlite3WalOpen(sqlite3_vfs*, sqlite3_file*, const char *, int, i64, Wal**); +SQLITE_PRIVATE int sqlite3WalClose(Wal *pWal, sqlite3*, int sync_flags, int, u8 *); + +/* Set the limiting size of a WAL file. */ +SQLITE_PRIVATE void sqlite3WalLimit(Wal*, i64); + +/* Used by readers to open (lock) and close (unlock) a snapshot. A +** snapshot is like a read-transaction. It is the state of the database +** at an instant in time. sqlite3WalOpenSnapshot gets a read lock and +** preserves the current state even if the other threads or processes +** write to or checkpoint the WAL. sqlite3WalCloseSnapshot() closes the +** transaction and releases the lock. +*/ +SQLITE_PRIVATE int sqlite3WalBeginReadTransaction(Wal *pWal, int *); +SQLITE_PRIVATE void sqlite3WalEndReadTransaction(Wal *pWal); + +/* Read a page from the write-ahead log, if it is present. */ +SQLITE_PRIVATE int sqlite3WalFindFrame(Wal *, Pgno, u32 *); +SQLITE_PRIVATE int sqlite3WalReadFrame(Wal *, u32, int, u8 *); + +/* If the WAL is not empty, return the size of the database. */ +SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal); + +/* Obtain or release the WRITER lock. */ +SQLITE_PRIVATE int sqlite3WalBeginWriteTransaction(Wal *pWal); +SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal); + +/* Undo any frames written (but not committed) to the log */ +SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx); + +/* Return an integer that records the current (uncommitted) write +** position in the WAL */ +SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData); + +/* Move the write position of the WAL back to iFrame. Called in +** response to a ROLLBACK TO command. */ +SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData); + +/* Write a frame or frames to the log. */ +SQLITE_PRIVATE int sqlite3WalFrames(Wal *pWal, int, PgHdr *, Pgno, int, int); + +/* Copy pages from the log to the database file */ +SQLITE_PRIVATE int sqlite3WalCheckpoint( + Wal *pWal, /* Write-ahead log connection */ + sqlite3 *db, /* Check this handle's interrupt flag */ + int eMode, /* One of PASSIVE, FULL and RESTART */ + int (*xBusy)(void*), /* Function to call when busy */ + void *pBusyArg, /* Context argument for xBusyHandler */ + int sync_flags, /* Flags to sync db file with (or 0) */ + int nBuf, /* Size of buffer nBuf */ + u8 *zBuf, /* Temporary buffer to use */ + int *pnLog, /* OUT: Number of frames in WAL */ + int *pnCkpt /* OUT: Number of backfilled frames in WAL */ +); + +/* Return the value to pass to a sqlite3_wal_hook callback, the +** number of frames in the WAL at the point of the last commit since +** sqlite3WalCallback() was called. If no commits have occurred since +** the last call, then return 0. +*/ +SQLITE_PRIVATE int sqlite3WalCallback(Wal *pWal); + +/* Tell the wal layer that an EXCLUSIVE lock has been obtained (or released) +** by the pager layer on the database file. +*/ +SQLITE_PRIVATE int sqlite3WalExclusiveMode(Wal *pWal, int op); + +/* Return true if the argument is non-NULL and the WAL module is using +** heap-memory for the wal-index. Otherwise, if the argument is NULL or the +** WAL module is using shared-memory, return false. +*/ +SQLITE_PRIVATE int sqlite3WalHeapMemory(Wal *pWal); + +#ifdef SQLITE_ENABLE_SNAPSHOT +SQLITE_PRIVATE int sqlite3WalSnapshotGet(Wal *pWal, sqlite3_snapshot **ppSnapshot); +SQLITE_PRIVATE void sqlite3WalSnapshotOpen(Wal *pWal, sqlite3_snapshot *pSnapshot); +SQLITE_PRIVATE int sqlite3WalSnapshotRecover(Wal *pWal); +SQLITE_PRIVATE int sqlite3WalSnapshotCheck(Wal *pWal, sqlite3_snapshot *pSnapshot); +SQLITE_PRIVATE void sqlite3WalSnapshotUnlock(Wal *pWal); +#endif + +#ifdef SQLITE_ENABLE_ZIPVFS +/* If the WAL file is not empty, return the number of bytes of content +** stored in each frame (i.e. the db page-size when the WAL was created). +*/ +SQLITE_PRIVATE int sqlite3WalFramesize(Wal *pWal); +#endif + +/* Return the sqlite3_file object for the WAL file */ +SQLITE_PRIVATE sqlite3_file *sqlite3WalFile(Wal *pWal); + +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT +SQLITE_PRIVATE int sqlite3WalWriteLock(Wal *pWal, int bLock); +SQLITE_PRIVATE void sqlite3WalDb(Wal *pWal, sqlite3 *db); +#endif + +#endif /* ifndef SQLITE_OMIT_WAL */ +#endif /* SQLITE_WAL_H */ + +/************** End of wal.h *************************************************/ +/************** Continuing where we left off in pager.c **********************/ + + +/******************* NOTES ON THE DESIGN OF THE PAGER ************************ +** +** This comment block describes invariants that hold when using a rollback +** journal. These invariants do not apply for journal_mode=WAL, +** journal_mode=MEMORY, or journal_mode=OFF. +** +** Within this comment block, a page is deemed to have been synced +** automatically as soon as it is written when PRAGMA synchronous=OFF. +** Otherwise, the page is not synced until the xSync method of the VFS +** is called successfully on the file containing the page. +** +** Definition: A page of the database file is said to be "overwriteable" if +** one or more of the following are true about the page: +** +** (a) The original content of the page as it was at the beginning of +** the transaction has been written into the rollback journal and +** synced. +** +** (b) The page was a freelist leaf page at the start of the transaction. +** +** (c) The page number is greater than the largest page that existed in +** the database file at the start of the transaction. +** +** (1) A page of the database file is never overwritten unless one of the +** following are true: +** +** (a) The page and all other pages on the same sector are overwriteable. +** +** (b) The atomic page write optimization is enabled, and the entire +** transaction other than the update of the transaction sequence +** number consists of a single page change. +** +** (2) The content of a page written into the rollback journal exactly matches +** both the content in the database when the rollback journal was written +** and the content in the database at the beginning of the current +** transaction. +** +** (3) Writes to the database file are an integer multiple of the page size +** in length and are aligned on a page boundary. +** +** (4) Reads from the database file are either aligned on a page boundary and +** an integer multiple of the page size in length or are taken from the +** first 100 bytes of the database file. +** +** (5) All writes to the database file are synced prior to the rollback journal +** being deleted, truncated, or zeroed. +** +** (6) If a super-journal file is used, then all writes to the database file +** are synced prior to the super-journal being deleted. +** +** Definition: Two databases (or the same database at two points it time) +** are said to be "logically equivalent" if they give the same answer to +** all queries. Note in particular the content of freelist leaf +** pages can be changed arbitrarily without affecting the logical equivalence +** of the database. +** +** (7) At any time, if any subset, including the empty set and the total set, +** of the unsynced changes to a rollback journal are removed and the +** journal is rolled back, the resulting database file will be logically +** equivalent to the database file at the beginning of the transaction. +** +** (8) When a transaction is rolled back, the xTruncate method of the VFS +** is called to restore the database file to the same size it was at +** the beginning of the transaction. (In some VFSes, the xTruncate +** method is a no-op, but that does not change the fact the SQLite will +** invoke it.) +** +** (9) Whenever the database file is modified, at least one bit in the range +** of bytes from 24 through 39 inclusive will be changed prior to releasing +** the EXCLUSIVE lock, thus signaling other connections on the same +** database to flush their caches. +** +** (10) The pattern of bits in bytes 24 through 39 shall not repeat in less +** than one billion transactions. +** +** (11) A database file is well-formed at the beginning and at the conclusion +** of every transaction. +** +** (12) An EXCLUSIVE lock is held on the database file when writing to +** the database file. +** +** (13) A SHARED lock is held on the database file while reading any +** content out of the database file. +** +******************************************************************************/ + +/* +** Macros for troubleshooting. Normally turned off +*/ +#if 0 +int sqlite3PagerTrace=1; /* True to enable tracing */ +#define sqlite3DebugPrintf printf +#define PAGERTRACE(X) if( sqlite3PagerTrace ){ sqlite3DebugPrintf X; } +#else +#define PAGERTRACE(X) +#endif + +/* +** The following two macros are used within the PAGERTRACE() macros above +** to print out file-descriptors. +** +** PAGERID() takes a pointer to a Pager struct as its argument. The +** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file +** struct as its argument. +*/ +#define PAGERID(p) (SQLITE_PTR_TO_INT(p->fd)) +#define FILEHANDLEID(fd) (SQLITE_PTR_TO_INT(fd)) + +/* +** The Pager.eState variable stores the current 'state' of a pager. A +** pager may be in any one of the seven states shown in the following +** state diagram. +** +** OPEN <------+------+ +** | | | +** V | | +** +---------> READER-------+ | +** | | | +** | V | +** |<-------WRITER_LOCKED------> ERROR +** | | ^ +** | V | +** |<------WRITER_CACHEMOD-------->| +** | | | +** | V | +** |<-------WRITER_DBMOD---------->| +** | | | +** | V | +** +<------WRITER_FINISHED-------->+ +** +** +** List of state transitions and the C [function] that performs each: +** +** OPEN -> READER [sqlite3PagerSharedLock] +** READER -> OPEN [pager_unlock] +** +** READER -> WRITER_LOCKED [sqlite3PagerBegin] +** WRITER_LOCKED -> WRITER_CACHEMOD [pager_open_journal] +** WRITER_CACHEMOD -> WRITER_DBMOD [syncJournal] +** WRITER_DBMOD -> WRITER_FINISHED [sqlite3PagerCommitPhaseOne] +** WRITER_*** -> READER [pager_end_transaction] +** +** WRITER_*** -> ERROR [pager_error] +** ERROR -> OPEN [pager_unlock] +** +** +** OPEN: +** +** The pager starts up in this state. Nothing is guaranteed in this +** state - the file may or may not be locked and the database size is +** unknown. The database may not be read or written. +** +** * No read or write transaction is active. +** * Any lock, or no lock at all, may be held on the database file. +** * The dbSize, dbOrigSize and dbFileSize variables may not be trusted. +** +** READER: +** +** In this state all the requirements for reading the database in +** rollback (non-WAL) mode are met. Unless the pager is (or recently +** was) in exclusive-locking mode, a user-level read transaction is +** open. The database size is known in this state. +** +** A connection running with locking_mode=normal enters this state when +** it opens a read-transaction on the database and returns to state +** OPEN after the read-transaction is completed. However a connection +** running in locking_mode=exclusive (including temp databases) remains in +** this state even after the read-transaction is closed. The only way +** a locking_mode=exclusive connection can transition from READER to OPEN +** is via the ERROR state (see below). +** +** * A read transaction may be active (but a write-transaction cannot). +** * A SHARED or greater lock is held on the database file. +** * The dbSize variable may be trusted (even if a user-level read +** transaction is not active). The dbOrigSize and dbFileSize variables +** may not be trusted at this point. +** * If the database is a WAL database, then the WAL connection is open. +** * Even if a read-transaction is not open, it is guaranteed that +** there is no hot-journal in the file-system. +** +** WRITER_LOCKED: +** +** The pager moves to this state from READER when a write-transaction +** is first opened on the database. In WRITER_LOCKED state, all locks +** required to start a write-transaction are held, but no actual +** modifications to the cache or database have taken place. +** +** In rollback mode, a RESERVED or (if the transaction was opened with +** BEGIN EXCLUSIVE) EXCLUSIVE lock is obtained on the database file when +** moving to this state, but the journal file is not written to or opened +** to in this state. If the transaction is committed or rolled back while +** in WRITER_LOCKED state, all that is required is to unlock the database +** file. +** +** IN WAL mode, WalBeginWriteTransaction() is called to lock the log file. +** If the connection is running with locking_mode=exclusive, an attempt +** is made to obtain an EXCLUSIVE lock on the database file. +** +** * A write transaction is active. +** * If the connection is open in rollback-mode, a RESERVED or greater +** lock is held on the database file. +** * If the connection is open in WAL-mode, a WAL write transaction +** is open (i.e. sqlite3WalBeginWriteTransaction() has been successfully +** called). +** * The dbSize, dbOrigSize and dbFileSize variables are all valid. +** * The contents of the pager cache have not been modified. +** * The journal file may or may not be open. +** * Nothing (not even the first header) has been written to the journal. +** +** WRITER_CACHEMOD: +** +** A pager moves from WRITER_LOCKED state to this state when a page is +** first modified by the upper layer. In rollback mode the journal file +** is opened (if it is not already open) and a header written to the +** start of it. The database file on disk has not been modified. +** +** * A write transaction is active. +** * A RESERVED or greater lock is held on the database file. +** * The journal file is open and the first header has been written +** to it, but the header has not been synced to disk. +** * The contents of the page cache have been modified. +** +** WRITER_DBMOD: +** +** The pager transitions from WRITER_CACHEMOD into WRITER_DBMOD state +** when it modifies the contents of the database file. WAL connections +** never enter this state (since they do not modify the database file, +** just the log file). +** +** * A write transaction is active. +** * An EXCLUSIVE or greater lock is held on the database file. +** * The journal file is open and the first header has been written +** and synced to disk. +** * The contents of the page cache have been modified (and possibly +** written to disk). +** +** WRITER_FINISHED: +** +** It is not possible for a WAL connection to enter this state. +** +** A rollback-mode pager changes to WRITER_FINISHED state from WRITER_DBMOD +** state after the entire transaction has been successfully written into the +** database file. In this state the transaction may be committed simply +** by finalizing the journal file. Once in WRITER_FINISHED state, it is +** not possible to modify the database further. At this point, the upper +** layer must either commit or rollback the transaction. +** +** * A write transaction is active. +** * An EXCLUSIVE or greater lock is held on the database file. +** * All writing and syncing of journal and database data has finished. +** If no error occurred, all that remains is to finalize the journal to +** commit the transaction. If an error did occur, the caller will need +** to rollback the transaction. +** +** ERROR: +** +** The ERROR state is entered when an IO or disk-full error (including +** SQLITE_IOERR_NOMEM) occurs at a point in the code that makes it +** difficult to be sure that the in-memory pager state (cache contents, +** db size etc.) are consistent with the contents of the file-system. +** +** Temporary pager files may enter the ERROR state, but in-memory pagers +** cannot. +** +** For example, if an IO error occurs while performing a rollback, +** the contents of the page-cache may be left in an inconsistent state. +** At this point it would be dangerous to change back to READER state +** (as usually happens after a rollback). Any subsequent readers might +** report database corruption (due to the inconsistent cache), and if +** they upgrade to writers, they may inadvertently corrupt the database +** file. To avoid this hazard, the pager switches into the ERROR state +** instead of READER following such an error. +** +** Once it has entered the ERROR state, any attempt to use the pager +** to read or write data returns an error. Eventually, once all +** outstanding transactions have been abandoned, the pager is able to +** transition back to OPEN state, discarding the contents of the +** page-cache and any other in-memory state at the same time. Everything +** is reloaded from disk (and, if necessary, hot-journal rollback peformed) +** when a read-transaction is next opened on the pager (transitioning +** the pager into READER state). At that point the system has recovered +** from the error. +** +** Specifically, the pager jumps into the ERROR state if: +** +** 1. An error occurs while attempting a rollback. This happens in +** function sqlite3PagerRollback(). +** +** 2. An error occurs while attempting to finalize a journal file +** following a commit in function sqlite3PagerCommitPhaseTwo(). +** +** 3. An error occurs while attempting to write to the journal or +** database file in function pagerStress() in order to free up +** memory. +** +** In other cases, the error is returned to the b-tree layer. The b-tree +** layer then attempts a rollback operation. If the error condition +** persists, the pager enters the ERROR state via condition (1) above. +** +** Condition (3) is necessary because it can be triggered by a read-only +** statement executed within a transaction. In this case, if the error +** code were simply returned to the user, the b-tree layer would not +** automatically attempt a rollback, as it assumes that an error in a +** read-only statement cannot leave the pager in an internally inconsistent +** state. +** +** * The Pager.errCode variable is set to something other than SQLITE_OK. +** * There are one or more outstanding references to pages (after the +** last reference is dropped the pager should move back to OPEN state). +** * The pager is not an in-memory pager. +** +** +** Notes: +** +** * A pager is never in WRITER_DBMOD or WRITER_FINISHED state if the +** connection is open in WAL mode. A WAL connection is always in one +** of the first four states. +** +** * Normally, a connection open in exclusive mode is never in PAGER_OPEN +** state. There are two exceptions: immediately after exclusive-mode has +** been turned on (and before any read or write transactions are +** executed), and when the pager is leaving the "error state". +** +** * See also: assert_pager_state(). +*/ +#define PAGER_OPEN 0 +#define PAGER_READER 1 +#define PAGER_WRITER_LOCKED 2 +#define PAGER_WRITER_CACHEMOD 3 +#define PAGER_WRITER_DBMOD 4 +#define PAGER_WRITER_FINISHED 5 +#define PAGER_ERROR 6 + +/* +** The Pager.eLock variable is almost always set to one of the +** following locking-states, according to the lock currently held on +** the database file: NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK. +** This variable is kept up to date as locks are taken and released by +** the pagerLockDb() and pagerUnlockDb() wrappers. +** +** If the VFS xLock() or xUnlock() returns an error other than SQLITE_BUSY +** (i.e. one of the SQLITE_IOERR subtypes), it is not clear whether or not +** the operation was successful. In these circumstances pagerLockDb() and +** pagerUnlockDb() take a conservative approach - eLock is always updated +** when unlocking the file, and only updated when locking the file if the +** VFS call is successful. This way, the Pager.eLock variable may be set +** to a less exclusive (lower) value than the lock that is actually held +** at the system level, but it is never set to a more exclusive value. +** +** This is usually safe. If an xUnlock fails or appears to fail, there may +** be a few redundant xLock() calls or a lock may be held for longer than +** required, but nothing really goes wrong. +** +** The exception is when the database file is unlocked as the pager moves +** from ERROR to OPEN state. At this point there may be a hot-journal file +** in the file-system that needs to be rolled back (as part of an OPEN->SHARED +** transition, by the same pager or any other). If the call to xUnlock() +** fails at this point and the pager is left holding an EXCLUSIVE lock, this +** can confuse the call to xCheckReservedLock() call made later as part +** of hot-journal detection. +** +** xCheckReservedLock() is defined as returning true "if there is a RESERVED +** lock held by this process or any others". So xCheckReservedLock may +** return true because the caller itself is holding an EXCLUSIVE lock (but +** doesn't know it because of a previous error in xUnlock). If this happens +** a hot-journal may be mistaken for a journal being created by an active +** transaction in another process, causing SQLite to read from the database +** without rolling it back. +** +** To work around this, if a call to xUnlock() fails when unlocking the +** database in the ERROR state, Pager.eLock is set to UNKNOWN_LOCK. It +** is only changed back to a real locking state after a successful call +** to xLock(EXCLUSIVE). Also, the code to do the OPEN->SHARED state transition +** omits the check for a hot-journal if Pager.eLock is set to UNKNOWN_LOCK +** lock. Instead, it assumes a hot-journal exists and obtains an EXCLUSIVE +** lock on the database file before attempting to roll it back. See function +** PagerSharedLock() for more detail. +** +** Pager.eLock may only be set to UNKNOWN_LOCK when the pager is in +** PAGER_OPEN state. +*/ +#define UNKNOWN_LOCK (EXCLUSIVE_LOCK+1) + +/* +** The maximum allowed sector size. 64KiB. If the xSectorsize() method +** returns a value larger than this, then MAX_SECTOR_SIZE is used instead. +** This could conceivably cause corruption following a power failure on +** such a system. This is currently an undocumented limit. +*/ +#define MAX_SECTOR_SIZE 0x10000 + + +/* +** An instance of the following structure is allocated for each active +** savepoint and statement transaction in the system. All such structures +** are stored in the Pager.aSavepoint[] array, which is allocated and +** resized using sqlite3Realloc(). +** +** When a savepoint is created, the PagerSavepoint.iHdrOffset field is +** set to 0. If a journal-header is written into the main journal while +** the savepoint is active, then iHdrOffset is set to the byte offset +** immediately following the last journal record written into the main +** journal before the journal-header. This is required during savepoint +** rollback (see pagerPlaybackSavepoint()). +*/ +typedef struct PagerSavepoint PagerSavepoint; +struct PagerSavepoint { + i64 iOffset; /* Starting offset in main journal */ + i64 iHdrOffset; /* See above */ + Bitvec *pInSavepoint; /* Set of pages in this savepoint */ + Pgno nOrig; /* Original number of pages in file */ + Pgno iSubRec; /* Index of first record in sub-journal */ +#ifndef SQLITE_OMIT_WAL + u32 aWalData[WAL_SAVEPOINT_NDATA]; /* WAL savepoint context */ +#endif +}; + +/* +** Bits of the Pager.doNotSpill flag. See further description below. +*/ +#define SPILLFLAG_OFF 0x01 /* Never spill cache. Set via pragma */ +#define SPILLFLAG_ROLLBACK 0x02 /* Current rolling back, so do not spill */ +#define SPILLFLAG_NOSYNC 0x04 /* Spill is ok, but do not sync */ + +/* +** An open page cache is an instance of struct Pager. A description of +** some of the more important member variables follows: +** +** eState +** +** The current 'state' of the pager object. See the comment and state +** diagram above for a description of the pager state. +** +** eLock +** +** For a real on-disk database, the current lock held on the database file - +** NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK. +** +** For a temporary or in-memory database (neither of which require any +** locks), this variable is always set to EXCLUSIVE_LOCK. Since such +** databases always have Pager.exclusiveMode==1, this tricks the pager +** logic into thinking that it already has all the locks it will ever +** need (and no reason to release them). +** +** In some (obscure) circumstances, this variable may also be set to +** UNKNOWN_LOCK. See the comment above the #define of UNKNOWN_LOCK for +** details. +** +** changeCountDone +** +** This boolean variable is used to make sure that the change-counter +** (the 4-byte header field at byte offset 24 of the database file) is +** not updated more often than necessary. +** +** It is set to true when the change-counter field is updated, which +** can only happen if an exclusive lock is held on the database file. +** It is cleared (set to false) whenever an exclusive lock is +** relinquished on the database file. Each time a transaction is committed, +** The changeCountDone flag is inspected. If it is true, the work of +** updating the change-counter is omitted for the current transaction. +** +** This mechanism means that when running in exclusive mode, a connection +** need only update the change-counter once, for the first transaction +** committed. +** +** setSuper +** +** When PagerCommitPhaseOne() is called to commit a transaction, it may +** (or may not) specify a super-journal name to be written into the +** journal file before it is synced to disk. +** +** Whether or not a journal file contains a super-journal pointer affects +** the way in which the journal file is finalized after the transaction is +** committed or rolled back when running in "journal_mode=PERSIST" mode. +** If a journal file does not contain a super-journal pointer, it is +** finalized by overwriting the first journal header with zeroes. If +** it does contain a super-journal pointer the journal file is finalized +** by truncating it to zero bytes, just as if the connection were +** running in "journal_mode=truncate" mode. +** +** Journal files that contain super-journal pointers cannot be finalized +** simply by overwriting the first journal-header with zeroes, as the +** super-journal pointer could interfere with hot-journal rollback of any +** subsequently interrupted transaction that reuses the journal file. +** +** The flag is cleared as soon as the journal file is finalized (either +** by PagerCommitPhaseTwo or PagerRollback). If an IO error prevents the +** journal file from being successfully finalized, the setSuper flag +** is cleared anyway (and the pager will move to ERROR state). +** +** doNotSpill +** +** This variables control the behavior of cache-spills (calls made by +** the pcache module to the pagerStress() routine to write cached data +** to the file-system in order to free up memory). +** +** When bits SPILLFLAG_OFF or SPILLFLAG_ROLLBACK of doNotSpill are set, +** writing to the database from pagerStress() is disabled altogether. +** The SPILLFLAG_ROLLBACK case is done in a very obscure case that +** comes up during savepoint rollback that requires the pcache module +** to allocate a new page to prevent the journal file from being written +** while it is being traversed by code in pager_playback(). The SPILLFLAG_OFF +** case is a user preference. +** +** If the SPILLFLAG_NOSYNC bit is set, writing to the database from +** pagerStress() is permitted, but syncing the journal file is not. +** This flag is set by sqlite3PagerWrite() when the file-system sector-size +** is larger than the database page-size in order to prevent a journal sync +** from happening in between the journalling of two pages on the same sector. +** +** subjInMemory +** +** This is a boolean variable. If true, then any required sub-journal +** is opened as an in-memory journal file. If false, then in-memory +** sub-journals are only used for in-memory pager files. +** +** This variable is updated by the upper layer each time a new +** write-transaction is opened. +** +** dbSize, dbOrigSize, dbFileSize +** +** Variable dbSize is set to the number of pages in the database file. +** It is valid in PAGER_READER and higher states (all states except for +** OPEN and ERROR). +** +** dbSize is set based on the size of the database file, which may be +** larger than the size of the database (the value stored at offset +** 28 of the database header by the btree). If the size of the file +** is not an integer multiple of the page-size, the value stored in +** dbSize is rounded down (i.e. a 5KB file with 2K page-size has dbSize==2). +** Except, any file that is greater than 0 bytes in size is considered +** to have at least one page. (i.e. a 1KB file with 2K page-size leads +** to dbSize==1). +** +** During a write-transaction, if pages with page-numbers greater than +** dbSize are modified in the cache, dbSize is updated accordingly. +** Similarly, if the database is truncated using PagerTruncateImage(), +** dbSize is updated. +** +** Variables dbOrigSize and dbFileSize are valid in states +** PAGER_WRITER_LOCKED and higher. dbOrigSize is a copy of the dbSize +** variable at the start of the transaction. It is used during rollback, +** and to determine whether or not pages need to be journalled before +** being modified. +** +** Throughout a write-transaction, dbFileSize contains the size of +** the file on disk in pages. It is set to a copy of dbSize when the +** write-transaction is first opened, and updated when VFS calls are made +** to write or truncate the database file on disk. +** +** The only reason the dbFileSize variable is required is to suppress +** unnecessary calls to xTruncate() after committing a transaction. If, +** when a transaction is committed, the dbFileSize variable indicates +** that the database file is larger than the database image (Pager.dbSize), +** pager_truncate() is called. The pager_truncate() call uses xFilesize() +** to measure the database file on disk, and then truncates it if required. +** dbFileSize is not used when rolling back a transaction. In this case +** pager_truncate() is called unconditionally (which means there may be +** a call to xFilesize() that is not strictly required). In either case, +** pager_truncate() may cause the file to become smaller or larger. +** +** dbHintSize +** +** The dbHintSize variable is used to limit the number of calls made to +** the VFS xFileControl(FCNTL_SIZE_HINT) method. +** +** dbHintSize is set to a copy of the dbSize variable when a +** write-transaction is opened (at the same time as dbFileSize and +** dbOrigSize). If the xFileControl(FCNTL_SIZE_HINT) method is called, +** dbHintSize is increased to the number of pages that correspond to the +** size-hint passed to the method call. See pager_write_pagelist() for +** details. +** +** errCode +** +** The Pager.errCode variable is only ever used in PAGER_ERROR state. It +** is set to zero in all other states. In PAGER_ERROR state, Pager.errCode +** is always set to SQLITE_FULL, SQLITE_IOERR or one of the SQLITE_IOERR_XXX +** sub-codes. +** +** syncFlags, walSyncFlags +** +** syncFlags is either SQLITE_SYNC_NORMAL (0x02) or SQLITE_SYNC_FULL (0x03). +** syncFlags is used for rollback mode. walSyncFlags is used for WAL mode +** and contains the flags used to sync the checkpoint operations in the +** lower two bits, and sync flags used for transaction commits in the WAL +** file in bits 0x04 and 0x08. In other words, to get the correct sync flags +** for checkpoint operations, use (walSyncFlags&0x03) and to get the correct +** sync flags for transaction commit, use ((walSyncFlags>>2)&0x03). Note +** that with synchronous=NORMAL in WAL mode, transaction commit is not synced +** meaning that the 0x04 and 0x08 bits are both zero. +*/ +struct Pager { + sqlite3_vfs *pVfs; /* OS functions to use for IO */ + u8 exclusiveMode; /* Boolean. True if locking_mode==EXCLUSIVE */ + u8 journalMode; /* One of the PAGER_JOURNALMODE_* values */ + u8 useJournal; /* Use a rollback journal on this file */ + u8 noSync; /* Do not sync the journal if true */ + u8 fullSync; /* Do extra syncs of the journal for robustness */ + u8 extraSync; /* sync directory after journal delete */ + u8 syncFlags; /* SYNC_NORMAL or SYNC_FULL otherwise */ + u8 walSyncFlags; /* See description above */ + u8 tempFile; /* zFilename is a temporary or immutable file */ + u8 noLock; /* Do not lock (except in WAL mode) */ + u8 readOnly; /* True for a read-only database */ + u8 memDb; /* True to inhibit all file I/O */ + + /************************************************************************** + ** The following block contains those class members that change during + ** routine operation. Class members not in this block are either fixed + ** when the pager is first created or else only change when there is a + ** significant mode change (such as changing the page_size, locking_mode, + ** or the journal_mode). From another view, these class members describe + ** the "state" of the pager, while other class members describe the + ** "configuration" of the pager. + */ + u8 eState; /* Pager state (OPEN, READER, WRITER_LOCKED..) */ + u8 eLock; /* Current lock held on database file */ + u8 changeCountDone; /* Set after incrementing the change-counter */ + u8 setSuper; /* Super-jrnl name is written into jrnl */ + u8 doNotSpill; /* Do not spill the cache when non-zero */ + u8 subjInMemory; /* True to use in-memory sub-journals */ + u8 bUseFetch; /* True to use xFetch() */ + u8 hasHeldSharedLock; /* True if a shared lock has ever been held */ + Pgno dbSize; /* Number of pages in the database */ + Pgno dbOrigSize; /* dbSize before the current transaction */ + Pgno dbFileSize; /* Number of pages in the database file */ + Pgno dbHintSize; /* Value passed to FCNTL_SIZE_HINT call */ + int errCode; /* One of several kinds of errors */ + int nRec; /* Pages journalled since last j-header written */ + u32 cksumInit; /* Quasi-random value added to every checksum */ + u32 nSubRec; /* Number of records written to sub-journal */ + Bitvec *pInJournal; /* One bit for each page in the database file */ + sqlite3_file *fd; /* File descriptor for database */ + sqlite3_file *jfd; /* File descriptor for main journal */ + sqlite3_file *sjfd; /* File descriptor for sub-journal */ + i64 journalOff; /* Current write offset in the journal file */ + i64 journalHdr; /* Byte offset to previous journal header */ + sqlite3_backup *pBackup; /* Pointer to list of ongoing backup processes */ + PagerSavepoint *aSavepoint; /* Array of active savepoints */ + int nSavepoint; /* Number of elements in aSavepoint[] */ + u32 iDataVersion; /* Changes whenever database content changes */ + char dbFileVers[16]; /* Changes whenever database file changes */ + + int nMmapOut; /* Number of mmap pages currently outstanding */ + sqlite3_int64 szMmap; /* Desired maximum mmap size */ + PgHdr *pMmapFreelist; /* List of free mmap page headers (pDirty) */ + /* + ** End of the routinely-changing class members + ***************************************************************************/ + + u16 nExtra; /* Add this many bytes to each in-memory page */ + i16 nReserve; /* Number of unused bytes at end of each page */ + u32 vfsFlags; /* Flags for sqlite3_vfs.xOpen() */ + u32 sectorSize; /* Assumed sector size during rollback */ + int pageSize; /* Number of bytes in a page */ + Pgno mxPgno; /* Maximum allowed size of the database */ + i64 journalSizeLimit; /* Size limit for persistent journal files */ + char *zFilename; /* Name of the database file */ + char *zJournal; /* Name of the journal file */ + int (*xBusyHandler)(void*); /* Function to call when busy */ + void *pBusyHandlerArg; /* Context argument for xBusyHandler */ + int aStat[4]; /* Total cache hits, misses, writes, spills */ +#ifdef SQLITE_TEST + int nRead; /* Database pages read */ +#endif + void (*xReiniter)(DbPage*); /* Call this routine when reloading pages */ + int (*xGet)(Pager*,Pgno,DbPage**,int); /* Routine to fetch a patch */ + char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */ + PCache *pPCache; /* Pointer to page cache object */ +#ifndef SQLITE_OMIT_WAL + Wal *pWal; /* Write-ahead log used by "journal_mode=wal" */ + char *zWal; /* File name for write-ahead log */ +#endif +}; + +/* +** Indexes for use with Pager.aStat[]. The Pager.aStat[] array contains +** the values accessed by passing SQLITE_DBSTATUS_CACHE_HIT, CACHE_MISS +** or CACHE_WRITE to sqlite3_db_status(). +*/ +#define PAGER_STAT_HIT 0 +#define PAGER_STAT_MISS 1 +#define PAGER_STAT_WRITE 2 +#define PAGER_STAT_SPILL 3 + +/* +** The following global variables hold counters used for +** testing purposes only. These variables do not exist in +** a non-testing build. These variables are not thread-safe. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_pager_readdb_count = 0; /* Number of full pages read from DB */ +SQLITE_API int sqlite3_pager_writedb_count = 0; /* Number of full pages written to DB */ +SQLITE_API int sqlite3_pager_writej_count = 0; /* Number of pages written to journal */ +# define PAGER_INCR(v) v++ +#else +# define PAGER_INCR(v) +#endif + + + +/* +** Journal files begin with the following magic string. The data +** was obtained from /dev/random. It is used only as a sanity check. +** +** Since version 2.8.0, the journal format contains additional sanity +** checking information. If the power fails while the journal is being +** written, semi-random garbage data might appear in the journal +** file after power is restored. If an attempt is then made +** to roll the journal back, the database could be corrupted. The additional +** sanity checking data is an attempt to discover the garbage in the +** journal and ignore it. +** +** The sanity checking information for the new journal format consists +** of a 32-bit checksum on each page of data. The checksum covers both +** the page number and the pPager->pageSize bytes of data for the page. +** This cksum is initialized to a 32-bit random value that appears in the +** journal file right after the header. The random initializer is important, +** because garbage data that appears at the end of a journal is likely +** data that was once in other files that have now been deleted. If the +** garbage data came from an obsolete journal file, the checksums might +** be correct. But by initializing the checksum to random value which +** is different for every journal, we minimize that risk. +*/ +static const unsigned char aJournalMagic[] = { + 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7, +}; + +/* +** The size of the of each page record in the journal is given by +** the following macro. +*/ +#define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8) + +/* +** The journal header size for this pager. This is usually the same +** size as a single disk sector. See also setSectorSize(). +*/ +#define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize) + +/* +** The macro MEMDB is true if we are dealing with an in-memory database. +** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set, +** the value of MEMDB will be a constant and the compiler will optimize +** out code that would never execute. +*/ +#ifdef SQLITE_OMIT_MEMORYDB +# define MEMDB 0 +#else +# define MEMDB pPager->memDb +#endif + +/* +** The macro USEFETCH is true if we are allowed to use the xFetch and xUnfetch +** interfaces to access the database using memory-mapped I/O. +*/ +#if SQLITE_MAX_MMAP_SIZE>0 +# define USEFETCH(x) ((x)->bUseFetch) +#else +# define USEFETCH(x) 0 +#endif + +/* +** The argument to this macro is a file descriptor (type sqlite3_file*). +** Return 0 if it is not open, or non-zero (but not 1) if it is. +** +** This is so that expressions can be written as: +** +** if( isOpen(pPager->jfd) ){ ... +** +** instead of +** +** if( pPager->jfd->pMethods ){ ... +*/ +#define isOpen(pFd) ((pFd)->pMethods!=0) + +#ifdef SQLITE_DIRECT_OVERFLOW_READ +/* +** Return true if page pgno can be read directly from the database file +** by the b-tree layer. This is the case if: +** +** * the database file is open, +** * there are no dirty pages in the cache, and +** * the desired page is not currently in the wal file. +*/ +SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno){ + if( pPager->fd->pMethods==0 ) return 0; + if( sqlite3PCacheIsDirty(pPager->pPCache) ) return 0; +#ifndef SQLITE_OMIT_WAL + if( pPager->pWal ){ + u32 iRead = 0; + int rc; + rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iRead); + return (rc==SQLITE_OK && iRead==0); + } +#endif + return 1; +} +#endif + +#ifndef SQLITE_OMIT_WAL +# define pagerUseWal(x) ((x)->pWal!=0) +#else +# define pagerUseWal(x) 0 +# define pagerRollbackWal(x) 0 +# define pagerWalFrames(v,w,x,y) 0 +# define pagerOpenWalIfPresent(z) SQLITE_OK +# define pagerBeginReadTransaction(z) SQLITE_OK +#endif + +#ifndef NDEBUG +/* +** Usage: +** +** assert( assert_pager_state(pPager) ); +** +** This function runs many asserts to try to find inconsistencies in +** the internal state of the Pager object. +*/ +static int assert_pager_state(Pager *p){ + Pager *pPager = p; + + /* State must be valid. */ + assert( p->eState==PAGER_OPEN + || p->eState==PAGER_READER + || p->eState==PAGER_WRITER_LOCKED + || p->eState==PAGER_WRITER_CACHEMOD + || p->eState==PAGER_WRITER_DBMOD + || p->eState==PAGER_WRITER_FINISHED + || p->eState==PAGER_ERROR + ); + + /* Regardless of the current state, a temp-file connection always behaves + ** as if it has an exclusive lock on the database file. It never updates + ** the change-counter field, so the changeCountDone flag is always set. + */ + assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK ); + assert( p->tempFile==0 || pPager->changeCountDone ); + + /* If the useJournal flag is clear, the journal-mode must be "OFF". + ** And if the journal-mode is "OFF", the journal file must not be open. + */ + assert( p->journalMode==PAGER_JOURNALMODE_OFF || p->useJournal ); + assert( p->journalMode!=PAGER_JOURNALMODE_OFF || !isOpen(p->jfd) ); + + /* Check that MEMDB implies noSync. And an in-memory journal. Since + ** this means an in-memory pager performs no IO at all, it cannot encounter + ** either SQLITE_IOERR or SQLITE_FULL during rollback or while finalizing + ** a journal file. (although the in-memory journal implementation may + ** return SQLITE_IOERR_NOMEM while the journal file is being written). It + ** is therefore not possible for an in-memory pager to enter the ERROR + ** state. + */ + if( MEMDB ){ + assert( !isOpen(p->fd) ); + assert( p->noSync ); + assert( p->journalMode==PAGER_JOURNALMODE_OFF + || p->journalMode==PAGER_JOURNALMODE_MEMORY + ); + assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN ); + assert( pagerUseWal(p)==0 ); + } + + /* If changeCountDone is set, a RESERVED lock or greater must be held + ** on the file. + */ + assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK ); + assert( p->eLock!=PENDING_LOCK ); + + switch( p->eState ){ + case PAGER_OPEN: + assert( !MEMDB ); + assert( pPager->errCode==SQLITE_OK ); + assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile ); + break; + + case PAGER_READER: + assert( pPager->errCode==SQLITE_OK ); + assert( p->eLock!=UNKNOWN_LOCK ); + assert( p->eLock>=SHARED_LOCK ); + break; + + case PAGER_WRITER_LOCKED: + assert( p->eLock!=UNKNOWN_LOCK ); + assert( pPager->errCode==SQLITE_OK ); + if( !pagerUseWal(pPager) ){ + assert( p->eLock>=RESERVED_LOCK ); + } + assert( pPager->dbSize==pPager->dbOrigSize ); + assert( pPager->dbOrigSize==pPager->dbFileSize ); + assert( pPager->dbOrigSize==pPager->dbHintSize ); + assert( pPager->setSuper==0 ); + break; + + case PAGER_WRITER_CACHEMOD: + assert( p->eLock!=UNKNOWN_LOCK ); + assert( pPager->errCode==SQLITE_OK ); + if( !pagerUseWal(pPager) ){ + /* It is possible that if journal_mode=wal here that neither the + ** journal file nor the WAL file are open. This happens during + ** a rollback transaction that switches from journal_mode=off + ** to journal_mode=wal. + */ + assert( p->eLock>=RESERVED_LOCK ); + assert( isOpen(p->jfd) + || p->journalMode==PAGER_JOURNALMODE_OFF + || p->journalMode==PAGER_JOURNALMODE_WAL + ); + } + assert( pPager->dbOrigSize==pPager->dbFileSize ); + assert( pPager->dbOrigSize==pPager->dbHintSize ); + break; + + case PAGER_WRITER_DBMOD: + assert( p->eLock==EXCLUSIVE_LOCK ); + assert( pPager->errCode==SQLITE_OK ); + assert( !pagerUseWal(pPager) ); + assert( p->eLock>=EXCLUSIVE_LOCK ); + assert( isOpen(p->jfd) + || p->journalMode==PAGER_JOURNALMODE_OFF + || p->journalMode==PAGER_JOURNALMODE_WAL + || (sqlite3OsDeviceCharacteristics(p->fd)&SQLITE_IOCAP_BATCH_ATOMIC) + ); + assert( pPager->dbOrigSize<=pPager->dbHintSize ); + break; + + case PAGER_WRITER_FINISHED: + assert( p->eLock==EXCLUSIVE_LOCK ); + assert( pPager->errCode==SQLITE_OK ); + assert( !pagerUseWal(pPager) ); + assert( isOpen(p->jfd) + || p->journalMode==PAGER_JOURNALMODE_OFF + || p->journalMode==PAGER_JOURNALMODE_WAL + || (sqlite3OsDeviceCharacteristics(p->fd)&SQLITE_IOCAP_BATCH_ATOMIC) + ); + break; + + case PAGER_ERROR: + /* There must be at least one outstanding reference to the pager if + ** in ERROR state. Otherwise the pager should have already dropped + ** back to OPEN state. + */ + assert( pPager->errCode!=SQLITE_OK ); + assert( sqlite3PcacheRefCount(pPager->pPCache)>0 || pPager->tempFile ); + break; + } + + return 1; +} +#endif /* ifndef NDEBUG */ + +#ifdef SQLITE_DEBUG +/* +** Return a pointer to a human readable string in a static buffer +** containing the state of the Pager object passed as an argument. This +** is intended to be used within debuggers. For example, as an alternative +** to "print *pPager" in gdb: +** +** (gdb) printf "%s", print_pager_state(pPager) +** +** This routine has external linkage in order to suppress compiler warnings +** about an unused function. It is enclosed within SQLITE_DEBUG and so does +** not appear in normal builds. +*/ +char *print_pager_state(Pager *p){ + static char zRet[1024]; + + sqlite3_snprintf(1024, zRet, + "Filename: %s\n" + "State: %s errCode=%d\n" + "Lock: %s\n" + "Locking mode: locking_mode=%s\n" + "Journal mode: journal_mode=%s\n" + "Backing store: tempFile=%d memDb=%d useJournal=%d\n" + "Journal: journalOff=%lld journalHdr=%lld\n" + "Size: dbsize=%d dbOrigSize=%d dbFileSize=%d\n" + , p->zFilename + , p->eState==PAGER_OPEN ? "OPEN" : + p->eState==PAGER_READER ? "READER" : + p->eState==PAGER_WRITER_LOCKED ? "WRITER_LOCKED" : + p->eState==PAGER_WRITER_CACHEMOD ? "WRITER_CACHEMOD" : + p->eState==PAGER_WRITER_DBMOD ? "WRITER_DBMOD" : + p->eState==PAGER_WRITER_FINISHED ? "WRITER_FINISHED" : + p->eState==PAGER_ERROR ? "ERROR" : "?error?" + , (int)p->errCode + , p->eLock==NO_LOCK ? "NO_LOCK" : + p->eLock==RESERVED_LOCK ? "RESERVED" : + p->eLock==EXCLUSIVE_LOCK ? "EXCLUSIVE" : + p->eLock==SHARED_LOCK ? "SHARED" : + p->eLock==UNKNOWN_LOCK ? "UNKNOWN" : "?error?" + , p->exclusiveMode ? "exclusive" : "normal" + , p->journalMode==PAGER_JOURNALMODE_MEMORY ? "memory" : + p->journalMode==PAGER_JOURNALMODE_OFF ? "off" : + p->journalMode==PAGER_JOURNALMODE_DELETE ? "delete" : + p->journalMode==PAGER_JOURNALMODE_PERSIST ? "persist" : + p->journalMode==PAGER_JOURNALMODE_TRUNCATE ? "truncate" : + p->journalMode==PAGER_JOURNALMODE_WAL ? "wal" : "?error?" + , (int)p->tempFile, (int)p->memDb, (int)p->useJournal + , p->journalOff, p->journalHdr + , (int)p->dbSize, (int)p->dbOrigSize, (int)p->dbFileSize + ); + + return zRet; +} +#endif + +/* Forward references to the various page getters */ +static int getPageNormal(Pager*,Pgno,DbPage**,int); +static int getPageError(Pager*,Pgno,DbPage**,int); +#if SQLITE_MAX_MMAP_SIZE>0 +static int getPageMMap(Pager*,Pgno,DbPage**,int); +#endif + +/* +** Set the Pager.xGet method for the appropriate routine used to fetch +** content from the pager. +*/ +static void setGetterMethod(Pager *pPager){ + if( pPager->errCode ){ + pPager->xGet = getPageError; +#if SQLITE_MAX_MMAP_SIZE>0 + }else if( USEFETCH(pPager) ){ + pPager->xGet = getPageMMap; +#endif /* SQLITE_MAX_MMAP_SIZE>0 */ + }else{ + pPager->xGet = getPageNormal; + } +} + +/* +** Return true if it is necessary to write page *pPg into the sub-journal. +** A page needs to be written into the sub-journal if there exists one +** or more open savepoints for which: +** +** * The page-number is less than or equal to PagerSavepoint.nOrig, and +** * The bit corresponding to the page-number is not set in +** PagerSavepoint.pInSavepoint. +*/ +static int subjRequiresPage(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + PagerSavepoint *p; + Pgno pgno = pPg->pgno; + int i; + for(i=0; inSavepoint; i++){ + p = &pPager->aSavepoint[i]; + if( p->nOrig>=pgno && 0==sqlite3BitvecTestNotNull(p->pInSavepoint, pgno) ){ + return 1; + } + } + return 0; +} + +#ifdef SQLITE_DEBUG +/* +** Return true if the page is already in the journal file. +*/ +static int pageInJournal(Pager *pPager, PgHdr *pPg){ + return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno); +} +#endif + +/* +** Read a 32-bit integer from the given file descriptor. Store the integer +** that is read in *pRes. Return SQLITE_OK if everything worked, or an +** error code is something goes wrong. +** +** All values are stored on disk as big-endian. +*/ +static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){ + unsigned char ac[4]; + int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset); + if( rc==SQLITE_OK ){ + *pRes = sqlite3Get4byte(ac); + } + return rc; +} + +/* +** Write a 32-bit integer into a string buffer in big-endian byte order. +*/ +#define put32bits(A,B) sqlite3Put4byte((u8*)A,B) + + +/* +** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK +** on success or an error code is something goes wrong. +*/ +static int write32bits(sqlite3_file *fd, i64 offset, u32 val){ + char ac[4]; + put32bits(ac, val); + return sqlite3OsWrite(fd, ac, 4, offset); +} + +/* +** Unlock the database file to level eLock, which must be either NO_LOCK +** or SHARED_LOCK. Regardless of whether or not the call to xUnlock() +** succeeds, set the Pager.eLock variable to match the (attempted) new lock. +** +** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is +** called, do not modify it. See the comment above the #define of +** UNKNOWN_LOCK for an explanation of this. +*/ +static int pagerUnlockDb(Pager *pPager, int eLock){ + int rc = SQLITE_OK; + + assert( !pPager->exclusiveMode || pPager->eLock==eLock ); + assert( eLock==NO_LOCK || eLock==SHARED_LOCK ); + assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 ); + if( isOpen(pPager->fd) ){ + assert( pPager->eLock>=eLock ); + rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock); + if( pPager->eLock!=UNKNOWN_LOCK ){ + pPager->eLock = (u8)eLock; + } + IOTRACE(("UNLOCK %p %d\n", pPager, eLock)) + } + pPager->changeCountDone = pPager->tempFile; /* ticket fb3b3024ea238d5c */ + return rc; +} + +/* +** Lock the database file to level eLock, which must be either SHARED_LOCK, +** RESERVED_LOCK or EXCLUSIVE_LOCK. If the caller is successful, set the +** Pager.eLock variable to the new locking state. +** +** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is +** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK. +** See the comment above the #define of UNKNOWN_LOCK for an explanation +** of this. +*/ +static int pagerLockDb(Pager *pPager, int eLock){ + int rc = SQLITE_OK; + + assert( eLock==SHARED_LOCK || eLock==RESERVED_LOCK || eLock==EXCLUSIVE_LOCK ); + if( pPager->eLockeLock==UNKNOWN_LOCK ){ + rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock); + if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){ + pPager->eLock = (u8)eLock; + IOTRACE(("LOCK %p %d\n", pPager, eLock)) + } + } + return rc; +} + +/* +** This function determines whether or not the atomic-write or +** atomic-batch-write optimizations can be used with this pager. The +** atomic-write optimization can be used if: +** +** (a) the value returned by OsDeviceCharacteristics() indicates that +** a database page may be written atomically, and +** (b) the value returned by OsSectorSize() is less than or equal +** to the page size. +** +** If it can be used, then the value returned is the size of the journal +** file when it contains rollback data for exactly one page. +** +** The atomic-batch-write optimization can be used if OsDeviceCharacteristics() +** returns a value with the SQLITE_IOCAP_BATCH_ATOMIC bit set. -1 is +** returned in this case. +** +** If neither optimization can be used, 0 is returned. +*/ +static int jrnlBufferSize(Pager *pPager){ + assert( !MEMDB ); + +#if defined(SQLITE_ENABLE_ATOMIC_WRITE) \ + || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE) + int dc; /* Device characteristics */ + + assert( isOpen(pPager->fd) ); + dc = sqlite3OsDeviceCharacteristics(pPager->fd); +#else + UNUSED_PARAMETER(pPager); +#endif + +#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE + if( pPager->dbSize>0 && (dc&SQLITE_IOCAP_BATCH_ATOMIC) ){ + return -1; + } +#endif + +#ifdef SQLITE_ENABLE_ATOMIC_WRITE + { + int nSector = pPager->sectorSize; + int szPage = pPager->pageSize; + + assert(SQLITE_IOCAP_ATOMIC512==(512>>8)); + assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8)); + if( 0==(dc&(SQLITE_IOCAP_ATOMIC|(szPage>>8)) || nSector>szPage) ){ + return 0; + } + } + + return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager); +#endif + + return 0; +} + +/* +** If SQLITE_CHECK_PAGES is defined then we do some sanity checking +** on the cache using a hash function. This is used for testing +** and debugging only. +*/ +#ifdef SQLITE_CHECK_PAGES +/* +** Return a 32-bit hash of the page data for pPage. +*/ +static u32 pager_datahash(int nByte, unsigned char *pData){ + u32 hash = 0; + int i; + for(i=0; ipPager->pageSize, (unsigned char *)pPage->pData); +} +static void pager_set_pagehash(PgHdr *pPage){ + pPage->pageHash = pager_pagehash(pPage); +} + +/* +** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES +** is defined, and NDEBUG is not defined, an assert() statement checks +** that the page is either dirty or still matches the calculated page-hash. +*/ +#define CHECK_PAGE(x) checkPage(x) +static void checkPage(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + assert( pPager->eState!=PAGER_ERROR ); + assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) ); +} + +#else +#define pager_datahash(X,Y) 0 +#define pager_pagehash(X) 0 +#define pager_set_pagehash(X) +#define CHECK_PAGE(x) +#endif /* SQLITE_CHECK_PAGES */ + +/* +** When this is called the journal file for pager pPager must be open. +** This function attempts to read a super-journal file name from the +** end of the file and, if successful, copies it into memory supplied +** by the caller. See comments above writeSuperJournal() for the format +** used to store a super-journal file name at the end of a journal file. +** +** zSuper must point to a buffer of at least nSuper bytes allocated by +** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is +** enough space to write the super-journal name). If the super-journal +** name in the journal is longer than nSuper bytes (including a +** nul-terminator), then this is handled as if no super-journal name +** were present in the journal. +** +** If a super-journal file name is present at the end of the journal +** file, then it is copied into the buffer pointed to by zSuper. A +** nul-terminator byte is appended to the buffer following the +** super-journal file name. +** +** If it is determined that no super-journal file name is present +** zSuper[0] is set to 0 and SQLITE_OK returned. +** +** If an error occurs while reading from the journal file, an SQLite +** error code is returned. +*/ +static int readSuperJournal(sqlite3_file *pJrnl, char *zSuper, u32 nSuper){ + int rc; /* Return code */ + u32 len; /* Length in bytes of super-journal name */ + i64 szJ; /* Total size in bytes of journal file pJrnl */ + u32 cksum; /* MJ checksum value read from journal */ + u32 u; /* Unsigned loop counter */ + unsigned char aMagic[8]; /* A buffer to hold the magic header */ + zSuper[0] = '\0'; + + if( SQLITE_OK!=(rc = sqlite3OsFileSize(pJrnl, &szJ)) + || szJ<16 + || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len)) + || len>=nSuper + || len>szJ-16 + || len==0 + || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum)) + || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8)) + || memcmp(aMagic, aJournalMagic, 8) + || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, zSuper, len, szJ-16-len)) + ){ + return rc; + } + + /* See if the checksum matches the super-journal name */ + for(u=0; ujournalOff, assuming a sector +** size of pPager->sectorSize bytes. +** +** i.e for a sector size of 512: +** +** Pager.journalOff Return value +** --------------------------------------- +** 0 0 +** 512 512 +** 100 512 +** 2000 2048 +** +*/ +static i64 journalHdrOffset(Pager *pPager){ + i64 offset = 0; + i64 c = pPager->journalOff; + if( c ){ + offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager); + } + assert( offset%JOURNAL_HDR_SZ(pPager)==0 ); + assert( offset>=c ); + assert( (offset-c)jfd) ); + assert( !sqlite3JournalIsInMemory(pPager->jfd) ); + if( pPager->journalOff ){ + const i64 iLimit = pPager->journalSizeLimit; /* Local cache of jsl */ + + IOTRACE(("JZEROHDR %p\n", pPager)) + if( doTruncate || iLimit==0 ){ + rc = sqlite3OsTruncate(pPager->jfd, 0); + }else{ + static const char zeroHdr[28] = {0}; + rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0); + } + if( rc==SQLITE_OK && !pPager->noSync ){ + rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->syncFlags); + } + + /* At this point the transaction is committed but the write lock + ** is still held on the file. If there is a size limit configured for + ** the persistent journal and the journal file currently consumes more + ** space than that limit allows for, truncate it now. There is no need + ** to sync the file following this operation. + */ + if( rc==SQLITE_OK && iLimit>0 ){ + i64 sz; + rc = sqlite3OsFileSize(pPager->jfd, &sz); + if( rc==SQLITE_OK && sz>iLimit ){ + rc = sqlite3OsTruncate(pPager->jfd, iLimit); + } + } + } + return rc; +} + +/* +** The journal file must be open when this routine is called. A journal +** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the +** current location. +** +** The format for the journal header is as follows: +** - 8 bytes: Magic identifying journal format. +** - 4 bytes: Number of records in journal, or -1 no-sync mode is on. +** - 4 bytes: Random number used for page hash. +** - 4 bytes: Initial database page count. +** - 4 bytes: Sector size used by the process that wrote this journal. +** - 4 bytes: Database page size. +** +** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space. +*/ +static int writeJournalHdr(Pager *pPager){ + int rc = SQLITE_OK; /* Return code */ + char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */ + u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */ + u32 nWrite; /* Bytes of header sector written */ + int ii; /* Loop counter */ + + assert( isOpen(pPager->jfd) ); /* Journal file must be open. */ + + if( nHeader>JOURNAL_HDR_SZ(pPager) ){ + nHeader = JOURNAL_HDR_SZ(pPager); + } + + /* If there are active savepoints and any of them were created + ** since the most recent journal header was written, update the + ** PagerSavepoint.iHdrOffset fields now. + */ + for(ii=0; iinSavepoint; ii++){ + if( pPager->aSavepoint[ii].iHdrOffset==0 ){ + pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff; + } + } + + pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager); + + /* + ** Write the nRec Field - the number of page records that follow this + ** journal header. Normally, zero is written to this value at this time. + ** After the records are added to the journal (and the journal synced, + ** if in full-sync mode), the zero is overwritten with the true number + ** of records (see syncJournal()). + ** + ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When + ** reading the journal this value tells SQLite to assume that the + ** rest of the journal file contains valid page records. This assumption + ** is dangerous, as if a failure occurred whilst writing to the journal + ** file it may contain some garbage data. There are two scenarios + ** where this risk can be ignored: + ** + ** * When the pager is in no-sync mode. Corruption can follow a + ** power failure in this case anyway. + ** + ** * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees + ** that garbage data is never appended to the journal file. + */ + assert( isOpen(pPager->fd) || pPager->noSync ); + if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY) + || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND) + ){ + memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic)); + put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff); + }else{ + memset(zHeader, 0, sizeof(aJournalMagic)+4); + } + + /* The random check-hash initializer */ + sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit); + put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit); + /* The initial database size */ + put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize); + /* The assumed sector size for this process */ + put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize); + + /* The page size */ + put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize); + + /* Initializing the tail of the buffer is not necessary. Everything + ** works find if the following memset() is omitted. But initializing + ** the memory prevents valgrind from complaining, so we are willing to + ** take the performance hit. + */ + memset(&zHeader[sizeof(aJournalMagic)+20], 0, + nHeader-(sizeof(aJournalMagic)+20)); + + /* In theory, it is only necessary to write the 28 bytes that the + ** journal header consumes to the journal file here. Then increment the + ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next + ** record is written to the following sector (leaving a gap in the file + ** that will be implicitly filled in by the OS). + ** + ** However it has been discovered that on some systems this pattern can + ** be significantly slower than contiguously writing data to the file, + ** even if that means explicitly writing data to the block of + ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what + ** is done. + ** + ** The loop is required here in case the sector-size is larger than the + ** database page size. Since the zHeader buffer is only Pager.pageSize + ** bytes in size, more than one call to sqlite3OsWrite() may be required + ** to populate the entire journal header sector. + */ + for(nWrite=0; rc==SQLITE_OK&&nWritejournalHdr, nHeader)) + rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff); + assert( pPager->journalHdr <= pPager->journalOff ); + pPager->journalOff += nHeader; + } + + return rc; +} + +/* +** The journal file must be open when this is called. A journal header file +** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal +** file. The current location in the journal file is given by +** pPager->journalOff. See comments above function writeJournalHdr() for +** a description of the journal header format. +** +** If the header is read successfully, *pNRec is set to the number of +** page records following this header and *pDbSize is set to the size of the +** database before the transaction began, in pages. Also, pPager->cksumInit +** is set to the value read from the journal header. SQLITE_OK is returned +** in this case. +** +** If the journal header file appears to be corrupted, SQLITE_DONE is +** returned and *pNRec and *PDbSize are undefined. If JOURNAL_HDR_SZ bytes +** cannot be read from the journal file an error code is returned. +*/ +static int readJournalHdr( + Pager *pPager, /* Pager object */ + int isHot, + i64 journalSize, /* Size of the open journal file in bytes */ + u32 *pNRec, /* OUT: Value read from the nRec field */ + u32 *pDbSize /* OUT: Value of original database size field */ +){ + int rc; /* Return code */ + unsigned char aMagic[8]; /* A buffer to hold the magic header */ + i64 iHdrOff; /* Offset of journal header being read */ + + assert( isOpen(pPager->jfd) ); /* Journal file must be open. */ + + /* Advance Pager.journalOff to the start of the next sector. If the + ** journal file is too small for there to be a header stored at this + ** point, return SQLITE_DONE. + */ + pPager->journalOff = journalHdrOffset(pPager); + if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){ + return SQLITE_DONE; + } + iHdrOff = pPager->journalOff; + + /* Read in the first 8 bytes of the journal header. If they do not match + ** the magic string found at the start of each journal header, return + ** SQLITE_DONE. If an IO error occurs, return an error code. Otherwise, + ** proceed. + */ + if( isHot || iHdrOff!=pPager->journalHdr ){ + rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff); + if( rc ){ + return rc; + } + if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){ + return SQLITE_DONE; + } + } + + /* Read the first three 32-bit fields of the journal header: The nRec + ** field, the checksum-initializer and the database size at the start + ** of the transaction. Return an error code if anything goes wrong. + */ + if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec)) + || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit)) + || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize)) + ){ + return rc; + } + + if( pPager->journalOff==0 ){ + u32 iPageSize; /* Page-size field of journal header */ + u32 iSectorSize; /* Sector-size field of journal header */ + + /* Read the page-size and sector-size journal header fields. */ + if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize)) + || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize)) + ){ + return rc; + } + + /* Versions of SQLite prior to 3.5.8 set the page-size field of the + ** journal header to zero. In this case, assume that the Pager.pageSize + ** variable is already set to the correct page size. + */ + if( iPageSize==0 ){ + iPageSize = pPager->pageSize; + } + + /* Check that the values read from the page-size and sector-size fields + ** are within range. To be 'in range', both values need to be a power + ** of two greater than or equal to 512 or 32, and not greater than their + ** respective compile time maximum limits. + */ + if( iPageSize<512 || iSectorSize<32 + || iPageSize>SQLITE_MAX_PAGE_SIZE || iSectorSize>MAX_SECTOR_SIZE + || ((iPageSize-1)&iPageSize)!=0 || ((iSectorSize-1)&iSectorSize)!=0 + ){ + /* If the either the page-size or sector-size in the journal-header is + ** invalid, then the process that wrote the journal-header must have + ** crashed before the header was synced. In this case stop reading + ** the journal file here. + */ + return SQLITE_DONE; + } + + /* Update the page-size to match the value read from the journal. + ** Use a testcase() macro to make sure that malloc failure within + ** PagerSetPagesize() is tested. + */ + rc = sqlite3PagerSetPagesize(pPager, &iPageSize, -1); + testcase( rc!=SQLITE_OK ); + + /* Update the assumed sector-size to match the value used by + ** the process that created this journal. If this journal was + ** created by a process other than this one, then this routine + ** is being called from within pager_playback(). The local value + ** of Pager.sectorSize is restored at the end of that routine. + */ + pPager->sectorSize = iSectorSize; + } + + pPager->journalOff += JOURNAL_HDR_SZ(pPager); + return rc; +} + + +/* +** Write the supplied super-journal name into the journal file for pager +** pPager at the current location. The super-journal name must be the last +** thing written to a journal file. If the pager is in full-sync mode, the +** journal file descriptor is advanced to the next sector boundary before +** anything is written. The format is: +** +** + 4 bytes: PAGER_MJ_PGNO. +** + N bytes: super-journal filename in utf-8. +** + 4 bytes: N (length of super-journal name in bytes, no nul-terminator). +** + 4 bytes: super-journal name checksum. +** + 8 bytes: aJournalMagic[]. +** +** The super-journal page checksum is the sum of the bytes in thesuper-journal +** name, where each byte is interpreted as a signed 8-bit integer. +** +** If zSuper is a NULL pointer (occurs for a single database transaction), +** this call is a no-op. +*/ +static int writeSuperJournal(Pager *pPager, const char *zSuper){ + int rc; /* Return code */ + int nSuper; /* Length of string zSuper */ + i64 iHdrOff; /* Offset of header in journal file */ + i64 jrnlSize; /* Size of journal file on disk */ + u32 cksum = 0; /* Checksum of string zSuper */ + + assert( pPager->setSuper==0 ); + assert( !pagerUseWal(pPager) ); + + if( !zSuper + || pPager->journalMode==PAGER_JOURNALMODE_MEMORY + || !isOpen(pPager->jfd) + ){ + return SQLITE_OK; + } + pPager->setSuper = 1; + assert( pPager->journalHdr <= pPager->journalOff ); + + /* Calculate the length in bytes and the checksum of zSuper */ + for(nSuper=0; zSuper[nSuper]; nSuper++){ + cksum += zSuper[nSuper]; + } + + /* If in full-sync mode, advance to the next disk sector before writing + ** the super-journal name. This is in case the previous page written to + ** the journal has already been synced. + */ + if( pPager->fullSync ){ + pPager->journalOff = journalHdrOffset(pPager); + } + iHdrOff = pPager->journalOff; + + /* Write the super-journal data to the end of the journal file. If + ** an error occurs, return the error code to the caller. + */ + if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_MJ_PGNO(pPager)))) + || (0 != (rc = sqlite3OsWrite(pPager->jfd, zSuper, nSuper, iHdrOff+4))) + || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper, nSuper))) + || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper+4, cksum))) + || (0 != (rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, 8, + iHdrOff+4+nSuper+8))) + ){ + return rc; + } + pPager->journalOff += (nSuper+20); + + /* If the pager is in peristent-journal mode, then the physical + ** journal-file may extend past the end of the super-journal name + ** and 8 bytes of magic data just written to the file. This is + ** dangerous because the code to rollback a hot-journal file + ** will not be able to find the super-journal name to determine + ** whether or not the journal is hot. + ** + ** Easiest thing to do in this scenario is to truncate the journal + ** file to the required size. + */ + if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize)) + && jrnlSize>pPager->journalOff + ){ + rc = sqlite3OsTruncate(pPager->jfd, pPager->journalOff); + } + return rc; +} + +/* +** Discard the entire contents of the in-memory page-cache. +*/ +static void pager_reset(Pager *pPager){ + pPager->iDataVersion++; + sqlite3BackupRestart(pPager->pBackup); + sqlite3PcacheClear(pPager->pPCache); +} + +/* +** Return the pPager->iDataVersion value +*/ +SQLITE_PRIVATE u32 sqlite3PagerDataVersion(Pager *pPager){ + return pPager->iDataVersion; +} + +/* +** Free all structures in the Pager.aSavepoint[] array and set both +** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal +** if it is open and the pager is not in exclusive mode. +*/ +static void releaseAllSavepoints(Pager *pPager){ + int ii; /* Iterator for looping through Pager.aSavepoint */ + for(ii=0; iinSavepoint; ii++){ + sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint); + } + if( !pPager->exclusiveMode || sqlite3JournalIsInMemory(pPager->sjfd) ){ + sqlite3OsClose(pPager->sjfd); + } + sqlite3_free(pPager->aSavepoint); + pPager->aSavepoint = 0; + pPager->nSavepoint = 0; + pPager->nSubRec = 0; +} + +/* +** Set the bit number pgno in the PagerSavepoint.pInSavepoint +** bitvecs of all open savepoints. Return SQLITE_OK if successful +** or SQLITE_NOMEM if a malloc failure occurs. +*/ +static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){ + int ii; /* Loop counter */ + int rc = SQLITE_OK; /* Result code */ + + for(ii=0; iinSavepoint; ii++){ + PagerSavepoint *p = &pPager->aSavepoint[ii]; + if( pgno<=p->nOrig ){ + rc |= sqlite3BitvecSet(p->pInSavepoint, pgno); + testcase( rc==SQLITE_NOMEM ); + assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); + } + } + return rc; +} + +/* +** This function is a no-op if the pager is in exclusive mode and not +** in the ERROR state. Otherwise, it switches the pager to PAGER_OPEN +** state. +** +** If the pager is not in exclusive-access mode, the database file is +** completely unlocked. If the file is unlocked and the file-system does +** not exhibit the UNDELETABLE_WHEN_OPEN property, the journal file is +** closed (if it is open). +** +** If the pager is in ERROR state when this function is called, the +** contents of the pager cache are discarded before switching back to +** the OPEN state. Regardless of whether the pager is in exclusive-mode +** or not, any journal file left in the file-system will be treated +** as a hot-journal and rolled back the next time a read-transaction +** is opened (by this or by any other connection). +*/ +static void pager_unlock(Pager *pPager){ + + assert( pPager->eState==PAGER_READER + || pPager->eState==PAGER_OPEN + || pPager->eState==PAGER_ERROR + ); + + sqlite3BitvecDestroy(pPager->pInJournal); + pPager->pInJournal = 0; + releaseAllSavepoints(pPager); + + if( pagerUseWal(pPager) ){ + assert( !isOpen(pPager->jfd) ); + sqlite3WalEndReadTransaction(pPager->pWal); + pPager->eState = PAGER_OPEN; + }else if( !pPager->exclusiveMode ){ + int rc; /* Error code returned by pagerUnlockDb() */ + int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0; + + /* If the operating system support deletion of open files, then + ** close the journal file when dropping the database lock. Otherwise + ** another connection with journal_mode=delete might delete the file + ** out from under us. + */ + assert( (PAGER_JOURNALMODE_MEMORY & 5)!=1 ); + assert( (PAGER_JOURNALMODE_OFF & 5)!=1 ); + assert( (PAGER_JOURNALMODE_WAL & 5)!=1 ); + assert( (PAGER_JOURNALMODE_DELETE & 5)!=1 ); + assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 ); + assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 ); + if( 0==(iDc & SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN) + || 1!=(pPager->journalMode & 5) + ){ + sqlite3OsClose(pPager->jfd); + } + + /* If the pager is in the ERROR state and the call to unlock the database + ** file fails, set the current lock to UNKNOWN_LOCK. See the comment + ** above the #define for UNKNOWN_LOCK for an explanation of why this + ** is necessary. + */ + rc = pagerUnlockDb(pPager, NO_LOCK); + if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){ + pPager->eLock = UNKNOWN_LOCK; + } + + /* The pager state may be changed from PAGER_ERROR to PAGER_OPEN here + ** without clearing the error code. This is intentional - the error + ** code is cleared and the cache reset in the block below. + */ + assert( pPager->errCode || pPager->eState!=PAGER_ERROR ); + pPager->eState = PAGER_OPEN; + } + + /* If Pager.errCode is set, the contents of the pager cache cannot be + ** trusted. Now that there are no outstanding references to the pager, + ** it can safely move back to PAGER_OPEN state. This happens in both + ** normal and exclusive-locking mode. + */ + assert( pPager->errCode==SQLITE_OK || !MEMDB ); + if( pPager->errCode ){ + if( pPager->tempFile==0 ){ + pager_reset(pPager); + pPager->changeCountDone = 0; + pPager->eState = PAGER_OPEN; + }else{ + pPager->eState = (isOpen(pPager->jfd) ? PAGER_OPEN : PAGER_READER); + } + if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0); + pPager->errCode = SQLITE_OK; + setGetterMethod(pPager); + } + + pPager->journalOff = 0; + pPager->journalHdr = 0; + pPager->setSuper = 0; +} + +/* +** This function is called whenever an IOERR or FULL error that requires +** the pager to transition into the ERROR state may ahve occurred. +** The first argument is a pointer to the pager structure, the second +** the error-code about to be returned by a pager API function. The +** value returned is a copy of the second argument to this function. +** +** If the second argument is SQLITE_FULL, SQLITE_IOERR or one of the +** IOERR sub-codes, the pager enters the ERROR state and the error code +** is stored in Pager.errCode. While the pager remains in the ERROR state, +** all major API calls on the Pager will immediately return Pager.errCode. +** +** The ERROR state indicates that the contents of the pager-cache +** cannot be trusted. This state can be cleared by completely discarding +** the contents of the pager-cache. If a transaction was active when +** the persistent error occurred, then the rollback journal may need +** to be replayed to restore the contents of the database file (as if +** it were a hot-journal). +*/ +static int pager_error(Pager *pPager, int rc){ + int rc2 = rc & 0xff; + assert( rc==SQLITE_OK || !MEMDB ); + assert( + pPager->errCode==SQLITE_FULL || + pPager->errCode==SQLITE_OK || + (pPager->errCode & 0xff)==SQLITE_IOERR + ); + if( rc2==SQLITE_FULL || rc2==SQLITE_IOERR ){ + pPager->errCode = rc; + pPager->eState = PAGER_ERROR; + setGetterMethod(pPager); + } + return rc; +} + +static int pager_truncate(Pager *pPager, Pgno nPage); + +/* +** The write transaction open on pPager is being committed (bCommit==1) +** or rolled back (bCommit==0). +** +** Return TRUE if and only if all dirty pages should be flushed to disk. +** +** Rules: +** +** * For non-TEMP databases, always sync to disk. This is necessary +** for transactions to be durable. +** +** * Sync TEMP database only on a COMMIT (not a ROLLBACK) when the backing +** file has been created already (via a spill on pagerStress()) and +** when the number of dirty pages in memory exceeds 25% of the total +** cache size. +*/ +static int pagerFlushOnCommit(Pager *pPager, int bCommit){ + if( pPager->tempFile==0 ) return 1; + if( !bCommit ) return 0; + if( !isOpen(pPager->fd) ) return 0; + return (sqlite3PCachePercentDirty(pPager->pPCache)>=25); +} + +/* +** This routine ends a transaction. A transaction is usually ended by +** either a COMMIT or a ROLLBACK operation. This routine may be called +** after rollback of a hot-journal, or if an error occurs while opening +** the journal file or writing the very first journal-header of a +** database transaction. +** +** This routine is never called in PAGER_ERROR state. If it is called +** in PAGER_NONE or PAGER_SHARED state and the lock held is less +** exclusive than a RESERVED lock, it is a no-op. +** +** Otherwise, any active savepoints are released. +** +** If the journal file is open, then it is "finalized". Once a journal +** file has been finalized it is not possible to use it to roll back a +** transaction. Nor will it be considered to be a hot-journal by this +** or any other database connection. Exactly how a journal is finalized +** depends on whether or not the pager is running in exclusive mode and +** the current journal-mode (Pager.journalMode value), as follows: +** +** journalMode==MEMORY +** Journal file descriptor is simply closed. This destroys an +** in-memory journal. +** +** journalMode==TRUNCATE +** Journal file is truncated to zero bytes in size. +** +** journalMode==PERSIST +** The first 28 bytes of the journal file are zeroed. This invalidates +** the first journal header in the file, and hence the entire journal +** file. An invalid journal file cannot be rolled back. +** +** journalMode==DELETE +** The journal file is closed and deleted using sqlite3OsDelete(). +** +** If the pager is running in exclusive mode, this method of finalizing +** the journal file is never used. Instead, if the journalMode is +** DELETE and the pager is in exclusive mode, the method described under +** journalMode==PERSIST is used instead. +** +** After the journal is finalized, the pager moves to PAGER_READER state. +** If running in non-exclusive rollback mode, the lock on the file is +** downgraded to a SHARED_LOCK. +** +** SQLITE_OK is returned if no error occurs. If an error occurs during +** any of the IO operations to finalize the journal file or unlock the +** database then the IO error code is returned to the user. If the +** operation to finalize the journal file fails, then the code still +** tries to unlock the database file if not in exclusive mode. If the +** unlock operation fails as well, then the first error code related +** to the first error encountered (the journal finalization one) is +** returned. +*/ +static int pager_end_transaction(Pager *pPager, int hasSuper, int bCommit){ + int rc = SQLITE_OK; /* Error code from journal finalization operation */ + int rc2 = SQLITE_OK; /* Error code from db file unlock operation */ + + /* Do nothing if the pager does not have an open write transaction + ** or at least a RESERVED lock. This function may be called when there + ** is no write-transaction active but a RESERVED or greater lock is + ** held under two circumstances: + ** + ** 1. After a successful hot-journal rollback, it is called with + ** eState==PAGER_NONE and eLock==EXCLUSIVE_LOCK. + ** + ** 2. If a connection with locking_mode=exclusive holding an EXCLUSIVE + ** lock switches back to locking_mode=normal and then executes a + ** read-transaction, this function is called with eState==PAGER_READER + ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed. + */ + assert( assert_pager_state(pPager) ); + assert( pPager->eState!=PAGER_ERROR ); + if( pPager->eStateeLockjfd) || pPager->pInJournal==0 + || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_BATCH_ATOMIC) + ); + if( isOpen(pPager->jfd) ){ + assert( !pagerUseWal(pPager) ); + + /* Finalize the journal file. */ + if( sqlite3JournalIsInMemory(pPager->jfd) ){ + /* assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ); */ + sqlite3OsClose(pPager->jfd); + }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){ + if( pPager->journalOff==0 ){ + rc = SQLITE_OK; + }else{ + rc = sqlite3OsTruncate(pPager->jfd, 0); + if( rc==SQLITE_OK && pPager->fullSync ){ + /* Make sure the new file size is written into the inode right away. + ** Otherwise the journal might resurrect following a power loss and + ** cause the last transaction to roll back. See + ** https://bugzilla.mozilla.org/show_bug.cgi?id=1072773 + */ + rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags); + } + } + pPager->journalOff = 0; + }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST + || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL) + ){ + rc = zeroJournalHdr(pPager, hasSuper||pPager->tempFile); + pPager->journalOff = 0; + }else{ + /* This branch may be executed with Pager.journalMode==MEMORY if + ** a hot-journal was just rolled back. In this case the journal + ** file should be closed and deleted. If this connection writes to + ** the database file, it will do so using an in-memory journal. + */ + int bDelete = !pPager->tempFile; + assert( sqlite3JournalIsInMemory(pPager->jfd)==0 ); + assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE + || pPager->journalMode==PAGER_JOURNALMODE_MEMORY + || pPager->journalMode==PAGER_JOURNALMODE_WAL + ); + sqlite3OsClose(pPager->jfd); + if( bDelete ){ + rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, pPager->extraSync); + } + } + } + +#ifdef SQLITE_CHECK_PAGES + sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash); + if( pPager->dbSize==0 && sqlite3PcacheRefCount(pPager->pPCache)>0 ){ + PgHdr *p = sqlite3PagerLookup(pPager, 1); + if( p ){ + p->pageHash = 0; + sqlite3PagerUnrefNotNull(p); + } + } +#endif + + sqlite3BitvecDestroy(pPager->pInJournal); + pPager->pInJournal = 0; + pPager->nRec = 0; + if( rc==SQLITE_OK ){ + if( MEMDB || pagerFlushOnCommit(pPager, bCommit) ){ + sqlite3PcacheCleanAll(pPager->pPCache); + }else{ + sqlite3PcacheClearWritable(pPager->pPCache); + } + sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize); + } + + if( pagerUseWal(pPager) ){ + /* Drop the WAL write-lock, if any. Also, if the connection was in + ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE + ** lock held on the database file. + */ + rc2 = sqlite3WalEndWriteTransaction(pPager->pWal); + assert( rc2==SQLITE_OK ); + }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){ + /* This branch is taken when committing a transaction in rollback-journal + ** mode if the database file on disk is larger than the database image. + ** At this point the journal has been finalized and the transaction + ** successfully committed, but the EXCLUSIVE lock is still held on the + ** file. So it is safe to truncate the database file to its minimum + ** required size. */ + assert( pPager->eLock==EXCLUSIVE_LOCK ); + rc = pager_truncate(pPager, pPager->dbSize); + } + + if( rc==SQLITE_OK && bCommit ){ + rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_COMMIT_PHASETWO, 0); + if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK; + } + + if( !pPager->exclusiveMode + && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0)) + ){ + rc2 = pagerUnlockDb(pPager, SHARED_LOCK); + } + pPager->eState = PAGER_READER; + pPager->setSuper = 0; + + return (rc==SQLITE_OK?rc2:rc); +} + +/* +** Execute a rollback if a transaction is active and unlock the +** database file. +** +** If the pager has already entered the ERROR state, do not attempt +** the rollback at this time. Instead, pager_unlock() is called. The +** call to pager_unlock() will discard all in-memory pages, unlock +** the database file and move the pager back to OPEN state. If this +** means that there is a hot-journal left in the file-system, the next +** connection to obtain a shared lock on the pager (which may be this one) +** will roll it back. +** +** If the pager has not already entered the ERROR state, but an IO or +** malloc error occurs during a rollback, then this will itself cause +** the pager to enter the ERROR state. Which will be cleared by the +** call to pager_unlock(), as described above. +*/ +static void pagerUnlockAndRollback(Pager *pPager){ + if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){ + assert( assert_pager_state(pPager) ); + if( pPager->eState>=PAGER_WRITER_LOCKED ){ + sqlite3BeginBenignMalloc(); + sqlite3PagerRollback(pPager); + sqlite3EndBenignMalloc(); + }else if( !pPager->exclusiveMode ){ + assert( pPager->eState==PAGER_READER ); + pager_end_transaction(pPager, 0, 0); + } + } + pager_unlock(pPager); +} + +/* +** Parameter aData must point to a buffer of pPager->pageSize bytes +** of data. Compute and return a checksum based ont the contents of the +** page of data and the current value of pPager->cksumInit. +** +** This is not a real checksum. It is really just the sum of the +** random initial value (pPager->cksumInit) and every 200th byte +** of the page data, starting with byte offset (pPager->pageSize%200). +** Each byte is interpreted as an 8-bit unsigned integer. +** +** Changing the formula used to compute this checksum results in an +** incompatible journal file format. +** +** If journal corruption occurs due to a power failure, the most likely +** scenario is that one end or the other of the record will be changed. +** It is much less likely that the two ends of the journal record will be +** correct and the middle be corrupt. Thus, this "checksum" scheme, +** though fast and simple, catches the mostly likely kind of corruption. +*/ +static u32 pager_cksum(Pager *pPager, const u8 *aData){ + u32 cksum = pPager->cksumInit; /* Checksum value to return */ + int i = pPager->pageSize-200; /* Loop counter */ + while( i>0 ){ + cksum += aData[i]; + i -= 200; + } + return cksum; +} + +/* +** Read a single page from either the journal file (if isMainJrnl==1) or +** from the sub-journal (if isMainJrnl==0) and playback that page. +** The page begins at offset *pOffset into the file. The *pOffset +** value is increased to the start of the next page in the journal. +** +** The main rollback journal uses checksums - the statement journal does +** not. +** +** If the page number of the page record read from the (sub-)journal file +** is greater than the current value of Pager.dbSize, then playback is +** skipped and SQLITE_OK is returned. +** +** If pDone is not NULL, then it is a record of pages that have already +** been played back. If the page at *pOffset has already been played back +** (if the corresponding pDone bit is set) then skip the playback. +** Make sure the pDone bit corresponding to the *pOffset page is set +** prior to returning. +** +** If the page record is successfully read from the (sub-)journal file +** and played back, then SQLITE_OK is returned. If an IO error occurs +** while reading the record from the (sub-)journal file or while writing +** to the database file, then the IO error code is returned. If data +** is successfully read from the (sub-)journal file but appears to be +** corrupted, SQLITE_DONE is returned. Data is considered corrupted in +** two circumstances: +** +** * If the record page-number is illegal (0 or PAGER_MJ_PGNO), or +** * If the record is being rolled back from the main journal file +** and the checksum field does not match the record content. +** +** Neither of these two scenarios are possible during a savepoint rollback. +** +** If this is a savepoint rollback, then memory may have to be dynamically +** allocated by this function. If this is the case and an allocation fails, +** SQLITE_NOMEM is returned. +*/ +static int pager_playback_one_page( + Pager *pPager, /* The pager being played back */ + i64 *pOffset, /* Offset of record to playback */ + Bitvec *pDone, /* Bitvec of pages already played back */ + int isMainJrnl, /* 1 -> main journal. 0 -> sub-journal. */ + int isSavepnt /* True for a savepoint rollback */ +){ + int rc; + PgHdr *pPg; /* An existing page in the cache */ + Pgno pgno; /* The page number of a page in journal */ + u32 cksum; /* Checksum used for sanity checking */ + char *aData; /* Temporary storage for the page */ + sqlite3_file *jfd; /* The file descriptor for the journal file */ + int isSynced; /* True if journal page is synced */ + + assert( (isMainJrnl&~1)==0 ); /* isMainJrnl is 0 or 1 */ + assert( (isSavepnt&~1)==0 ); /* isSavepnt is 0 or 1 */ + assert( isMainJrnl || pDone ); /* pDone always used on sub-journals */ + assert( isSavepnt || pDone==0 ); /* pDone never used on non-savepoint */ + + aData = pPager->pTmpSpace; + assert( aData ); /* Temp storage must have already been allocated */ + assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) ); + + /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction + ** or savepoint rollback done at the request of the caller) or this is + ** a hot-journal rollback. If it is a hot-journal rollback, the pager + ** is in state OPEN and holds an EXCLUSIVE lock. Hot-journal rollback + ** only reads from the main journal, not the sub-journal. + */ + assert( pPager->eState>=PAGER_WRITER_CACHEMOD + || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK) + ); + assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl ); + + /* Read the page number and page data from the journal or sub-journal + ** file. Return an error code to the caller if an IO error occurs. + */ + jfd = isMainJrnl ? pPager->jfd : pPager->sjfd; + rc = read32bits(jfd, *pOffset, &pgno); + if( rc!=SQLITE_OK ) return rc; + rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4); + if( rc!=SQLITE_OK ) return rc; + *pOffset += pPager->pageSize + 4 + isMainJrnl*4; + + /* Sanity checking on the page. This is more important that I originally + ** thought. If a power failure occurs while the journal is being written, + ** it could cause invalid data to be written into the journal. We need to + ** detect this invalid data (with high probability) and ignore it. + */ + if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){ + assert( !isSavepnt ); + return SQLITE_DONE; + } + if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){ + return SQLITE_OK; + } + if( isMainJrnl ){ + rc = read32bits(jfd, (*pOffset)-4, &cksum); + if( rc ) return rc; + if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){ + return SQLITE_DONE; + } + } + + /* If this page has already been played back before during the current + ** rollback, then don't bother to play it back again. + */ + if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){ + return rc; + } + + /* When playing back page 1, restore the nReserve setting + */ + if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){ + pPager->nReserve = ((u8*)aData)[20]; + } + + /* If the pager is in CACHEMOD state, then there must be a copy of this + ** page in the pager cache. In this case just update the pager cache, + ** not the database file. The page is left marked dirty in this case. + ** + ** An exception to the above rule: If the database is in no-sync mode + ** and a page is moved during an incremental vacuum then the page may + ** not be in the pager cache. Later: if a malloc() or IO error occurs + ** during a Movepage() call, then the page may not be in the cache + ** either. So the condition described in the above paragraph is not + ** assert()able. + ** + ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the + ** pager cache if it exists and the main file. The page is then marked + ** not dirty. Since this code is only executed in PAGER_OPEN state for + ** a hot-journal rollback, it is guaranteed that the page-cache is empty + ** if the pager is in OPEN state. + ** + ** Ticket #1171: The statement journal might contain page content that is + ** different from the page content at the start of the transaction. + ** This occurs when a page is changed prior to the start of a statement + ** then changed again within the statement. When rolling back such a + ** statement we must not write to the original database unless we know + ** for certain that original page contents are synced into the main rollback + ** journal. Otherwise, a power loss might leave modified data in the + ** database file without an entry in the rollback journal that can + ** restore the database to its original form. Two conditions must be + ** met before writing to the database files. (1) the database must be + ** locked. (2) we know that the original page content is fully synced + ** in the main journal either because the page is not in cache or else + ** the page is marked as needSync==0. + ** + ** 2008-04-14: When attempting to vacuum a corrupt database file, it + ** is possible to fail a statement on a database that does not yet exist. + ** Do not attempt to write if database file has never been opened. + */ + if( pagerUseWal(pPager) ){ + pPg = 0; + }else{ + pPg = sqlite3PagerLookup(pPager, pgno); + } + assert( pPg || !MEMDB ); + assert( pPager->eState!=PAGER_OPEN || pPg==0 || pPager->tempFile ); + PAGERTRACE(("PLAYBACK %d page %d hash(%08x) %s\n", + PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData), + (isMainJrnl?"main-journal":"sub-journal") + )); + if( isMainJrnl ){ + isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr); + }else{ + isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC)); + } + if( isOpen(pPager->fd) + && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN) + && isSynced + ){ + i64 ofst = (pgno-1)*(i64)pPager->pageSize; + testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 ); + assert( !pagerUseWal(pPager) ); + + /* Write the data read from the journal back into the database file. + ** This is usually safe even for an encrypted database - as the data + ** was encrypted before it was written to the journal file. The exception + ** is if the data was just read from an in-memory sub-journal. In that + ** case it must be encrypted here before it is copied into the database + ** file. */ + rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst); + + if( pgno>pPager->dbFileSize ){ + pPager->dbFileSize = pgno; + } + if( pPager->pBackup ){ + sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData); + } + }else if( !isMainJrnl && pPg==0 ){ + /* If this is a rollback of a savepoint and data was not written to + ** the database and the page is not in-memory, there is a potential + ** problem. When the page is next fetched by the b-tree layer, it + ** will be read from the database file, which may or may not be + ** current. + ** + ** There are a couple of different ways this can happen. All are quite + ** obscure. When running in synchronous mode, this can only happen + ** if the page is on the free-list at the start of the transaction, then + ** populated, then moved using sqlite3PagerMovepage(). + ** + ** The solution is to add an in-memory page to the cache containing + ** the data just read from the sub-journal. Mark the page as dirty + ** and if the pager requires a journal-sync, then mark the page as + ** requiring a journal-sync before it is written. + */ + assert( isSavepnt ); + assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)==0 ); + pPager->doNotSpill |= SPILLFLAG_ROLLBACK; + rc = sqlite3PagerGet(pPager, pgno, &pPg, 1); + assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)!=0 ); + pPager->doNotSpill &= ~SPILLFLAG_ROLLBACK; + if( rc!=SQLITE_OK ) return rc; + sqlite3PcacheMakeDirty(pPg); + } + if( pPg ){ + /* No page should ever be explicitly rolled back that is in use, except + ** for page 1 which is held in use in order to keep the lock on the + ** database active. However such a page may be rolled back as a result + ** of an internal error resulting in an automatic call to + ** sqlite3PagerRollback(). + */ + void *pData; + pData = pPg->pData; + memcpy(pData, (u8*)aData, pPager->pageSize); + pPager->xReiniter(pPg); + /* It used to be that sqlite3PcacheMakeClean(pPg) was called here. But + ** that call was dangerous and had no detectable benefit since the cache + ** is normally cleaned by sqlite3PcacheCleanAll() after rollback and so + ** has been removed. */ + pager_set_pagehash(pPg); + + /* If this was page 1, then restore the value of Pager.dbFileVers. + ** Do this before any decoding. */ + if( pgno==1 ){ + memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers)); + } + sqlite3PcacheRelease(pPg); + } + return rc; +} + +/* +** Parameter zSuper is the name of a super-journal file. A single journal +** file that referred to the super-journal file has just been rolled back. +** This routine checks if it is possible to delete the super-journal file, +** and does so if it is. +** +** Argument zSuper may point to Pager.pTmpSpace. So that buffer is not +** available for use within this function. +** +** When a super-journal file is created, it is populated with the names +** of all of its child journals, one after another, formatted as utf-8 +** encoded text. The end of each child journal file is marked with a +** nul-terminator byte (0x00). i.e. the entire contents of a super-journal +** file for a transaction involving two databases might be: +** +** "/home/bill/a.db-journal\x00/home/bill/b.db-journal\x00" +** +** A super-journal file may only be deleted once all of its child +** journals have been rolled back. +** +** This function reads the contents of the super-journal file into +** memory and loops through each of the child journal names. For +** each child journal, it checks if: +** +** * if the child journal exists, and if so +** * if the child journal contains a reference to super-journal +** file zSuper +** +** If a child journal can be found that matches both of the criteria +** above, this function returns without doing anything. Otherwise, if +** no such child journal can be found, file zSuper is deleted from +** the file-system using sqlite3OsDelete(). +** +** If an IO error within this function, an error code is returned. This +** function allocates memory by calling sqlite3Malloc(). If an allocation +** fails, SQLITE_NOMEM is returned. Otherwise, if no IO or malloc errors +** occur, SQLITE_OK is returned. +** +** TODO: This function allocates a single block of memory to load +** the entire contents of the super-journal file. This could be +** a couple of kilobytes or so - potentially larger than the page +** size. +*/ +static int pager_delsuper(Pager *pPager, const char *zSuper){ + sqlite3_vfs *pVfs = pPager->pVfs; + int rc; /* Return code */ + sqlite3_file *pSuper; /* Malloc'd super-journal file descriptor */ + sqlite3_file *pJournal; /* Malloc'd child-journal file descriptor */ + char *zSuperJournal = 0; /* Contents of super-journal file */ + i64 nSuperJournal; /* Size of super-journal file */ + char *zJournal; /* Pointer to one journal within MJ file */ + char *zSuperPtr; /* Space to hold super-journal filename */ + char *zFree = 0; /* Free this buffer */ + int nSuperPtr; /* Amount of space allocated to zSuperPtr[] */ + + /* Allocate space for both the pJournal and pSuper file descriptors. + ** If successful, open the super-journal file for reading. + */ + pSuper = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile * 2); + if( !pSuper ){ + rc = SQLITE_NOMEM_BKPT; + pJournal = 0; + }else{ + const int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_SUPER_JOURNAL); + rc = sqlite3OsOpen(pVfs, zSuper, pSuper, flags, 0); + pJournal = (sqlite3_file *)(((u8 *)pSuper) + pVfs->szOsFile); + } + if( rc!=SQLITE_OK ) goto delsuper_out; + + /* Load the entire super-journal file into space obtained from + ** sqlite3_malloc() and pointed to by zSuperJournal. Also obtain + ** sufficient space (in zSuperPtr) to hold the names of super-journal + ** files extracted from regular rollback-journals. + */ + rc = sqlite3OsFileSize(pSuper, &nSuperJournal); + if( rc!=SQLITE_OK ) goto delsuper_out; + nSuperPtr = pVfs->mxPathname+1; + zFree = sqlite3Malloc(4 + nSuperJournal + nSuperPtr + 2); + if( !zFree ){ + rc = SQLITE_NOMEM_BKPT; + goto delsuper_out; + } + zFree[0] = zFree[1] = zFree[2] = zFree[3] = 0; + zSuperJournal = &zFree[4]; + zSuperPtr = &zSuperJournal[nSuperJournal+2]; + rc = sqlite3OsRead(pSuper, zSuperJournal, (int)nSuperJournal, 0); + if( rc!=SQLITE_OK ) goto delsuper_out; + zSuperJournal[nSuperJournal] = 0; + zSuperJournal[nSuperJournal+1] = 0; + + zJournal = zSuperJournal; + while( (zJournal-zSuperJournal)pageSize bytes). +** If the file on disk is currently larger than nPage pages, then use the VFS +** xTruncate() method to truncate it. +** +** Or, it might be the case that the file on disk is smaller than +** nPage pages. Some operating system implementations can get confused if +** you try to truncate a file to some size that is larger than it +** currently is, so detect this case and write a single zero byte to +** the end of the new file instead. +** +** If successful, return SQLITE_OK. If an IO error occurs while modifying +** the database file, return the error code to the caller. +*/ +static int pager_truncate(Pager *pPager, Pgno nPage){ + int rc = SQLITE_OK; + assert( pPager->eState!=PAGER_ERROR ); + assert( pPager->eState!=PAGER_READER ); + + if( isOpen(pPager->fd) + && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN) + ){ + i64 currentSize, newSize; + int szPage = pPager->pageSize; + assert( pPager->eLock==EXCLUSIVE_LOCK ); + /* TODO: Is it safe to use Pager.dbFileSize here? */ + rc = sqlite3OsFileSize(pPager->fd, ¤tSize); + newSize = szPage*(i64)nPage; + if( rc==SQLITE_OK && currentSize!=newSize ){ + if( currentSize>newSize ){ + rc = sqlite3OsTruncate(pPager->fd, newSize); + }else if( (currentSize+szPage)<=newSize ){ + char *pTmp = pPager->pTmpSpace; + memset(pTmp, 0, szPage); + testcase( (newSize-szPage) == currentSize ); + testcase( (newSize-szPage) > currentSize ); + rc = sqlite3OsWrite(pPager->fd, pTmp, szPage, newSize-szPage); + } + if( rc==SQLITE_OK ){ + pPager->dbFileSize = nPage; + } + } + } + return rc; +} + +/* +** Return a sanitized version of the sector-size of OS file pFile. The +** return value is guaranteed to lie between 32 and MAX_SECTOR_SIZE. +*/ +SQLITE_PRIVATE int sqlite3SectorSize(sqlite3_file *pFile){ + int iRet = sqlite3OsSectorSize(pFile); + if( iRet<32 ){ + iRet = 512; + }else if( iRet>MAX_SECTOR_SIZE ){ + assert( MAX_SECTOR_SIZE>=512 ); + iRet = MAX_SECTOR_SIZE; + } + return iRet; +} + +/* +** Set the value of the Pager.sectorSize variable for the given +** pager based on the value returned by the xSectorSize method +** of the open database file. The sector size will be used +** to determine the size and alignment of journal header and +** super-journal pointers within created journal files. +** +** For temporary files the effective sector size is always 512 bytes. +** +** Otherwise, for non-temporary files, the effective sector size is +** the value returned by the xSectorSize() method rounded up to 32 if +** it is less than 32, or rounded down to MAX_SECTOR_SIZE if it +** is greater than MAX_SECTOR_SIZE. +** +** If the file has the SQLITE_IOCAP_POWERSAFE_OVERWRITE property, then set +** the effective sector size to its minimum value (512). The purpose of +** pPager->sectorSize is to define the "blast radius" of bytes that +** might change if a crash occurs while writing to a single byte in +** that range. But with POWERSAFE_OVERWRITE, the blast radius is zero +** (that is what POWERSAFE_OVERWRITE means), so we minimize the sector +** size. For backwards compatibility of the rollback journal file format, +** we cannot reduce the effective sector size below 512. +*/ +static void setSectorSize(Pager *pPager){ + assert( isOpen(pPager->fd) || pPager->tempFile ); + + if( pPager->tempFile + || (sqlite3OsDeviceCharacteristics(pPager->fd) & + SQLITE_IOCAP_POWERSAFE_OVERWRITE)!=0 + ){ + /* Sector size doesn't matter for temporary files. Also, the file + ** may not have been opened yet, in which case the OsSectorSize() + ** call will segfault. */ + pPager->sectorSize = 512; + }else{ + pPager->sectorSize = sqlite3SectorSize(pPager->fd); + } +} + +/* +** Playback the journal and thus restore the database file to +** the state it was in before we started making changes. +** +** The journal file format is as follows: +** +** (1) 8 byte prefix. A copy of aJournalMagic[]. +** (2) 4 byte big-endian integer which is the number of valid page records +** in the journal. If this value is 0xffffffff, then compute the +** number of page records from the journal size. +** (3) 4 byte big-endian integer which is the initial value for the +** sanity checksum. +** (4) 4 byte integer which is the number of pages to truncate the +** database to during a rollback. +** (5) 4 byte big-endian integer which is the sector size. The header +** is this many bytes in size. +** (6) 4 byte big-endian integer which is the page size. +** (7) zero padding out to the next sector size. +** (8) Zero or more pages instances, each as follows: +** + 4 byte page number. +** + pPager->pageSize bytes of data. +** + 4 byte checksum +** +** When we speak of the journal header, we mean the first 7 items above. +** Each entry in the journal is an instance of the 8th item. +** +** Call the value from the second bullet "nRec". nRec is the number of +** valid page entries in the journal. In most cases, you can compute the +** value of nRec from the size of the journal file. But if a power +** failure occurred while the journal was being written, it could be the +** case that the size of the journal file had already been increased but +** the extra entries had not yet made it safely to disk. In such a case, +** the value of nRec computed from the file size would be too large. For +** that reason, we always use the nRec value in the header. +** +** If the nRec value is 0xffffffff it means that nRec should be computed +** from the file size. This value is used when the user selects the +** no-sync option for the journal. A power failure could lead to corruption +** in this case. But for things like temporary table (which will be +** deleted when the power is restored) we don't care. +** +** If the file opened as the journal file is not a well-formed +** journal file then all pages up to the first corrupted page are rolled +** back (or no pages if the journal header is corrupted). The journal file +** is then deleted and SQLITE_OK returned, just as if no corruption had +** been encountered. +** +** If an I/O or malloc() error occurs, the journal-file is not deleted +** and an error code is returned. +** +** The isHot parameter indicates that we are trying to rollback a journal +** that might be a hot journal. Or, it could be that the journal is +** preserved because of JOURNALMODE_PERSIST or JOURNALMODE_TRUNCATE. +** If the journal really is hot, reset the pager cache prior rolling +** back any content. If the journal is merely persistent, no reset is +** needed. +*/ +static int pager_playback(Pager *pPager, int isHot){ + sqlite3_vfs *pVfs = pPager->pVfs; + i64 szJ; /* Size of the journal file in bytes */ + u32 nRec; /* Number of Records in the journal */ + u32 u; /* Unsigned loop counter */ + Pgno mxPg = 0; /* Size of the original file in pages */ + int rc; /* Result code of a subroutine */ + int res = 1; /* Value returned by sqlite3OsAccess() */ + char *zSuper = 0; /* Name of super-journal file if any */ + int needPagerReset; /* True to reset page prior to first page rollback */ + int nPlayback = 0; /* Total number of pages restored from journal */ + u32 savedPageSize = pPager->pageSize; + + /* Figure out how many records are in the journal. Abort early if + ** the journal is empty. + */ + assert( isOpen(pPager->jfd) ); + rc = sqlite3OsFileSize(pPager->jfd, &szJ); + if( rc!=SQLITE_OK ){ + goto end_playback; + } + + /* Read the super-journal name from the journal, if it is present. + ** If a super-journal file name is specified, but the file is not + ** present on disk, then the journal is not hot and does not need to be + ** played back. + ** + ** TODO: Technically the following is an error because it assumes that + ** buffer Pager.pTmpSpace is (mxPathname+1) bytes or larger. i.e. that + ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c, + ** mxPathname is 512, which is the same as the minimum allowable value + ** for pageSize. + */ + zSuper = pPager->pTmpSpace; + rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1); + if( rc==SQLITE_OK && zSuper[0] ){ + rc = sqlite3OsAccess(pVfs, zSuper, SQLITE_ACCESS_EXISTS, &res); + } + zSuper = 0; + if( rc!=SQLITE_OK || !res ){ + goto end_playback; + } + pPager->journalOff = 0; + needPagerReset = isHot; + + /* This loop terminates either when a readJournalHdr() or + ** pager_playback_one_page() call returns SQLITE_DONE or an IO error + ** occurs. + */ + while( 1 ){ + /* Read the next journal header from the journal file. If there are + ** not enough bytes left in the journal file for a complete header, or + ** it is corrupted, then a process must have failed while writing it. + ** This indicates nothing more needs to be rolled back. + */ + rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + } + goto end_playback; + } + + /* If nRec is 0xffffffff, then this journal was created by a process + ** working in no-sync mode. This means that the rest of the journal + ** file consists of pages, there are no more journal headers. Compute + ** the value of nRec based on this assumption. + */ + if( nRec==0xffffffff ){ + assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ); + nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager)); + } + + /* If nRec is 0 and this rollback is of a transaction created by this + ** process and if this is the final header in the journal, then it means + ** that this part of the journal was being filled but has not yet been + ** synced to disk. Compute the number of pages based on the remaining + ** size of the file. + ** + ** The third term of the test was added to fix ticket #2565. + ** When rolling back a hot journal, nRec==0 always means that the next + ** chunk of the journal contains zero pages to be rolled back. But + ** when doing a ROLLBACK and the nRec==0 chunk is the last chunk in + ** the journal, it means that the journal might contain additional + ** pages that need to be rolled back and that the number of pages + ** should be computed based on the journal file size. + */ + if( nRec==0 && !isHot && + pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){ + nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager)); + } + + /* If this is the first header read from the journal, truncate the + ** database file back to its original size. + */ + if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){ + rc = pager_truncate(pPager, mxPg); + if( rc!=SQLITE_OK ){ + goto end_playback; + } + pPager->dbSize = mxPg; + } + + /* Copy original pages out of the journal and back into the + ** database file and/or page cache. + */ + for(u=0; ujournalOff,0,1,0); + if( rc==SQLITE_OK ){ + nPlayback++; + }else{ + if( rc==SQLITE_DONE ){ + pPager->journalOff = szJ; + break; + }else if( rc==SQLITE_IOERR_SHORT_READ ){ + /* If the journal has been truncated, simply stop reading and + ** processing the journal. This might happen if the journal was + ** not completely written and synced prior to a crash. In that + ** case, the database should have never been written in the + ** first place so it is OK to simply abandon the rollback. */ + rc = SQLITE_OK; + goto end_playback; + }else{ + /* If we are unable to rollback, quit and return the error + ** code. This will cause the pager to enter the error state + ** so that no further harm will be done. Perhaps the next + ** process to come along will be able to rollback the database. + */ + goto end_playback; + } + } + } + } + /*NOTREACHED*/ + assert( 0 ); + +end_playback: + if( rc==SQLITE_OK ){ + rc = sqlite3PagerSetPagesize(pPager, &savedPageSize, -1); + } + /* Following a rollback, the database file should be back in its original + ** state prior to the start of the transaction, so invoke the + ** SQLITE_FCNTL_DB_UNCHANGED file-control method to disable the + ** assertion that the transaction counter was modified. + */ +#ifdef SQLITE_DEBUG + sqlite3OsFileControlHint(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0); +#endif + + /* If this playback is happening automatically as a result of an IO or + ** malloc error that occurred after the change-counter was updated but + ** before the transaction was committed, then the change-counter + ** modification may just have been reverted. If this happens in exclusive + ** mode, then subsequent transactions performed by the connection will not + ** update the change-counter at all. This may lead to cache inconsistency + ** problems for other processes at some point in the future. So, just + ** in case this has happened, clear the changeCountDone flag now. + */ + pPager->changeCountDone = pPager->tempFile; + + if( rc==SQLITE_OK ){ + /* Leave 4 bytes of space before the super-journal filename in memory. + ** This is because it may end up being passed to sqlite3OsOpen(), in + ** which case it requires 4 0x00 bytes in memory immediately before + ** the filename. */ + zSuper = &pPager->pTmpSpace[4]; + rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1); + testcase( rc!=SQLITE_OK ); + } + if( rc==SQLITE_OK + && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN) + ){ + rc = sqlite3PagerSync(pPager, 0); + } + if( rc==SQLITE_OK ){ + rc = pager_end_transaction(pPager, zSuper[0]!='\0', 0); + testcase( rc!=SQLITE_OK ); + } + if( rc==SQLITE_OK && zSuper[0] && res ){ + /* If there was a super-journal and this routine will return success, + ** see if it is possible to delete the super-journal. + */ + assert( zSuper==&pPager->pTmpSpace[4] ); + memset(&zSuper[-4], 0, 4); + rc = pager_delsuper(pPager, zSuper); + testcase( rc!=SQLITE_OK ); + } + if( isHot && nPlayback ){ + sqlite3_log(SQLITE_NOTICE_RECOVER_ROLLBACK, "recovered %d pages from %s", + nPlayback, pPager->zJournal); + } + + /* The Pager.sectorSize variable may have been updated while rolling + ** back a journal created by a process with a different sector size + ** value. Reset it to the correct value for this process. + */ + setSectorSize(pPager); + return rc; +} + + +/* +** Read the content for page pPg out of the database file (or out of +** the WAL if that is where the most recent copy if found) into +** pPg->pData. A shared lock or greater must be held on the database +** file before this function is called. +** +** If page 1 is read, then the value of Pager.dbFileVers[] is set to +** the value read from the database file. +** +** If an IO error occurs, then the IO error is returned to the caller. +** Otherwise, SQLITE_OK is returned. +*/ +static int readDbPage(PgHdr *pPg){ + Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */ + int rc = SQLITE_OK; /* Return code */ + +#ifndef SQLITE_OMIT_WAL + u32 iFrame = 0; /* Frame of WAL containing pgno */ + + assert( pPager->eState>=PAGER_READER && !MEMDB ); + assert( isOpen(pPager->fd) ); + + if( pagerUseWal(pPager) ){ + rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame); + if( rc ) return rc; + } + if( iFrame ){ + rc = sqlite3WalReadFrame(pPager->pWal, iFrame,pPager->pageSize,pPg->pData); + }else +#endif + { + i64 iOffset = (pPg->pgno-1)*(i64)pPager->pageSize; + rc = sqlite3OsRead(pPager->fd, pPg->pData, pPager->pageSize, iOffset); + if( rc==SQLITE_IOERR_SHORT_READ ){ + rc = SQLITE_OK; + } + } + + if( pPg->pgno==1 ){ + if( rc ){ + /* If the read is unsuccessful, set the dbFileVers[] to something + ** that will never be a valid file version. dbFileVers[] is a copy + ** of bytes 24..39 of the database. Bytes 28..31 should always be + ** zero or the size of the database in page. Bytes 32..35 and 35..39 + ** should be page numbers which are never 0xffffffff. So filling + ** pPager->dbFileVers[] with all 0xff bytes should suffice. + ** + ** For an encrypted database, the situation is more complex: bytes + ** 24..39 of the database are white noise. But the probability of + ** white noise equaling 16 bytes of 0xff is vanishingly small so + ** we should still be ok. + */ + memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers)); + }else{ + u8 *dbFileVers = &((u8*)pPg->pData)[24]; + memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers)); + } + } + PAGER_INCR(sqlite3_pager_readdb_count); + PAGER_INCR(pPager->nRead); + IOTRACE(("PGIN %p %d\n", pPager, pPg->pgno)); + PAGERTRACE(("FETCH %d page %d hash(%08x)\n", + PAGERID(pPager), pPg->pgno, pager_pagehash(pPg))); + + return rc; +} + +/* +** Update the value of the change-counter at offsets 24 and 92 in +** the header and the sqlite version number at offset 96. +** +** This is an unconditional update. See also the pager_incr_changecounter() +** routine which only updates the change-counter if the update is actually +** needed, as determined by the pPager->changeCountDone state variable. +*/ +static void pager_write_changecounter(PgHdr *pPg){ + u32 change_counter; + + /* Increment the value just read and write it back to byte 24. */ + change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1; + put32bits(((char*)pPg->pData)+24, change_counter); + + /* Also store the SQLite version number in bytes 96..99 and in + ** bytes 92..95 store the change counter for which the version number + ** is valid. */ + put32bits(((char*)pPg->pData)+92, change_counter); + put32bits(((char*)pPg->pData)+96, SQLITE_VERSION_NUMBER); +} + +#ifndef SQLITE_OMIT_WAL +/* +** This function is invoked once for each page that has already been +** written into the log file when a WAL transaction is rolled back. +** Parameter iPg is the page number of said page. The pCtx argument +** is actually a pointer to the Pager structure. +** +** If page iPg is present in the cache, and has no outstanding references, +** it is discarded. Otherwise, if there are one or more outstanding +** references, the page content is reloaded from the database. If the +** attempt to reload content from the database is required and fails, +** return an SQLite error code. Otherwise, SQLITE_OK. +*/ +static int pagerUndoCallback(void *pCtx, Pgno iPg){ + int rc = SQLITE_OK; + Pager *pPager = (Pager *)pCtx; + PgHdr *pPg; + + assert( pagerUseWal(pPager) ); + pPg = sqlite3PagerLookup(pPager, iPg); + if( pPg ){ + if( sqlite3PcachePageRefcount(pPg)==1 ){ + sqlite3PcacheDrop(pPg); + }else{ + rc = readDbPage(pPg); + if( rc==SQLITE_OK ){ + pPager->xReiniter(pPg); + } + sqlite3PagerUnrefNotNull(pPg); + } + } + + /* Normally, if a transaction is rolled back, any backup processes are + ** updated as data is copied out of the rollback journal and into the + ** database. This is not generally possible with a WAL database, as + ** rollback involves simply truncating the log file. Therefore, if one + ** or more frames have already been written to the log (and therefore + ** also copied into the backup databases) as part of this transaction, + ** the backups must be restarted. + */ + sqlite3BackupRestart(pPager->pBackup); + + return rc; +} + +/* +** This function is called to rollback a transaction on a WAL database. +*/ +static int pagerRollbackWal(Pager *pPager){ + int rc; /* Return Code */ + PgHdr *pList; /* List of dirty pages to revert */ + + /* For all pages in the cache that are currently dirty or have already + ** been written (but not committed) to the log file, do one of the + ** following: + ** + ** + Discard the cached page (if refcount==0), or + ** + Reload page content from the database (if refcount>0). + */ + pPager->dbSize = pPager->dbOrigSize; + rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager); + pList = sqlite3PcacheDirtyList(pPager->pPCache); + while( pList && rc==SQLITE_OK ){ + PgHdr *pNext = pList->pDirty; + rc = pagerUndoCallback((void *)pPager, pList->pgno); + pList = pNext; + } + + return rc; +} + +/* +** This function is a wrapper around sqlite3WalFrames(). As well as logging +** the contents of the list of pages headed by pList (connected by pDirty), +** this function notifies any active backup processes that the pages have +** changed. +** +** The list of pages passed into this routine is always sorted by page number. +** Hence, if page 1 appears anywhere on the list, it will be the first page. +*/ +static int pagerWalFrames( + Pager *pPager, /* Pager object */ + PgHdr *pList, /* List of frames to log */ + Pgno nTruncate, /* Database size after this commit */ + int isCommit /* True if this is a commit */ +){ + int rc; /* Return code */ + int nList; /* Number of pages in pList */ + PgHdr *p; /* For looping over pages */ + + assert( pPager->pWal ); + assert( pList ); +#ifdef SQLITE_DEBUG + /* Verify that the page list is in accending order */ + for(p=pList; p && p->pDirty; p=p->pDirty){ + assert( p->pgno < p->pDirty->pgno ); + } +#endif + + assert( pList->pDirty==0 || isCommit ); + if( isCommit ){ + /* If a WAL transaction is being committed, there is no point in writing + ** any pages with page numbers greater than nTruncate into the WAL file. + ** They will never be read by any client. So remove them from the pDirty + ** list here. */ + PgHdr **ppNext = &pList; + nList = 0; + for(p=pList; (*ppNext = p)!=0; p=p->pDirty){ + if( p->pgno<=nTruncate ){ + ppNext = &p->pDirty; + nList++; + } + } + assert( pList ); + }else{ + nList = 1; + } + pPager->aStat[PAGER_STAT_WRITE] += nList; + + if( pList->pgno==1 ) pager_write_changecounter(pList); + rc = sqlite3WalFrames(pPager->pWal, + pPager->pageSize, pList, nTruncate, isCommit, pPager->walSyncFlags + ); + if( rc==SQLITE_OK && pPager->pBackup ){ + for(p=pList; p; p=p->pDirty){ + sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData); + } + } + +#ifdef SQLITE_CHECK_PAGES + pList = sqlite3PcacheDirtyList(pPager->pPCache); + for(p=pList; p; p=p->pDirty){ + pager_set_pagehash(p); + } +#endif + + return rc; +} + +/* +** Begin a read transaction on the WAL. +** +** This routine used to be called "pagerOpenSnapshot()" because it essentially +** makes a snapshot of the database at the current point in time and preserves +** that snapshot for use by the reader in spite of concurrently changes by +** other writers or checkpointers. +*/ +static int pagerBeginReadTransaction(Pager *pPager){ + int rc; /* Return code */ + int changed = 0; /* True if cache must be reset */ + + assert( pagerUseWal(pPager) ); + assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER ); + + /* sqlite3WalEndReadTransaction() was not called for the previous + ** transaction in locking_mode=EXCLUSIVE. So call it now. If we + ** are in locking_mode=NORMAL and EndRead() was previously called, + ** the duplicate call is harmless. + */ + sqlite3WalEndReadTransaction(pPager->pWal); + + rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed); + if( rc!=SQLITE_OK || changed ){ + pager_reset(pPager); + if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0); + } + + return rc; +} +#endif + +/* +** This function is called as part of the transition from PAGER_OPEN +** to PAGER_READER state to determine the size of the database file +** in pages (assuming the page size currently stored in Pager.pageSize). +** +** If no error occurs, SQLITE_OK is returned and the size of the database +** in pages is stored in *pnPage. Otherwise, an error code (perhaps +** SQLITE_IOERR_FSTAT) is returned and *pnPage is left unmodified. +*/ +static int pagerPagecount(Pager *pPager, Pgno *pnPage){ + Pgno nPage; /* Value to return via *pnPage */ + + /* Query the WAL sub-system for the database size. The WalDbsize() + ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or + ** if the database size is not available. The database size is not + ** available from the WAL sub-system if the log file is empty or + ** contains no valid committed transactions. + */ + assert( pPager->eState==PAGER_OPEN ); + assert( pPager->eLock>=SHARED_LOCK ); + assert( isOpen(pPager->fd) ); + assert( pPager->tempFile==0 ); + nPage = sqlite3WalDbsize(pPager->pWal); + + /* If the number of pages in the database is not available from the + ** WAL sub-system, determine the page count based on the size of + ** the database file. If the size of the database file is not an + ** integer multiple of the page-size, round up the result. + */ + if( nPage==0 && ALWAYS(isOpen(pPager->fd)) ){ + i64 n = 0; /* Size of db file in bytes */ + int rc = sqlite3OsFileSize(pPager->fd, &n); + if( rc!=SQLITE_OK ){ + return rc; + } + nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize); + } + + /* If the current number of pages in the file is greater than the + ** configured maximum pager number, increase the allowed limit so + ** that the file can be read. + */ + if( nPage>pPager->mxPgno ){ + pPager->mxPgno = (Pgno)nPage; + } + + *pnPage = nPage; + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_WAL +/* +** Check if the *-wal file that corresponds to the database opened by pPager +** exists if the database is not empy, or verify that the *-wal file does +** not exist (by deleting it) if the database file is empty. +** +** If the database is not empty and the *-wal file exists, open the pager +** in WAL mode. If the database is empty or if no *-wal file exists and +** if no error occurs, make sure Pager.journalMode is not set to +** PAGER_JOURNALMODE_WAL. +** +** Return SQLITE_OK or an error code. +** +** The caller must hold a SHARED lock on the database file to call this +** function. Because an EXCLUSIVE lock on the db file is required to delete +** a WAL on a none-empty database, this ensures there is no race condition +** between the xAccess() below and an xDelete() being executed by some +** other connection. +*/ +static int pagerOpenWalIfPresent(Pager *pPager){ + int rc = SQLITE_OK; + assert( pPager->eState==PAGER_OPEN ); + assert( pPager->eLock>=SHARED_LOCK ); + + if( !pPager->tempFile ){ + int isWal; /* True if WAL file exists */ + rc = sqlite3OsAccess( + pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal + ); + if( rc==SQLITE_OK ){ + if( isWal ){ + Pgno nPage; /* Size of the database file */ + + rc = pagerPagecount(pPager, &nPage); + if( rc ) return rc; + if( nPage==0 ){ + rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0); + }else{ + testcase( sqlite3PcachePagecount(pPager->pPCache)==0 ); + rc = sqlite3PagerOpenWal(pPager, 0); + } + }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){ + pPager->journalMode = PAGER_JOURNALMODE_DELETE; + } + } + } + return rc; +} +#endif + +/* +** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback +** the entire super-journal file. The case pSavepoint==NULL occurs when +** a ROLLBACK TO command is invoked on a SAVEPOINT that is a transaction +** savepoint. +** +** When pSavepoint is not NULL (meaning a non-transaction savepoint is +** being rolled back), then the rollback consists of up to three stages, +** performed in the order specified: +** +** * Pages are played back from the main journal starting at byte +** offset PagerSavepoint.iOffset and continuing to +** PagerSavepoint.iHdrOffset, or to the end of the main journal +** file if PagerSavepoint.iHdrOffset is zero. +** +** * If PagerSavepoint.iHdrOffset is not zero, then pages are played +** back starting from the journal header immediately following +** PagerSavepoint.iHdrOffset to the end of the main journal file. +** +** * Pages are then played back from the sub-journal file, starting +** with the PagerSavepoint.iSubRec and continuing to the end of +** the journal file. +** +** Throughout the rollback process, each time a page is rolled back, the +** corresponding bit is set in a bitvec structure (variable pDone in the +** implementation below). This is used to ensure that a page is only +** rolled back the first time it is encountered in either journal. +** +** If pSavepoint is NULL, then pages are only played back from the main +** journal file. There is no need for a bitvec in this case. +** +** In either case, before playback commences the Pager.dbSize variable +** is reset to the value that it held at the start of the savepoint +** (or transaction). No page with a page-number greater than this value +** is played back. If one is encountered it is simply skipped. +*/ +static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){ + i64 szJ; /* Effective size of the main journal */ + i64 iHdrOff; /* End of first segment of main-journal records */ + int rc = SQLITE_OK; /* Return code */ + Bitvec *pDone = 0; /* Bitvec to ensure pages played back only once */ + + assert( pPager->eState!=PAGER_ERROR ); + assert( pPager->eState>=PAGER_WRITER_LOCKED ); + + /* Allocate a bitvec to use to store the set of pages rolled back */ + if( pSavepoint ){ + pDone = sqlite3BitvecCreate(pSavepoint->nOrig); + if( !pDone ){ + return SQLITE_NOMEM_BKPT; + } + } + + /* Set the database size back to the value it was before the savepoint + ** being reverted was opened. + */ + pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize; + pPager->changeCountDone = pPager->tempFile; + + if( !pSavepoint && pagerUseWal(pPager) ){ + return pagerRollbackWal(pPager); + } + + /* Use pPager->journalOff as the effective size of the main rollback + ** journal. The actual file might be larger than this in + ** PAGER_JOURNALMODE_TRUNCATE or PAGER_JOURNALMODE_PERSIST. But anything + ** past pPager->journalOff is off-limits to us. + */ + szJ = pPager->journalOff; + assert( pagerUseWal(pPager)==0 || szJ==0 ); + + /* Begin by rolling back records from the main journal starting at + ** PagerSavepoint.iOffset and continuing to the next journal header. + ** There might be records in the main journal that have a page number + ** greater than the current database size (pPager->dbSize) but those + ** will be skipped automatically. Pages are added to pDone as they + ** are played back. + */ + if( pSavepoint && !pagerUseWal(pPager) ){ + iHdrOff = pSavepoint->iHdrOffset ? pSavepoint->iHdrOffset : szJ; + pPager->journalOff = pSavepoint->iOffset; + while( rc==SQLITE_OK && pPager->journalOffjournalOff, pDone, 1, 1); + } + assert( rc!=SQLITE_DONE ); + }else{ + pPager->journalOff = 0; + } + + /* Continue rolling back records out of the main journal starting at + ** the first journal header seen and continuing until the effective end + ** of the main journal file. Continue to skip out-of-range pages and + ** continue adding pages rolled back to pDone. + */ + while( rc==SQLITE_OK && pPager->journalOffjournalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff" + ** test is related to ticket #2565. See the discussion in the + ** pager_playback() function for additional information. + */ + if( nJRec==0 + && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff + ){ + nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager)); + } + for(ii=0; rc==SQLITE_OK && iijournalOffjournalOff, pDone, 1, 1); + } + assert( rc!=SQLITE_DONE ); + } + assert( rc!=SQLITE_OK || pPager->journalOff>=szJ ); + + /* Finally, rollback pages from the sub-journal. Page that were + ** previously rolled back out of the main journal (and are hence in pDone) + ** will be skipped. Out-of-range pages are also skipped. + */ + if( pSavepoint ){ + u32 ii; /* Loop counter */ + i64 offset = (i64)pSavepoint->iSubRec*(4+pPager->pageSize); + + if( pagerUseWal(pPager) ){ + rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData); + } + for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && iinSubRec; ii++){ + assert( offset==(i64)ii*(4+pPager->pageSize) ); + rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1); + } + assert( rc!=SQLITE_DONE ); + } + + sqlite3BitvecDestroy(pDone); + if( rc==SQLITE_OK ){ + pPager->journalOff = szJ; + } + + return rc; +} + +/* +** Change the maximum number of in-memory pages that are allowed +** before attempting to recycle clean and unused pages. +*/ +SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){ + sqlite3PcacheSetCachesize(pPager->pPCache, mxPage); +} + +/* +** Change the maximum number of in-memory pages that are allowed +** before attempting to spill pages to journal. +*/ +SQLITE_PRIVATE int sqlite3PagerSetSpillsize(Pager *pPager, int mxPage){ + return sqlite3PcacheSetSpillsize(pPager->pPCache, mxPage); +} + +/* +** Invoke SQLITE_FCNTL_MMAP_SIZE based on the current value of szMmap. +*/ +static void pagerFixMaplimit(Pager *pPager){ +#if SQLITE_MAX_MMAP_SIZE>0 + sqlite3_file *fd = pPager->fd; + if( isOpen(fd) && fd->pMethods->iVersion>=3 ){ + sqlite3_int64 sz; + sz = pPager->szMmap; + pPager->bUseFetch = (sz>0); + setGetterMethod(pPager); + sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_MMAP_SIZE, &sz); + } +#endif +} + +/* +** Change the maximum size of any memory mapping made of the database file. +*/ +SQLITE_PRIVATE void sqlite3PagerSetMmapLimit(Pager *pPager, sqlite3_int64 szMmap){ + pPager->szMmap = szMmap; + pagerFixMaplimit(pPager); +} + +/* +** Free as much memory as possible from the pager. +*/ +SQLITE_PRIVATE void sqlite3PagerShrink(Pager *pPager){ + sqlite3PcacheShrink(pPager->pPCache); +} + +/* +** Adjust settings of the pager to those specified in the pgFlags parameter. +** +** The "level" in pgFlags & PAGER_SYNCHRONOUS_MASK sets the robustness +** of the database to damage due to OS crashes or power failures by +** changing the number of syncs()s when writing the journals. +** There are four levels: +** +** OFF sqlite3OsSync() is never called. This is the default +** for temporary and transient files. +** +** NORMAL The journal is synced once before writes begin on the +** database. This is normally adequate protection, but +** it is theoretically possible, though very unlikely, +** that an inopertune power failure could leave the journal +** in a state which would cause damage to the database +** when it is rolled back. +** +** FULL The journal is synced twice before writes begin on the +** database (with some additional information - the nRec field +** of the journal header - being written in between the two +** syncs). If we assume that writing a +** single disk sector is atomic, then this mode provides +** assurance that the journal will not be corrupted to the +** point of causing damage to the database during rollback. +** +** EXTRA This is like FULL except that is also syncs the directory +** that contains the rollback journal after the rollback +** journal is unlinked. +** +** The above is for a rollback-journal mode. For WAL mode, OFF continues +** to mean that no syncs ever occur. NORMAL means that the WAL is synced +** prior to the start of checkpoint and that the database file is synced +** at the conclusion of the checkpoint if the entire content of the WAL +** was written back into the database. But no sync operations occur for +** an ordinary commit in NORMAL mode with WAL. FULL means that the WAL +** file is synced following each commit operation, in addition to the +** syncs associated with NORMAL. There is no difference between FULL +** and EXTRA for WAL mode. +** +** Do not confuse synchronous=FULL with SQLITE_SYNC_FULL. The +** SQLITE_SYNC_FULL macro means to use the MacOSX-style full-fsync +** using fcntl(F_FULLFSYNC). SQLITE_SYNC_NORMAL means to do an +** ordinary fsync() call. There is no difference between SQLITE_SYNC_FULL +** and SQLITE_SYNC_NORMAL on platforms other than MacOSX. But the +** synchronous=FULL versus synchronous=NORMAL setting determines when +** the xSync primitive is called and is relevant to all platforms. +** +** Numeric values associated with these states are OFF==1, NORMAL=2, +** and FULL=3. +*/ +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +SQLITE_PRIVATE void sqlite3PagerSetFlags( + Pager *pPager, /* The pager to set safety level for */ + unsigned pgFlags /* Various flags */ +){ + unsigned level = pgFlags & PAGER_SYNCHRONOUS_MASK; + if( pPager->tempFile ){ + pPager->noSync = 1; + pPager->fullSync = 0; + pPager->extraSync = 0; + }else{ + pPager->noSync = level==PAGER_SYNCHRONOUS_OFF ?1:0; + pPager->fullSync = level>=PAGER_SYNCHRONOUS_FULL ?1:0; + pPager->extraSync = level==PAGER_SYNCHRONOUS_EXTRA ?1:0; + } + if( pPager->noSync ){ + pPager->syncFlags = 0; + }else if( pgFlags & PAGER_FULLFSYNC ){ + pPager->syncFlags = SQLITE_SYNC_FULL; + }else{ + pPager->syncFlags = SQLITE_SYNC_NORMAL; + } + pPager->walSyncFlags = (pPager->syncFlags<<2); + if( pPager->fullSync ){ + pPager->walSyncFlags |= pPager->syncFlags; + } + if( (pgFlags & PAGER_CKPT_FULLFSYNC) && !pPager->noSync ){ + pPager->walSyncFlags |= (SQLITE_SYNC_FULL<<2); + } + if( pgFlags & PAGER_CACHESPILL ){ + pPager->doNotSpill &= ~SPILLFLAG_OFF; + }else{ + pPager->doNotSpill |= SPILLFLAG_OFF; + } +} +#endif + +/* +** The following global variable is incremented whenever the library +** attempts to open a temporary file. This information is used for +** testing and analysis only. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_opentemp_count = 0; +#endif + +/* +** Open a temporary file. +** +** Write the file descriptor into *pFile. Return SQLITE_OK on success +** or some other error code if we fail. The OS will automatically +** delete the temporary file when it is closed. +** +** The flags passed to the VFS layer xOpen() call are those specified +** by parameter vfsFlags ORed with the following: +** +** SQLITE_OPEN_READWRITE +** SQLITE_OPEN_CREATE +** SQLITE_OPEN_EXCLUSIVE +** SQLITE_OPEN_DELETEONCLOSE +*/ +static int pagerOpentemp( + Pager *pPager, /* The pager object */ + sqlite3_file *pFile, /* Write the file descriptor here */ + int vfsFlags /* Flags passed through to the VFS */ +){ + int rc; /* Return code */ + +#ifdef SQLITE_TEST + sqlite3_opentemp_count++; /* Used for testing and analysis only */ +#endif + + vfsFlags |= SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | + SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE; + rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0); + assert( rc!=SQLITE_OK || isOpen(pFile) ); + return rc; +} + +/* +** Set the busy handler function. +** +** The pager invokes the busy-handler if sqlite3OsLock() returns +** SQLITE_BUSY when trying to upgrade from no-lock to a SHARED lock, +** or when trying to upgrade from a RESERVED lock to an EXCLUSIVE +** lock. It does *not* invoke the busy handler when upgrading from +** SHARED to RESERVED, or when upgrading from SHARED to EXCLUSIVE +** (which occurs during hot-journal rollback). Summary: +** +** Transition | Invokes xBusyHandler +** -------------------------------------------------------- +** NO_LOCK -> SHARED_LOCK | Yes +** SHARED_LOCK -> RESERVED_LOCK | No +** SHARED_LOCK -> EXCLUSIVE_LOCK | No +** RESERVED_LOCK -> EXCLUSIVE_LOCK | Yes +** +** If the busy-handler callback returns non-zero, the lock is +** retried. If it returns zero, then the SQLITE_BUSY error is +** returned to the caller of the pager API function. +*/ +SQLITE_PRIVATE void sqlite3PagerSetBusyHandler( + Pager *pPager, /* Pager object */ + int (*xBusyHandler)(void *), /* Pointer to busy-handler function */ + void *pBusyHandlerArg /* Argument to pass to xBusyHandler */ +){ + void **ap; + pPager->xBusyHandler = xBusyHandler; + pPager->pBusyHandlerArg = pBusyHandlerArg; + ap = (void **)&pPager->xBusyHandler; + assert( ((int(*)(void *))(ap[0]))==xBusyHandler ); + assert( ap[1]==pBusyHandlerArg ); + sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_BUSYHANDLER, (void *)ap); +} + +/* +** Change the page size used by the Pager object. The new page size +** is passed in *pPageSize. +** +** If the pager is in the error state when this function is called, it +** is a no-op. The value returned is the error state error code (i.e. +** one of SQLITE_IOERR, an SQLITE_IOERR_xxx sub-code or SQLITE_FULL). +** +** Otherwise, if all of the following are true: +** +** * the new page size (value of *pPageSize) is valid (a power +** of two between 512 and SQLITE_MAX_PAGE_SIZE, inclusive), and +** +** * there are no outstanding page references, and +** +** * the database is either not an in-memory database or it is +** an in-memory database that currently consists of zero pages. +** +** then the pager object page size is set to *pPageSize. +** +** If the page size is changed, then this function uses sqlite3PagerMalloc() +** to obtain a new Pager.pTmpSpace buffer. If this allocation attempt +** fails, SQLITE_NOMEM is returned and the page size remains unchanged. +** In all other cases, SQLITE_OK is returned. +** +** If the page size is not changed, either because one of the enumerated +** conditions above is not true, the pager was in error state when this +** function was called, or because the memory allocation attempt failed, +** then *pPageSize is set to the old, retained page size before returning. +*/ +SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){ + int rc = SQLITE_OK; + + /* It is not possible to do a full assert_pager_state() here, as this + ** function may be called from within PagerOpen(), before the state + ** of the Pager object is internally consistent. + ** + ** At one point this function returned an error if the pager was in + ** PAGER_ERROR state. But since PAGER_ERROR state guarantees that + ** there is at least one outstanding page reference, this function + ** is a no-op for that case anyhow. + */ + + u32 pageSize = *pPageSize; + assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) ); + if( (pPager->memDb==0 || pPager->dbSize==0) + && sqlite3PcacheRefCount(pPager->pPCache)==0 + && pageSize && pageSize!=(u32)pPager->pageSize + ){ + char *pNew = NULL; /* New temp space */ + i64 nByte = 0; + + if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){ + rc = sqlite3OsFileSize(pPager->fd, &nByte); + } + if( rc==SQLITE_OK ){ + /* 8 bytes of zeroed overrun space is sufficient so that the b-tree + * cell header parser will never run off the end of the allocation */ + pNew = (char *)sqlite3PageMalloc(pageSize+8); + if( !pNew ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + memset(pNew+pageSize, 0, 8); + } + } + + if( rc==SQLITE_OK ){ + pager_reset(pPager); + rc = sqlite3PcacheSetPageSize(pPager->pPCache, pageSize); + } + if( rc==SQLITE_OK ){ + sqlite3PageFree(pPager->pTmpSpace); + pPager->pTmpSpace = pNew; + pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize); + pPager->pageSize = pageSize; + }else{ + sqlite3PageFree(pNew); + } + } + + *pPageSize = pPager->pageSize; + if( rc==SQLITE_OK ){ + if( nReserve<0 ) nReserve = pPager->nReserve; + assert( nReserve>=0 && nReserve<1000 ); + pPager->nReserve = (i16)nReserve; + pagerFixMaplimit(pPager); + } + return rc; +} + +/* +** Return a pointer to the "temporary page" buffer held internally +** by the pager. This is a buffer that is big enough to hold the +** entire content of a database page. This buffer is used internally +** during rollback and will be overwritten whenever a rollback +** occurs. But other modules are free to use it too, as long as +** no rollbacks are happening. +*/ +SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager *pPager){ + return pPager->pTmpSpace; +} + +/* +** Attempt to set the maximum database page count if mxPage is positive. +** Make no changes if mxPage is zero or negative. And never reduce the +** maximum page count below the current size of the database. +** +** Regardless of mxPage, return the current maximum page count. +*/ +SQLITE_PRIVATE Pgno sqlite3PagerMaxPageCount(Pager *pPager, Pgno mxPage){ + if( mxPage>0 ){ + pPager->mxPgno = mxPage; + } + assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */ + /* assert( pPager->mxPgno>=pPager->dbSize ); */ + /* OP_MaxPgcnt ensures that the parameter passed to this function is not + ** less than the total number of valid pages in the database. But this + ** may be less than Pager.dbSize, and so the assert() above is not valid */ + return pPager->mxPgno; +} + +/* +** The following set of routines are used to disable the simulated +** I/O error mechanism. These routines are used to avoid simulated +** errors in places where we do not care about errors. +** +** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops +** and generate no code. +*/ +#ifdef SQLITE_TEST +SQLITE_API extern int sqlite3_io_error_pending; +SQLITE_API extern int sqlite3_io_error_hit; +static int saved_cnt; +void disable_simulated_io_errors(void){ + saved_cnt = sqlite3_io_error_pending; + sqlite3_io_error_pending = -1; +} +void enable_simulated_io_errors(void){ + sqlite3_io_error_pending = saved_cnt; +} +#else +# define disable_simulated_io_errors() +# define enable_simulated_io_errors() +#endif + +/* +** Read the first N bytes from the beginning of the file into memory +** that pDest points to. +** +** If the pager was opened on a transient file (zFilename==""), or +** opened on a file less than N bytes in size, the output buffer is +** zeroed and SQLITE_OK returned. The rationale for this is that this +** function is used to read database headers, and a new transient or +** zero sized database has a header than consists entirely of zeroes. +** +** If any IO error apart from SQLITE_IOERR_SHORT_READ is encountered, +** the error code is returned to the caller and the contents of the +** output buffer undefined. +*/ +SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){ + int rc = SQLITE_OK; + memset(pDest, 0, N); + assert( isOpen(pPager->fd) || pPager->tempFile ); + + /* This routine is only called by btree immediately after creating + ** the Pager object. There has not been an opportunity to transition + ** to WAL mode yet. + */ + assert( !pagerUseWal(pPager) ); + + if( isOpen(pPager->fd) ){ + IOTRACE(("DBHDR %p 0 %d\n", pPager, N)) + rc = sqlite3OsRead(pPager->fd, pDest, N, 0); + if( rc==SQLITE_IOERR_SHORT_READ ){ + rc = SQLITE_OK; + } + } + return rc; +} + +/* +** This function may only be called when a read-transaction is open on +** the pager. It returns the total number of pages in the database. +** +** However, if the file is between 1 and bytes in size, then +** this is considered a 1 page file. +*/ +SQLITE_PRIVATE void sqlite3PagerPagecount(Pager *pPager, int *pnPage){ + assert( pPager->eState>=PAGER_READER ); + assert( pPager->eState!=PAGER_WRITER_FINISHED ); + *pnPage = (int)pPager->dbSize; +} + + +/* +** Try to obtain a lock of type locktype on the database file. If +** a similar or greater lock is already held, this function is a no-op +** (returning SQLITE_OK immediately). +** +** Otherwise, attempt to obtain the lock using sqlite3OsLock(). Invoke +** the busy callback if the lock is currently not available. Repeat +** until the busy callback returns false or until the attempt to +** obtain the lock succeeds. +** +** Return SQLITE_OK on success and an error code if we cannot obtain +** the lock. If the lock is obtained successfully, set the Pager.state +** variable to locktype before returning. +*/ +static int pager_wait_on_lock(Pager *pPager, int locktype){ + int rc; /* Return code */ + + /* Check that this is either a no-op (because the requested lock is + ** already held), or one of the transitions that the busy-handler + ** may be invoked during, according to the comment above + ** sqlite3PagerSetBusyhandler(). + */ + assert( (pPager->eLock>=locktype) + || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK) + || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK) + ); + + do { + rc = pagerLockDb(pPager, locktype); + }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) ); + return rc; +} + +/* +** Function assertTruncateConstraint(pPager) checks that one of the +** following is true for all dirty pages currently in the page-cache: +** +** a) The page number is less than or equal to the size of the +** current database image, in pages, OR +** +** b) if the page content were written at this time, it would not +** be necessary to write the current content out to the sub-journal +** (as determined by function subjRequiresPage()). +** +** If the condition asserted by this function were not true, and the +** dirty page were to be discarded from the cache via the pagerStress() +** routine, pagerStress() would not write the current page content to +** the database file. If a savepoint transaction were rolled back after +** this happened, the correct behavior would be to restore the current +** content of the page. However, since this content is not present in either +** the database file or the portion of the rollback journal and +** sub-journal rolled back the content could not be restored and the +** database image would become corrupt. It is therefore fortunate that +** this circumstance cannot arise. +*/ +#if defined(SQLITE_DEBUG) +static void assertTruncateConstraintCb(PgHdr *pPg){ + assert( pPg->flags&PGHDR_DIRTY ); + assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize ); +} +static void assertTruncateConstraint(Pager *pPager){ + sqlite3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb); +} +#else +# define assertTruncateConstraint(pPager) +#endif + +/* +** Truncate the in-memory database file image to nPage pages. This +** function does not actually modify the database file on disk. It +** just sets the internal state of the pager object so that the +** truncation will be done when the current transaction is committed. +** +** This function is only called right before committing a transaction. +** Once this function has been called, the transaction must either be +** rolled back or committed. It is not safe to call this function and +** then continue writing to the database. +*/ +SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){ + assert( pPager->dbSize>=nPage ); + assert( pPager->eState>=PAGER_WRITER_CACHEMOD ); + pPager->dbSize = nPage; + + /* At one point the code here called assertTruncateConstraint() to + ** ensure that all pages being truncated away by this operation are, + ** if one or more savepoints are open, present in the savepoint + ** journal so that they can be restored if the savepoint is rolled + ** back. This is no longer necessary as this function is now only + ** called right before committing a transaction. So although the + ** Pager object may still have open savepoints (Pager.nSavepoint!=0), + ** they cannot be rolled back. So the assertTruncateConstraint() call + ** is no longer correct. */ +} + + +/* +** This function is called before attempting a hot-journal rollback. It +** syncs the journal file to disk, then sets pPager->journalHdr to the +** size of the journal file so that the pager_playback() routine knows +** that the entire journal file has been synced. +** +** Syncing a hot-journal to disk before attempting to roll it back ensures +** that if a power-failure occurs during the rollback, the process that +** attempts rollback following system recovery sees the same journal +** content as this process. +** +** If everything goes as planned, SQLITE_OK is returned. Otherwise, +** an SQLite error code. +*/ +static int pagerSyncHotJournal(Pager *pPager){ + int rc = SQLITE_OK; + if( !pPager->noSync ){ + rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL); + } + if( rc==SQLITE_OK ){ + rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr); + } + return rc; +} + +#if SQLITE_MAX_MMAP_SIZE>0 +/* +** Obtain a reference to a memory mapped page object for page number pgno. +** The new object will use the pointer pData, obtained from xFetch(). +** If successful, set *ppPage to point to the new page reference +** and return SQLITE_OK. Otherwise, return an SQLite error code and set +** *ppPage to zero. +** +** Page references obtained by calling this function should be released +** by calling pagerReleaseMapPage(). +*/ +static int pagerAcquireMapPage( + Pager *pPager, /* Pager object */ + Pgno pgno, /* Page number */ + void *pData, /* xFetch()'d data for this page */ + PgHdr **ppPage /* OUT: Acquired page object */ +){ + PgHdr *p; /* Memory mapped page to return */ + + if( pPager->pMmapFreelist ){ + *ppPage = p = pPager->pMmapFreelist; + pPager->pMmapFreelist = p->pDirty; + p->pDirty = 0; + assert( pPager->nExtra>=8 ); + memset(p->pExtra, 0, 8); + }else{ + *ppPage = p = (PgHdr *)sqlite3MallocZero(sizeof(PgHdr) + pPager->nExtra); + if( p==0 ){ + sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData); + return SQLITE_NOMEM_BKPT; + } + p->pExtra = (void *)&p[1]; + p->flags = PGHDR_MMAP; + p->nRef = 1; + p->pPager = pPager; + } + + assert( p->pExtra==(void *)&p[1] ); + assert( p->pPage==0 ); + assert( p->flags==PGHDR_MMAP ); + assert( p->pPager==pPager ); + assert( p->nRef==1 ); + + p->pgno = pgno; + p->pData = pData; + pPager->nMmapOut++; + + return SQLITE_OK; +} +#endif + +/* +** Release a reference to page pPg. pPg must have been returned by an +** earlier call to pagerAcquireMapPage(). +*/ +static void pagerReleaseMapPage(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + pPager->nMmapOut--; + pPg->pDirty = pPager->pMmapFreelist; + pPager->pMmapFreelist = pPg; + + assert( pPager->fd->pMethods->iVersion>=3 ); + sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData); +} + +/* +** Free all PgHdr objects stored in the Pager.pMmapFreelist list. +*/ +static void pagerFreeMapHdrs(Pager *pPager){ + PgHdr *p; + PgHdr *pNext; + for(p=pPager->pMmapFreelist; p; p=pNext){ + pNext = p->pDirty; + sqlite3_free(p); + } +} + +/* Verify that the database file has not be deleted or renamed out from +** under the pager. Return SQLITE_OK if the database is still where it ought +** to be on disk. Return non-zero (SQLITE_READONLY_DBMOVED or some other error +** code from sqlite3OsAccess()) if the database has gone missing. +*/ +static int databaseIsUnmoved(Pager *pPager){ + int bHasMoved = 0; + int rc; + + if( pPager->tempFile ) return SQLITE_OK; + if( pPager->dbSize==0 ) return SQLITE_OK; + assert( pPager->zFilename && pPager->zFilename[0] ); + rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_HAS_MOVED, &bHasMoved); + if( rc==SQLITE_NOTFOUND ){ + /* If the HAS_MOVED file-control is unimplemented, assume that the file + ** has not been moved. That is the historical behavior of SQLite: prior to + ** version 3.8.3, it never checked */ + rc = SQLITE_OK; + }else if( rc==SQLITE_OK && bHasMoved ){ + rc = SQLITE_READONLY_DBMOVED; + } + return rc; +} + + +/* +** Shutdown the page cache. Free all memory and close all files. +** +** If a transaction was in progress when this routine is called, that +** transaction is rolled back. All outstanding pages are invalidated +** and their memory is freed. Any attempt to use a page associated +** with this page cache after this function returns will likely +** result in a coredump. +** +** This function always succeeds. If a transaction is active an attempt +** is made to roll it back. If an error occurs during the rollback +** a hot journal may be left in the filesystem but no error is returned +** to the caller. +*/ +SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager, sqlite3 *db){ + u8 *pTmp = (u8*)pPager->pTmpSpace; + assert( db || pagerUseWal(pPager)==0 ); + assert( assert_pager_state(pPager) ); + disable_simulated_io_errors(); + sqlite3BeginBenignMalloc(); + pagerFreeMapHdrs(pPager); + /* pPager->errCode = 0; */ + pPager->exclusiveMode = 0; +#ifndef SQLITE_OMIT_WAL + { + u8 *a = 0; + assert( db || pPager->pWal==0 ); + if( db && 0==(db->flags & SQLITE_NoCkptOnClose) + && SQLITE_OK==databaseIsUnmoved(pPager) + ){ + a = pTmp; + } + sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags, pPager->pageSize,a); + pPager->pWal = 0; + } +#endif + pager_reset(pPager); + if( MEMDB ){ + pager_unlock(pPager); + }else{ + /* If it is open, sync the journal file before calling UnlockAndRollback. + ** If this is not done, then an unsynced portion of the open journal + ** file may be played back into the database. If a power failure occurs + ** while this is happening, the database could become corrupt. + ** + ** If an error occurs while trying to sync the journal, shift the pager + ** into the ERROR state. This causes UnlockAndRollback to unlock the + ** database and close the journal file without attempting to roll it + ** back or finalize it. The next database user will have to do hot-journal + ** rollback before accessing the database file. + */ + if( isOpen(pPager->jfd) ){ + pager_error(pPager, pagerSyncHotJournal(pPager)); + } + pagerUnlockAndRollback(pPager); + } + sqlite3EndBenignMalloc(); + enable_simulated_io_errors(); + PAGERTRACE(("CLOSE %d\n", PAGERID(pPager))); + IOTRACE(("CLOSE %p\n", pPager)) + sqlite3OsClose(pPager->jfd); + sqlite3OsClose(pPager->fd); + sqlite3PageFree(pTmp); + sqlite3PcacheClose(pPager->pPCache); + assert( !pPager->aSavepoint && !pPager->pInJournal ); + assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) ); + + sqlite3_free(pPager); + return SQLITE_OK; +} + +#if !defined(NDEBUG) || defined(SQLITE_TEST) +/* +** Return the page number for page pPg. +*/ +SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage *pPg){ + return pPg->pgno; +} +#endif + +/* +** Increment the reference count for page pPg. +*/ +SQLITE_PRIVATE void sqlite3PagerRef(DbPage *pPg){ + sqlite3PcacheRef(pPg); +} + +/* +** Sync the journal. In other words, make sure all the pages that have +** been written to the journal have actually reached the surface of the +** disk and can be restored in the event of a hot-journal rollback. +** +** If the Pager.noSync flag is set, then this function is a no-op. +** Otherwise, the actions required depend on the journal-mode and the +** device characteristics of the file-system, as follows: +** +** * If the journal file is an in-memory journal file, no action need +** be taken. +** +** * Otherwise, if the device does not support the SAFE_APPEND property, +** then the nRec field of the most recently written journal header +** is updated to contain the number of journal records that have +** been written following it. If the pager is operating in full-sync +** mode, then the journal file is synced before this field is updated. +** +** * If the device does not support the SEQUENTIAL property, then +** journal file is synced. +** +** Or, in pseudo-code: +** +** if( NOT ){ +** if( NOT SAFE_APPEND ){ +** if( ) xSync(); +** +** } +** if( NOT SEQUENTIAL ) xSync(); +** } +** +** If successful, this routine clears the PGHDR_NEED_SYNC flag of every +** page currently held in memory before returning SQLITE_OK. If an IO +** error is encountered, then the IO error code is returned to the caller. +*/ +static int syncJournal(Pager *pPager, int newHdr){ + int rc; /* Return code */ + + assert( pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + ); + assert( assert_pager_state(pPager) ); + assert( !pagerUseWal(pPager) ); + + rc = sqlite3PagerExclusiveLock(pPager); + if( rc!=SQLITE_OK ) return rc; + + if( !pPager->noSync ){ + assert( !pPager->tempFile ); + if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){ + const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd); + assert( isOpen(pPager->jfd) ); + + if( 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){ + /* This block deals with an obscure problem. If the last connection + ** that wrote to this database was operating in persistent-journal + ** mode, then the journal file may at this point actually be larger + ** than Pager.journalOff bytes. If the next thing in the journal + ** file happens to be a journal-header (written as part of the + ** previous connection's transaction), and a crash or power-failure + ** occurs after nRec is updated but before this connection writes + ** anything else to the journal file (or commits/rolls back its + ** transaction), then SQLite may become confused when doing the + ** hot-journal rollback following recovery. It may roll back all + ** of this connections data, then proceed to rolling back the old, + ** out-of-date data that follows it. Database corruption. + ** + ** To work around this, if the journal file does appear to contain + ** a valid header following Pager.journalOff, then write a 0x00 + ** byte to the start of it to prevent it from being recognized. + ** + ** Variable iNextHdrOffset is set to the offset at which this + ** problematic header will occur, if it exists. aMagic is used + ** as a temporary buffer to inspect the first couple of bytes of + ** the potential journal header. + */ + i64 iNextHdrOffset; + u8 aMagic[8]; + u8 zHeader[sizeof(aJournalMagic)+4]; + + memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic)); + put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec); + + iNextHdrOffset = journalHdrOffset(pPager); + rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset); + if( rc==SQLITE_OK && 0==memcmp(aMagic, aJournalMagic, 8) ){ + static const u8 zerobyte = 0; + rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset); + } + if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){ + return rc; + } + + /* Write the nRec value into the journal file header. If in + ** full-synchronous mode, sync the journal first. This ensures that + ** all data has really hit the disk before nRec is updated to mark + ** it as a candidate for rollback. + ** + ** This is not required if the persistent media supports the + ** SAFE_APPEND property. Because in this case it is not possible + ** for garbage data to be appended to the file, the nRec field + ** is populated with 0xFFFFFFFF when the journal header is written + ** and never needs to be updated. + */ + if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){ + PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager))); + IOTRACE(("JSYNC %p\n", pPager)) + rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags); + if( rc!=SQLITE_OK ) return rc; + } + IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr)); + rc = sqlite3OsWrite( + pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr + ); + if( rc!=SQLITE_OK ) return rc; + } + if( 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){ + PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager))); + IOTRACE(("JSYNC %p\n", pPager)) + rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags| + (pPager->syncFlags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0) + ); + if( rc!=SQLITE_OK ) return rc; + } + + pPager->journalHdr = pPager->journalOff; + if( newHdr && 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){ + pPager->nRec = 0; + rc = writeJournalHdr(pPager); + if( rc!=SQLITE_OK ) return rc; + } + }else{ + pPager->journalHdr = pPager->journalOff; + } + } + + /* Unless the pager is in noSync mode, the journal file was just + ** successfully synced. Either way, clear the PGHDR_NEED_SYNC flag on + ** all pages. + */ + sqlite3PcacheClearSyncFlags(pPager->pPCache); + pPager->eState = PAGER_WRITER_DBMOD; + assert( assert_pager_state(pPager) ); + return SQLITE_OK; +} + +/* +** The argument is the first in a linked list of dirty pages connected +** by the PgHdr.pDirty pointer. This function writes each one of the +** in-memory pages in the list to the database file. The argument may +** be NULL, representing an empty list. In this case this function is +** a no-op. +** +** The pager must hold at least a RESERVED lock when this function +** is called. Before writing anything to the database file, this lock +** is upgraded to an EXCLUSIVE lock. If the lock cannot be obtained, +** SQLITE_BUSY is returned and no data is written to the database file. +** +** If the pager is a temp-file pager and the actual file-system file +** is not yet open, it is created and opened before any data is +** written out. +** +** Once the lock has been upgraded and, if necessary, the file opened, +** the pages are written out to the database file in list order. Writing +** a page is skipped if it meets either of the following criteria: +** +** * The page number is greater than Pager.dbSize, or +** * The PGHDR_DONT_WRITE flag is set on the page. +** +** If writing out a page causes the database file to grow, Pager.dbFileSize +** is updated accordingly. If page 1 is written out, then the value cached +** in Pager.dbFileVers[] is updated to match the new value stored in +** the database file. +** +** If everything is successful, SQLITE_OK is returned. If an IO error +** occurs, an IO error code is returned. Or, if the EXCLUSIVE lock cannot +** be obtained, SQLITE_BUSY is returned. +*/ +static int pager_write_pagelist(Pager *pPager, PgHdr *pList){ + int rc = SQLITE_OK; /* Return code */ + + /* This function is only called for rollback pagers in WRITER_DBMOD state. */ + assert( !pagerUseWal(pPager) ); + assert( pPager->tempFile || pPager->eState==PAGER_WRITER_DBMOD ); + assert( pPager->eLock==EXCLUSIVE_LOCK ); + assert( isOpen(pPager->fd) || pList->pDirty==0 ); + + /* If the file is a temp-file has not yet been opened, open it now. It + ** is not possible for rc to be other than SQLITE_OK if this branch + ** is taken, as pager_wait_on_lock() is a no-op for temp-files. + */ + if( !isOpen(pPager->fd) ){ + assert( pPager->tempFile && rc==SQLITE_OK ); + rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags); + } + + /* Before the first write, give the VFS a hint of what the final + ** file size will be. + */ + assert( rc!=SQLITE_OK || isOpen(pPager->fd) ); + if( rc==SQLITE_OK + && pPager->dbHintSizedbSize + && (pList->pDirty || pList->pgno>pPager->dbHintSize) + ){ + sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize; + sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile); + pPager->dbHintSize = pPager->dbSize; + } + + while( rc==SQLITE_OK && pList ){ + Pgno pgno = pList->pgno; + + /* If there are dirty pages in the page cache with page numbers greater + ** than Pager.dbSize, this means sqlite3PagerTruncateImage() was called to + ** make the file smaller (presumably by auto-vacuum code). Do not write + ** any such pages to the file. + ** + ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag + ** set (set by sqlite3PagerDontWrite()). + */ + if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){ + i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */ + char *pData; /* Data to write */ + + assert( (pList->flags&PGHDR_NEED_SYNC)==0 ); + if( pList->pgno==1 ) pager_write_changecounter(pList); + + pData = pList->pData; + + /* Write out the page data. */ + rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset); + + /* If page 1 was just written, update Pager.dbFileVers to match + ** the value now stored in the database file. If writing this + ** page caused the database file to grow, update dbFileSize. + */ + if( pgno==1 ){ + memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers)); + } + if( pgno>pPager->dbFileSize ){ + pPager->dbFileSize = pgno; + } + pPager->aStat[PAGER_STAT_WRITE]++; + + /* Update any backup objects copying the contents of this pager. */ + sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData); + + PAGERTRACE(("STORE %d page %d hash(%08x)\n", + PAGERID(pPager), pgno, pager_pagehash(pList))); + IOTRACE(("PGOUT %p %d\n", pPager, pgno)); + PAGER_INCR(sqlite3_pager_writedb_count); + }else{ + PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno)); + } + pager_set_pagehash(pList); + pList = pList->pDirty; + } + + return rc; +} + +/* +** Ensure that the sub-journal file is open. If it is already open, this +** function is a no-op. +** +** SQLITE_OK is returned if everything goes according to plan. An +** SQLITE_IOERR_XXX error code is returned if a call to sqlite3OsOpen() +** fails. +*/ +static int openSubJournal(Pager *pPager){ + int rc = SQLITE_OK; + if( !isOpen(pPager->sjfd) ){ + const int flags = SQLITE_OPEN_SUBJOURNAL | SQLITE_OPEN_READWRITE + | SQLITE_OPEN_CREATE | SQLITE_OPEN_EXCLUSIVE + | SQLITE_OPEN_DELETEONCLOSE; + int nStmtSpill = sqlite3Config.nStmtSpill; + if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){ + nStmtSpill = -1; + } + rc = sqlite3JournalOpen(pPager->pVfs, 0, pPager->sjfd, flags, nStmtSpill); + } + return rc; +} + +/* +** Append a record of the current state of page pPg to the sub-journal. +** +** If successful, set the bit corresponding to pPg->pgno in the bitvecs +** for all open savepoints before returning. +** +** This function returns SQLITE_OK if everything is successful, an IO +** error code if the attempt to write to the sub-journal fails, or +** SQLITE_NOMEM if a malloc fails while setting a bit in a savepoint +** bitvec. +*/ +static int subjournalPage(PgHdr *pPg){ + int rc = SQLITE_OK; + Pager *pPager = pPg->pPager; + if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){ + + /* Open the sub-journal, if it has not already been opened */ + assert( pPager->useJournal ); + assert( isOpen(pPager->jfd) || pagerUseWal(pPager) ); + assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 ); + assert( pagerUseWal(pPager) + || pageInJournal(pPager, pPg) + || pPg->pgno>pPager->dbOrigSize + ); + rc = openSubJournal(pPager); + + /* If the sub-journal was opened successfully (or was already open), + ** write the journal record into the file. */ + if( rc==SQLITE_OK ){ + void *pData = pPg->pData; + i64 offset = (i64)pPager->nSubRec*(4+pPager->pageSize); + char *pData2; + pData2 = pData; + PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno)); + rc = write32bits(pPager->sjfd, offset, pPg->pgno); + if( rc==SQLITE_OK ){ + rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4); + } + } + } + if( rc==SQLITE_OK ){ + pPager->nSubRec++; + assert( pPager->nSavepoint>0 ); + rc = addToSavepointBitvecs(pPager, pPg->pgno); + } + return rc; +} +static int subjournalPageIfRequired(PgHdr *pPg){ + if( subjRequiresPage(pPg) ){ + return subjournalPage(pPg); + }else{ + return SQLITE_OK; + } +} + +/* +** This function is called by the pcache layer when it has reached some +** soft memory limit. The first argument is a pointer to a Pager object +** (cast as a void*). The pager is always 'purgeable' (not an in-memory +** database). The second argument is a reference to a page that is +** currently dirty but has no outstanding references. The page +** is always associated with the Pager object passed as the first +** argument. +** +** The job of this function is to make pPg clean by writing its contents +** out to the database file, if possible. This may involve syncing the +** journal file. +** +** If successful, sqlite3PcacheMakeClean() is called on the page and +** SQLITE_OK returned. If an IO error occurs while trying to make the +** page clean, the IO error code is returned. If the page cannot be +** made clean for some other reason, but no error occurs, then SQLITE_OK +** is returned by sqlite3PcacheMakeClean() is not called. +*/ +static int pagerStress(void *p, PgHdr *pPg){ + Pager *pPager = (Pager *)p; + int rc = SQLITE_OK; + + assert( pPg->pPager==pPager ); + assert( pPg->flags&PGHDR_DIRTY ); + + /* The doNotSpill NOSYNC bit is set during times when doing a sync of + ** journal (and adding a new header) is not allowed. This occurs + ** during calls to sqlite3PagerWrite() while trying to journal multiple + ** pages belonging to the same sector. + ** + ** The doNotSpill ROLLBACK and OFF bits inhibits all cache spilling + ** regardless of whether or not a sync is required. This is set during + ** a rollback or by user request, respectively. + ** + ** Spilling is also prohibited when in an error state since that could + ** lead to database corruption. In the current implementation it + ** is impossible for sqlite3PcacheFetch() to be called with createFlag==3 + ** while in the error state, hence it is impossible for this routine to + ** be called in the error state. Nevertheless, we include a NEVER() + ** test for the error state as a safeguard against future changes. + */ + if( NEVER(pPager->errCode) ) return SQLITE_OK; + testcase( pPager->doNotSpill & SPILLFLAG_ROLLBACK ); + testcase( pPager->doNotSpill & SPILLFLAG_OFF ); + testcase( pPager->doNotSpill & SPILLFLAG_NOSYNC ); + if( pPager->doNotSpill + && ((pPager->doNotSpill & (SPILLFLAG_ROLLBACK|SPILLFLAG_OFF))!=0 + || (pPg->flags & PGHDR_NEED_SYNC)!=0) + ){ + return SQLITE_OK; + } + + pPager->aStat[PAGER_STAT_SPILL]++; + pPg->pDirty = 0; + if( pagerUseWal(pPager) ){ + /* Write a single frame for this page to the log. */ + rc = subjournalPageIfRequired(pPg); + if( rc==SQLITE_OK ){ + rc = pagerWalFrames(pPager, pPg, 0, 0); + } + }else{ + +#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE + if( pPager->tempFile==0 ){ + rc = sqlite3JournalCreate(pPager->jfd); + if( rc!=SQLITE_OK ) return pager_error(pPager, rc); + } +#endif + + /* Sync the journal file if required. */ + if( pPg->flags&PGHDR_NEED_SYNC + || pPager->eState==PAGER_WRITER_CACHEMOD + ){ + rc = syncJournal(pPager, 1); + } + + /* Write the contents of the page out to the database file. */ + if( rc==SQLITE_OK ){ + assert( (pPg->flags&PGHDR_NEED_SYNC)==0 ); + rc = pager_write_pagelist(pPager, pPg); + } + } + + /* Mark the page as clean. */ + if( rc==SQLITE_OK ){ + PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno)); + sqlite3PcacheMakeClean(pPg); + } + + return pager_error(pPager, rc); +} + +/* +** Flush all unreferenced dirty pages to disk. +*/ +SQLITE_PRIVATE int sqlite3PagerFlush(Pager *pPager){ + int rc = pPager->errCode; + if( !MEMDB ){ + PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache); + assert( assert_pager_state(pPager) ); + while( rc==SQLITE_OK && pList ){ + PgHdr *pNext = pList->pDirty; + if( pList->nRef==0 ){ + rc = pagerStress((void*)pPager, pList); + } + pList = pNext; + } + } + + return rc; +} + +/* +** Allocate and initialize a new Pager object and put a pointer to it +** in *ppPager. The pager should eventually be freed by passing it +** to sqlite3PagerClose(). +** +** The zFilename argument is the path to the database file to open. +** If zFilename is NULL then a randomly-named temporary file is created +** and used as the file to be cached. Temporary files are be deleted +** automatically when they are closed. If zFilename is ":memory:" then +** all information is held in cache. It is never written to disk. +** This can be used to implement an in-memory database. +** +** The nExtra parameter specifies the number of bytes of space allocated +** along with each page reference. This space is available to the user +** via the sqlite3PagerGetExtra() API. When a new page is allocated, the +** first 8 bytes of this space are zeroed but the remainder is uninitialized. +** (The extra space is used by btree as the MemPage object.) +** +** The flags argument is used to specify properties that affect the +** operation of the pager. It should be passed some bitwise combination +** of the PAGER_* flags. +** +** The vfsFlags parameter is a bitmask to pass to the flags parameter +** of the xOpen() method of the supplied VFS when opening files. +** +** If the pager object is allocated and the specified file opened +** successfully, SQLITE_OK is returned and *ppPager set to point to +** the new pager object. If an error occurs, *ppPager is set to NULL +** and error code returned. This function may return SQLITE_NOMEM +** (sqlite3Malloc() is used to allocate memory), SQLITE_CANTOPEN or +** various SQLITE_IO_XXX errors. +*/ +SQLITE_PRIVATE int sqlite3PagerOpen( + sqlite3_vfs *pVfs, /* The virtual file system to use */ + Pager **ppPager, /* OUT: Return the Pager structure here */ + const char *zFilename, /* Name of the database file to open */ + int nExtra, /* Extra bytes append to each in-memory page */ + int flags, /* flags controlling this file */ + int vfsFlags, /* flags passed through to sqlite3_vfs.xOpen() */ + void (*xReinit)(DbPage*) /* Function to reinitialize pages */ +){ + u8 *pPtr; + Pager *pPager = 0; /* Pager object to allocate and return */ + int rc = SQLITE_OK; /* Return code */ + int tempFile = 0; /* True for temp files (incl. in-memory files) */ + int memDb = 0; /* True if this is an in-memory file */ +#ifdef SQLITE_ENABLE_DESERIALIZE + int memJM = 0; /* Memory journal mode */ +#else +# define memJM 0 +#endif + int readOnly = 0; /* True if this is a read-only file */ + int journalFileSize; /* Bytes to allocate for each journal fd */ + char *zPathname = 0; /* Full path to database file */ + int nPathname = 0; /* Number of bytes in zPathname */ + int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; /* False to omit journal */ + int pcacheSize = sqlite3PcacheSize(); /* Bytes to allocate for PCache */ + u32 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE; /* Default page size */ + const char *zUri = 0; /* URI args to copy */ + int nUriByte = 1; /* Number of bytes of URI args at *zUri */ + int nUri = 0; /* Number of URI parameters */ + + /* Figure out how much space is required for each journal file-handle + ** (there are two of them, the main journal and the sub-journal). */ + journalFileSize = ROUND8(sqlite3JournalSize(pVfs)); + + /* Set the output variable to NULL in case an error occurs. */ + *ppPager = 0; + +#ifndef SQLITE_OMIT_MEMORYDB + if( flags & PAGER_MEMORY ){ + memDb = 1; + if( zFilename && zFilename[0] ){ + zPathname = sqlite3DbStrDup(0, zFilename); + if( zPathname==0 ) return SQLITE_NOMEM_BKPT; + nPathname = sqlite3Strlen30(zPathname); + zFilename = 0; + } + } +#endif + + /* Compute and store the full pathname in an allocated buffer pointed + ** to by zPathname, length nPathname. Or, if this is a temporary file, + ** leave both nPathname and zPathname set to 0. + */ + if( zFilename && zFilename[0] ){ + const char *z; + nPathname = pVfs->mxPathname+1; + zPathname = sqlite3DbMallocRaw(0, nPathname*2); + if( zPathname==0 ){ + return SQLITE_NOMEM_BKPT; + } + zPathname[0] = 0; /* Make sure initialized even if FullPathname() fails */ + rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_OK_SYMLINK ){ + if( vfsFlags & SQLITE_OPEN_NOFOLLOW ){ + rc = SQLITE_CANTOPEN_SYMLINK; + }else{ + rc = SQLITE_OK; + } + } + } + nPathname = sqlite3Strlen30(zPathname); + z = zUri = &zFilename[sqlite3Strlen30(zFilename)+1]; + while( *z ){ + z += strlen(z)+1; + z += strlen(z)+1; + nUri++; + } + nUriByte = (int)(&z[1] - zUri); + assert( nUriByte>=1 ); + if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){ + /* This branch is taken when the journal path required by + ** the database being opened will be more than pVfs->mxPathname + ** bytes in length. This means the database cannot be opened, + ** as it will not be possible to open the journal file or even + ** check for a hot-journal before reading. + */ + rc = SQLITE_CANTOPEN_BKPT; + } + if( rc!=SQLITE_OK ){ + sqlite3DbFree(0, zPathname); + return rc; + } + } + + /* Allocate memory for the Pager structure, PCache object, the + ** three file descriptors, the database file name and the journal + ** file name. The layout in memory is as follows: + ** + ** Pager object (sizeof(Pager) bytes) + ** PCache object (sqlite3PcacheSize() bytes) + ** Database file handle (pVfs->szOsFile bytes) + ** Sub-journal file handle (journalFileSize bytes) + ** Main journal file handle (journalFileSize bytes) + ** Ptr back to the Pager (sizeof(Pager*) bytes) + ** \0\0\0\0 database prefix (4 bytes) + ** Database file name (nPathname+1 bytes) + ** URI query parameters (nUriByte bytes) + ** Journal filename (nPathname+8+1 bytes) + ** WAL filename (nPathname+4+1 bytes) + ** \0\0\0 terminator (3 bytes) + ** + ** Some 3rd-party software, over which we have no control, depends on + ** the specific order of the filenames and the \0 separators between them + ** so that it can (for example) find the database filename given the WAL + ** filename without using the sqlite3_filename_database() API. This is a + ** misuse of SQLite and a bug in the 3rd-party software, but the 3rd-party + ** software is in widespread use, so we try to avoid changing the filename + ** order and formatting if possible. In particular, the details of the + ** filename format expected by 3rd-party software should be as follows: + ** + ** - Main Database Path + ** - \0 + ** - Multiple URI components consisting of: + ** - Key + ** - \0 + ** - Value + ** - \0 + ** - \0 + ** - Journal Path + ** - \0 + ** - WAL Path (zWALName) + ** - \0 + ** + ** The sqlite3_create_filename() interface and the databaseFilename() utility + ** that is used by sqlite3_filename_database() and kin also depend on the + ** specific formatting and order of the various filenames, so if the format + ** changes here, be sure to change it there as well. + */ + pPtr = (u8 *)sqlite3MallocZero( + ROUND8(sizeof(*pPager)) + /* Pager structure */ + ROUND8(pcacheSize) + /* PCache object */ + ROUND8(pVfs->szOsFile) + /* The main db file */ + journalFileSize * 2 + /* The two journal files */ + sizeof(pPager) + /* Space to hold a pointer */ + 4 + /* Database prefix */ + nPathname + 1 + /* database filename */ + nUriByte + /* query parameters */ + nPathname + 8 + 1 + /* Journal filename */ +#ifndef SQLITE_OMIT_WAL + nPathname + 4 + 1 + /* WAL filename */ +#endif + 3 /* Terminator */ + ); + assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize)) ); + if( !pPtr ){ + sqlite3DbFree(0, zPathname); + return SQLITE_NOMEM_BKPT; + } + pPager = (Pager*)pPtr; pPtr += ROUND8(sizeof(*pPager)); + pPager->pPCache = (PCache*)pPtr; pPtr += ROUND8(pcacheSize); + pPager->fd = (sqlite3_file*)pPtr; pPtr += ROUND8(pVfs->szOsFile); + pPager->sjfd = (sqlite3_file*)pPtr; pPtr += journalFileSize; + pPager->jfd = (sqlite3_file*)pPtr; pPtr += journalFileSize; + assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) ); + memcpy(pPtr, &pPager, sizeof(pPager)); pPtr += sizeof(pPager); + + /* Fill in the Pager.zFilename and pPager.zQueryParam fields */ + pPtr += 4; /* Skip zero prefix */ + pPager->zFilename = (char*)pPtr; + if( nPathname>0 ){ + memcpy(pPtr, zPathname, nPathname); pPtr += nPathname + 1; + if( zUri ){ + memcpy(pPtr, zUri, nUriByte); pPtr += nUriByte; + }else{ + pPtr++; + } + } + + + /* Fill in Pager.zJournal */ + if( nPathname>0 ){ + pPager->zJournal = (char*)pPtr; + memcpy(pPtr, zPathname, nPathname); pPtr += nPathname; + memcpy(pPtr, "-journal",8); pPtr += 8 + 1; +#ifdef SQLITE_ENABLE_8_3_NAMES + sqlite3FileSuffix3(zFilename,pPager->zJournal); + pPtr = (u8*)(pPager->zJournal + sqlite3Strlen30(pPager->zJournal)+1); +#endif + }else{ + pPager->zJournal = 0; + } + +#ifndef SQLITE_OMIT_WAL + /* Fill in Pager.zWal */ + if( nPathname>0 ){ + pPager->zWal = (char*)pPtr; + memcpy(pPtr, zPathname, nPathname); pPtr += nPathname; + memcpy(pPtr, "-wal", 4); pPtr += 4 + 1; +#ifdef SQLITE_ENABLE_8_3_NAMES + sqlite3FileSuffix3(zFilename, pPager->zWal); + pPtr = (u8*)(pPager->zWal + sqlite3Strlen30(pPager->zWal)+1); +#endif + }else{ + pPager->zWal = 0; + } +#endif + + if( nPathname ) sqlite3DbFree(0, zPathname); + pPager->pVfs = pVfs; + pPager->vfsFlags = vfsFlags; + + /* Open the pager file. + */ + if( zFilename && zFilename[0] ){ + int fout = 0; /* VFS flags returned by xOpen() */ + rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout); + assert( !memDb ); +#ifdef SQLITE_ENABLE_DESERIALIZE + memJM = (fout&SQLITE_OPEN_MEMORY)!=0; +#endif + readOnly = (fout&SQLITE_OPEN_READONLY)!=0; + + /* If the file was successfully opened for read/write access, + ** choose a default page size in case we have to create the + ** database file. The default page size is the maximum of: + ** + ** + SQLITE_DEFAULT_PAGE_SIZE, + ** + The value returned by sqlite3OsSectorSize() + ** + The largest page size that can be written atomically. + */ + if( rc==SQLITE_OK ){ + int iDc = sqlite3OsDeviceCharacteristics(pPager->fd); + if( !readOnly ){ + setSectorSize(pPager); + assert(SQLITE_DEFAULT_PAGE_SIZE<=SQLITE_MAX_DEFAULT_PAGE_SIZE); + if( szPageDfltsectorSize ){ + if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){ + szPageDflt = SQLITE_MAX_DEFAULT_PAGE_SIZE; + }else{ + szPageDflt = (u32)pPager->sectorSize; + } + } +#ifdef SQLITE_ENABLE_ATOMIC_WRITE + { + int ii; + assert(SQLITE_IOCAP_ATOMIC512==(512>>8)); + assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8)); + assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536); + for(ii=szPageDflt; ii<=SQLITE_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){ + if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ){ + szPageDflt = ii; + } + } + } +#endif + } + pPager->noLock = sqlite3_uri_boolean(pPager->zFilename, "nolock", 0); + if( (iDc & SQLITE_IOCAP_IMMUTABLE)!=0 + || sqlite3_uri_boolean(pPager->zFilename, "immutable", 0) ){ + vfsFlags |= SQLITE_OPEN_READONLY; + goto act_like_temp_file; + } + } + }else{ + /* If a temporary file is requested, it is not opened immediately. + ** In this case we accept the default page size and delay actually + ** opening the file until the first call to OsWrite(). + ** + ** This branch is also run for an in-memory database. An in-memory + ** database is the same as a temp-file that is never written out to + ** disk and uses an in-memory rollback journal. + ** + ** This branch also runs for files marked as immutable. + */ +act_like_temp_file: + tempFile = 1; + pPager->eState = PAGER_READER; /* Pretend we already have a lock */ + pPager->eLock = EXCLUSIVE_LOCK; /* Pretend we are in EXCLUSIVE mode */ + pPager->noLock = 1; /* Do no locking */ + readOnly = (vfsFlags&SQLITE_OPEN_READONLY); + } + + /* The following call to PagerSetPagesize() serves to set the value of + ** Pager.pageSize and to allocate the Pager.pTmpSpace buffer. + */ + if( rc==SQLITE_OK ){ + assert( pPager->memDb==0 ); + rc = sqlite3PagerSetPagesize(pPager, &szPageDflt, -1); + testcase( rc!=SQLITE_OK ); + } + + /* Initialize the PCache object. */ + if( rc==SQLITE_OK ){ + nExtra = ROUND8(nExtra); + assert( nExtra>=8 && nExtra<1000 ); + rc = sqlite3PcacheOpen(szPageDflt, nExtra, !memDb, + !memDb?pagerStress:0, (void *)pPager, pPager->pPCache); + } + + /* If an error occurred above, free the Pager structure and close the file. + */ + if( rc!=SQLITE_OK ){ + sqlite3OsClose(pPager->fd); + sqlite3PageFree(pPager->pTmpSpace); + sqlite3_free(pPager); + return rc; + } + + PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename)); + IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename)) + + pPager->useJournal = (u8)useJournal; + /* pPager->stmtOpen = 0; */ + /* pPager->stmtInUse = 0; */ + /* pPager->nRef = 0; */ + /* pPager->stmtSize = 0; */ + /* pPager->stmtJSize = 0; */ + /* pPager->nPage = 0; */ + pPager->mxPgno = SQLITE_MAX_PAGE_COUNT; + /* pPager->state = PAGER_UNLOCK; */ + /* pPager->errMask = 0; */ + pPager->tempFile = (u8)tempFile; + assert( tempFile==PAGER_LOCKINGMODE_NORMAL + || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE ); + assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 ); + pPager->exclusiveMode = (u8)tempFile; + pPager->changeCountDone = pPager->tempFile; + pPager->memDb = (u8)memDb; + pPager->readOnly = (u8)readOnly; + assert( useJournal || pPager->tempFile ); + pPager->noSync = pPager->tempFile; + if( pPager->noSync ){ + assert( pPager->fullSync==0 ); + assert( pPager->extraSync==0 ); + assert( pPager->syncFlags==0 ); + assert( pPager->walSyncFlags==0 ); + }else{ + pPager->fullSync = 1; + pPager->extraSync = 0; + pPager->syncFlags = SQLITE_SYNC_NORMAL; + pPager->walSyncFlags = SQLITE_SYNC_NORMAL | (SQLITE_SYNC_NORMAL<<2); + } + /* pPager->pFirst = 0; */ + /* pPager->pFirstSynced = 0; */ + /* pPager->pLast = 0; */ + pPager->nExtra = (u16)nExtra; + pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT; + assert( isOpen(pPager->fd) || tempFile ); + setSectorSize(pPager); + if( !useJournal ){ + pPager->journalMode = PAGER_JOURNALMODE_OFF; + }else if( memDb || memJM ){ + pPager->journalMode = PAGER_JOURNALMODE_MEMORY; + } + /* pPager->xBusyHandler = 0; */ + /* pPager->pBusyHandlerArg = 0; */ + pPager->xReiniter = xReinit; + setGetterMethod(pPager); + /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */ + /* pPager->szMmap = SQLITE_DEFAULT_MMAP_SIZE // will be set by btree.c */ + + *ppPager = pPager; + return SQLITE_OK; +} + +/* +** Return the sqlite3_file for the main database given the name +** of the corresonding WAL or Journal name as passed into +** xOpen. +*/ +SQLITE_API sqlite3_file *sqlite3_database_file_object(const char *zName){ + Pager *pPager; + while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){ + zName--; + } + pPager = *(Pager**)(zName - 4 - sizeof(Pager*)); + return pPager->fd; +} + + +/* +** This function is called after transitioning from PAGER_UNLOCK to +** PAGER_SHARED state. It tests if there is a hot journal present in +** the file-system for the given pager. A hot journal is one that +** needs to be played back. According to this function, a hot-journal +** file exists if the following criteria are met: +** +** * The journal file exists in the file system, and +** * No process holds a RESERVED or greater lock on the database file, and +** * The database file itself is greater than 0 bytes in size, and +** * The first byte of the journal file exists and is not 0x00. +** +** If the current size of the database file is 0 but a journal file +** exists, that is probably an old journal left over from a prior +** database with the same name. In this case the journal file is +** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK +** is returned. +** +** This routine does not check if there is a super-journal filename +** at the end of the file. If there is, and that super-journal file +** does not exist, then the journal file is not really hot. In this +** case this routine will return a false-positive. The pager_playback() +** routine will discover that the journal file is not really hot and +** will not roll it back. +** +** If a hot-journal file is found to exist, *pExists is set to 1 and +** SQLITE_OK returned. If no hot-journal file is present, *pExists is +** set to 0 and SQLITE_OK returned. If an IO error occurs while trying +** to determine whether or not a hot-journal file exists, the IO error +** code is returned and the value of *pExists is undefined. +*/ +static int hasHotJournal(Pager *pPager, int *pExists){ + sqlite3_vfs * const pVfs = pPager->pVfs; + int rc = SQLITE_OK; /* Return code */ + int exists = 1; /* True if a journal file is present */ + int jrnlOpen = !!isOpen(pPager->jfd); + + assert( pPager->useJournal ); + assert( isOpen(pPager->fd) ); + assert( pPager->eState==PAGER_OPEN ); + + assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) & + SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN + )); + + *pExists = 0; + if( !jrnlOpen ){ + rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists); + } + if( rc==SQLITE_OK && exists ){ + int locked = 0; /* True if some process holds a RESERVED lock */ + + /* Race condition here: Another process might have been holding the + ** the RESERVED lock and have a journal open at the sqlite3OsAccess() + ** call above, but then delete the journal and drop the lock before + ** we get to the following sqlite3OsCheckReservedLock() call. If that + ** is the case, this routine might think there is a hot journal when + ** in fact there is none. This results in a false-positive which will + ** be dealt with by the playback routine. Ticket #3883. + */ + rc = sqlite3OsCheckReservedLock(pPager->fd, &locked); + if( rc==SQLITE_OK && !locked ){ + Pgno nPage; /* Number of pages in database file */ + + assert( pPager->tempFile==0 ); + rc = pagerPagecount(pPager, &nPage); + if( rc==SQLITE_OK ){ + /* If the database is zero pages in size, that means that either (1) the + ** journal is a remnant from a prior database with the same name where + ** the database file but not the journal was deleted, or (2) the initial + ** transaction that populates a new database is being rolled back. + ** In either case, the journal file can be deleted. However, take care + ** not to delete the journal file if it is already open due to + ** journal_mode=PERSIST. + */ + if( nPage==0 && !jrnlOpen ){ + sqlite3BeginBenignMalloc(); + if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){ + sqlite3OsDelete(pVfs, pPager->zJournal, 0); + if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK); + } + sqlite3EndBenignMalloc(); + }else{ + /* The journal file exists and no other connection has a reserved + ** or greater lock on the database file. Now check that there is + ** at least one non-zero bytes at the start of the journal file. + ** If there is, then we consider this journal to be hot. If not, + ** it can be ignored. + */ + if( !jrnlOpen ){ + int f = SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL; + rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f); + } + if( rc==SQLITE_OK ){ + u8 first = 0; + rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0); + if( rc==SQLITE_IOERR_SHORT_READ ){ + rc = SQLITE_OK; + } + if( !jrnlOpen ){ + sqlite3OsClose(pPager->jfd); + } + *pExists = (first!=0); + }else if( rc==SQLITE_CANTOPEN ){ + /* If we cannot open the rollback journal file in order to see if + ** it has a zero header, that might be due to an I/O error, or + ** it might be due to the race condition described above and in + ** ticket #3883. Either way, assume that the journal is hot. + ** This might be a false positive. But if it is, then the + ** automatic journal playback and recovery mechanism will deal + ** with it under an EXCLUSIVE lock where we do not need to + ** worry so much with race conditions. + */ + *pExists = 1; + rc = SQLITE_OK; + } + } + } + } + } + + return rc; +} + +/* +** This function is called to obtain a shared lock on the database file. +** It is illegal to call sqlite3PagerGet() until after this function +** has been successfully called. If a shared-lock is already held when +** this function is called, it is a no-op. +** +** The following operations are also performed by this function. +** +** 1) If the pager is currently in PAGER_OPEN state (no lock held +** on the database file), then an attempt is made to obtain a +** SHARED lock on the database file. Immediately after obtaining +** the SHARED lock, the file-system is checked for a hot-journal, +** which is played back if present. Following any hot-journal +** rollback, the contents of the cache are validated by checking +** the 'change-counter' field of the database file header and +** discarded if they are found to be invalid. +** +** 2) If the pager is running in exclusive-mode, and there are currently +** no outstanding references to any pages, and is in the error state, +** then an attempt is made to clear the error state by discarding +** the contents of the page cache and rolling back any open journal +** file. +** +** If everything is successful, SQLITE_OK is returned. If an IO error +** occurs while locking the database, checking for a hot-journal file or +** rolling back a journal file, the IO error code is returned. +*/ +SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager){ + int rc = SQLITE_OK; /* Return code */ + + /* This routine is only called from b-tree and only when there are no + ** outstanding pages. This implies that the pager state should either + ** be OPEN or READER. READER is only possible if the pager is or was in + ** exclusive access mode. */ + assert( sqlite3PcacheRefCount(pPager->pPCache)==0 ); + assert( assert_pager_state(pPager) ); + assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER ); + assert( pPager->errCode==SQLITE_OK ); + + if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){ + int bHotJournal = 1; /* True if there exists a hot journal-file */ + + assert( !MEMDB ); + assert( pPager->tempFile==0 || pPager->eLock==EXCLUSIVE_LOCK ); + + rc = pager_wait_on_lock(pPager, SHARED_LOCK); + if( rc!=SQLITE_OK ){ + assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK ); + goto failed; + } + + /* If a journal file exists, and there is no RESERVED lock on the + ** database file, then it either needs to be played back or deleted. + */ + if( pPager->eLock<=SHARED_LOCK ){ + rc = hasHotJournal(pPager, &bHotJournal); + } + if( rc!=SQLITE_OK ){ + goto failed; + } + if( bHotJournal ){ + if( pPager->readOnly ){ + rc = SQLITE_READONLY_ROLLBACK; + goto failed; + } + + /* Get an EXCLUSIVE lock on the database file. At this point it is + ** important that a RESERVED lock is not obtained on the way to the + ** EXCLUSIVE lock. If it were, another process might open the + ** database file, detect the RESERVED lock, and conclude that the + ** database is safe to read while this process is still rolling the + ** hot-journal back. + ** + ** Because the intermediate RESERVED lock is not requested, any + ** other process attempting to access the database file will get to + ** this point in the code and fail to obtain its own EXCLUSIVE lock + ** on the database file. + ** + ** Unless the pager is in locking_mode=exclusive mode, the lock is + ** downgraded to SHARED_LOCK before this function returns. + */ + rc = pagerLockDb(pPager, EXCLUSIVE_LOCK); + if( rc!=SQLITE_OK ){ + goto failed; + } + + /* If it is not already open and the file exists on disk, open the + ** journal for read/write access. Write access is required because + ** in exclusive-access mode the file descriptor will be kept open + ** and possibly used for a transaction later on. Also, write-access + ** is usually required to finalize the journal in journal_mode=persist + ** mode (and also for journal_mode=truncate on some systems). + ** + ** If the journal does not exist, it usually means that some + ** other connection managed to get in and roll it back before + ** this connection obtained the exclusive lock above. Or, it + ** may mean that the pager was in the error-state when this + ** function was called and the journal file does not exist. + */ + if( !isOpen(pPager->jfd) ){ + sqlite3_vfs * const pVfs = pPager->pVfs; + int bExists; /* True if journal file exists */ + rc = sqlite3OsAccess( + pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists); + if( rc==SQLITE_OK && bExists ){ + int fout = 0; + int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL; + assert( !pPager->tempFile ); + rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout); + assert( rc!=SQLITE_OK || isOpen(pPager->jfd) ); + if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){ + rc = SQLITE_CANTOPEN_BKPT; + sqlite3OsClose(pPager->jfd); + } + } + } + + /* Playback and delete the journal. Drop the database write + ** lock and reacquire the read lock. Purge the cache before + ** playing back the hot-journal so that we don't end up with + ** an inconsistent cache. Sync the hot journal before playing + ** it back since the process that crashed and left the hot journal + ** probably did not sync it and we are required to always sync + ** the journal before playing it back. + */ + if( isOpen(pPager->jfd) ){ + assert( rc==SQLITE_OK ); + rc = pagerSyncHotJournal(pPager); + if( rc==SQLITE_OK ){ + rc = pager_playback(pPager, !pPager->tempFile); + pPager->eState = PAGER_OPEN; + } + }else if( !pPager->exclusiveMode ){ + pagerUnlockDb(pPager, SHARED_LOCK); + } + + if( rc!=SQLITE_OK ){ + /* This branch is taken if an error occurs while trying to open + ** or roll back a hot-journal while holding an EXCLUSIVE lock. The + ** pager_unlock() routine will be called before returning to unlock + ** the file. If the unlock attempt fails, then Pager.eLock must be + ** set to UNKNOWN_LOCK (see the comment above the #define for + ** UNKNOWN_LOCK above for an explanation). + ** + ** In order to get pager_unlock() to do this, set Pager.eState to + ** PAGER_ERROR now. This is not actually counted as a transition + ** to ERROR state in the state diagram at the top of this file, + ** since we know that the same call to pager_unlock() will very + ** shortly transition the pager object to the OPEN state. Calling + ** assert_pager_state() would fail now, as it should not be possible + ** to be in ERROR state when there are zero outstanding page + ** references. + */ + pager_error(pPager, rc); + goto failed; + } + + assert( pPager->eState==PAGER_OPEN ); + assert( (pPager->eLock==SHARED_LOCK) + || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK) + ); + } + + if( !pPager->tempFile && pPager->hasHeldSharedLock ){ + /* The shared-lock has just been acquired then check to + ** see if the database has been modified. If the database has changed, + ** flush the cache. The hasHeldSharedLock flag prevents this from + ** occurring on the very first access to a file, in order to save a + ** single unnecessary sqlite3OsRead() call at the start-up. + ** + ** Database changes are detected by looking at 15 bytes beginning + ** at offset 24 into the file. The first 4 of these 16 bytes are + ** a 32-bit counter that is incremented with each change. The + ** other bytes change randomly with each file change when + ** a codec is in use. + ** + ** There is a vanishingly small chance that a change will not be + ** detected. The chance of an undetected change is so small that + ** it can be neglected. + */ + char dbFileVers[sizeof(pPager->dbFileVers)]; + + IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers))); + rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24); + if( rc!=SQLITE_OK ){ + if( rc!=SQLITE_IOERR_SHORT_READ ){ + goto failed; + } + memset(dbFileVers, 0, sizeof(dbFileVers)); + } + + if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){ + pager_reset(pPager); + + /* Unmap the database file. It is possible that external processes + ** may have truncated the database file and then extended it back + ** to its original size while this process was not holding a lock. + ** In this case there may exist a Pager.pMap mapping that appears + ** to be the right size but is not actually valid. Avoid this + ** possibility by unmapping the db here. */ + if( USEFETCH(pPager) ){ + sqlite3OsUnfetch(pPager->fd, 0, 0); + } + } + } + + /* If there is a WAL file in the file-system, open this database in WAL + ** mode. Otherwise, the following function call is a no-op. + */ + rc = pagerOpenWalIfPresent(pPager); +#ifndef SQLITE_OMIT_WAL + assert( pPager->pWal==0 || rc==SQLITE_OK ); +#endif + } + + if( pagerUseWal(pPager) ){ + assert( rc==SQLITE_OK ); + rc = pagerBeginReadTransaction(pPager); + } + + if( pPager->tempFile==0 && pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){ + rc = pagerPagecount(pPager, &pPager->dbSize); + } + + failed: + if( rc!=SQLITE_OK ){ + assert( !MEMDB ); + pager_unlock(pPager); + assert( pPager->eState==PAGER_OPEN ); + }else{ + pPager->eState = PAGER_READER; + pPager->hasHeldSharedLock = 1; + } + return rc; +} + +/* +** If the reference count has reached zero, rollback any active +** transaction and unlock the pager. +** +** Except, in locking_mode=EXCLUSIVE when there is nothing to in +** the rollback journal, the unlock is not performed and there is +** nothing to rollback, so this routine is a no-op. +*/ +static void pagerUnlockIfUnused(Pager *pPager){ + if( sqlite3PcacheRefCount(pPager->pPCache)==0 ){ + assert( pPager->nMmapOut==0 ); /* because page1 is never memory mapped */ + pagerUnlockAndRollback(pPager); + } +} + +/* +** The page getter methods each try to acquire a reference to a +** page with page number pgno. If the requested reference is +** successfully obtained, it is copied to *ppPage and SQLITE_OK returned. +** +** There are different implementations of the getter method depending +** on the current state of the pager. +** +** getPageNormal() -- The normal getter +** getPageError() -- Used if the pager is in an error state +** getPageMmap() -- Used if memory-mapped I/O is enabled +** +** If the requested page is already in the cache, it is returned. +** Otherwise, a new page object is allocated and populated with data +** read from the database file. In some cases, the pcache module may +** choose not to allocate a new page object and may reuse an existing +** object with no outstanding references. +** +** The extra data appended to a page is always initialized to zeros the +** first time a page is loaded into memory. If the page requested is +** already in the cache when this function is called, then the extra +** data is left as it was when the page object was last used. +** +** If the database image is smaller than the requested page or if +** the flags parameter contains the PAGER_GET_NOCONTENT bit and the +** requested page is not already stored in the cache, then no +** actual disk read occurs. In this case the memory image of the +** page is initialized to all zeros. +** +** If PAGER_GET_NOCONTENT is true, it means that we do not care about +** the contents of the page. This occurs in two scenarios: +** +** a) When reading a free-list leaf page from the database, and +** +** b) When a savepoint is being rolled back and we need to load +** a new page into the cache to be filled with the data read +** from the savepoint journal. +** +** If PAGER_GET_NOCONTENT is true, then the data returned is zeroed instead +** of being read from the database. Additionally, the bits corresponding +** to pgno in Pager.pInJournal (bitvec of pages already written to the +** journal file) and the PagerSavepoint.pInSavepoint bitvecs of any open +** savepoints are set. This means if the page is made writable at any +** point in the future, using a call to sqlite3PagerWrite(), its contents +** will not be journaled. This saves IO. +** +** The acquisition might fail for several reasons. In all cases, +** an appropriate error code is returned and *ppPage is set to NULL. +** +** See also sqlite3PagerLookup(). Both this routine and Lookup() attempt +** to find a page in the in-memory cache first. If the page is not already +** in memory, this routine goes to disk to read it in whereas Lookup() +** just returns 0. This routine acquires a read-lock the first time it +** has to go to disk, and could also playback an old journal if necessary. +** Since Lookup() never goes to disk, it never has to deal with locks +** or journal files. +*/ +static int getPageNormal( + Pager *pPager, /* The pager open on the database file */ + Pgno pgno, /* Page number to fetch */ + DbPage **ppPage, /* Write a pointer to the page here */ + int flags /* PAGER_GET_XXX flags */ +){ + int rc = SQLITE_OK; + PgHdr *pPg; + u8 noContent; /* True if PAGER_GET_NOCONTENT is set */ + sqlite3_pcache_page *pBase; + + assert( pPager->errCode==SQLITE_OK ); + assert( pPager->eState>=PAGER_READER ); + assert( assert_pager_state(pPager) ); + assert( pPager->hasHeldSharedLock==1 ); + + if( pgno==0 ) return SQLITE_CORRUPT_BKPT; + pBase = sqlite3PcacheFetch(pPager->pPCache, pgno, 3); + if( pBase==0 ){ + pPg = 0; + rc = sqlite3PcacheFetchStress(pPager->pPCache, pgno, &pBase); + if( rc!=SQLITE_OK ) goto pager_acquire_err; + if( pBase==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto pager_acquire_err; + } + } + pPg = *ppPage = sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pBase); + assert( pPg==(*ppPage) ); + assert( pPg->pgno==pgno ); + assert( pPg->pPager==pPager || pPg->pPager==0 ); + + noContent = (flags & PAGER_GET_NOCONTENT)!=0; + if( pPg->pPager && !noContent ){ + /* In this case the pcache already contains an initialized copy of + ** the page. Return without further ado. */ + assert( pgno!=PAGER_MJ_PGNO(pPager) ); + pPager->aStat[PAGER_STAT_HIT]++; + return SQLITE_OK; + + }else{ + /* The pager cache has created a new page. Its content needs to + ** be initialized. But first some error checks: + ** + ** (*) obsolete. Was: maximum page number is 2^31 + ** (2) Never try to fetch the locking page + */ + if( pgno==PAGER_MJ_PGNO(pPager) ){ + rc = SQLITE_CORRUPT_BKPT; + goto pager_acquire_err; + } + + pPg->pPager = pPager; + + assert( !isOpen(pPager->fd) || !MEMDB ); + if( !isOpen(pPager->fd) || pPager->dbSizepPager->mxPgno ){ + rc = SQLITE_FULL; + goto pager_acquire_err; + } + if( noContent ){ + /* Failure to set the bits in the InJournal bit-vectors is benign. + ** It merely means that we might do some extra work to journal a + ** page that does not need to be journaled. Nevertheless, be sure + ** to test the case where a malloc error occurs while trying to set + ** a bit in a bit vector. + */ + sqlite3BeginBenignMalloc(); + if( pgno<=pPager->dbOrigSize ){ + TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno); + testcase( rc==SQLITE_NOMEM ); + } + TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno); + testcase( rc==SQLITE_NOMEM ); + sqlite3EndBenignMalloc(); + } + memset(pPg->pData, 0, pPager->pageSize); + IOTRACE(("ZERO %p %d\n", pPager, pgno)); + }else{ + assert( pPg->pPager==pPager ); + pPager->aStat[PAGER_STAT_MISS]++; + rc = readDbPage(pPg); + if( rc!=SQLITE_OK ){ + goto pager_acquire_err; + } + } + pager_set_pagehash(pPg); + } + return SQLITE_OK; + +pager_acquire_err: + assert( rc!=SQLITE_OK ); + if( pPg ){ + sqlite3PcacheDrop(pPg); + } + pagerUnlockIfUnused(pPager); + *ppPage = 0; + return rc; +} + +#if SQLITE_MAX_MMAP_SIZE>0 +/* The page getter for when memory-mapped I/O is enabled */ +static int getPageMMap( + Pager *pPager, /* The pager open on the database file */ + Pgno pgno, /* Page number to fetch */ + DbPage **ppPage, /* Write a pointer to the page here */ + int flags /* PAGER_GET_XXX flags */ +){ + int rc = SQLITE_OK; + PgHdr *pPg = 0; + u32 iFrame = 0; /* Frame to read from WAL file */ + + /* It is acceptable to use a read-only (mmap) page for any page except + ** page 1 if there is no write-transaction open or the ACQUIRE_READONLY + ** flag was specified by the caller. And so long as the db is not a + ** temporary or in-memory database. */ + const int bMmapOk = (pgno>1 + && (pPager->eState==PAGER_READER || (flags & PAGER_GET_READONLY)) + ); + + assert( USEFETCH(pPager) ); + + /* Optimization note: Adding the "pgno<=1" term before "pgno==0" here + ** allows the compiler optimizer to reuse the results of the "pgno>1" + ** test in the previous statement, and avoid testing pgno==0 in the + ** common case where pgno is large. */ + if( pgno<=1 && pgno==0 ){ + return SQLITE_CORRUPT_BKPT; + } + assert( pPager->eState>=PAGER_READER ); + assert( assert_pager_state(pPager) ); + assert( pPager->hasHeldSharedLock==1 ); + assert( pPager->errCode==SQLITE_OK ); + + if( bMmapOk && pagerUseWal(pPager) ){ + rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame); + if( rc!=SQLITE_OK ){ + *ppPage = 0; + return rc; + } + } + if( bMmapOk && iFrame==0 ){ + void *pData = 0; + rc = sqlite3OsFetch(pPager->fd, + (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData + ); + if( rc==SQLITE_OK && pData ){ + if( pPager->eState>PAGER_READER || pPager->tempFile ){ + pPg = sqlite3PagerLookup(pPager, pgno); + } + if( pPg==0 ){ + rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg); + }else{ + sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData); + } + if( pPg ){ + assert( rc==SQLITE_OK ); + *ppPage = pPg; + return SQLITE_OK; + } + } + if( rc!=SQLITE_OK ){ + *ppPage = 0; + return rc; + } + } + return getPageNormal(pPager, pgno, ppPage, flags); +} +#endif /* SQLITE_MAX_MMAP_SIZE>0 */ + +/* The page getter method for when the pager is an error state */ +static int getPageError( + Pager *pPager, /* The pager open on the database file */ + Pgno pgno, /* Page number to fetch */ + DbPage **ppPage, /* Write a pointer to the page here */ + int flags /* PAGER_GET_XXX flags */ +){ + UNUSED_PARAMETER(pgno); + UNUSED_PARAMETER(flags); + assert( pPager->errCode!=SQLITE_OK ); + *ppPage = 0; + return pPager->errCode; +} + + +/* Dispatch all page fetch requests to the appropriate getter method. +*/ +SQLITE_PRIVATE int sqlite3PagerGet( + Pager *pPager, /* The pager open on the database file */ + Pgno pgno, /* Page number to fetch */ + DbPage **ppPage, /* Write a pointer to the page here */ + int flags /* PAGER_GET_XXX flags */ +){ + return pPager->xGet(pPager, pgno, ppPage, flags); +} + +/* +** Acquire a page if it is already in the in-memory cache. Do +** not read the page from disk. Return a pointer to the page, +** or 0 if the page is not in cache. +** +** See also sqlite3PagerGet(). The difference between this routine +** and sqlite3PagerGet() is that _get() will go to the disk and read +** in the page if the page is not already in cache. This routine +** returns NULL if the page is not in cache or if a disk I/O error +** has ever happened. +*/ +SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){ + sqlite3_pcache_page *pPage; + assert( pPager!=0 ); + assert( pgno!=0 ); + assert( pPager->pPCache!=0 ); + pPage = sqlite3PcacheFetch(pPager->pPCache, pgno, 0); + assert( pPage==0 || pPager->hasHeldSharedLock ); + if( pPage==0 ) return 0; + return sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pPage); +} + +/* +** Release a page reference. +** +** The sqlite3PagerUnref() and sqlite3PagerUnrefNotNull() may only be +** used if we know that the page being released is not the last page. +** The btree layer always holds page1 open until the end, so these first +** to routines can be used to release any page other than BtShared.pPage1. +** +** Use sqlite3PagerUnrefPageOne() to release page1. This latter routine +** checks the total number of outstanding pages and if the number of +** pages reaches zero it drops the database lock. +*/ +SQLITE_PRIVATE void sqlite3PagerUnrefNotNull(DbPage *pPg){ + TESTONLY( Pager *pPager = pPg->pPager; ) + assert( pPg!=0 ); + if( pPg->flags & PGHDR_MMAP ){ + assert( pPg->pgno!=1 ); /* Page1 is never memory mapped */ + pagerReleaseMapPage(pPg); + }else{ + sqlite3PcacheRelease(pPg); + } + /* Do not use this routine to release the last reference to page1 */ + assert( sqlite3PcacheRefCount(pPager->pPCache)>0 ); +} +SQLITE_PRIVATE void sqlite3PagerUnref(DbPage *pPg){ + if( pPg ) sqlite3PagerUnrefNotNull(pPg); +} +SQLITE_PRIVATE void sqlite3PagerUnrefPageOne(DbPage *pPg){ + Pager *pPager; + assert( pPg!=0 ); + assert( pPg->pgno==1 ); + assert( (pPg->flags & PGHDR_MMAP)==0 ); /* Page1 is never memory mapped */ + pPager = pPg->pPager; + sqlite3PcacheRelease(pPg); + pagerUnlockIfUnused(pPager); +} + +/* +** This function is called at the start of every write transaction. +** There must already be a RESERVED or EXCLUSIVE lock on the database +** file when this routine is called. +** +** Open the journal file for pager pPager and write a journal header +** to the start of it. If there are active savepoints, open the sub-journal +** as well. This function is only used when the journal file is being +** opened to write a rollback log for a transaction. It is not used +** when opening a hot journal file to roll it back. +** +** If the journal file is already open (as it may be in exclusive mode), +** then this function just writes a journal header to the start of the +** already open file. +** +** Whether or not the journal file is opened by this function, the +** Pager.pInJournal bitvec structure is allocated. +** +** Return SQLITE_OK if everything is successful. Otherwise, return +** SQLITE_NOMEM if the attempt to allocate Pager.pInJournal fails, or +** an IO error code if opening or writing the journal file fails. +*/ +static int pager_open_journal(Pager *pPager){ + int rc = SQLITE_OK; /* Return code */ + sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */ + + assert( pPager->eState==PAGER_WRITER_LOCKED ); + assert( assert_pager_state(pPager) ); + assert( pPager->pInJournal==0 ); + + /* If already in the error state, this function is a no-op. But on + ** the other hand, this routine is never called if we are already in + ** an error state. */ + if( NEVER(pPager->errCode) ) return pPager->errCode; + + if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){ + pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize); + if( pPager->pInJournal==0 ){ + return SQLITE_NOMEM_BKPT; + } + + /* Open the journal file if it is not already open. */ + if( !isOpen(pPager->jfd) ){ + if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){ + sqlite3MemJournalOpen(pPager->jfd); + }else{ + int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE; + int nSpill; + + if( pPager->tempFile ){ + flags |= (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL); + nSpill = sqlite3Config.nStmtSpill; + }else{ + flags |= SQLITE_OPEN_MAIN_JOURNAL; + nSpill = jrnlBufferSize(pPager); + } + + /* Verify that the database still has the same name as it did when + ** it was originally opened. */ + rc = databaseIsUnmoved(pPager); + if( rc==SQLITE_OK ){ + rc = sqlite3JournalOpen ( + pVfs, pPager->zJournal, pPager->jfd, flags, nSpill + ); + } + } + assert( rc!=SQLITE_OK || isOpen(pPager->jfd) ); + } + + + /* Write the first journal header to the journal file and open + ** the sub-journal if necessary. + */ + if( rc==SQLITE_OK ){ + /* TODO: Check if all of these are really required. */ + pPager->nRec = 0; + pPager->journalOff = 0; + pPager->setSuper = 0; + pPager->journalHdr = 0; + rc = writeJournalHdr(pPager); + } + } + + if( rc!=SQLITE_OK ){ + sqlite3BitvecDestroy(pPager->pInJournal); + pPager->pInJournal = 0; + }else{ + assert( pPager->eState==PAGER_WRITER_LOCKED ); + pPager->eState = PAGER_WRITER_CACHEMOD; + } + + return rc; +} + +/* +** Begin a write-transaction on the specified pager object. If a +** write-transaction has already been opened, this function is a no-op. +** +** If the exFlag argument is false, then acquire at least a RESERVED +** lock on the database file. If exFlag is true, then acquire at least +** an EXCLUSIVE lock. If such a lock is already held, no locking +** functions need be called. +** +** If the subjInMemory argument is non-zero, then any sub-journal opened +** within this transaction will be opened as an in-memory file. This +** has no effect if the sub-journal is already opened (as it may be when +** running in exclusive mode) or if the transaction does not require a +** sub-journal. If the subjInMemory argument is zero, then any required +** sub-journal is implemented in-memory if pPager is an in-memory database, +** or using a temporary file otherwise. +*/ +SQLITE_PRIVATE int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){ + int rc = SQLITE_OK; + + if( pPager->errCode ) return pPager->errCode; + assert( pPager->eState>=PAGER_READER && pPager->eStatesubjInMemory = (u8)subjInMemory; + + if( ALWAYS(pPager->eState==PAGER_READER) ){ + assert( pPager->pInJournal==0 ); + + if( pagerUseWal(pPager) ){ + /* If the pager is configured to use locking_mode=exclusive, and an + ** exclusive lock on the database is not already held, obtain it now. + */ + if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){ + rc = pagerLockDb(pPager, EXCLUSIVE_LOCK); + if( rc!=SQLITE_OK ){ + return rc; + } + (void)sqlite3WalExclusiveMode(pPager->pWal, 1); + } + + /* Grab the write lock on the log file. If successful, upgrade to + ** PAGER_RESERVED state. Otherwise, return an error code to the caller. + ** The busy-handler is not invoked if another connection already + ** holds the write-lock. If possible, the upper layer will call it. + */ + rc = sqlite3WalBeginWriteTransaction(pPager->pWal); + }else{ + /* Obtain a RESERVED lock on the database file. If the exFlag parameter + ** is true, then immediately upgrade this to an EXCLUSIVE lock. The + ** busy-handler callback can be used when upgrading to the EXCLUSIVE + ** lock, but not when obtaining the RESERVED lock. + */ + rc = pagerLockDb(pPager, RESERVED_LOCK); + if( rc==SQLITE_OK && exFlag ){ + rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK); + } + } + + if( rc==SQLITE_OK ){ + /* Change to WRITER_LOCKED state. + ** + ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD + ** when it has an open transaction, but never to DBMOD or FINISHED. + ** This is because in those states the code to roll back savepoint + ** transactions may copy data from the sub-journal into the database + ** file as well as into the page cache. Which would be incorrect in + ** WAL mode. + */ + pPager->eState = PAGER_WRITER_LOCKED; + pPager->dbHintSize = pPager->dbSize; + pPager->dbFileSize = pPager->dbSize; + pPager->dbOrigSize = pPager->dbSize; + pPager->journalOff = 0; + } + + assert( rc==SQLITE_OK || pPager->eState==PAGER_READER ); + assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED ); + assert( assert_pager_state(pPager) ); + } + + PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager))); + return rc; +} + +/* +** Write page pPg onto the end of the rollback journal. +*/ +static SQLITE_NOINLINE int pagerAddPageToRollbackJournal(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + int rc; + u32 cksum; + char *pData2; + i64 iOff = pPager->journalOff; + + /* We should never write to the journal file the page that + ** contains the database locks. The following assert verifies + ** that we do not. */ + assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) ); + + assert( pPager->journalHdr<=pPager->journalOff ); + pData2 = pPg->pData; + cksum = pager_cksum(pPager, (u8*)pData2); + + /* Even if an IO or diskfull error occurs while journalling the + ** page in the block above, set the need-sync flag for the page. + ** Otherwise, when the transaction is rolled back, the logic in + ** playback_one_page() will think that the page needs to be restored + ** in the database file. And if an IO error occurs while doing so, + ** then corruption may follow. + */ + pPg->flags |= PGHDR_NEED_SYNC; + + rc = write32bits(pPager->jfd, iOff, pPg->pgno); + if( rc!=SQLITE_OK ) return rc; + rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4); + if( rc!=SQLITE_OK ) return rc; + rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum); + if( rc!=SQLITE_OK ) return rc; + + IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno, + pPager->journalOff, pPager->pageSize)); + PAGER_INCR(sqlite3_pager_writej_count); + PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n", + PAGERID(pPager), pPg->pgno, + ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg))); + + pPager->journalOff += 8 + pPager->pageSize; + pPager->nRec++; + assert( pPager->pInJournal!=0 ); + rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno); + testcase( rc==SQLITE_NOMEM ); + assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); + rc |= addToSavepointBitvecs(pPager, pPg->pgno); + assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); + return rc; +} + +/* +** Mark a single data page as writeable. The page is written into the +** main journal or sub-journal as required. If the page is written into +** one of the journals, the corresponding bit is set in the +** Pager.pInJournal bitvec and the PagerSavepoint.pInSavepoint bitvecs +** of any open savepoints as appropriate. +*/ +static int pager_write(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + int rc = SQLITE_OK; + + /* This routine is not called unless a write-transaction has already + ** been started. The journal file may or may not be open at this point. + ** It is never called in the ERROR state. + */ + assert( pPager->eState==PAGER_WRITER_LOCKED + || pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + ); + assert( assert_pager_state(pPager) ); + assert( pPager->errCode==0 ); + assert( pPager->readOnly==0 ); + CHECK_PAGE(pPg); + + /* The journal file needs to be opened. Higher level routines have already + ** obtained the necessary locks to begin the write-transaction, but the + ** rollback journal might not yet be open. Open it now if this is the case. + ** + ** This is done before calling sqlite3PcacheMakeDirty() on the page. + ** Otherwise, if it were done after calling sqlite3PcacheMakeDirty(), then + ** an error might occur and the pager would end up in WRITER_LOCKED state + ** with pages marked as dirty in the cache. + */ + if( pPager->eState==PAGER_WRITER_LOCKED ){ + rc = pager_open_journal(pPager); + if( rc!=SQLITE_OK ) return rc; + } + assert( pPager->eState>=PAGER_WRITER_CACHEMOD ); + assert( assert_pager_state(pPager) ); + + /* Mark the page that is about to be modified as dirty. */ + sqlite3PcacheMakeDirty(pPg); + + /* If a rollback journal is in use, them make sure the page that is about + ** to change is in the rollback journal, or if the page is a new page off + ** then end of the file, make sure it is marked as PGHDR_NEED_SYNC. + */ + assert( (pPager->pInJournal!=0) == isOpen(pPager->jfd) ); + if( pPager->pInJournal!=0 + && sqlite3BitvecTestNotNull(pPager->pInJournal, pPg->pgno)==0 + ){ + assert( pagerUseWal(pPager)==0 ); + if( pPg->pgno<=pPager->dbOrigSize ){ + rc = pagerAddPageToRollbackJournal(pPg); + if( rc!=SQLITE_OK ){ + return rc; + } + }else{ + if( pPager->eState!=PAGER_WRITER_DBMOD ){ + pPg->flags |= PGHDR_NEED_SYNC; + } + PAGERTRACE(("APPEND %d page %d needSync=%d\n", + PAGERID(pPager), pPg->pgno, + ((pPg->flags&PGHDR_NEED_SYNC)?1:0))); + } + } + + /* The PGHDR_DIRTY bit is set above when the page was added to the dirty-list + ** and before writing the page into the rollback journal. Wait until now, + ** after the page has been successfully journalled, before setting the + ** PGHDR_WRITEABLE bit that indicates that the page can be safely modified. + */ + pPg->flags |= PGHDR_WRITEABLE; + + /* If the statement journal is open and the page is not in it, + ** then write the page into the statement journal. + */ + if( pPager->nSavepoint>0 ){ + rc = subjournalPageIfRequired(pPg); + } + + /* Update the database size and return. */ + if( pPager->dbSizepgno ){ + pPager->dbSize = pPg->pgno; + } + return rc; +} + +/* +** This is a variant of sqlite3PagerWrite() that runs when the sector size +** is larger than the page size. SQLite makes the (reasonable) assumption that +** all bytes of a sector are written together by hardware. Hence, all bytes of +** a sector need to be journalled in case of a power loss in the middle of +** a write. +** +** Usually, the sector size is less than or equal to the page size, in which +** case pages can be individually written. This routine only runs in the +** exceptional case where the page size is smaller than the sector size. +*/ +static SQLITE_NOINLINE int pagerWriteLargeSector(PgHdr *pPg){ + int rc = SQLITE_OK; /* Return code */ + Pgno nPageCount; /* Total number of pages in database file */ + Pgno pg1; /* First page of the sector pPg is located on. */ + int nPage = 0; /* Number of pages starting at pg1 to journal */ + int ii; /* Loop counter */ + int needSync = 0; /* True if any page has PGHDR_NEED_SYNC */ + Pager *pPager = pPg->pPager; /* The pager that owns pPg */ + Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize); + + /* Set the doNotSpill NOSYNC bit to 1. This is because we cannot allow + ** a journal header to be written between the pages journaled by + ** this function. + */ + assert( !MEMDB ); + assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)==0 ); + pPager->doNotSpill |= SPILLFLAG_NOSYNC; + + /* This trick assumes that both the page-size and sector-size are + ** an integer power of 2. It sets variable pg1 to the identifier + ** of the first page of the sector pPg is located on. + */ + pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1; + + nPageCount = pPager->dbSize; + if( pPg->pgno>nPageCount ){ + nPage = (pPg->pgno - pg1)+1; + }else if( (pg1+nPagePerSector-1)>nPageCount ){ + nPage = nPageCount+1-pg1; + }else{ + nPage = nPagePerSector; + } + assert(nPage>0); + assert(pg1<=pPg->pgno); + assert((pg1+nPage)>pPg->pgno); + + for(ii=0; iipgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){ + if( pg!=PAGER_MJ_PGNO(pPager) ){ + rc = sqlite3PagerGet(pPager, pg, &pPage, 0); + if( rc==SQLITE_OK ){ + rc = pager_write(pPage); + if( pPage->flags&PGHDR_NEED_SYNC ){ + needSync = 1; + } + sqlite3PagerUnrefNotNull(pPage); + } + } + }else if( (pPage = sqlite3PagerLookup(pPager, pg))!=0 ){ + if( pPage->flags&PGHDR_NEED_SYNC ){ + needSync = 1; + } + sqlite3PagerUnrefNotNull(pPage); + } + } + + /* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages + ** starting at pg1, then it needs to be set for all of them. Because + ** writing to any of these nPage pages may damage the others, the + ** journal file must contain sync()ed copies of all of them + ** before any of them can be written out to the database file. + */ + if( rc==SQLITE_OK && needSync ){ + assert( !MEMDB ); + for(ii=0; iiflags |= PGHDR_NEED_SYNC; + sqlite3PagerUnrefNotNull(pPage); + } + } + } + + assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)!=0 ); + pPager->doNotSpill &= ~SPILLFLAG_NOSYNC; + return rc; +} + +/* +** Mark a data page as writeable. This routine must be called before +** making changes to a page. The caller must check the return value +** of this function and be careful not to change any page data unless +** this routine returns SQLITE_OK. +** +** The difference between this function and pager_write() is that this +** function also deals with the special case where 2 or more pages +** fit on a single disk sector. In this case all co-resident pages +** must have been written to the journal file before returning. +** +** If an error occurs, SQLITE_NOMEM or an IO error code is returned +** as appropriate. Otherwise, SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3PagerWrite(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + assert( (pPg->flags & PGHDR_MMAP)==0 ); + assert( pPager->eState>=PAGER_WRITER_LOCKED ); + assert( assert_pager_state(pPager) ); + if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){ + if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg); + return SQLITE_OK; + }else if( pPager->errCode ){ + return pPager->errCode; + }else if( pPager->sectorSize > (u32)pPager->pageSize ){ + assert( pPager->tempFile==0 ); + return pagerWriteLargeSector(pPg); + }else{ + return pager_write(pPg); + } +} + +/* +** Return TRUE if the page given in the argument was previously passed +** to sqlite3PagerWrite(). In other words, return TRUE if it is ok +** to change the content of the page. +*/ +#ifndef NDEBUG +SQLITE_PRIVATE int sqlite3PagerIswriteable(DbPage *pPg){ + return pPg->flags & PGHDR_WRITEABLE; +} +#endif + +/* +** A call to this routine tells the pager that it is not necessary to +** write the information on page pPg back to the disk, even though +** that page might be marked as dirty. This happens, for example, when +** the page has been added as a leaf of the freelist and so its +** content no longer matters. +** +** The overlying software layer calls this routine when all of the data +** on the given page is unused. The pager marks the page as clean so +** that it does not get written to disk. +** +** Tests show that this optimization can quadruple the speed of large +** DELETE operations. +** +** This optimization cannot be used with a temp-file, as the page may +** have been dirty at the start of the transaction. In that case, if +** memory pressure forces page pPg out of the cache, the data does need +** to be written out to disk so that it may be read back in if the +** current transaction is rolled back. +*/ +SQLITE_PRIVATE void sqlite3PagerDontWrite(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + if( !pPager->tempFile && (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){ + PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager))); + IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno)) + pPg->flags |= PGHDR_DONT_WRITE; + pPg->flags &= ~PGHDR_WRITEABLE; + testcase( pPg->flags & PGHDR_NEED_SYNC ); + pager_set_pagehash(pPg); + } +} + +/* +** This routine is called to increment the value of the database file +** change-counter, stored as a 4-byte big-endian integer starting at +** byte offset 24 of the pager file. The secondary change counter at +** 92 is also updated, as is the SQLite version number at offset 96. +** +** But this only happens if the pPager->changeCountDone flag is false. +** To avoid excess churning of page 1, the update only happens once. +** See also the pager_write_changecounter() routine that does an +** unconditional update of the change counters. +** +** If the isDirectMode flag is zero, then this is done by calling +** sqlite3PagerWrite() on page 1, then modifying the contents of the +** page data. In this case the file will be updated when the current +** transaction is committed. +** +** The isDirectMode flag may only be non-zero if the library was compiled +** with the SQLITE_ENABLE_ATOMIC_WRITE macro defined. In this case, +** if isDirect is non-zero, then the database file is updated directly +** by writing an updated version of page 1 using a call to the +** sqlite3OsWrite() function. +*/ +static int pager_incr_changecounter(Pager *pPager, int isDirectMode){ + int rc = SQLITE_OK; + + assert( pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + ); + assert( assert_pager_state(pPager) ); + + /* Declare and initialize constant integer 'isDirect'. If the + ** atomic-write optimization is enabled in this build, then isDirect + ** is initialized to the value passed as the isDirectMode parameter + ** to this function. Otherwise, it is always set to zero. + ** + ** The idea is that if the atomic-write optimization is not + ** enabled at compile time, the compiler can omit the tests of + ** 'isDirect' below, as well as the block enclosed in the + ** "if( isDirect )" condition. + */ +#ifndef SQLITE_ENABLE_ATOMIC_WRITE +# define DIRECT_MODE 0 + assert( isDirectMode==0 ); + UNUSED_PARAMETER(isDirectMode); +#else +# define DIRECT_MODE isDirectMode +#endif + + if( !pPager->changeCountDone && ALWAYS(pPager->dbSize>0) ){ + PgHdr *pPgHdr; /* Reference to page 1 */ + + assert( !pPager->tempFile && isOpen(pPager->fd) ); + + /* Open page 1 of the file for writing. */ + rc = sqlite3PagerGet(pPager, 1, &pPgHdr, 0); + assert( pPgHdr==0 || rc==SQLITE_OK ); + + /* If page one was fetched successfully, and this function is not + ** operating in direct-mode, make page 1 writable. When not in + ** direct mode, page 1 is always held in cache and hence the PagerGet() + ** above is always successful - hence the ALWAYS on rc==SQLITE_OK. + */ + if( !DIRECT_MODE && ALWAYS(rc==SQLITE_OK) ){ + rc = sqlite3PagerWrite(pPgHdr); + } + + if( rc==SQLITE_OK ){ + /* Actually do the update of the change counter */ + pager_write_changecounter(pPgHdr); + + /* If running in direct mode, write the contents of page 1 to the file. */ + if( DIRECT_MODE ){ + const void *zBuf; + assert( pPager->dbFileSize>0 ); + zBuf = pPgHdr->pData; + if( rc==SQLITE_OK ){ + rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0); + pPager->aStat[PAGER_STAT_WRITE]++; + } + if( rc==SQLITE_OK ){ + /* Update the pager's copy of the change-counter. Otherwise, the + ** next time a read transaction is opened the cache will be + ** flushed (as the change-counter values will not match). */ + const void *pCopy = (const void *)&((const char *)zBuf)[24]; + memcpy(&pPager->dbFileVers, pCopy, sizeof(pPager->dbFileVers)); + pPager->changeCountDone = 1; + } + }else{ + pPager->changeCountDone = 1; + } + } + + /* Release the page reference. */ + sqlite3PagerUnref(pPgHdr); + } + return rc; +} + +/* +** Sync the database file to disk. This is a no-op for in-memory databases +** or pages with the Pager.noSync flag set. +** +** If successful, or if called on a pager for which it is a no-op, this +** function returns SQLITE_OK. Otherwise, an IO error code is returned. +*/ +SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zSuper){ + int rc = SQLITE_OK; + void *pArg = (void*)zSuper; + rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg); + if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK; + if( rc==SQLITE_OK && !pPager->noSync ){ + assert( !MEMDB ); + rc = sqlite3OsSync(pPager->fd, pPager->syncFlags); + } + return rc; +} + +/* +** This function may only be called while a write-transaction is active in +** rollback. If the connection is in WAL mode, this call is a no-op. +** Otherwise, if the connection does not already have an EXCLUSIVE lock on +** the database file, an attempt is made to obtain one. +** +** If the EXCLUSIVE lock is already held or the attempt to obtain it is +** successful, or the connection is in WAL mode, SQLITE_OK is returned. +** Otherwise, either SQLITE_BUSY or an SQLITE_IOERR_XXX error code is +** returned. +*/ +SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager *pPager){ + int rc = pPager->errCode; + assert( assert_pager_state(pPager) ); + if( rc==SQLITE_OK ){ + assert( pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + || pPager->eState==PAGER_WRITER_LOCKED + ); + assert( assert_pager_state(pPager) ); + if( 0==pagerUseWal(pPager) ){ + rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK); + } + } + return rc; +} + +/* +** Sync the database file for the pager pPager. zSuper points to the name +** of a super-journal file that should be written into the individual +** journal file. zSuper may be NULL, which is interpreted as no +** super-journal (a single database transaction). +** +** This routine ensures that: +** +** * The database file change-counter is updated, +** * the journal is synced (unless the atomic-write optimization is used), +** * all dirty pages are written to the database file, +** * the database file is truncated (if required), and +** * the database file synced. +** +** The only thing that remains to commit the transaction is to finalize +** (delete, truncate or zero the first part of) the journal file (or +** delete the super-journal file if specified). +** +** Note that if zSuper==NULL, this does not overwrite a previous value +** passed to an sqlite3PagerCommitPhaseOne() call. +** +** If the final parameter - noSync - is true, then the database file itself +** is not synced. The caller must call sqlite3PagerSync() directly to +** sync the database file before calling CommitPhaseTwo() to delete the +** journal file in this case. +*/ +SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne( + Pager *pPager, /* Pager object */ + const char *zSuper, /* If not NULL, the super-journal name */ + int noSync /* True to omit the xSync on the db file */ +){ + int rc = SQLITE_OK; /* Return code */ + + assert( pPager->eState==PAGER_WRITER_LOCKED + || pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + || pPager->eState==PAGER_ERROR + ); + assert( assert_pager_state(pPager) ); + + /* If a prior error occurred, report that error again. */ + if( NEVER(pPager->errCode) ) return pPager->errCode; + + /* Provide the ability to easily simulate an I/O error during testing */ + if( sqlite3FaultSim(400) ) return SQLITE_IOERR; + + PAGERTRACE(("DATABASE SYNC: File=%s zSuper=%s nSize=%d\n", + pPager->zFilename, zSuper, pPager->dbSize)); + + /* If no database changes have been made, return early. */ + if( pPager->eStatetempFile ); + assert( isOpen(pPager->fd) || pPager->tempFile ); + if( 0==pagerFlushOnCommit(pPager, 1) ){ + /* If this is an in-memory db, or no pages have been written to, or this + ** function has already been called, it is mostly a no-op. However, any + ** backup in progress needs to be restarted. */ + sqlite3BackupRestart(pPager->pBackup); + }else{ + PgHdr *pList; + if( pagerUseWal(pPager) ){ + PgHdr *pPageOne = 0; + pList = sqlite3PcacheDirtyList(pPager->pPCache); + if( pList==0 ){ + /* Must have at least one page for the WAL commit flag. + ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */ + rc = sqlite3PagerGet(pPager, 1, &pPageOne, 0); + pList = pPageOne; + pList->pDirty = 0; + } + assert( rc==SQLITE_OK ); + if( ALWAYS(pList) ){ + rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1); + } + sqlite3PagerUnref(pPageOne); + if( rc==SQLITE_OK ){ + sqlite3PcacheCleanAll(pPager->pPCache); + } + }else{ + /* The bBatch boolean is true if the batch-atomic-write commit method + ** should be used. No rollback journal is created if batch-atomic-write + ** is enabled. + */ +#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE + sqlite3_file *fd = pPager->fd; + int bBatch = zSuper==0 /* An SQLITE_IOCAP_BATCH_ATOMIC commit */ + && (sqlite3OsDeviceCharacteristics(fd) & SQLITE_IOCAP_BATCH_ATOMIC) + && !pPager->noSync + && sqlite3JournalIsInMemory(pPager->jfd); +#else +# define bBatch 0 +#endif + +#ifdef SQLITE_ENABLE_ATOMIC_WRITE + /* The following block updates the change-counter. Exactly how it + ** does this depends on whether or not the atomic-update optimization + ** was enabled at compile time, and if this transaction meets the + ** runtime criteria to use the operation: + ** + ** * The file-system supports the atomic-write property for + ** blocks of size page-size, and + ** * This commit is not part of a multi-file transaction, and + ** * Exactly one page has been modified and store in the journal file. + ** + ** If the optimization was not enabled at compile time, then the + ** pager_incr_changecounter() function is called to update the change + ** counter in 'indirect-mode'. If the optimization is compiled in but + ** is not applicable to this transaction, call sqlite3JournalCreate() + ** to make sure the journal file has actually been created, then call + ** pager_incr_changecounter() to update the change-counter in indirect + ** mode. + ** + ** Otherwise, if the optimization is both enabled and applicable, + ** then call pager_incr_changecounter() to update the change-counter + ** in 'direct' mode. In this case the journal file will never be + ** created for this transaction. + */ + if( bBatch==0 ){ + PgHdr *pPg; + assert( isOpen(pPager->jfd) + || pPager->journalMode==PAGER_JOURNALMODE_OFF + || pPager->journalMode==PAGER_JOURNALMODE_WAL + ); + if( !zSuper && isOpen(pPager->jfd) + && pPager->journalOff==jrnlBufferSize(pPager) + && pPager->dbSize>=pPager->dbOrigSize + && (!(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty) + ){ + /* Update the db file change counter via the direct-write method. The + ** following call will modify the in-memory representation of page 1 + ** to include the updated change counter and then write page 1 + ** directly to the database file. Because of the atomic-write + ** property of the host file-system, this is safe. + */ + rc = pager_incr_changecounter(pPager, 1); + }else{ + rc = sqlite3JournalCreate(pPager->jfd); + if( rc==SQLITE_OK ){ + rc = pager_incr_changecounter(pPager, 0); + } + } + } +#else /* SQLITE_ENABLE_ATOMIC_WRITE */ +#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE + if( zSuper ){ + rc = sqlite3JournalCreate(pPager->jfd); + if( rc!=SQLITE_OK ) goto commit_phase_one_exit; + assert( bBatch==0 ); + } +#endif + rc = pager_incr_changecounter(pPager, 0); +#endif /* !SQLITE_ENABLE_ATOMIC_WRITE */ + if( rc!=SQLITE_OK ) goto commit_phase_one_exit; + + /* Write the super-journal name into the journal file. If a + ** super-journal file name has already been written to the journal file, + ** or if zSuper is NULL (no super-journal), then this call is a no-op. + */ + rc = writeSuperJournal(pPager, zSuper); + if( rc!=SQLITE_OK ) goto commit_phase_one_exit; + + /* Sync the journal file and write all dirty pages to the database. + ** If the atomic-update optimization is being used, this sync will not + ** create the journal file or perform any real IO. + ** + ** Because the change-counter page was just modified, unless the + ** atomic-update optimization is used it is almost certain that the + ** journal requires a sync here. However, in locking_mode=exclusive + ** on a system under memory pressure it is just possible that this is + ** not the case. In this case it is likely enough that the redundant + ** xSync() call will be changed to a no-op by the OS anyhow. + */ + rc = syncJournal(pPager, 0); + if( rc!=SQLITE_OK ) goto commit_phase_one_exit; + + pList = sqlite3PcacheDirtyList(pPager->pPCache); +#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE + if( bBatch ){ + rc = sqlite3OsFileControl(fd, SQLITE_FCNTL_BEGIN_ATOMIC_WRITE, 0); + if( rc==SQLITE_OK ){ + rc = pager_write_pagelist(pPager, pList); + if( rc==SQLITE_OK ){ + rc = sqlite3OsFileControl(fd, SQLITE_FCNTL_COMMIT_ATOMIC_WRITE, 0); + } + if( rc!=SQLITE_OK ){ + sqlite3OsFileControlHint(fd, SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE, 0); + } + } + + if( (rc&0xFF)==SQLITE_IOERR && rc!=SQLITE_IOERR_NOMEM ){ + rc = sqlite3JournalCreate(pPager->jfd); + if( rc!=SQLITE_OK ){ + sqlite3OsClose(pPager->jfd); + goto commit_phase_one_exit; + } + bBatch = 0; + }else{ + sqlite3OsClose(pPager->jfd); + } + } +#endif /* SQLITE_ENABLE_BATCH_ATOMIC_WRITE */ + + if( bBatch==0 ){ + rc = pager_write_pagelist(pPager, pList); + } + if( rc!=SQLITE_OK ){ + assert( rc!=SQLITE_IOERR_BLOCKED ); + goto commit_phase_one_exit; + } + sqlite3PcacheCleanAll(pPager->pPCache); + + /* If the file on disk is smaller than the database image, use + ** pager_truncate to grow the file here. This can happen if the database + ** image was extended as part of the current transaction and then the + ** last page in the db image moved to the free-list. In this case the + ** last page is never written out to disk, leaving the database file + ** undersized. Fix this now if it is the case. */ + if( pPager->dbSize>pPager->dbFileSize ){ + Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager)); + assert( pPager->eState==PAGER_WRITER_DBMOD ); + rc = pager_truncate(pPager, nNew); + if( rc!=SQLITE_OK ) goto commit_phase_one_exit; + } + + /* Finally, sync the database file. */ + if( !noSync ){ + rc = sqlite3PagerSync(pPager, zSuper); + } + IOTRACE(("DBSYNC %p\n", pPager)) + } + } + +commit_phase_one_exit: + if( rc==SQLITE_OK && !pagerUseWal(pPager) ){ + pPager->eState = PAGER_WRITER_FINISHED; + } + return rc; +} + + +/* +** When this function is called, the database file has been completely +** updated to reflect the changes made by the current transaction and +** synced to disk. The journal file still exists in the file-system +** though, and if a failure occurs at this point it will eventually +** be used as a hot-journal and the current transaction rolled back. +** +** This function finalizes the journal file, either by deleting, +** truncating or partially zeroing it, so that it cannot be used +** for hot-journal rollback. Once this is done the transaction is +** irrevocably committed. +** +** If an error occurs, an IO error code is returned and the pager +** moves into the error state. Otherwise, SQLITE_OK is returned. +*/ +SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager *pPager){ + int rc = SQLITE_OK; /* Return code */ + + /* This routine should not be called if a prior error has occurred. + ** But if (due to a coding error elsewhere in the system) it does get + ** called, just return the same error code without doing anything. */ + if( NEVER(pPager->errCode) ) return pPager->errCode; + pPager->iDataVersion++; + + assert( pPager->eState==PAGER_WRITER_LOCKED + || pPager->eState==PAGER_WRITER_FINISHED + || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD) + ); + assert( assert_pager_state(pPager) ); + + /* An optimization. If the database was not actually modified during + ** this transaction, the pager is running in exclusive-mode and is + ** using persistent journals, then this function is a no-op. + ** + ** The start of the journal file currently contains a single journal + ** header with the nRec field set to 0. If such a journal is used as + ** a hot-journal during hot-journal rollback, 0 changes will be made + ** to the database file. So there is no need to zero the journal + ** header. Since the pager is in exclusive mode, there is no need + ** to drop any locks either. + */ + if( pPager->eState==PAGER_WRITER_LOCKED + && pPager->exclusiveMode + && pPager->journalMode==PAGER_JOURNALMODE_PERSIST + ){ + assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff ); + pPager->eState = PAGER_READER; + return SQLITE_OK; + } + + PAGERTRACE(("COMMIT %d\n", PAGERID(pPager))); + rc = pager_end_transaction(pPager, pPager->setSuper, 1); + return pager_error(pPager, rc); +} + +/* +** If a write transaction is open, then all changes made within the +** transaction are reverted and the current write-transaction is closed. +** The pager falls back to PAGER_READER state if successful, or PAGER_ERROR +** state if an error occurs. +** +** If the pager is already in PAGER_ERROR state when this function is called, +** it returns Pager.errCode immediately. No work is performed in this case. +** +** Otherwise, in rollback mode, this function performs two functions: +** +** 1) It rolls back the journal file, restoring all database file and +** in-memory cache pages to the state they were in when the transaction +** was opened, and +** +** 2) It finalizes the journal file, so that it is not used for hot +** rollback at any point in the future. +** +** Finalization of the journal file (task 2) is only performed if the +** rollback is successful. +** +** In WAL mode, all cache-entries containing data modified within the +** current transaction are either expelled from the cache or reverted to +** their pre-transaction state by re-reading data from the database or +** WAL files. The WAL transaction is then closed. +*/ +SQLITE_PRIVATE int sqlite3PagerRollback(Pager *pPager){ + int rc = SQLITE_OK; /* Return code */ + PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager))); + + /* PagerRollback() is a no-op if called in READER or OPEN state. If + ** the pager is already in the ERROR state, the rollback is not + ** attempted here. Instead, the error code is returned to the caller. + */ + assert( assert_pager_state(pPager) ); + if( pPager->eState==PAGER_ERROR ) return pPager->errCode; + if( pPager->eState<=PAGER_READER ) return SQLITE_OK; + + if( pagerUseWal(pPager) ){ + int rc2; + rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1); + rc2 = pager_end_transaction(pPager, pPager->setSuper, 0); + if( rc==SQLITE_OK ) rc = rc2; + }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){ + int eState = pPager->eState; + rc = pager_end_transaction(pPager, 0, 0); + if( !MEMDB && eState>PAGER_WRITER_LOCKED ){ + /* This can happen using journal_mode=off. Move the pager to the error + ** state to indicate that the contents of the cache may not be trusted. + ** Any active readers will get SQLITE_ABORT. + */ + pPager->errCode = SQLITE_ABORT; + pPager->eState = PAGER_ERROR; + setGetterMethod(pPager); + return rc; + } + }else{ + rc = pager_playback(pPager, 0); + } + + assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK ); + assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT + || rc==SQLITE_NOMEM || (rc&0xFF)==SQLITE_IOERR + || rc==SQLITE_CANTOPEN + ); + + /* If an error occurs during a ROLLBACK, we can no longer trust the pager + ** cache. So call pager_error() on the way out to make any error persistent. + */ + return pager_error(pPager, rc); +} + +/* +** Return TRUE if the database file is opened read-only. Return FALSE +** if the database is (in theory) writable. +*/ +SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager *pPager){ + return pPager->readOnly; +} + +#ifdef SQLITE_DEBUG +/* +** Return the sum of the reference counts for all pages held by pPager. +*/ +SQLITE_PRIVATE int sqlite3PagerRefcount(Pager *pPager){ + return sqlite3PcacheRefCount(pPager->pPCache); +} +#endif + +/* +** Return the approximate number of bytes of memory currently +** used by the pager and its associated cache. +*/ +SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager *pPager){ + int perPageSize = pPager->pageSize + pPager->nExtra + sizeof(PgHdr) + + 5*sizeof(void*); + return perPageSize*sqlite3PcachePagecount(pPager->pPCache) + + sqlite3MallocSize(pPager) + + pPager->pageSize; +} + +/* +** Return the number of references to the specified page. +*/ +SQLITE_PRIVATE int sqlite3PagerPageRefcount(DbPage *pPage){ + return sqlite3PcachePageRefcount(pPage); +} + +#ifdef SQLITE_TEST +/* +** This routine is used for testing and analysis only. +*/ +SQLITE_PRIVATE int *sqlite3PagerStats(Pager *pPager){ + static int a[11]; + a[0] = sqlite3PcacheRefCount(pPager->pPCache); + a[1] = sqlite3PcachePagecount(pPager->pPCache); + a[2] = sqlite3PcacheGetCachesize(pPager->pPCache); + a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize; + a[4] = pPager->eState; + a[5] = pPager->errCode; + a[6] = pPager->aStat[PAGER_STAT_HIT]; + a[7] = pPager->aStat[PAGER_STAT_MISS]; + a[8] = 0; /* Used to be pPager->nOvfl */ + a[9] = pPager->nRead; + a[10] = pPager->aStat[PAGER_STAT_WRITE]; + return a; +} +#endif + +/* +** Parameter eStat must be one of SQLITE_DBSTATUS_CACHE_HIT, _MISS, _WRITE, +** or _WRITE+1. The SQLITE_DBSTATUS_CACHE_WRITE+1 case is a translation +** of SQLITE_DBSTATUS_CACHE_SPILL. The _SPILL case is not contiguous because +** it was added later. +** +** Before returning, *pnVal is incremented by the +** current cache hit or miss count, according to the value of eStat. If the +** reset parameter is non-zero, the cache hit or miss count is zeroed before +** returning. +*/ +SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *pPager, int eStat, int reset, int *pnVal){ + + assert( eStat==SQLITE_DBSTATUS_CACHE_HIT + || eStat==SQLITE_DBSTATUS_CACHE_MISS + || eStat==SQLITE_DBSTATUS_CACHE_WRITE + || eStat==SQLITE_DBSTATUS_CACHE_WRITE+1 + ); + + assert( SQLITE_DBSTATUS_CACHE_HIT+1==SQLITE_DBSTATUS_CACHE_MISS ); + assert( SQLITE_DBSTATUS_CACHE_HIT+2==SQLITE_DBSTATUS_CACHE_WRITE ); + assert( PAGER_STAT_HIT==0 && PAGER_STAT_MISS==1 + && PAGER_STAT_WRITE==2 && PAGER_STAT_SPILL==3 ); + + eStat -= SQLITE_DBSTATUS_CACHE_HIT; + *pnVal += pPager->aStat[eStat]; + if( reset ){ + pPager->aStat[eStat] = 0; + } +} + +/* +** Return true if this is an in-memory or temp-file backed pager. +*/ +SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager *pPager){ + return pPager->tempFile; +} + +/* +** Check that there are at least nSavepoint savepoints open. If there are +** currently less than nSavepoints open, then open one or more savepoints +** to make up the difference. If the number of savepoints is already +** equal to nSavepoint, then this function is a no-op. +** +** If a memory allocation fails, SQLITE_NOMEM is returned. If an error +** occurs while opening the sub-journal file, then an IO error code is +** returned. Otherwise, SQLITE_OK. +*/ +static SQLITE_NOINLINE int pagerOpenSavepoint(Pager *pPager, int nSavepoint){ + int rc = SQLITE_OK; /* Return code */ + int nCurrent = pPager->nSavepoint; /* Current number of savepoints */ + int ii; /* Iterator variable */ + PagerSavepoint *aNew; /* New Pager.aSavepoint array */ + + assert( pPager->eState>=PAGER_WRITER_LOCKED ); + assert( assert_pager_state(pPager) ); + assert( nSavepoint>nCurrent && pPager->useJournal ); + + /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM + ** if the allocation fails. Otherwise, zero the new portion in case a + ** malloc failure occurs while populating it in the for(...) loop below. + */ + aNew = (PagerSavepoint *)sqlite3Realloc( + pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint + ); + if( !aNew ){ + return SQLITE_NOMEM_BKPT; + } + memset(&aNew[nCurrent], 0, (nSavepoint-nCurrent) * sizeof(PagerSavepoint)); + pPager->aSavepoint = aNew; + + /* Populate the PagerSavepoint structures just allocated. */ + for(ii=nCurrent; iidbSize; + if( isOpen(pPager->jfd) && pPager->journalOff>0 ){ + aNew[ii].iOffset = pPager->journalOff; + }else{ + aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager); + } + aNew[ii].iSubRec = pPager->nSubRec; + aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize); + if( !aNew[ii].pInSavepoint ){ + return SQLITE_NOMEM_BKPT; + } + if( pagerUseWal(pPager) ){ + sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData); + } + pPager->nSavepoint = ii+1; + } + assert( pPager->nSavepoint==nSavepoint ); + assertTruncateConstraint(pPager); + return rc; +} +SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){ + assert( pPager->eState>=PAGER_WRITER_LOCKED ); + assert( assert_pager_state(pPager) ); + + if( nSavepoint>pPager->nSavepoint && pPager->useJournal ){ + return pagerOpenSavepoint(pPager, nSavepoint); + }else{ + return SQLITE_OK; + } +} + + +/* +** This function is called to rollback or release (commit) a savepoint. +** The savepoint to release or rollback need not be the most recently +** created savepoint. +** +** Parameter op is always either SAVEPOINT_ROLLBACK or SAVEPOINT_RELEASE. +** If it is SAVEPOINT_RELEASE, then release and destroy the savepoint with +** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes +** that have occurred since the specified savepoint was created. +** +** The savepoint to rollback or release is identified by parameter +** iSavepoint. A value of 0 means to operate on the outermost savepoint +** (the first created). A value of (Pager.nSavepoint-1) means operate +** on the most recently created savepoint. If iSavepoint is greater than +** (Pager.nSavepoint-1), then this function is a no-op. +** +** If a negative value is passed to this function, then the current +** transaction is rolled back. This is different to calling +** sqlite3PagerRollback() because this function does not terminate +** the transaction or unlock the database, it just restores the +** contents of the database to its original state. +** +** In any case, all savepoints with an index greater than iSavepoint +** are destroyed. If this is a release operation (op==SAVEPOINT_RELEASE), +** then savepoint iSavepoint is also destroyed. +** +** This function may return SQLITE_NOMEM if a memory allocation fails, +** or an IO error code if an IO error occurs while rolling back a +** savepoint. If no errors occur, SQLITE_OK is returned. +*/ +SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){ + int rc = pPager->errCode; + +#ifdef SQLITE_ENABLE_ZIPVFS + if( op==SAVEPOINT_RELEASE ) rc = SQLITE_OK; +#endif + + assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK ); + assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK ); + + if( rc==SQLITE_OK && iSavepointnSavepoint ){ + int ii; /* Iterator variable */ + int nNew; /* Number of remaining savepoints after this op. */ + + /* Figure out how many savepoints will still be active after this + ** operation. Store this value in nNew. Then free resources associated + ** with any savepoints that are destroyed by this operation. + */ + nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1); + for(ii=nNew; iinSavepoint; ii++){ + sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint); + } + pPager->nSavepoint = nNew; + + /* If this is a release of the outermost savepoint, truncate + ** the sub-journal to zero bytes in size. */ + if( op==SAVEPOINT_RELEASE ){ + if( nNew==0 && isOpen(pPager->sjfd) ){ + /* Only truncate if it is an in-memory sub-journal. */ + if( sqlite3JournalIsInMemory(pPager->sjfd) ){ + rc = sqlite3OsTruncate(pPager->sjfd, 0); + assert( rc==SQLITE_OK ); + } + pPager->nSubRec = 0; + } + } + /* Else this is a rollback operation, playback the specified savepoint. + ** If this is a temp-file, it is possible that the journal file has + ** not yet been opened. In this case there have been no changes to + ** the database file, so the playback operation can be skipped. + */ + else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){ + PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1]; + rc = pagerPlaybackSavepoint(pPager, pSavepoint); + assert(rc!=SQLITE_DONE); + } + +#ifdef SQLITE_ENABLE_ZIPVFS + /* If the cache has been modified but the savepoint cannot be rolled + ** back journal_mode=off, put the pager in the error state. This way, + ** if the VFS used by this pager includes ZipVFS, the entire transaction + ** can be rolled back at the ZipVFS level. */ + else if( + pPager->journalMode==PAGER_JOURNALMODE_OFF + && pPager->eState>=PAGER_WRITER_CACHEMOD + ){ + pPager->errCode = SQLITE_ABORT; + pPager->eState = PAGER_ERROR; + setGetterMethod(pPager); + } +#endif + } + + return rc; +} + +/* +** Return the full pathname of the database file. +** +** Except, if the pager is in-memory only, then return an empty string if +** nullIfMemDb is true. This routine is called with nullIfMemDb==1 when +** used to report the filename to the user, for compatibility with legacy +** behavior. But when the Btree needs to know the filename for matching to +** shared cache, it uses nullIfMemDb==0 so that in-memory databases can +** participate in shared-cache. +** +** The return value to this routine is always safe to use with +** sqlite3_uri_parameter() and sqlite3_filename_database() and friends. +*/ +SQLITE_PRIVATE const char *sqlite3PagerFilename(const Pager *pPager, int nullIfMemDb){ + static const char zFake[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + return (nullIfMemDb && pPager->memDb) ? &zFake[4] : pPager->zFilename; +} + +/* +** Return the VFS structure for the pager. +*/ +SQLITE_PRIVATE sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){ + return pPager->pVfs; +} + +/* +** Return the file handle for the database file associated +** with the pager. This might return NULL if the file has +** not yet been opened. +*/ +SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager *pPager){ + return pPager->fd; +} + +/* +** Return the file handle for the journal file (if it exists). +** This will be either the rollback journal or the WAL file. +*/ +SQLITE_PRIVATE sqlite3_file *sqlite3PagerJrnlFile(Pager *pPager){ +#if SQLITE_OMIT_WAL + return pPager->jfd; +#else + return pPager->pWal ? sqlite3WalFile(pPager->pWal) : pPager->jfd; +#endif +} + +/* +** Return the full pathname of the journal file. +*/ +SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager *pPager){ + return pPager->zJournal; +} + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** Move the page pPg to location pgno in the file. +** +** There must be no references to the page previously located at +** pgno (which we call pPgOld) though that page is allowed to be +** in cache. If the page previously located at pgno is not already +** in the rollback journal, it is not put there by by this routine. +** +** References to the page pPg remain valid. Updating any +** meta-data associated with pPg (i.e. data stored in the nExtra bytes +** allocated along with the page) is the responsibility of the caller. +** +** A transaction must be active when this routine is called. It used to be +** required that a statement transaction was not active, but this restriction +** has been removed (CREATE INDEX needs to move a page when a statement +** transaction is active). +** +** If the fourth argument, isCommit, is non-zero, then this page is being +** moved as part of a database reorganization just before the transaction +** is being committed. In this case, it is guaranteed that the database page +** pPg refers to will not be written to again within this transaction. +** +** This function may return SQLITE_NOMEM or an IO error code if an error +** occurs. Otherwise, it returns SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){ + PgHdr *pPgOld; /* The page being overwritten. */ + Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */ + int rc; /* Return code */ + Pgno origPgno; /* The original page number */ + + assert( pPg->nRef>0 ); + assert( pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + ); + assert( assert_pager_state(pPager) ); + + /* In order to be able to rollback, an in-memory database must journal + ** the page we are moving from. + */ + assert( pPager->tempFile || !MEMDB ); + if( pPager->tempFile ){ + rc = sqlite3PagerWrite(pPg); + if( rc ) return rc; + } + + /* If the page being moved is dirty and has not been saved by the latest + ** savepoint, then save the current contents of the page into the + ** sub-journal now. This is required to handle the following scenario: + ** + ** BEGIN; + ** + ** SAVEPOINT one; + ** + ** ROLLBACK TO one; + ** + ** If page X were not written to the sub-journal here, it would not + ** be possible to restore its contents when the "ROLLBACK TO one" + ** statement were is processed. + ** + ** subjournalPage() may need to allocate space to store pPg->pgno into + ** one or more savepoint bitvecs. This is the reason this function + ** may return SQLITE_NOMEM. + */ + if( (pPg->flags & PGHDR_DIRTY)!=0 + && SQLITE_OK!=(rc = subjournalPageIfRequired(pPg)) + ){ + return rc; + } + + PAGERTRACE(("MOVE %d page %d (needSync=%d) moves to %d\n", + PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno)); + IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno)) + + /* If the journal needs to be sync()ed before page pPg->pgno can + ** be written to, store pPg->pgno in local variable needSyncPgno. + ** + ** If the isCommit flag is set, there is no need to remember that + ** the journal needs to be sync()ed before database page pPg->pgno + ** can be written to. The caller has already promised not to write to it. + */ + if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){ + needSyncPgno = pPg->pgno; + assert( pPager->journalMode==PAGER_JOURNALMODE_OFF || + pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize ); + assert( pPg->flags&PGHDR_DIRTY ); + } + + /* If the cache contains a page with page-number pgno, remove it + ** from its hash chain. Also, if the PGHDR_NEED_SYNC flag was set for + ** page pgno before the 'move' operation, it needs to be retained + ** for the page moved there. + */ + pPg->flags &= ~PGHDR_NEED_SYNC; + pPgOld = sqlite3PagerLookup(pPager, pgno); + assert( !pPgOld || pPgOld->nRef==1 || CORRUPT_DB ); + if( pPgOld ){ + if( pPgOld->nRef>1 ){ + sqlite3PagerUnrefNotNull(pPgOld); + return SQLITE_CORRUPT_BKPT; + } + pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC); + if( pPager->tempFile ){ + /* Do not discard pages from an in-memory database since we might + ** need to rollback later. Just move the page out of the way. */ + sqlite3PcacheMove(pPgOld, pPager->dbSize+1); + }else{ + sqlite3PcacheDrop(pPgOld); + } + } + + origPgno = pPg->pgno; + sqlite3PcacheMove(pPg, pgno); + sqlite3PcacheMakeDirty(pPg); + + /* For an in-memory database, make sure the original page continues + ** to exist, in case the transaction needs to roll back. Use pPgOld + ** as the original page since it has already been allocated. + */ + if( pPager->tempFile && pPgOld ){ + sqlite3PcacheMove(pPgOld, origPgno); + sqlite3PagerUnrefNotNull(pPgOld); + } + + if( needSyncPgno ){ + /* If needSyncPgno is non-zero, then the journal file needs to be + ** sync()ed before any data is written to database file page needSyncPgno. + ** Currently, no such page exists in the page-cache and the + ** "is journaled" bitvec flag has been set. This needs to be remedied by + ** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC + ** flag. + ** + ** If the attempt to load the page into the page-cache fails, (due + ** to a malloc() or IO failure), clear the bit in the pInJournal[] + ** array. Otherwise, if the page is loaded and written again in + ** this transaction, it may be written to the database file before + ** it is synced into the journal file. This way, it may end up in + ** the journal file twice, but that is not a problem. + */ + PgHdr *pPgHdr; + rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr, 0); + if( rc!=SQLITE_OK ){ + if( needSyncPgno<=pPager->dbOrigSize ){ + assert( pPager->pTmpSpace!=0 ); + sqlite3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace); + } + return rc; + } + pPgHdr->flags |= PGHDR_NEED_SYNC; + sqlite3PcacheMakeDirty(pPgHdr); + sqlite3PagerUnrefNotNull(pPgHdr); + } + + return SQLITE_OK; +} +#endif + +/* +** The page handle passed as the first argument refers to a dirty page +** with a page number other than iNew. This function changes the page's +** page number to iNew and sets the value of the PgHdr.flags field to +** the value passed as the third parameter. +*/ +SQLITE_PRIVATE void sqlite3PagerRekey(DbPage *pPg, Pgno iNew, u16 flags){ + assert( pPg->pgno!=iNew ); + pPg->flags = flags; + sqlite3PcacheMove(pPg, iNew); +} + +/* +** Return a pointer to the data for the specified page. +*/ +SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *pPg){ + assert( pPg->nRef>0 || pPg->pPager->memDb ); + return pPg->pData; +} + +/* +** Return a pointer to the Pager.nExtra bytes of "extra" space +** allocated along with the specified page. +*/ +SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *pPg){ + return pPg->pExtra; +} + +/* +** Get/set the locking-mode for this pager. Parameter eMode must be one +** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or +** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then +** the locking-mode is set to the value specified. +** +** The returned value is either PAGER_LOCKINGMODE_NORMAL or +** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated) +** locking-mode. +*/ +SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *pPager, int eMode){ + assert( eMode==PAGER_LOCKINGMODE_QUERY + || eMode==PAGER_LOCKINGMODE_NORMAL + || eMode==PAGER_LOCKINGMODE_EXCLUSIVE ); + assert( PAGER_LOCKINGMODE_QUERY<0 ); + assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 ); + assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) ); + if( eMode>=0 && !pPager->tempFile && !sqlite3WalHeapMemory(pPager->pWal) ){ + pPager->exclusiveMode = (u8)eMode; + } + return (int)pPager->exclusiveMode; +} + +/* +** Set the journal-mode for this pager. Parameter eMode must be one of: +** +** PAGER_JOURNALMODE_DELETE +** PAGER_JOURNALMODE_TRUNCATE +** PAGER_JOURNALMODE_PERSIST +** PAGER_JOURNALMODE_OFF +** PAGER_JOURNALMODE_MEMORY +** PAGER_JOURNALMODE_WAL +** +** The journalmode is set to the value specified if the change is allowed. +** The change may be disallowed for the following reasons: +** +** * An in-memory database can only have its journal_mode set to _OFF +** or _MEMORY. +** +** * Temporary databases cannot have _WAL journalmode. +** +** The returned indicate the current (possibly updated) journal-mode. +*/ +SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){ + u8 eOld = pPager->journalMode; /* Prior journalmode */ + + /* The eMode parameter is always valid */ + assert( eMode==PAGER_JOURNALMODE_DELETE + || eMode==PAGER_JOURNALMODE_TRUNCATE + || eMode==PAGER_JOURNALMODE_PERSIST + || eMode==PAGER_JOURNALMODE_OFF + || eMode==PAGER_JOURNALMODE_WAL + || eMode==PAGER_JOURNALMODE_MEMORY ); + + /* This routine is only called from the OP_JournalMode opcode, and + ** the logic there will never allow a temporary file to be changed + ** to WAL mode. + */ + assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL ); + + /* Do allow the journalmode of an in-memory database to be set to + ** anything other than MEMORY or OFF + */ + if( MEMDB ){ + assert( eOld==PAGER_JOURNALMODE_MEMORY || eOld==PAGER_JOURNALMODE_OFF ); + if( eMode!=PAGER_JOURNALMODE_MEMORY && eMode!=PAGER_JOURNALMODE_OFF ){ + eMode = eOld; + } + } + + if( eMode!=eOld ){ + + /* Change the journal mode. */ + assert( pPager->eState!=PAGER_ERROR ); + pPager->journalMode = (u8)eMode; + + /* When transistioning from TRUNCATE or PERSIST to any other journal + ** mode except WAL, unless the pager is in locking_mode=exclusive mode, + ** delete the journal file. + */ + assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 ); + assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 ); + assert( (PAGER_JOURNALMODE_DELETE & 5)==0 ); + assert( (PAGER_JOURNALMODE_MEMORY & 5)==4 ); + assert( (PAGER_JOURNALMODE_OFF & 5)==0 ); + assert( (PAGER_JOURNALMODE_WAL & 5)==5 ); + + assert( isOpen(pPager->fd) || pPager->exclusiveMode ); + if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){ + + /* In this case we would like to delete the journal file. If it is + ** not possible, then that is not a problem. Deleting the journal file + ** here is an optimization only. + ** + ** Before deleting the journal file, obtain a RESERVED lock on the + ** database file. This ensures that the journal file is not deleted + ** while it is in use by some other client. + */ + sqlite3OsClose(pPager->jfd); + if( pPager->eLock>=RESERVED_LOCK ){ + sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0); + }else{ + int rc = SQLITE_OK; + int state = pPager->eState; + assert( state==PAGER_OPEN || state==PAGER_READER ); + if( state==PAGER_OPEN ){ + rc = sqlite3PagerSharedLock(pPager); + } + if( pPager->eState==PAGER_READER ){ + assert( rc==SQLITE_OK ); + rc = pagerLockDb(pPager, RESERVED_LOCK); + } + if( rc==SQLITE_OK ){ + sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0); + } + if( rc==SQLITE_OK && state==PAGER_READER ){ + pagerUnlockDb(pPager, SHARED_LOCK); + }else if( state==PAGER_OPEN ){ + pager_unlock(pPager); + } + assert( state==pPager->eState ); + } + }else if( eMode==PAGER_JOURNALMODE_OFF ){ + sqlite3OsClose(pPager->jfd); + } + } + + /* Return the new journal mode */ + return (int)pPager->journalMode; +} + +/* +** Return the current journal mode. +*/ +SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager *pPager){ + return (int)pPager->journalMode; +} + +/* +** Return TRUE if the pager is in a state where it is OK to change the +** journalmode. Journalmode changes can only happen when the database +** is unmodified. +*/ +SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager *pPager){ + assert( assert_pager_state(pPager) ); + if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0; + if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0; + return 1; +} + +/* +** Get/set the size-limit used for persistent journal files. +** +** Setting the size limit to -1 means no limit is enforced. +** An attempt to set a limit smaller than -1 is a no-op. +*/ +SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){ + if( iLimit>=-1 ){ + pPager->journalSizeLimit = iLimit; + sqlite3WalLimit(pPager->pWal, iLimit); + } + return pPager->journalSizeLimit; +} + +/* +** Return a pointer to the pPager->pBackup variable. The backup module +** in backup.c maintains the content of this variable. This module +** uses it opaquely as an argument to sqlite3BackupRestart() and +** sqlite3BackupUpdate() only. +*/ +SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){ + return &pPager->pBackup; +} + +#ifndef SQLITE_OMIT_VACUUM +/* +** Unless this is an in-memory or temporary database, clear the pager cache. +*/ +SQLITE_PRIVATE void sqlite3PagerClearCache(Pager *pPager){ + assert( MEMDB==0 || pPager->tempFile ); + if( pPager->tempFile==0 ) pager_reset(pPager); +} +#endif + + +#ifndef SQLITE_OMIT_WAL +/* +** This function is called when the user invokes "PRAGMA wal_checkpoint", +** "PRAGMA wal_blocking_checkpoint" or calls the sqlite3_wal_checkpoint() +** or wal_blocking_checkpoint() API functions. +** +** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART. +*/ +SQLITE_PRIVATE int sqlite3PagerCheckpoint( + Pager *pPager, /* Checkpoint on this pager */ + sqlite3 *db, /* Db handle used to check for interrupts */ + int eMode, /* Type of checkpoint */ + int *pnLog, /* OUT: Final number of frames in log */ + int *pnCkpt /* OUT: Final number of checkpointed frames */ +){ + int rc = SQLITE_OK; + if( pPager->pWal ){ + rc = sqlite3WalCheckpoint(pPager->pWal, db, eMode, + (eMode==SQLITE_CHECKPOINT_PASSIVE ? 0 : pPager->xBusyHandler), + pPager->pBusyHandlerArg, + pPager->walSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace, + pnLog, pnCkpt + ); + } + return rc; +} + +SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager){ + return sqlite3WalCallback(pPager->pWal); +} + +/* +** Return true if the underlying VFS for the given pager supports the +** primitives necessary for write-ahead logging. +*/ +SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager){ + const sqlite3_io_methods *pMethods = pPager->fd->pMethods; + if( pPager->noLock ) return 0; + return pPager->exclusiveMode || (pMethods->iVersion>=2 && pMethods->xShmMap); +} + +/* +** Attempt to take an exclusive lock on the database file. If a PENDING lock +** is obtained instead, immediately release it. +*/ +static int pagerExclusiveLock(Pager *pPager){ + int rc; /* Return code */ + + assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK ); + rc = pagerLockDb(pPager, EXCLUSIVE_LOCK); + if( rc!=SQLITE_OK ){ + /* If the attempt to grab the exclusive lock failed, release the + ** pending lock that may have been obtained instead. */ + pagerUnlockDb(pPager, SHARED_LOCK); + } + + return rc; +} + +/* +** Call sqlite3WalOpen() to open the WAL handle. If the pager is in +** exclusive-locking mode when this function is called, take an EXCLUSIVE +** lock on the database file and use heap-memory to store the wal-index +** in. Otherwise, use the normal shared-memory. +*/ +static int pagerOpenWal(Pager *pPager){ + int rc = SQLITE_OK; + + assert( pPager->pWal==0 && pPager->tempFile==0 ); + assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK ); + + /* If the pager is already in exclusive-mode, the WAL module will use + ** heap-memory for the wal-index instead of the VFS shared-memory + ** implementation. Take the exclusive lock now, before opening the WAL + ** file, to make sure this is safe. + */ + if( pPager->exclusiveMode ){ + rc = pagerExclusiveLock(pPager); + } + + /* Open the connection to the log file. If this operation fails, + ** (e.g. due to malloc() failure), return an error code. + */ + if( rc==SQLITE_OK ){ + rc = sqlite3WalOpen(pPager->pVfs, + pPager->fd, pPager->zWal, pPager->exclusiveMode, + pPager->journalSizeLimit, &pPager->pWal + ); + } + pagerFixMaplimit(pPager); + + return rc; +} + + +/* +** The caller must be holding a SHARED lock on the database file to call +** this function. +** +** If the pager passed as the first argument is open on a real database +** file (not a temp file or an in-memory database), and the WAL file +** is not already open, make an attempt to open it now. If successful, +** return SQLITE_OK. If an error occurs or the VFS used by the pager does +** not support the xShmXXX() methods, return an error code. *pbOpen is +** not modified in either case. +** +** If the pager is open on a temp-file (or in-memory database), or if +** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK +** without doing anything. +*/ +SQLITE_PRIVATE int sqlite3PagerOpenWal( + Pager *pPager, /* Pager object */ + int *pbOpen /* OUT: Set to true if call is a no-op */ +){ + int rc = SQLITE_OK; /* Return code */ + + assert( assert_pager_state(pPager) ); + assert( pPager->eState==PAGER_OPEN || pbOpen ); + assert( pPager->eState==PAGER_READER || !pbOpen ); + assert( pbOpen==0 || *pbOpen==0 ); + assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) ); + + if( !pPager->tempFile && !pPager->pWal ){ + if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN; + + /* Close any rollback journal previously open */ + sqlite3OsClose(pPager->jfd); + + rc = pagerOpenWal(pPager); + if( rc==SQLITE_OK ){ + pPager->journalMode = PAGER_JOURNALMODE_WAL; + pPager->eState = PAGER_OPEN; + } + }else{ + *pbOpen = 1; + } + + return rc; +} + +/* +** This function is called to close the connection to the log file prior +** to switching from WAL to rollback mode. +** +** Before closing the log file, this function attempts to take an +** EXCLUSIVE lock on the database file. If this cannot be obtained, an +** error (SQLITE_BUSY) is returned and the log connection is not closed. +** If successful, the EXCLUSIVE lock is not released before returning. +*/ +SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager, sqlite3 *db){ + int rc = SQLITE_OK; + + assert( pPager->journalMode==PAGER_JOURNALMODE_WAL ); + + /* If the log file is not already open, but does exist in the file-system, + ** it may need to be checkpointed before the connection can switch to + ** rollback mode. Open it now so this can happen. + */ + if( !pPager->pWal ){ + int logexists = 0; + rc = pagerLockDb(pPager, SHARED_LOCK); + if( rc==SQLITE_OK ){ + rc = sqlite3OsAccess( + pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists + ); + } + if( rc==SQLITE_OK && logexists ){ + rc = pagerOpenWal(pPager); + } + } + + /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on + ** the database file, the log and log-summary files will be deleted. + */ + if( rc==SQLITE_OK && pPager->pWal ){ + rc = pagerExclusiveLock(pPager); + if( rc==SQLITE_OK ){ + rc = sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags, + pPager->pageSize, (u8*)pPager->pTmpSpace); + pPager->pWal = 0; + pagerFixMaplimit(pPager); + if( rc && !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK); + } + } + return rc; +} + +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT +/* +** If pager pPager is a wal-mode database not in exclusive locking mode, +** invoke the sqlite3WalWriteLock() function on the associated Wal object +** with the same db and bLock parameters as were passed to this function. +** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise. +*/ +SQLITE_PRIVATE int sqlite3PagerWalWriteLock(Pager *pPager, int bLock){ + int rc = SQLITE_OK; + if( pagerUseWal(pPager) && pPager->exclusiveMode==0 ){ + rc = sqlite3WalWriteLock(pPager->pWal, bLock); + } + return rc; +} + +/* +** Set the database handle used by the wal layer to determine if +** blocking locks are required. +*/ +SQLITE_PRIVATE void sqlite3PagerWalDb(Pager *pPager, sqlite3 *db){ + if( pagerUseWal(pPager) ){ + sqlite3WalDb(pPager->pWal, db); + } +} +#endif + +#ifdef SQLITE_ENABLE_SNAPSHOT +/* +** If this is a WAL database, obtain a snapshot handle for the snapshot +** currently open. Otherwise, return an error. +*/ +SQLITE_PRIVATE int sqlite3PagerSnapshotGet(Pager *pPager, sqlite3_snapshot **ppSnapshot){ + int rc = SQLITE_ERROR; + if( pPager->pWal ){ + rc = sqlite3WalSnapshotGet(pPager->pWal, ppSnapshot); + } + return rc; +} + +/* +** If this is a WAL database, store a pointer to pSnapshot. Next time a +** read transaction is opened, attempt to read from the snapshot it +** identifies. If this is not a WAL database, return an error. +*/ +SQLITE_PRIVATE int sqlite3PagerSnapshotOpen( + Pager *pPager, + sqlite3_snapshot *pSnapshot +){ + int rc = SQLITE_OK; + if( pPager->pWal ){ + sqlite3WalSnapshotOpen(pPager->pWal, pSnapshot); + }else{ + rc = SQLITE_ERROR; + } + return rc; +} + +/* +** If this is a WAL database, call sqlite3WalSnapshotRecover(). If this +** is not a WAL database, return an error. +*/ +SQLITE_PRIVATE int sqlite3PagerSnapshotRecover(Pager *pPager){ + int rc; + if( pPager->pWal ){ + rc = sqlite3WalSnapshotRecover(pPager->pWal); + }else{ + rc = SQLITE_ERROR; + } + return rc; +} + +/* +** The caller currently has a read transaction open on the database. +** If this is not a WAL database, SQLITE_ERROR is returned. Otherwise, +** this function takes a SHARED lock on the CHECKPOINTER slot and then +** checks if the snapshot passed as the second argument is still +** available. If so, SQLITE_OK is returned. +** +** If the snapshot is not available, SQLITE_ERROR is returned. Or, if +** the CHECKPOINTER lock cannot be obtained, SQLITE_BUSY. If any error +** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER +** lock is released before returning. +*/ +SQLITE_PRIVATE int sqlite3PagerSnapshotCheck(Pager *pPager, sqlite3_snapshot *pSnapshot){ + int rc; + if( pPager->pWal ){ + rc = sqlite3WalSnapshotCheck(pPager->pWal, pSnapshot); + }else{ + rc = SQLITE_ERROR; + } + return rc; +} + +/* +** Release a lock obtained by an earlier successful call to +** sqlite3PagerSnapshotCheck(). +*/ +SQLITE_PRIVATE void sqlite3PagerSnapshotUnlock(Pager *pPager){ + assert( pPager->pWal ); + sqlite3WalSnapshotUnlock(pPager->pWal); +} + +#endif /* SQLITE_ENABLE_SNAPSHOT */ +#endif /* !SQLITE_OMIT_WAL */ + +#ifdef SQLITE_ENABLE_ZIPVFS +/* +** A read-lock must be held on the pager when this function is called. If +** the pager is in WAL mode and the WAL file currently contains one or more +** frames, return the size in bytes of the page images stored within the +** WAL frames. Otherwise, if this is not a WAL database or the WAL file +** is empty, return 0. +*/ +SQLITE_PRIVATE int sqlite3PagerWalFramesize(Pager *pPager){ + assert( pPager->eState>=PAGER_READER ); + return sqlite3WalFramesize(pPager->pWal); +} +#endif + +#endif /* SQLITE_OMIT_DISKIO */ + +/************** End of pager.c ***********************************************/ +/************** Begin file wal.c *********************************************/ +/* +** 2010 February 1 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains the implementation of a write-ahead log (WAL) used in +** "journal_mode=WAL" mode. +** +** WRITE-AHEAD LOG (WAL) FILE FORMAT +** +** A WAL file consists of a header followed by zero or more "frames". +** Each frame records the revised content of a single page from the +** database file. All changes to the database are recorded by writing +** frames into the WAL. Transactions commit when a frame is written that +** contains a commit marker. A single WAL can and usually does record +** multiple transactions. Periodically, the content of the WAL is +** transferred back into the database file in an operation called a +** "checkpoint". +** +** A single WAL file can be used multiple times. In other words, the +** WAL can fill up with frames and then be checkpointed and then new +** frames can overwrite the old ones. A WAL always grows from beginning +** toward the end. Checksums and counters attached to each frame are +** used to determine which frames within the WAL are valid and which +** are leftovers from prior checkpoints. +** +** The WAL header is 32 bytes in size and consists of the following eight +** big-endian 32-bit unsigned integer values: +** +** 0: Magic number. 0x377f0682 or 0x377f0683 +** 4: File format version. Currently 3007000 +** 8: Database page size. Example: 1024 +** 12: Checkpoint sequence number +** 16: Salt-1, random integer incremented with each checkpoint +** 20: Salt-2, a different random integer changing with each ckpt +** 24: Checksum-1 (first part of checksum for first 24 bytes of header). +** 28: Checksum-2 (second part of checksum for first 24 bytes of header). +** +** Immediately following the wal-header are zero or more frames. Each +** frame consists of a 24-byte frame-header followed by a bytes +** of page data. The frame-header is six big-endian 32-bit unsigned +** integer values, as follows: +** +** 0: Page number. +** 4: For commit records, the size of the database image in pages +** after the commit. For all other records, zero. +** 8: Salt-1 (copied from the header) +** 12: Salt-2 (copied from the header) +** 16: Checksum-1. +** 20: Checksum-2. +** +** A frame is considered valid if and only if the following conditions are +** true: +** +** (1) The salt-1 and salt-2 values in the frame-header match +** salt values in the wal-header +** +** (2) The checksum values in the final 8 bytes of the frame-header +** exactly match the checksum computed consecutively on the +** WAL header and the first 8 bytes and the content of all frames +** up to and including the current frame. +** +** The checksum is computed using 32-bit big-endian integers if the +** magic number in the first 4 bytes of the WAL is 0x377f0683 and it +** is computed using little-endian if the magic number is 0x377f0682. +** The checksum values are always stored in the frame header in a +** big-endian format regardless of which byte order is used to compute +** the checksum. The checksum is computed by interpreting the input as +** an even number of unsigned 32-bit integers: x[0] through x[N]. The +** algorithm used for the checksum is as follows: +** +** for i from 0 to n-1 step 2: +** s0 += x[i] + s1; +** s1 += x[i+1] + s0; +** endfor +** +** Note that s0 and s1 are both weighted checksums using fibonacci weights +** in reverse order (the largest fibonacci weight occurs on the first element +** of the sequence being summed.) The s1 value spans all 32-bit +** terms of the sequence whereas s0 omits the final term. +** +** On a checkpoint, the WAL is first VFS.xSync-ed, then valid content of the +** WAL is transferred into the database, then the database is VFS.xSync-ed. +** The VFS.xSync operations serve as write barriers - all writes launched +** before the xSync must complete before any write that launches after the +** xSync begins. +** +** After each checkpoint, the salt-1 value is incremented and the salt-2 +** value is randomized. This prevents old and new frames in the WAL from +** being considered valid at the same time and being checkpointing together +** following a crash. +** +** READER ALGORITHM +** +** To read a page from the database (call it page number P), a reader +** first checks the WAL to see if it contains page P. If so, then the +** last valid instance of page P that is a followed by a commit frame +** or is a commit frame itself becomes the value read. If the WAL +** contains no copies of page P that are valid and which are a commit +** frame or are followed by a commit frame, then page P is read from +** the database file. +** +** To start a read transaction, the reader records the index of the last +** valid frame in the WAL. The reader uses this recorded "mxFrame" value +** for all subsequent read operations. New transactions can be appended +** to the WAL, but as long as the reader uses its original mxFrame value +** and ignores the newly appended content, it will see a consistent snapshot +** of the database from a single point in time. This technique allows +** multiple concurrent readers to view different versions of the database +** content simultaneously. +** +** The reader algorithm in the previous paragraphs works correctly, but +** because frames for page P can appear anywhere within the WAL, the +** reader has to scan the entire WAL looking for page P frames. If the +** WAL is large (multiple megabytes is typical) that scan can be slow, +** and read performance suffers. To overcome this problem, a separate +** data structure called the wal-index is maintained to expedite the +** search for frames of a particular page. +** +** WAL-INDEX FORMAT +** +** Conceptually, the wal-index is shared memory, though VFS implementations +** might choose to implement the wal-index using a mmapped file. Because +** the wal-index is shared memory, SQLite does not support journal_mode=WAL +** on a network filesystem. All users of the database must be able to +** share memory. +** +** In the default unix and windows implementation, the wal-index is a mmapped +** file whose name is the database name with a "-shm" suffix added. For that +** reason, the wal-index is sometimes called the "shm" file. +** +** The wal-index is transient. After a crash, the wal-index can (and should +** be) reconstructed from the original WAL file. In fact, the VFS is required +** to either truncate or zero the header of the wal-index when the last +** connection to it closes. Because the wal-index is transient, it can +** use an architecture-specific format; it does not have to be cross-platform. +** Hence, unlike the database and WAL file formats which store all values +** as big endian, the wal-index can store multi-byte values in the native +** byte order of the host computer. +** +** The purpose of the wal-index is to answer this question quickly: Given +** a page number P and a maximum frame index M, return the index of the +** last frame in the wal before frame M for page P in the WAL, or return +** NULL if there are no frames for page P in the WAL prior to M. +** +** The wal-index consists of a header region, followed by an one or +** more index blocks. +** +** The wal-index header contains the total number of frames within the WAL +** in the mxFrame field. +** +** Each index block except for the first contains information on +** HASHTABLE_NPAGE frames. The first index block contains information on +** HASHTABLE_NPAGE_ONE frames. The values of HASHTABLE_NPAGE_ONE and +** HASHTABLE_NPAGE are selected so that together the wal-index header and +** first index block are the same size as all other index blocks in the +** wal-index. +** +** Each index block contains two sections, a page-mapping that contains the +** database page number associated with each wal frame, and a hash-table +** that allows readers to query an index block for a specific page number. +** The page-mapping is an array of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE +** for the first index block) 32-bit page numbers. The first entry in the +** first index-block contains the database page number corresponding to the +** first frame in the WAL file. The first entry in the second index block +** in the WAL file corresponds to the (HASHTABLE_NPAGE_ONE+1)th frame in +** the log, and so on. +** +** The last index block in a wal-index usually contains less than the full +** complement of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE) page-numbers, +** depending on the contents of the WAL file. This does not change the +** allocated size of the page-mapping array - the page-mapping array merely +** contains unused entries. +** +** Even without using the hash table, the last frame for page P +** can be found by scanning the page-mapping sections of each index block +** starting with the last index block and moving toward the first, and +** within each index block, starting at the end and moving toward the +** beginning. The first entry that equals P corresponds to the frame +** holding the content for that page. +** +** The hash table consists of HASHTABLE_NSLOT 16-bit unsigned integers. +** HASHTABLE_NSLOT = 2*HASHTABLE_NPAGE, and there is one entry in the +** hash table for each page number in the mapping section, so the hash +** table is never more than half full. The expected number of collisions +** prior to finding a match is 1. Each entry of the hash table is an +** 1-based index of an entry in the mapping section of the same +** index block. Let K be the 1-based index of the largest entry in +** the mapping section. (For index blocks other than the last, K will +** always be exactly HASHTABLE_NPAGE (4096) and for the last index block +** K will be (mxFrame%HASHTABLE_NPAGE).) Unused slots of the hash table +** contain a value of 0. +** +** To look for page P in the hash table, first compute a hash iKey on +** P as follows: +** +** iKey = (P * 383) % HASHTABLE_NSLOT +** +** Then start scanning entries of the hash table, starting with iKey +** (wrapping around to the beginning when the end of the hash table is +** reached) until an unused hash slot is found. Let the first unused slot +** be at index iUnused. (iUnused might be less than iKey if there was +** wrap-around.) Because the hash table is never more than half full, +** the search is guaranteed to eventually hit an unused entry. Let +** iMax be the value between iKey and iUnused, closest to iUnused, +** where aHash[iMax]==P. If there is no iMax entry (if there exists +** no hash slot such that aHash[i]==p) then page P is not in the +** current index block. Otherwise the iMax-th mapping entry of the +** current index block corresponds to the last entry that references +** page P. +** +** A hash search begins with the last index block and moves toward the +** first index block, looking for entries corresponding to page P. On +** average, only two or three slots in each index block need to be +** examined in order to either find the last entry for page P, or to +** establish that no such entry exists in the block. Each index block +** holds over 4000 entries. So two or three index blocks are sufficient +** to cover a typical 10 megabyte WAL file, assuming 1K pages. 8 or 10 +** comparisons (on average) suffice to either locate a frame in the +** WAL or to establish that the frame does not exist in the WAL. This +** is much faster than scanning the entire 10MB WAL. +** +** Note that entries are added in order of increasing K. Hence, one +** reader might be using some value K0 and a second reader that started +** at a later time (after additional transactions were added to the WAL +** and to the wal-index) might be using a different value K1, where K1>K0. +** Both readers can use the same hash table and mapping section to get +** the correct result. There may be entries in the hash table with +** K>K0 but to the first reader, those entries will appear to be unused +** slots in the hash table and so the first reader will get an answer as +** if no values greater than K0 had ever been inserted into the hash table +** in the first place - which is what reader one wants. Meanwhile, the +** second reader using K1 will see additional values that were inserted +** later, which is exactly what reader two wants. +** +** When a rollback occurs, the value of K is decreased. Hash table entries +** that correspond to frames greater than the new K value are removed +** from the hash table at this point. +*/ +#ifndef SQLITE_OMIT_WAL + +/* #include "wal.h" */ + +/* +** Trace output macros +*/ +#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG) +SQLITE_PRIVATE int sqlite3WalTrace = 0; +# define WALTRACE(X) if(sqlite3WalTrace) sqlite3DebugPrintf X +#else +# define WALTRACE(X) +#endif + +/* +** The maximum (and only) versions of the wal and wal-index formats +** that may be interpreted by this version of SQLite. +** +** If a client begins recovering a WAL file and finds that (a) the checksum +** values in the wal-header are correct and (b) the version field is not +** WAL_MAX_VERSION, recovery fails and SQLite returns SQLITE_CANTOPEN. +** +** Similarly, if a client successfully reads a wal-index header (i.e. the +** checksum test is successful) and finds that the version field is not +** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite +** returns SQLITE_CANTOPEN. +*/ +#define WAL_MAX_VERSION 3007000 +#define WALINDEX_MAX_VERSION 3007000 + +/* +** Index numbers for various locking bytes. WAL_NREADER is the number +** of available reader locks and should be at least 3. The default +** is SQLITE_SHM_NLOCK==8 and WAL_NREADER==5. +** +** Technically, the various VFSes are free to implement these locks however +** they see fit. However, compatibility is encouraged so that VFSes can +** interoperate. The standard implemention used on both unix and windows +** is for the index number to indicate a byte offset into the +** WalCkptInfo.aLock[] array in the wal-index header. In other words, all +** locks are on the shm file. The WALINDEX_LOCK_OFFSET constant (which +** should be 120) is the location in the shm file for the first locking +** byte. +*/ +#define WAL_WRITE_LOCK 0 +#define WAL_ALL_BUT_WRITE 1 +#define WAL_CKPT_LOCK 1 +#define WAL_RECOVER_LOCK 2 +#define WAL_READ_LOCK(I) (3+(I)) +#define WAL_NREADER (SQLITE_SHM_NLOCK-3) + + +/* Object declarations */ +typedef struct WalIndexHdr WalIndexHdr; +typedef struct WalIterator WalIterator; +typedef struct WalCkptInfo WalCkptInfo; + + +/* +** The following object holds a copy of the wal-index header content. +** +** The actual header in the wal-index consists of two copies of this +** object followed by one instance of the WalCkptInfo object. +** For all versions of SQLite through 3.10.0 and probably beyond, +** the locking bytes (WalCkptInfo.aLock) start at offset 120 and +** the total header size is 136 bytes. +** +** The szPage value can be any power of 2 between 512 and 32768, inclusive. +** Or it can be 1 to represent a 65536-byte page. The latter case was +** added in 3.7.1 when support for 64K pages was added. +*/ +struct WalIndexHdr { + u32 iVersion; /* Wal-index version */ + u32 unused; /* Unused (padding) field */ + u32 iChange; /* Counter incremented each transaction */ + u8 isInit; /* 1 when initialized */ + u8 bigEndCksum; /* True if checksums in WAL are big-endian */ + u16 szPage; /* Database page size in bytes. 1==64K */ + u32 mxFrame; /* Index of last valid frame in the WAL */ + u32 nPage; /* Size of database in pages */ + u32 aFrameCksum[2]; /* Checksum of last frame in log */ + u32 aSalt[2]; /* Two salt values copied from WAL header */ + u32 aCksum[2]; /* Checksum over all prior fields */ +}; + +/* +** A copy of the following object occurs in the wal-index immediately +** following the second copy of the WalIndexHdr. This object stores +** information used by checkpoint. +** +** nBackfill is the number of frames in the WAL that have been written +** back into the database. (We call the act of moving content from WAL to +** database "backfilling".) The nBackfill number is never greater than +** WalIndexHdr.mxFrame. nBackfill can only be increased by threads +** holding the WAL_CKPT_LOCK lock (which includes a recovery thread). +** However, a WAL_WRITE_LOCK thread can move the value of nBackfill from +** mxFrame back to zero when the WAL is reset. +** +** nBackfillAttempted is the largest value of nBackfill that a checkpoint +** has attempted to achieve. Normally nBackfill==nBackfillAtempted, however +** the nBackfillAttempted is set before any backfilling is done and the +** nBackfill is only set after all backfilling completes. So if a checkpoint +** crashes, nBackfillAttempted might be larger than nBackfill. The +** WalIndexHdr.mxFrame must never be less than nBackfillAttempted. +** +** The aLock[] field is a set of bytes used for locking. These bytes should +** never be read or written. +** +** There is one entry in aReadMark[] for each reader lock. If a reader +** holds read-lock K, then the value in aReadMark[K] is no greater than +** the mxFrame for that reader. The value READMARK_NOT_USED (0xffffffff) +** for any aReadMark[] means that entry is unused. aReadMark[0] is +** a special case; its value is never used and it exists as a place-holder +** to avoid having to offset aReadMark[] indexs by one. Readers holding +** WAL_READ_LOCK(0) always ignore the entire WAL and read all content +** directly from the database. +** +** The value of aReadMark[K] may only be changed by a thread that +** is holding an exclusive lock on WAL_READ_LOCK(K). Thus, the value of +** aReadMark[K] cannot changed while there is a reader is using that mark +** since the reader will be holding a shared lock on WAL_READ_LOCK(K). +** +** The checkpointer may only transfer frames from WAL to database where +** the frame numbers are less than or equal to every aReadMark[] that is +** in use (that is, every aReadMark[j] for which there is a corresponding +** WAL_READ_LOCK(j)). New readers (usually) pick the aReadMark[] with the +** largest value and will increase an unused aReadMark[] to mxFrame if there +** is not already an aReadMark[] equal to mxFrame. The exception to the +** previous sentence is when nBackfill equals mxFrame (meaning that everything +** in the WAL has been backfilled into the database) then new readers +** will choose aReadMark[0] which has value 0 and hence such reader will +** get all their all content directly from the database file and ignore +** the WAL. +** +** Writers normally append new frames to the end of the WAL. However, +** if nBackfill equals mxFrame (meaning that all WAL content has been +** written back into the database) and if no readers are using the WAL +** (in other words, if there are no WAL_READ_LOCK(i) where i>0) then +** the writer will first "reset" the WAL back to the beginning and start +** writing new content beginning at frame 1. +** +** We assume that 32-bit loads are atomic and so no locks are needed in +** order to read from any aReadMark[] entries. +*/ +struct WalCkptInfo { + u32 nBackfill; /* Number of WAL frames backfilled into DB */ + u32 aReadMark[WAL_NREADER]; /* Reader marks */ + u8 aLock[SQLITE_SHM_NLOCK]; /* Reserved space for locks */ + u32 nBackfillAttempted; /* WAL frames perhaps written, or maybe not */ + u32 notUsed0; /* Available for future enhancements */ +}; +#define READMARK_NOT_USED 0xffffffff + + +/* A block of WALINDEX_LOCK_RESERVED bytes beginning at +** WALINDEX_LOCK_OFFSET is reserved for locks. Since some systems +** only support mandatory file-locks, we do not read or write data +** from the region of the file on which locks are applied. +*/ +#define WALINDEX_LOCK_OFFSET (sizeof(WalIndexHdr)*2+offsetof(WalCkptInfo,aLock)) +#define WALINDEX_HDR_SIZE (sizeof(WalIndexHdr)*2+sizeof(WalCkptInfo)) + +/* Size of header before each frame in wal */ +#define WAL_FRAME_HDRSIZE 24 + +/* Size of write ahead log header, including checksum. */ +#define WAL_HDRSIZE 32 + +/* WAL magic value. Either this value, or the same value with the least +** significant bit also set (WAL_MAGIC | 0x00000001) is stored in 32-bit +** big-endian format in the first 4 bytes of a WAL file. +** +** If the LSB is set, then the checksums for each frame within the WAL +** file are calculated by treating all data as an array of 32-bit +** big-endian words. Otherwise, they are calculated by interpreting +** all data as 32-bit little-endian words. +*/ +#define WAL_MAGIC 0x377f0682 + +/* +** Return the offset of frame iFrame in the write-ahead log file, +** assuming a database page size of szPage bytes. The offset returned +** is to the start of the write-ahead log frame-header. +*/ +#define walFrameOffset(iFrame, szPage) ( \ + WAL_HDRSIZE + ((iFrame)-1)*(i64)((szPage)+WAL_FRAME_HDRSIZE) \ +) + +/* +** An open write-ahead log file is represented by an instance of the +** following object. +*/ +struct Wal { + sqlite3_vfs *pVfs; /* The VFS used to create pDbFd */ + sqlite3_file *pDbFd; /* File handle for the database file */ + sqlite3_file *pWalFd; /* File handle for WAL file */ + u32 iCallback; /* Value to pass to log callback (or 0) */ + i64 mxWalSize; /* Truncate WAL to this size upon reset */ + int nWiData; /* Size of array apWiData */ + int szFirstBlock; /* Size of first block written to WAL file */ + volatile u32 **apWiData; /* Pointer to wal-index content in memory */ + u32 szPage; /* Database page size */ + i16 readLock; /* Which read lock is being held. -1 for none */ + u8 syncFlags; /* Flags to use to sync header writes */ + u8 exclusiveMode; /* Non-zero if connection is in exclusive mode */ + u8 writeLock; /* True if in a write transaction */ + u8 ckptLock; /* True if holding a checkpoint lock */ + u8 readOnly; /* WAL_RDWR, WAL_RDONLY, or WAL_SHM_RDONLY */ + u8 truncateOnCommit; /* True to truncate WAL file on commit */ + u8 syncHeader; /* Fsync the WAL header if true */ + u8 padToSectorBoundary; /* Pad transactions out to the next sector */ + u8 bShmUnreliable; /* SHM content is read-only and unreliable */ + WalIndexHdr hdr; /* Wal-index header for current transaction */ + u32 minFrame; /* Ignore wal frames before this one */ + u32 iReCksum; /* On commit, recalculate checksums from here */ + const char *zWalName; /* Name of WAL file */ + u32 nCkpt; /* Checkpoint sequence counter in the wal-header */ +#ifdef SQLITE_DEBUG + u8 lockError; /* True if a locking error has occurred */ +#endif +#ifdef SQLITE_ENABLE_SNAPSHOT + WalIndexHdr *pSnapshot; /* Start transaction here if not NULL */ +#endif +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + sqlite3 *db; +#endif +}; + +/* +** Candidate values for Wal.exclusiveMode. +*/ +#define WAL_NORMAL_MODE 0 +#define WAL_EXCLUSIVE_MODE 1 +#define WAL_HEAPMEMORY_MODE 2 + +/* +** Possible values for WAL.readOnly +*/ +#define WAL_RDWR 0 /* Normal read/write connection */ +#define WAL_RDONLY 1 /* The WAL file is readonly */ +#define WAL_SHM_RDONLY 2 /* The SHM file is readonly */ + +/* +** Each page of the wal-index mapping contains a hash-table made up of +** an array of HASHTABLE_NSLOT elements of the following type. +*/ +typedef u16 ht_slot; + +/* +** This structure is used to implement an iterator that loops through +** all frames in the WAL in database page order. Where two or more frames +** correspond to the same database page, the iterator visits only the +** frame most recently written to the WAL (in other words, the frame with +** the largest index). +** +** The internals of this structure are only accessed by: +** +** walIteratorInit() - Create a new iterator, +** walIteratorNext() - Step an iterator, +** walIteratorFree() - Free an iterator. +** +** This functionality is used by the checkpoint code (see walCheckpoint()). +*/ +struct WalIterator { + u32 iPrior; /* Last result returned from the iterator */ + int nSegment; /* Number of entries in aSegment[] */ + struct WalSegment { + int iNext; /* Next slot in aIndex[] not yet returned */ + ht_slot *aIndex; /* i0, i1, i2... such that aPgno[iN] ascend */ + u32 *aPgno; /* Array of page numbers. */ + int nEntry; /* Nr. of entries in aPgno[] and aIndex[] */ + int iZero; /* Frame number associated with aPgno[0] */ + } aSegment[1]; /* One for every 32KB page in the wal-index */ +}; + +/* +** Define the parameters of the hash tables in the wal-index file. There +** is a hash-table following every HASHTABLE_NPAGE page numbers in the +** wal-index. +** +** Changing any of these constants will alter the wal-index format and +** create incompatibilities. +*/ +#define HASHTABLE_NPAGE 4096 /* Must be power of 2 */ +#define HASHTABLE_HASH_1 383 /* Should be prime */ +#define HASHTABLE_NSLOT (HASHTABLE_NPAGE*2) /* Must be a power of 2 */ + +/* +** The block of page numbers associated with the first hash-table in a +** wal-index is smaller than usual. This is so that there is a complete +** hash-table on each aligned 32KB page of the wal-index. +*/ +#define HASHTABLE_NPAGE_ONE (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32))) + +/* The wal-index is divided into pages of WALINDEX_PGSZ bytes each. */ +#define WALINDEX_PGSZ ( \ + sizeof(ht_slot)*HASHTABLE_NSLOT + HASHTABLE_NPAGE*sizeof(u32) \ +) + +/* +** Obtain a pointer to the iPage'th page of the wal-index. The wal-index +** is broken into pages of WALINDEX_PGSZ bytes. Wal-index pages are +** numbered from zero. +** +** If the wal-index is currently smaller the iPage pages then the size +** of the wal-index might be increased, but only if it is safe to do +** so. It is safe to enlarge the wal-index if pWal->writeLock is true +** or pWal->exclusiveMode==WAL_HEAPMEMORY_MODE. +** +** If this call is successful, *ppPage is set to point to the wal-index +** page and SQLITE_OK is returned. If an error (an OOM or VFS error) occurs, +** then an SQLite error code is returned and *ppPage is set to 0. +*/ +static SQLITE_NOINLINE int walIndexPageRealloc( + Wal *pWal, /* The WAL context */ + int iPage, /* The page we seek */ + volatile u32 **ppPage /* Write the page pointer here */ +){ + int rc = SQLITE_OK; + + /* Enlarge the pWal->apWiData[] array if required */ + if( pWal->nWiData<=iPage ){ + sqlite3_int64 nByte = sizeof(u32*)*(iPage+1); + volatile u32 **apNew; + apNew = (volatile u32 **)sqlite3Realloc((void *)pWal->apWiData, nByte); + if( !apNew ){ + *ppPage = 0; + return SQLITE_NOMEM_BKPT; + } + memset((void*)&apNew[pWal->nWiData], 0, + sizeof(u32*)*(iPage+1-pWal->nWiData)); + pWal->apWiData = apNew; + pWal->nWiData = iPage+1; + } + + /* Request a pointer to the required page from the VFS */ + assert( pWal->apWiData[iPage]==0 ); + if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){ + pWal->apWiData[iPage] = (u32 volatile *)sqlite3MallocZero(WALINDEX_PGSZ); + if( !pWal->apWiData[iPage] ) rc = SQLITE_NOMEM_BKPT; + }else{ + rc = sqlite3OsShmMap(pWal->pDbFd, iPage, WALINDEX_PGSZ, + pWal->writeLock, (void volatile **)&pWal->apWiData[iPage] + ); + assert( pWal->apWiData[iPage]!=0 || rc!=SQLITE_OK || pWal->writeLock==0 ); + testcase( pWal->apWiData[iPage]==0 && rc==SQLITE_OK ); + if( rc==SQLITE_OK ){ + if( iPage>0 && sqlite3FaultSim(600) ) rc = SQLITE_NOMEM; + }else if( (rc&0xff)==SQLITE_READONLY ){ + pWal->readOnly |= WAL_SHM_RDONLY; + if( rc==SQLITE_READONLY ){ + rc = SQLITE_OK; + } + } + } + + *ppPage = pWal->apWiData[iPage]; + assert( iPage==0 || *ppPage || rc!=SQLITE_OK ); + return rc; +} +static int walIndexPage( + Wal *pWal, /* The WAL context */ + int iPage, /* The page we seek */ + volatile u32 **ppPage /* Write the page pointer here */ +){ + if( pWal->nWiData<=iPage || (*ppPage = pWal->apWiData[iPage])==0 ){ + return walIndexPageRealloc(pWal, iPage, ppPage); + } + return SQLITE_OK; +} + +/* +** Return a pointer to the WalCkptInfo structure in the wal-index. +*/ +static volatile WalCkptInfo *walCkptInfo(Wal *pWal){ + assert( pWal->nWiData>0 && pWal->apWiData[0] ); + return (volatile WalCkptInfo*)&(pWal->apWiData[0][sizeof(WalIndexHdr)/2]); +} + +/* +** Return a pointer to the WalIndexHdr structure in the wal-index. +*/ +static volatile WalIndexHdr *walIndexHdr(Wal *pWal){ + assert( pWal->nWiData>0 && pWal->apWiData[0] ); + return (volatile WalIndexHdr*)pWal->apWiData[0]; +} + +/* +** The argument to this macro must be of type u32. On a little-endian +** architecture, it returns the u32 value that results from interpreting +** the 4 bytes as a big-endian value. On a big-endian architecture, it +** returns the value that would be produced by interpreting the 4 bytes +** of the input value as a little-endian integer. +*/ +#define BYTESWAP32(x) ( \ + (((x)&0x000000FF)<<24) + (((x)&0x0000FF00)<<8) \ + + (((x)&0x00FF0000)>>8) + (((x)&0xFF000000)>>24) \ +) + +/* +** Generate or extend an 8 byte checksum based on the data in +** array aByte[] and the initial values of aIn[0] and aIn[1] (or +** initial values of 0 and 0 if aIn==NULL). +** +** The checksum is written back into aOut[] before returning. +** +** nByte must be a positive multiple of 8. +*/ +static void walChecksumBytes( + int nativeCksum, /* True for native byte-order, false for non-native */ + u8 *a, /* Content to be checksummed */ + int nByte, /* Bytes of content in a[]. Must be a multiple of 8. */ + const u32 *aIn, /* Initial checksum value input */ + u32 *aOut /* OUT: Final checksum value output */ +){ + u32 s1, s2; + u32 *aData = (u32 *)a; + u32 *aEnd = (u32 *)&a[nByte]; + + if( aIn ){ + s1 = aIn[0]; + s2 = aIn[1]; + }else{ + s1 = s2 = 0; + } + + assert( nByte>=8 ); + assert( (nByte&0x00000007)==0 ); + assert( nByte<=65536 ); + + if( nativeCksum ){ + do { + s1 += *aData++ + s2; + s2 += *aData++ + s1; + }while( aDataexclusiveMode!=WAL_HEAPMEMORY_MODE ){ + sqlite3OsShmBarrier(pWal->pDbFd); + } +} + +/* +** Add the SQLITE_NO_TSAN as part of the return-type of a function +** definition as a hint that the function contains constructs that +** might give false-positive TSAN warnings. +** +** See tag-20200519-1. +*/ +#if defined(__clang__) && !defined(SQLITE_NO_TSAN) +# define SQLITE_NO_TSAN __attribute__((no_sanitize_thread)) +#else +# define SQLITE_NO_TSAN +#endif + +/* +** Write the header information in pWal->hdr into the wal-index. +** +** The checksum on pWal->hdr is updated before it is written. +*/ +static SQLITE_NO_TSAN void walIndexWriteHdr(Wal *pWal){ + volatile WalIndexHdr *aHdr = walIndexHdr(pWal); + const int nCksum = offsetof(WalIndexHdr, aCksum); + + assert( pWal->writeLock ); + pWal->hdr.isInit = 1; + pWal->hdr.iVersion = WALINDEX_MAX_VERSION; + walChecksumBytes(1, (u8*)&pWal->hdr, nCksum, 0, pWal->hdr.aCksum); + /* Possible TSAN false-positive. See tag-20200519-1 */ + memcpy((void*)&aHdr[1], (const void*)&pWal->hdr, sizeof(WalIndexHdr)); + walShmBarrier(pWal); + memcpy((void*)&aHdr[0], (const void*)&pWal->hdr, sizeof(WalIndexHdr)); +} + +/* +** This function encodes a single frame header and writes it to a buffer +** supplied by the caller. A frame-header is made up of a series of +** 4-byte big-endian integers, as follows: +** +** 0: Page number. +** 4: For commit records, the size of the database image in pages +** after the commit. For all other records, zero. +** 8: Salt-1 (copied from the wal-header) +** 12: Salt-2 (copied from the wal-header) +** 16: Checksum-1. +** 20: Checksum-2. +*/ +static void walEncodeFrame( + Wal *pWal, /* The write-ahead log */ + u32 iPage, /* Database page number for frame */ + u32 nTruncate, /* New db size (or 0 for non-commit frames) */ + u8 *aData, /* Pointer to page data */ + u8 *aFrame /* OUT: Write encoded frame here */ +){ + int nativeCksum; /* True for native byte-order checksums */ + u32 *aCksum = pWal->hdr.aFrameCksum; + assert( WAL_FRAME_HDRSIZE==24 ); + sqlite3Put4byte(&aFrame[0], iPage); + sqlite3Put4byte(&aFrame[4], nTruncate); + if( pWal->iReCksum==0 ){ + memcpy(&aFrame[8], pWal->hdr.aSalt, 8); + + nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN); + walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum); + walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum); + + sqlite3Put4byte(&aFrame[16], aCksum[0]); + sqlite3Put4byte(&aFrame[20], aCksum[1]); + }else{ + memset(&aFrame[8], 0, 16); + } +} + +/* +** Check to see if the frame with header in aFrame[] and content +** in aData[] is valid. If it is a valid frame, fill *piPage and +** *pnTruncate and return true. Return if the frame is not valid. +*/ +static int walDecodeFrame( + Wal *pWal, /* The write-ahead log */ + u32 *piPage, /* OUT: Database page number for frame */ + u32 *pnTruncate, /* OUT: New db size (or 0 if not commit) */ + u8 *aData, /* Pointer to page data (for checksum) */ + u8 *aFrame /* Frame data */ +){ + int nativeCksum; /* True for native byte-order checksums */ + u32 *aCksum = pWal->hdr.aFrameCksum; + u32 pgno; /* Page number of the frame */ + assert( WAL_FRAME_HDRSIZE==24 ); + + /* A frame is only valid if the salt values in the frame-header + ** match the salt values in the wal-header. + */ + if( memcmp(&pWal->hdr.aSalt, &aFrame[8], 8)!=0 ){ + return 0; + } + + /* A frame is only valid if the page number is creater than zero. + */ + pgno = sqlite3Get4byte(&aFrame[0]); + if( pgno==0 ){ + return 0; + } + + /* A frame is only valid if a checksum of the WAL header, + ** all prior frams, the first 16 bytes of this frame-header, + ** and the frame-data matches the checksum in the last 8 + ** bytes of this frame-header. + */ + nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN); + walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum); + walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum); + if( aCksum[0]!=sqlite3Get4byte(&aFrame[16]) + || aCksum[1]!=sqlite3Get4byte(&aFrame[20]) + ){ + /* Checksum failed. */ + return 0; + } + + /* If we reach this point, the frame is valid. Return the page number + ** and the new database size. + */ + *piPage = pgno; + *pnTruncate = sqlite3Get4byte(&aFrame[4]); + return 1; +} + + +#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG) +/* +** Names of locks. This routine is used to provide debugging output and is not +** a part of an ordinary build. +*/ +static const char *walLockName(int lockIdx){ + if( lockIdx==WAL_WRITE_LOCK ){ + return "WRITE-LOCK"; + }else if( lockIdx==WAL_CKPT_LOCK ){ + return "CKPT-LOCK"; + }else if( lockIdx==WAL_RECOVER_LOCK ){ + return "RECOVER-LOCK"; + }else{ + static char zName[15]; + sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]", + lockIdx-WAL_READ_LOCK(0)); + return zName; + } +} +#endif /*defined(SQLITE_TEST) || defined(SQLITE_DEBUG) */ + + +/* +** Set or release locks on the WAL. Locks are either shared or exclusive. +** A lock cannot be moved directly between shared and exclusive - it must go +** through the unlocked state first. +** +** In locking_mode=EXCLUSIVE, all of these routines become no-ops. +*/ +static int walLockShared(Wal *pWal, int lockIdx){ + int rc; + if( pWal->exclusiveMode ) return SQLITE_OK; + rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1, + SQLITE_SHM_LOCK | SQLITE_SHM_SHARED); + WALTRACE(("WAL%p: acquire SHARED-%s %s\n", pWal, + walLockName(lockIdx), rc ? "failed" : "ok")); + VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && (rc&0xFF)!=SQLITE_BUSY); ) + return rc; +} +static void walUnlockShared(Wal *pWal, int lockIdx){ + if( pWal->exclusiveMode ) return; + (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1, + SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED); + WALTRACE(("WAL%p: release SHARED-%s\n", pWal, walLockName(lockIdx))); +} +static int walLockExclusive(Wal *pWal, int lockIdx, int n){ + int rc; + if( pWal->exclusiveMode ) return SQLITE_OK; + rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, n, + SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE); + WALTRACE(("WAL%p: acquire EXCLUSIVE-%s cnt=%d %s\n", pWal, + walLockName(lockIdx), n, rc ? "failed" : "ok")); + VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && (rc&0xFF)!=SQLITE_BUSY); ) + return rc; +} +static void walUnlockExclusive(Wal *pWal, int lockIdx, int n){ + if( pWal->exclusiveMode ) return; + (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, n, + SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE); + WALTRACE(("WAL%p: release EXCLUSIVE-%s cnt=%d\n", pWal, + walLockName(lockIdx), n)); +} + +/* +** Compute a hash on a page number. The resulting hash value must land +** between 0 and (HASHTABLE_NSLOT-1). The walHashNext() function advances +** the hash to the next value in the event of a collision. +*/ +static int walHash(u32 iPage){ + assert( iPage>0 ); + assert( (HASHTABLE_NSLOT & (HASHTABLE_NSLOT-1))==0 ); + return (iPage*HASHTABLE_HASH_1) & (HASHTABLE_NSLOT-1); +} +static int walNextHash(int iPriorHash){ + return (iPriorHash+1)&(HASHTABLE_NSLOT-1); +} + +/* +** An instance of the WalHashLoc object is used to describe the location +** of a page hash table in the wal-index. This becomes the return value +** from walHashGet(). +*/ +typedef struct WalHashLoc WalHashLoc; +struct WalHashLoc { + volatile ht_slot *aHash; /* Start of the wal-index hash table */ + volatile u32 *aPgno; /* aPgno[1] is the page of first frame indexed */ + u32 iZero; /* One less than the frame number of first indexed*/ +}; + +/* +** Return pointers to the hash table and page number array stored on +** page iHash of the wal-index. The wal-index is broken into 32KB pages +** numbered starting from 0. +** +** Set output variable pLoc->aHash to point to the start of the hash table +** in the wal-index file. Set pLoc->iZero to one less than the frame +** number of the first frame indexed by this hash table. If a +** slot in the hash table is set to N, it refers to frame number +** (pLoc->iZero+N) in the log. +** +** Finally, set pLoc->aPgno so that pLoc->aPgno[1] is the page number of the +** first frame indexed by the hash table, frame (pLoc->iZero+1). +*/ +static int walHashGet( + Wal *pWal, /* WAL handle */ + int iHash, /* Find the iHash'th table */ + WalHashLoc *pLoc /* OUT: Hash table location */ +){ + int rc; /* Return code */ + + rc = walIndexPage(pWal, iHash, &pLoc->aPgno); + assert( rc==SQLITE_OK || iHash>0 ); + + if( rc==SQLITE_OK ){ + pLoc->aHash = (volatile ht_slot *)&pLoc->aPgno[HASHTABLE_NPAGE]; + if( iHash==0 ){ + pLoc->aPgno = &pLoc->aPgno[WALINDEX_HDR_SIZE/sizeof(u32)]; + pLoc->iZero = 0; + }else{ + pLoc->iZero = HASHTABLE_NPAGE_ONE + (iHash-1)*HASHTABLE_NPAGE; + } + pLoc->aPgno = &pLoc->aPgno[-1]; + } + return rc; +} + +/* +** Return the number of the wal-index page that contains the hash-table +** and page-number array that contain entries corresponding to WAL frame +** iFrame. The wal-index is broken up into 32KB pages. Wal-index pages +** are numbered starting from 0. +*/ +static int walFramePage(u32 iFrame){ + int iHash = (iFrame+HASHTABLE_NPAGE-HASHTABLE_NPAGE_ONE-1) / HASHTABLE_NPAGE; + assert( (iHash==0 || iFrame>HASHTABLE_NPAGE_ONE) + && (iHash>=1 || iFrame<=HASHTABLE_NPAGE_ONE) + && (iHash<=1 || iFrame>(HASHTABLE_NPAGE_ONE+HASHTABLE_NPAGE)) + && (iHash>=2 || iFrame<=HASHTABLE_NPAGE_ONE+HASHTABLE_NPAGE) + && (iHash<=2 || iFrame>(HASHTABLE_NPAGE_ONE+2*HASHTABLE_NPAGE)) + ); + assert( iHash>=0 ); + return iHash; +} + +/* +** Return the page number associated with frame iFrame in this WAL. +*/ +static u32 walFramePgno(Wal *pWal, u32 iFrame){ + int iHash = walFramePage(iFrame); + if( iHash==0 ){ + return pWal->apWiData[0][WALINDEX_HDR_SIZE/sizeof(u32) + iFrame - 1]; + } + return pWal->apWiData[iHash][(iFrame-1-HASHTABLE_NPAGE_ONE)%HASHTABLE_NPAGE]; +} + +/* +** Remove entries from the hash table that point to WAL slots greater +** than pWal->hdr.mxFrame. +** +** This function is called whenever pWal->hdr.mxFrame is decreased due +** to a rollback or savepoint. +** +** At most only the hash table containing pWal->hdr.mxFrame needs to be +** updated. Any later hash tables will be automatically cleared when +** pWal->hdr.mxFrame advances to the point where those hash tables are +** actually needed. +*/ +static void walCleanupHash(Wal *pWal){ + WalHashLoc sLoc; /* Hash table location */ + int iLimit = 0; /* Zero values greater than this */ + int nByte; /* Number of bytes to zero in aPgno[] */ + int i; /* Used to iterate through aHash[] */ + int rc; /* Return code form walHashGet() */ + + assert( pWal->writeLock ); + testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 ); + testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE ); + testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE+1 ); + + if( pWal->hdr.mxFrame==0 ) return; + + /* Obtain pointers to the hash-table and page-number array containing + ** the entry that corresponds to frame pWal->hdr.mxFrame. It is guaranteed + ** that the page said hash-table and array reside on is already mapped.(1) + */ + assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) ); + assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] ); + rc = walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &sLoc); + if( NEVER(rc) ) return; /* Defense-in-depth, in case (1) above is wrong */ + + /* Zero all hash-table entries that correspond to frame numbers greater + ** than pWal->hdr.mxFrame. + */ + iLimit = pWal->hdr.mxFrame - sLoc.iZero; + assert( iLimit>0 ); + for(i=0; iiLimit ){ + sLoc.aHash[i] = 0; + } + } + + /* Zero the entries in the aPgno array that correspond to frames with + ** frame numbers greater than pWal->hdr.mxFrame. + */ + nByte = (int)((char *)sLoc.aHash - (char *)&sLoc.aPgno[iLimit+1]); + memset((void *)&sLoc.aPgno[iLimit+1], 0, nByte); + +#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT + /* Verify that the every entry in the mapping region is still reachable + ** via the hash table even after the cleanup. + */ + if( iLimit ){ + int j; /* Loop counter */ + int iKey; /* Hash key */ + for(j=1; j<=iLimit; j++){ + for(iKey=walHash(sLoc.aPgno[j]);sLoc.aHash[iKey];iKey=walNextHash(iKey)){ + if( sLoc.aHash[iKey]==j ) break; + } + assert( sLoc.aHash[iKey]==j ); + } + } +#endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */ +} + + +/* +** Set an entry in the wal-index that will map database page number +** pPage into WAL frame iFrame. +*/ +static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){ + int rc; /* Return code */ + WalHashLoc sLoc; /* Wal-index hash table location */ + + rc = walHashGet(pWal, walFramePage(iFrame), &sLoc); + + /* Assuming the wal-index file was successfully mapped, populate the + ** page number array and hash table entry. + */ + if( rc==SQLITE_OK ){ + int iKey; /* Hash table key */ + int idx; /* Value to write to hash-table slot */ + int nCollide; /* Number of hash collisions */ + + idx = iFrame - sLoc.iZero; + assert( idx <= HASHTABLE_NSLOT/2 + 1 ); + + /* If this is the first entry to be added to this hash-table, zero the + ** entire hash table and aPgno[] array before proceeding. + */ + if( idx==1 ){ + int nByte = (int)((u8 *)&sLoc.aHash[HASHTABLE_NSLOT] + - (u8 *)&sLoc.aPgno[1]); + memset((void*)&sLoc.aPgno[1], 0, nByte); + } + + /* If the entry in aPgno[] is already set, then the previous writer + ** must have exited unexpectedly in the middle of a transaction (after + ** writing one or more dirty pages to the WAL to free up memory). + ** Remove the remnants of that writers uncommitted transaction from + ** the hash-table before writing any new entries. + */ + if( sLoc.aPgno[idx] ){ + walCleanupHash(pWal); + assert( !sLoc.aPgno[idx] ); + } + + /* Write the aPgno[] array entry and the hash-table slot. */ + nCollide = idx; + for(iKey=walHash(iPage); sLoc.aHash[iKey]; iKey=walNextHash(iKey)){ + if( (nCollide--)==0 ) return SQLITE_CORRUPT_BKPT; + } + sLoc.aPgno[idx] = iPage; + AtomicStore(&sLoc.aHash[iKey], (ht_slot)idx); + +#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT + /* Verify that the number of entries in the hash table exactly equals + ** the number of entries in the mapping region. + */ + { + int i; /* Loop counter */ + int nEntry = 0; /* Number of entries in the hash table */ + for(i=0; ickptLock==1 || pWal->ckptLock==0 ); + assert( WAL_ALL_BUT_WRITE==WAL_WRITE_LOCK+1 ); + assert( WAL_CKPT_LOCK==WAL_ALL_BUT_WRITE ); + assert( pWal->writeLock ); + iLock = WAL_ALL_BUT_WRITE + pWal->ckptLock; + rc = walLockExclusive(pWal, iLock, WAL_READ_LOCK(0)-iLock); + if( rc ){ + return rc; + } + + WALTRACE(("WAL%p: recovery begin...\n", pWal)); + + memset(&pWal->hdr, 0, sizeof(WalIndexHdr)); + + rc = sqlite3OsFileSize(pWal->pWalFd, &nSize); + if( rc!=SQLITE_OK ){ + goto recovery_error; + } + + if( nSize>WAL_HDRSIZE ){ + u8 aBuf[WAL_HDRSIZE]; /* Buffer to load WAL header into */ + u32 *aPrivate = 0; /* Heap copy of *-shm hash being populated */ + u8 *aFrame = 0; /* Malloc'd buffer to load entire frame */ + int szFrame; /* Number of bytes in buffer aFrame[] */ + u8 *aData; /* Pointer to data part of aFrame buffer */ + int szPage; /* Page size according to the log */ + u32 magic; /* Magic value read from WAL header */ + u32 version; /* Magic value read from WAL header */ + int isValid; /* True if this frame is valid */ + u32 iPg; /* Current 32KB wal-index page */ + u32 iLastFrame; /* Last frame in wal, based on nSize alone */ + + /* Read in the WAL header. */ + rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0); + if( rc!=SQLITE_OK ){ + goto recovery_error; + } + + /* If the database page size is not a power of two, or is greater than + ** SQLITE_MAX_PAGE_SIZE, conclude that the WAL file contains no valid + ** data. Similarly, if the 'magic' value is invalid, ignore the whole + ** WAL file. + */ + magic = sqlite3Get4byte(&aBuf[0]); + szPage = sqlite3Get4byte(&aBuf[8]); + if( (magic&0xFFFFFFFE)!=WAL_MAGIC + || szPage&(szPage-1) + || szPage>SQLITE_MAX_PAGE_SIZE + || szPage<512 + ){ + goto finished; + } + pWal->hdr.bigEndCksum = (u8)(magic&0x00000001); + pWal->szPage = szPage; + pWal->nCkpt = sqlite3Get4byte(&aBuf[12]); + memcpy(&pWal->hdr.aSalt, &aBuf[16], 8); + + /* Verify that the WAL header checksum is correct */ + walChecksumBytes(pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN, + aBuf, WAL_HDRSIZE-2*4, 0, pWal->hdr.aFrameCksum + ); + if( pWal->hdr.aFrameCksum[0]!=sqlite3Get4byte(&aBuf[24]) + || pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[28]) + ){ + goto finished; + } + + /* Verify that the version number on the WAL format is one that + ** are able to understand */ + version = sqlite3Get4byte(&aBuf[4]); + if( version!=WAL_MAX_VERSION ){ + rc = SQLITE_CANTOPEN_BKPT; + goto finished; + } + + /* Malloc a buffer to read frames into. */ + szFrame = szPage + WAL_FRAME_HDRSIZE; + aFrame = (u8 *)sqlite3_malloc64(szFrame + WALINDEX_PGSZ); + if( !aFrame ){ + rc = SQLITE_NOMEM_BKPT; + goto recovery_error; + } + aData = &aFrame[WAL_FRAME_HDRSIZE]; + aPrivate = (u32*)&aData[szPage]; + + /* Read all frames from the log file. */ + iLastFrame = (nSize - WAL_HDRSIZE) / szFrame; + for(iPg=0; iPg<=(u32)walFramePage(iLastFrame); iPg++){ + u32 *aShare; + u32 iFrame; /* Index of last frame read */ + u32 iLast = MIN(iLastFrame, HASHTABLE_NPAGE_ONE+iPg*HASHTABLE_NPAGE); + u32 iFirst = 1 + (iPg==0?0:HASHTABLE_NPAGE_ONE+(iPg-1)*HASHTABLE_NPAGE); + u32 nHdr, nHdr32; + rc = walIndexPage(pWal, iPg, (volatile u32**)&aShare); + if( rc ) break; + pWal->apWiData[iPg] = aPrivate; + + for(iFrame=iFirst; iFrame<=iLast; iFrame++){ + i64 iOffset = walFrameOffset(iFrame, szPage); + u32 pgno; /* Database page number for frame */ + u32 nTruncate; /* dbsize field from frame header */ + + /* Read and decode the next log frame. */ + rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset); + if( rc!=SQLITE_OK ) break; + isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame); + if( !isValid ) break; + rc = walIndexAppend(pWal, iFrame, pgno); + if( NEVER(rc!=SQLITE_OK) ) break; + + /* If nTruncate is non-zero, this is a commit record. */ + if( nTruncate ){ + pWal->hdr.mxFrame = iFrame; + pWal->hdr.nPage = nTruncate; + pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16)); + testcase( szPage<=32768 ); + testcase( szPage>=65536 ); + aFrameCksum[0] = pWal->hdr.aFrameCksum[0]; + aFrameCksum[1] = pWal->hdr.aFrameCksum[1]; + } + } + pWal->apWiData[iPg] = aShare; + nHdr = (iPg==0 ? WALINDEX_HDR_SIZE : 0); + nHdr32 = nHdr / sizeof(u32); +#ifndef SQLITE_SAFER_WALINDEX_RECOVERY + /* Memcpy() should work fine here, on all reasonable implementations. + ** Technically, memcpy() might change the destination to some + ** intermediate value before setting to the final value, and that might + ** cause a concurrent reader to malfunction. Memcpy() is allowed to + ** do that, according to the spec, but no memcpy() implementation that + ** we know of actually does that, which is why we say that memcpy() + ** is safe for this. Memcpy() is certainly a lot faster. + */ + memcpy(&aShare[nHdr32], &aPrivate[nHdr32], WALINDEX_PGSZ-nHdr); +#else + /* In the event that some platform is found for which memcpy() + ** changes the destination to some intermediate value before + ** setting the final value, this alternative copy routine is + ** provided. + */ + { + int i; + for(i=nHdr32; ihdr.aFrameCksum[0] = aFrameCksum[0]; + pWal->hdr.aFrameCksum[1] = aFrameCksum[1]; + walIndexWriteHdr(pWal); + + /* Reset the checkpoint-header. This is safe because this thread is + ** currently holding locks that exclude all other writers and + ** checkpointers. Then set the values of read-mark slots 1 through N. + */ + pInfo = walCkptInfo(pWal); + pInfo->nBackfill = 0; + pInfo->nBackfillAttempted = pWal->hdr.mxFrame; + pInfo->aReadMark[0] = 0; + for(i=1; ihdr.mxFrame ){ + pInfo->aReadMark[i] = pWal->hdr.mxFrame; + }else{ + pInfo->aReadMark[i] = READMARK_NOT_USED; + } + walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1); + }else if( rc!=SQLITE_BUSY ){ + goto recovery_error; + } + } + + /* If more than one frame was recovered from the log file, report an + ** event via sqlite3_log(). This is to help with identifying performance + ** problems caused by applications routinely shutting down without + ** checkpointing the log file. + */ + if( pWal->hdr.nPage ){ + sqlite3_log(SQLITE_NOTICE_RECOVER_WAL, + "recovered %d frames from WAL file %s", + pWal->hdr.mxFrame, pWal->zWalName + ); + } + } + +recovery_error: + WALTRACE(("WAL%p: recovery %s\n", pWal, rc ? "failed" : "ok")); + walUnlockExclusive(pWal, iLock, WAL_READ_LOCK(0)-iLock); + return rc; +} + +/* +** Close an open wal-index. +*/ +static void walIndexClose(Wal *pWal, int isDelete){ + if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE || pWal->bShmUnreliable ){ + int i; + for(i=0; inWiData; i++){ + sqlite3_free((void *)pWal->apWiData[i]); + pWal->apWiData[i] = 0; + } + } + if( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE ){ + sqlite3OsShmUnmap(pWal->pDbFd, isDelete); + } +} + +/* +** Open a connection to the WAL file zWalName. The database file must +** already be opened on connection pDbFd. The buffer that zWalName points +** to must remain valid for the lifetime of the returned Wal* handle. +** +** A SHARED lock should be held on the database file when this function +** is called. The purpose of this SHARED lock is to prevent any other +** client from unlinking the WAL or wal-index file. If another process +** were to do this just after this client opened one of these files, the +** system would be badly broken. +** +** If the log file is successfully opened, SQLITE_OK is returned and +** *ppWal is set to point to a new WAL handle. If an error occurs, +** an SQLite error code is returned and *ppWal is left unmodified. +*/ +SQLITE_PRIVATE int sqlite3WalOpen( + sqlite3_vfs *pVfs, /* vfs module to open wal and wal-index */ + sqlite3_file *pDbFd, /* The open database file */ + const char *zWalName, /* Name of the WAL file */ + int bNoShm, /* True to run in heap-memory mode */ + i64 mxWalSize, /* Truncate WAL to this size on reset */ + Wal **ppWal /* OUT: Allocated Wal handle */ +){ + int rc; /* Return Code */ + Wal *pRet; /* Object to allocate and return */ + int flags; /* Flags passed to OsOpen() */ + + assert( zWalName && zWalName[0] ); + assert( pDbFd ); + + /* In the amalgamation, the os_unix.c and os_win.c source files come before + ** this source file. Verify that the #defines of the locking byte offsets + ** in os_unix.c and os_win.c agree with the WALINDEX_LOCK_OFFSET value. + ** For that matter, if the lock offset ever changes from its initial design + ** value of 120, we need to know that so there is an assert() to check it. + */ + assert( 120==WALINDEX_LOCK_OFFSET ); + assert( 136==WALINDEX_HDR_SIZE ); +#ifdef WIN_SHM_BASE + assert( WIN_SHM_BASE==WALINDEX_LOCK_OFFSET ); +#endif +#ifdef UNIX_SHM_BASE + assert( UNIX_SHM_BASE==WALINDEX_LOCK_OFFSET ); +#endif + + + /* Allocate an instance of struct Wal to return. */ + *ppWal = 0; + pRet = (Wal*)sqlite3MallocZero(sizeof(Wal) + pVfs->szOsFile); + if( !pRet ){ + return SQLITE_NOMEM_BKPT; + } + + pRet->pVfs = pVfs; + pRet->pWalFd = (sqlite3_file *)&pRet[1]; + pRet->pDbFd = pDbFd; + pRet->readLock = -1; + pRet->mxWalSize = mxWalSize; + pRet->zWalName = zWalName; + pRet->syncHeader = 1; + pRet->padToSectorBoundary = 1; + pRet->exclusiveMode = (bNoShm ? WAL_HEAPMEMORY_MODE: WAL_NORMAL_MODE); + + /* Open file handle on the write-ahead log file. */ + flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_WAL); + rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags); + if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){ + pRet->readOnly = WAL_RDONLY; + } + + if( rc!=SQLITE_OK ){ + walIndexClose(pRet, 0); + sqlite3OsClose(pRet->pWalFd); + sqlite3_free(pRet); + }else{ + int iDC = sqlite3OsDeviceCharacteristics(pDbFd); + if( iDC & SQLITE_IOCAP_SEQUENTIAL ){ pRet->syncHeader = 0; } + if( iDC & SQLITE_IOCAP_POWERSAFE_OVERWRITE ){ + pRet->padToSectorBoundary = 0; + } + *ppWal = pRet; + WALTRACE(("WAL%d: opened\n", pRet)); + } + return rc; +} + +/* +** Change the size to which the WAL file is trucated on each reset. +*/ +SQLITE_PRIVATE void sqlite3WalLimit(Wal *pWal, i64 iLimit){ + if( pWal ) pWal->mxWalSize = iLimit; +} + +/* +** Find the smallest page number out of all pages held in the WAL that +** has not been returned by any prior invocation of this method on the +** same WalIterator object. Write into *piFrame the frame index where +** that page was last written into the WAL. Write into *piPage the page +** number. +** +** Return 0 on success. If there are no pages in the WAL with a page +** number larger than *piPage, then return 1. +*/ +static int walIteratorNext( + WalIterator *p, /* Iterator */ + u32 *piPage, /* OUT: The page number of the next page */ + u32 *piFrame /* OUT: Wal frame index of next page */ +){ + u32 iMin; /* Result pgno must be greater than iMin */ + u32 iRet = 0xFFFFFFFF; /* 0xffffffff is never a valid page number */ + int i; /* For looping through segments */ + + iMin = p->iPrior; + assert( iMin<0xffffffff ); + for(i=p->nSegment-1; i>=0; i--){ + struct WalSegment *pSegment = &p->aSegment[i]; + while( pSegment->iNextnEntry ){ + u32 iPg = pSegment->aPgno[pSegment->aIndex[pSegment->iNext]]; + if( iPg>iMin ){ + if( iPgiZero + pSegment->aIndex[pSegment->iNext]; + } + break; + } + pSegment->iNext++; + } + } + + *piPage = p->iPrior = iRet; + return (iRet==0xFFFFFFFF); +} + +/* +** This function merges two sorted lists into a single sorted list. +** +** aLeft[] and aRight[] are arrays of indices. The sort key is +** aContent[aLeft[]] and aContent[aRight[]]. Upon entry, the following +** is guaranteed for all J0 && nRight>0 ); + while( iRight=nRight || aContent[aLeft[iLeft]]=nLeft || aContent[aLeft[iLeft]]>dbpage ); + assert( iRight>=nRight || aContent[aRight[iRight]]>dbpage ); + } + + *paRight = aLeft; + *pnRight = iOut; + memcpy(aLeft, aTmp, sizeof(aTmp[0])*iOut); +} + +/* +** Sort the elements in list aList using aContent[] as the sort key. +** Remove elements with duplicate keys, preferring to keep the +** larger aList[] values. +** +** The aList[] entries are indices into aContent[]. The values in +** aList[] are to be sorted so that for all J0 ); + assert( HASHTABLE_NPAGE==(1<<(ArraySize(aSub)-1)) ); + + for(iList=0; iListaList && p->nList<=(1<aList==&aList[iList&~((2<aList, p->nList, &aMerge, &nMerge, aBuffer); + } + aSub[iSub].aList = aMerge; + aSub[iSub].nList = nMerge; + } + + for(iSub++; iSubnList<=(1<aList==&aList[nList&~((2<aList, p->nList, &aMerge, &nMerge, aBuffer); + } + } + assert( aMerge==aList ); + *pnList = nMerge; + +#ifdef SQLITE_DEBUG + { + int i; + for(i=1; i<*pnList; i++){ + assert( aContent[aList[i]] > aContent[aList[i-1]] ); + } + } +#endif +} + +/* +** Free an iterator allocated by walIteratorInit(). +*/ +static void walIteratorFree(WalIterator *p){ + sqlite3_free(p); +} + +/* +** Construct a WalInterator object that can be used to loop over all +** pages in the WAL following frame nBackfill in ascending order. Frames +** nBackfill or earlier may be included - excluding them is an optimization +** only. The caller must hold the checkpoint lock. +** +** On success, make *pp point to the newly allocated WalInterator object +** return SQLITE_OK. Otherwise, return an error code. If this routine +** returns an error, the value of *pp is undefined. +** +** The calling routine should invoke walIteratorFree() to destroy the +** WalIterator object when it has finished with it. +*/ +static int walIteratorInit(Wal *pWal, u32 nBackfill, WalIterator **pp){ + WalIterator *p; /* Return value */ + int nSegment; /* Number of segments to merge */ + u32 iLast; /* Last frame in log */ + sqlite3_int64 nByte; /* Number of bytes to allocate */ + int i; /* Iterator variable */ + ht_slot *aTmp; /* Temp space used by merge-sort */ + int rc = SQLITE_OK; /* Return Code */ + + /* This routine only runs while holding the checkpoint lock. And + ** it only runs if there is actually content in the log (mxFrame>0). + */ + assert( pWal->ckptLock && pWal->hdr.mxFrame>0 ); + iLast = pWal->hdr.mxFrame; + + /* Allocate space for the WalIterator object. */ + nSegment = walFramePage(iLast) + 1; + nByte = sizeof(WalIterator) + + (nSegment-1)*sizeof(struct WalSegment) + + iLast*sizeof(ht_slot); + p = (WalIterator *)sqlite3_malloc64(nByte); + if( !p ){ + return SQLITE_NOMEM_BKPT; + } + memset(p, 0, nByte); + p->nSegment = nSegment; + + /* Allocate temporary space used by the merge-sort routine. This block + ** of memory will be freed before this function returns. + */ + aTmp = (ht_slot *)sqlite3_malloc64( + sizeof(ht_slot) * (iLast>HASHTABLE_NPAGE?HASHTABLE_NPAGE:iLast) + ); + if( !aTmp ){ + rc = SQLITE_NOMEM_BKPT; + } + + for(i=walFramePage(nBackfill+1); rc==SQLITE_OK && iaSegment[p->nSegment])[sLoc.iZero]; + sLoc.iZero++; + + for(j=0; jaSegment[i].iZero = sLoc.iZero; + p->aSegment[i].nEntry = nEntry; + p->aSegment[i].aIndex = aIndex; + p->aSegment[i].aPgno = (u32 *)sLoc.aPgno; + } + } + sqlite3_free(aTmp); + + if( rc!=SQLITE_OK ){ + walIteratorFree(p); + p = 0; + } + *pp = p; + return rc; +} + +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT +/* +** Attempt to enable blocking locks. Blocking locks are enabled only if (a) +** they are supported by the VFS, and (b) the database handle is configured +** with a busy-timeout. Return 1 if blocking locks are successfully enabled, +** or 0 otherwise. +*/ +static int walEnableBlocking(Wal *pWal){ + int res = 0; + if( pWal->db ){ + int tmout = pWal->db->busyTimeout; + if( tmout ){ + int rc; + rc = sqlite3OsFileControl( + pWal->pDbFd, SQLITE_FCNTL_LOCK_TIMEOUT, (void*)&tmout + ); + res = (rc==SQLITE_OK); + } + } + return res; +} + +/* +** Disable blocking locks. +*/ +static void walDisableBlocking(Wal *pWal){ + int tmout = 0; + sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_LOCK_TIMEOUT, (void*)&tmout); +} + +/* +** If parameter bLock is true, attempt to enable blocking locks, take +** the WRITER lock, and then disable blocking locks. If blocking locks +** cannot be enabled, no attempt to obtain the WRITER lock is made. Return +** an SQLite error code if an error occurs, or SQLITE_OK otherwise. It is not +** an error if blocking locks can not be enabled. +** +** If the bLock parameter is false and the WRITER lock is held, release it. +*/ +SQLITE_PRIVATE int sqlite3WalWriteLock(Wal *pWal, int bLock){ + int rc = SQLITE_OK; + assert( pWal->readLock<0 || bLock==0 ); + if( bLock ){ + assert( pWal->db ); + if( walEnableBlocking(pWal) ){ + rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1); + if( rc==SQLITE_OK ){ + pWal->writeLock = 1; + } + walDisableBlocking(pWal); + } + }else if( pWal->writeLock ){ + walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1); + pWal->writeLock = 0; + } + return rc; +} + +/* +** Set the database handle used to determine if blocking locks are required. +*/ +SQLITE_PRIVATE void sqlite3WalDb(Wal *pWal, sqlite3 *db){ + pWal->db = db; +} + +/* +** Take an exclusive WRITE lock. Blocking if so configured. +*/ +static int walLockWriter(Wal *pWal){ + int rc; + walEnableBlocking(pWal); + rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1); + walDisableBlocking(pWal); + return rc; +} +#else +# define walEnableBlocking(x) 0 +# define walDisableBlocking(x) +# define walLockWriter(pWal) walLockExclusive((pWal), WAL_WRITE_LOCK, 1) +# define sqlite3WalDb(pWal, db) +#endif /* ifdef SQLITE_ENABLE_SETLK_TIMEOUT */ + + +/* +** Attempt to obtain the exclusive WAL lock defined by parameters lockIdx and +** n. If the attempt fails and parameter xBusy is not NULL, then it is a +** busy-handler function. Invoke it and retry the lock until either the +** lock is successfully obtained or the busy-handler returns 0. +*/ +static int walBusyLock( + Wal *pWal, /* WAL connection */ + int (*xBusy)(void*), /* Function to call when busy */ + void *pBusyArg, /* Context argument for xBusyHandler */ + int lockIdx, /* Offset of first byte to lock */ + int n /* Number of bytes to lock */ +){ + int rc; + do { + rc = walLockExclusive(pWal, lockIdx, n); + }while( xBusy && rc==SQLITE_BUSY && xBusy(pBusyArg) ); +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + if( rc==SQLITE_BUSY_TIMEOUT ){ + walDisableBlocking(pWal); + rc = SQLITE_BUSY; + } +#endif + return rc; +} + +/* +** The cache of the wal-index header must be valid to call this function. +** Return the page-size in bytes used by the database. +*/ +static int walPagesize(Wal *pWal){ + return (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16); +} + +/* +** The following is guaranteed when this function is called: +** +** a) the WRITER lock is held, +** b) the entire log file has been checkpointed, and +** c) any existing readers are reading exclusively from the database +** file - there are no readers that may attempt to read a frame from +** the log file. +** +** This function updates the shared-memory structures so that the next +** client to write to the database (which may be this one) does so by +** writing frames into the start of the log file. +** +** The value of parameter salt1 is used as the aSalt[1] value in the +** new wal-index header. It should be passed a pseudo-random value (i.e. +** one obtained from sqlite3_randomness()). +*/ +static void walRestartHdr(Wal *pWal, u32 salt1){ + volatile WalCkptInfo *pInfo = walCkptInfo(pWal); + int i; /* Loop counter */ + u32 *aSalt = pWal->hdr.aSalt; /* Big-endian salt values */ + pWal->nCkpt++; + pWal->hdr.mxFrame = 0; + sqlite3Put4byte((u8*)&aSalt[0], 1 + sqlite3Get4byte((u8*)&aSalt[0])); + memcpy(&pWal->hdr.aSalt[1], &salt1, 4); + walIndexWriteHdr(pWal); + AtomicStore(&pInfo->nBackfill, 0); + pInfo->nBackfillAttempted = 0; + pInfo->aReadMark[1] = 0; + for(i=2; iaReadMark[i] = READMARK_NOT_USED; + assert( pInfo->aReadMark[0]==0 ); +} + +/* +** Copy as much content as we can from the WAL back into the database file +** in response to an sqlite3_wal_checkpoint() request or the equivalent. +** +** The amount of information copies from WAL to database might be limited +** by active readers. This routine will never overwrite a database page +** that a concurrent reader might be using. +** +** All I/O barrier operations (a.k.a fsyncs) occur in this routine when +** SQLite is in WAL-mode in synchronous=NORMAL. That means that if +** checkpoints are always run by a background thread or background +** process, foreground threads will never block on a lengthy fsync call. +** +** Fsync is called on the WAL before writing content out of the WAL and +** into the database. This ensures that if the new content is persistent +** in the WAL and can be recovered following a power-loss or hard reset. +** +** Fsync is also called on the database file if (and only if) the entire +** WAL content is copied into the database file. This second fsync makes +** it safe to delete the WAL since the new content will persist in the +** database file. +** +** This routine uses and updates the nBackfill field of the wal-index header. +** This is the only routine that will increase the value of nBackfill. +** (A WAL reset or recovery will revert nBackfill to zero, but not increase +** its value.) +** +** The caller must be holding sufficient locks to ensure that no other +** checkpoint is running (in any other thread or process) at the same +** time. +*/ +static int walCheckpoint( + Wal *pWal, /* Wal connection */ + sqlite3 *db, /* Check for interrupts on this handle */ + int eMode, /* One of PASSIVE, FULL or RESTART */ + int (*xBusy)(void*), /* Function to call when busy */ + void *pBusyArg, /* Context argument for xBusyHandler */ + int sync_flags, /* Flags for OsSync() (or 0) */ + u8 *zBuf /* Temporary buffer to use */ +){ + int rc = SQLITE_OK; /* Return code */ + int szPage; /* Database page-size */ + WalIterator *pIter = 0; /* Wal iterator context */ + u32 iDbpage = 0; /* Next database page to write */ + u32 iFrame = 0; /* Wal frame containing data for iDbpage */ + u32 mxSafeFrame; /* Max frame that can be backfilled */ + u32 mxPage; /* Max database page to write */ + int i; /* Loop counter */ + volatile WalCkptInfo *pInfo; /* The checkpoint status information */ + + szPage = walPagesize(pWal); + testcase( szPage<=32768 ); + testcase( szPage>=65536 ); + pInfo = walCkptInfo(pWal); + if( pInfo->nBackfillhdr.mxFrame ){ + + /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked + ** in the SQLITE_CHECKPOINT_PASSIVE mode. */ + assert( eMode!=SQLITE_CHECKPOINT_PASSIVE || xBusy==0 ); + + /* Compute in mxSafeFrame the index of the last frame of the WAL that is + ** safe to write into the database. Frames beyond mxSafeFrame might + ** overwrite database pages that are in use by active readers and thus + ** cannot be backfilled from the WAL. + */ + mxSafeFrame = pWal->hdr.mxFrame; + mxPage = pWal->hdr.nPage; + for(i=1; iaReadMark+i); + if( mxSafeFrame>y ){ + assert( y<=pWal->hdr.mxFrame ); + rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(i), 1); + if( rc==SQLITE_OK ){ + u32 iMark = (i==1 ? mxSafeFrame : READMARK_NOT_USED); + AtomicStore(pInfo->aReadMark+i, iMark); + walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1); + }else if( rc==SQLITE_BUSY ){ + mxSafeFrame = y; + xBusy = 0; + }else{ + goto walcheckpoint_out; + } + } + } + + /* Allocate the iterator */ + if( pInfo->nBackfillnBackfill, &pIter); + assert( rc==SQLITE_OK || pIter==0 ); + } + + if( pIter + && (rc = walBusyLock(pWal,xBusy,pBusyArg,WAL_READ_LOCK(0),1))==SQLITE_OK + ){ + u32 nBackfill = pInfo->nBackfill; + + pInfo->nBackfillAttempted = mxSafeFrame; + + /* Sync the WAL to disk */ + rc = sqlite3OsSync(pWal->pWalFd, CKPT_SYNC_FLAGS(sync_flags)); + + /* If the database may grow as a result of this checkpoint, hint + ** about the eventual size of the db file to the VFS layer. + */ + if( rc==SQLITE_OK ){ + i64 nReq = ((i64)mxPage * szPage); + i64 nSize; /* Current size of database file */ + sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_CKPT_START, 0); + rc = sqlite3OsFileSize(pWal->pDbFd, &nSize); + if( rc==SQLITE_OK && nSizehdr.mxFrame*szPage)pDbFd, SQLITE_FCNTL_SIZE_HINT,&nReq); + } + } + + } + + /* Iterate through the contents of the WAL, copying data to the db file */ + while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){ + i64 iOffset; + assert( walFramePgno(pWal, iFrame)==iDbpage ); + if( AtomicLoad(&db->u1.isInterrupted) ){ + rc = db->mallocFailed ? SQLITE_NOMEM_BKPT : SQLITE_INTERRUPT; + break; + } + if( iFrame<=nBackfill || iFrame>mxSafeFrame || iDbpage>mxPage ){ + continue; + } + iOffset = walFrameOffset(iFrame, szPage) + WAL_FRAME_HDRSIZE; + /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */ + rc = sqlite3OsRead(pWal->pWalFd, zBuf, szPage, iOffset); + if( rc!=SQLITE_OK ) break; + iOffset = (iDbpage-1)*(i64)szPage; + testcase( IS_BIG_INT(iOffset) ); + rc = sqlite3OsWrite(pWal->pDbFd, zBuf, szPage, iOffset); + if( rc!=SQLITE_OK ) break; + } + sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_CKPT_DONE, 0); + + /* If work was actually accomplished... */ + if( rc==SQLITE_OK ){ + if( mxSafeFrame==walIndexHdr(pWal)->mxFrame ){ + i64 szDb = pWal->hdr.nPage*(i64)szPage; + testcase( IS_BIG_INT(szDb) ); + rc = sqlite3OsTruncate(pWal->pDbFd, szDb); + if( rc==SQLITE_OK ){ + rc = sqlite3OsSync(pWal->pDbFd, CKPT_SYNC_FLAGS(sync_flags)); + } + } + if( rc==SQLITE_OK ){ + AtomicStore(&pInfo->nBackfill, mxSafeFrame); + } + } + + /* Release the reader lock held while backfilling */ + walUnlockExclusive(pWal, WAL_READ_LOCK(0), 1); + } + + if( rc==SQLITE_BUSY ){ + /* Reset the return code so as not to report a checkpoint failure + ** just because there are active readers. */ + rc = SQLITE_OK; + } + } + + /* If this is an SQLITE_CHECKPOINT_RESTART or TRUNCATE operation, and the + ** entire wal file has been copied into the database file, then block + ** until all readers have finished using the wal file. This ensures that + ** the next process to write to the database restarts the wal file. + */ + if( rc==SQLITE_OK && eMode!=SQLITE_CHECKPOINT_PASSIVE ){ + assert( pWal->writeLock ); + if( pInfo->nBackfillhdr.mxFrame ){ + rc = SQLITE_BUSY; + }else if( eMode>=SQLITE_CHECKPOINT_RESTART ){ + u32 salt1; + sqlite3_randomness(4, &salt1); + assert( pInfo->nBackfill==pWal->hdr.mxFrame ); + rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(1), WAL_NREADER-1); + if( rc==SQLITE_OK ){ + if( eMode==SQLITE_CHECKPOINT_TRUNCATE ){ + /* IMPLEMENTATION-OF: R-44699-57140 This mode works the same way as + ** SQLITE_CHECKPOINT_RESTART with the addition that it also + ** truncates the log file to zero bytes just prior to a + ** successful return. + ** + ** In theory, it might be safe to do this without updating the + ** wal-index header in shared memory, as all subsequent reader or + ** writer clients should see that the entire log file has been + ** checkpointed and behave accordingly. This seems unsafe though, + ** as it would leave the system in a state where the contents of + ** the wal-index header do not match the contents of the + ** file-system. To avoid this, update the wal-index header to + ** indicate that the log file contains zero valid frames. */ + walRestartHdr(pWal, salt1); + rc = sqlite3OsTruncate(pWal->pWalFd, 0); + } + walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1); + } + } + } + + walcheckpoint_out: + walIteratorFree(pIter); + return rc; +} + +/* +** If the WAL file is currently larger than nMax bytes in size, truncate +** it to exactly nMax bytes. If an error occurs while doing so, ignore it. +*/ +static void walLimitSize(Wal *pWal, i64 nMax){ + i64 sz; + int rx; + sqlite3BeginBenignMalloc(); + rx = sqlite3OsFileSize(pWal->pWalFd, &sz); + if( rx==SQLITE_OK && (sz > nMax ) ){ + rx = sqlite3OsTruncate(pWal->pWalFd, nMax); + } + sqlite3EndBenignMalloc(); + if( rx ){ + sqlite3_log(rx, "cannot limit WAL size: %s", pWal->zWalName); + } +} + +/* +** Close a connection to a log file. +*/ +SQLITE_PRIVATE int sqlite3WalClose( + Wal *pWal, /* Wal to close */ + sqlite3 *db, /* For interrupt flag */ + int sync_flags, /* Flags to pass to OsSync() (or 0) */ + int nBuf, + u8 *zBuf /* Buffer of at least nBuf bytes */ +){ + int rc = SQLITE_OK; + if( pWal ){ + int isDelete = 0; /* True to unlink wal and wal-index files */ + + /* If an EXCLUSIVE lock can be obtained on the database file (using the + ** ordinary, rollback-mode locking methods, this guarantees that the + ** connection associated with this log file is the only connection to + ** the database. In this case checkpoint the database and unlink both + ** the wal and wal-index files. + ** + ** The EXCLUSIVE lock is not released before returning. + */ + if( zBuf!=0 + && SQLITE_OK==(rc = sqlite3OsLock(pWal->pDbFd, SQLITE_LOCK_EXCLUSIVE)) + ){ + if( pWal->exclusiveMode==WAL_NORMAL_MODE ){ + pWal->exclusiveMode = WAL_EXCLUSIVE_MODE; + } + rc = sqlite3WalCheckpoint(pWal, db, + SQLITE_CHECKPOINT_PASSIVE, 0, 0, sync_flags, nBuf, zBuf, 0, 0 + ); + if( rc==SQLITE_OK ){ + int bPersist = -1; + sqlite3OsFileControlHint( + pWal->pDbFd, SQLITE_FCNTL_PERSIST_WAL, &bPersist + ); + if( bPersist!=1 ){ + /* Try to delete the WAL file if the checkpoint completed and + ** fsyned (rc==SQLITE_OK) and if we are not in persistent-wal + ** mode (!bPersist) */ + isDelete = 1; + }else if( pWal->mxWalSize>=0 ){ + /* Try to truncate the WAL file to zero bytes if the checkpoint + ** completed and fsynced (rc==SQLITE_OK) and we are in persistent + ** WAL mode (bPersist) and if the PRAGMA journal_size_limit is a + ** non-negative value (pWal->mxWalSize>=0). Note that we truncate + ** to zero bytes as truncating to the journal_size_limit might + ** leave a corrupt WAL file on disk. */ + walLimitSize(pWal, 0); + } + } + } + + walIndexClose(pWal, isDelete); + sqlite3OsClose(pWal->pWalFd); + if( isDelete ){ + sqlite3BeginBenignMalloc(); + sqlite3OsDelete(pWal->pVfs, pWal->zWalName, 0); + sqlite3EndBenignMalloc(); + } + WALTRACE(("WAL%p: closed\n", pWal)); + sqlite3_free((void *)pWal->apWiData); + sqlite3_free(pWal); + } + return rc; +} + +/* +** Try to read the wal-index header. Return 0 on success and 1 if +** there is a problem. +** +** The wal-index is in shared memory. Another thread or process might +** be writing the header at the same time this procedure is trying to +** read it, which might result in inconsistency. A dirty read is detected +** by verifying that both copies of the header are the same and also by +** a checksum on the header. +** +** If and only if the read is consistent and the header is different from +** pWal->hdr, then pWal->hdr is updated to the content of the new header +** and *pChanged is set to 1. +** +** If the checksum cannot be verified return non-zero. If the header +** is read successfully and the checksum verified, return zero. +*/ +static SQLITE_NO_TSAN int walIndexTryHdr(Wal *pWal, int *pChanged){ + u32 aCksum[2]; /* Checksum on the header content */ + WalIndexHdr h1, h2; /* Two copies of the header content */ + WalIndexHdr volatile *aHdr; /* Header in shared memory */ + + /* The first page of the wal-index must be mapped at this point. */ + assert( pWal->nWiData>0 && pWal->apWiData[0] ); + + /* Read the header. This might happen concurrently with a write to the + ** same area of shared memory on a different CPU in a SMP, + ** meaning it is possible that an inconsistent snapshot is read + ** from the file. If this happens, return non-zero. + ** + ** tag-20200519-1: + ** There are two copies of the header at the beginning of the wal-index. + ** When reading, read [0] first then [1]. Writes are in the reverse order. + ** Memory barriers are used to prevent the compiler or the hardware from + ** reordering the reads and writes. TSAN and similar tools can sometimes + ** give false-positive warnings about these accesses because the tools do not + ** account for the double-read and the memory barrier. The use of mutexes + ** here would be problematic as the memory being accessed is potentially + ** shared among multiple processes and not all mutex implementions work + ** reliably in that environment. + */ + aHdr = walIndexHdr(pWal); + memcpy(&h1, (void *)&aHdr[0], sizeof(h1)); /* Possible TSAN false-positive */ + walShmBarrier(pWal); + memcpy(&h2, (void *)&aHdr[1], sizeof(h2)); + + if( memcmp(&h1, &h2, sizeof(h1))!=0 ){ + return 1; /* Dirty read */ + } + if( h1.isInit==0 ){ + return 1; /* Malformed header - probably all zeros */ + } + walChecksumBytes(1, (u8*)&h1, sizeof(h1)-sizeof(h1.aCksum), 0, aCksum); + if( aCksum[0]!=h1.aCksum[0] || aCksum[1]!=h1.aCksum[1] ){ + return 1; /* Checksum does not match */ + } + + if( memcmp(&pWal->hdr, &h1, sizeof(WalIndexHdr)) ){ + *pChanged = 1; + memcpy(&pWal->hdr, &h1, sizeof(WalIndexHdr)); + pWal->szPage = (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16); + testcase( pWal->szPage<=32768 ); + testcase( pWal->szPage>=65536 ); + } + + /* The header was successfully read. Return zero. */ + return 0; +} + +/* +** This is the value that walTryBeginRead returns when it needs to +** be retried. +*/ +#define WAL_RETRY (-1) + +/* +** Read the wal-index header from the wal-index and into pWal->hdr. +** If the wal-header appears to be corrupt, try to reconstruct the +** wal-index from the WAL before returning. +** +** Set *pChanged to 1 if the wal-index header value in pWal->hdr is +** changed by this operation. If pWal->hdr is unchanged, set *pChanged +** to 0. +** +** If the wal-index header is successfully read, return SQLITE_OK. +** Otherwise an SQLite error code. +*/ +static int walIndexReadHdr(Wal *pWal, int *pChanged){ + int rc; /* Return code */ + int badHdr; /* True if a header read failed */ + volatile u32 *page0; /* Chunk of wal-index containing header */ + + /* Ensure that page 0 of the wal-index (the page that contains the + ** wal-index header) is mapped. Return early if an error occurs here. + */ + assert( pChanged ); + rc = walIndexPage(pWal, 0, &page0); + if( rc!=SQLITE_OK ){ + assert( rc!=SQLITE_READONLY ); /* READONLY changed to OK in walIndexPage */ + if( rc==SQLITE_READONLY_CANTINIT ){ + /* The SQLITE_READONLY_CANTINIT return means that the shared-memory + ** was openable but is not writable, and this thread is unable to + ** confirm that another write-capable connection has the shared-memory + ** open, and hence the content of the shared-memory is unreliable, + ** since the shared-memory might be inconsistent with the WAL file + ** and there is no writer on hand to fix it. */ + assert( page0==0 ); + assert( pWal->writeLock==0 ); + assert( pWal->readOnly & WAL_SHM_RDONLY ); + pWal->bShmUnreliable = 1; + pWal->exclusiveMode = WAL_HEAPMEMORY_MODE; + *pChanged = 1; + }else{ + return rc; /* Any other non-OK return is just an error */ + } + }else{ + /* page0 can be NULL if the SHM is zero bytes in size and pWal->writeLock + ** is zero, which prevents the SHM from growing */ + testcase( page0!=0 ); + } + assert( page0!=0 || pWal->writeLock==0 ); + + /* If the first page of the wal-index has been mapped, try to read the + ** wal-index header immediately, without holding any lock. This usually + ** works, but may fail if the wal-index header is corrupt or currently + ** being modified by another thread or process. + */ + badHdr = (page0 ? walIndexTryHdr(pWal, pChanged) : 1); + + /* If the first attempt failed, it might have been due to a race + ** with a writer. So get a WRITE lock and try again. + */ + if( badHdr ){ + if( pWal->bShmUnreliable==0 && (pWal->readOnly & WAL_SHM_RDONLY) ){ + if( SQLITE_OK==(rc = walLockShared(pWal, WAL_WRITE_LOCK)) ){ + walUnlockShared(pWal, WAL_WRITE_LOCK); + rc = SQLITE_READONLY_RECOVERY; + } + }else{ + int bWriteLock = pWal->writeLock; + if( bWriteLock || SQLITE_OK==(rc = walLockWriter(pWal)) ){ + pWal->writeLock = 1; + if( SQLITE_OK==(rc = walIndexPage(pWal, 0, &page0)) ){ + badHdr = walIndexTryHdr(pWal, pChanged); + if( badHdr ){ + /* If the wal-index header is still malformed even while holding + ** a WRITE lock, it can only mean that the header is corrupted and + ** needs to be reconstructed. So run recovery to do exactly that. + */ + rc = walIndexRecover(pWal); + *pChanged = 1; + } + } + if( bWriteLock==0 ){ + pWal->writeLock = 0; + walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1); + } + } + } + } + + /* If the header is read successfully, check the version number to make + ** sure the wal-index was not constructed with some future format that + ** this version of SQLite cannot understand. + */ + if( badHdr==0 && pWal->hdr.iVersion!=WALINDEX_MAX_VERSION ){ + rc = SQLITE_CANTOPEN_BKPT; + } + if( pWal->bShmUnreliable ){ + if( rc!=SQLITE_OK ){ + walIndexClose(pWal, 0); + pWal->bShmUnreliable = 0; + assert( pWal->nWiData>0 && pWal->apWiData[0]==0 ); + /* walIndexRecover() might have returned SHORT_READ if a concurrent + ** writer truncated the WAL out from under it. If that happens, it + ** indicates that a writer has fixed the SHM file for us, so retry */ + if( rc==SQLITE_IOERR_SHORT_READ ) rc = WAL_RETRY; + } + pWal->exclusiveMode = WAL_NORMAL_MODE; + } + + return rc; +} + +/* +** Open a transaction in a connection where the shared-memory is read-only +** and where we cannot verify that there is a separate write-capable connection +** on hand to keep the shared-memory up-to-date with the WAL file. +** +** This can happen, for example, when the shared-memory is implemented by +** memory-mapping a *-shm file, where a prior writer has shut down and +** left the *-shm file on disk, and now the present connection is trying +** to use that database but lacks write permission on the *-shm file. +** Other scenarios are also possible, depending on the VFS implementation. +** +** Precondition: +** +** The *-wal file has been read and an appropriate wal-index has been +** constructed in pWal->apWiData[] using heap memory instead of shared +** memory. +** +** If this function returns SQLITE_OK, then the read transaction has +** been successfully opened. In this case output variable (*pChanged) +** is set to true before returning if the caller should discard the +** contents of the page cache before proceeding. Or, if it returns +** WAL_RETRY, then the heap memory wal-index has been discarded and +** the caller should retry opening the read transaction from the +** beginning (including attempting to map the *-shm file). +** +** If an error occurs, an SQLite error code is returned. +*/ +static int walBeginShmUnreliable(Wal *pWal, int *pChanged){ + i64 szWal; /* Size of wal file on disk in bytes */ + i64 iOffset; /* Current offset when reading wal file */ + u8 aBuf[WAL_HDRSIZE]; /* Buffer to load WAL header into */ + u8 *aFrame = 0; /* Malloc'd buffer to load entire frame */ + int szFrame; /* Number of bytes in buffer aFrame[] */ + u8 *aData; /* Pointer to data part of aFrame buffer */ + volatile void *pDummy; /* Dummy argument for xShmMap */ + int rc; /* Return code */ + u32 aSaveCksum[2]; /* Saved copy of pWal->hdr.aFrameCksum */ + + assert( pWal->bShmUnreliable ); + assert( pWal->readOnly & WAL_SHM_RDONLY ); + assert( pWal->nWiData>0 && pWal->apWiData[0] ); + + /* Take WAL_READ_LOCK(0). This has the effect of preventing any + ** writers from running a checkpoint, but does not stop them + ** from running recovery. */ + rc = walLockShared(pWal, WAL_READ_LOCK(0)); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_BUSY ) rc = WAL_RETRY; + goto begin_unreliable_shm_out; + } + pWal->readLock = 0; + + /* Check to see if a separate writer has attached to the shared-memory area, + ** thus making the shared-memory "reliable" again. Do this by invoking + ** the xShmMap() routine of the VFS and looking to see if the return + ** is SQLITE_READONLY instead of SQLITE_READONLY_CANTINIT. + ** + ** If the shared-memory is now "reliable" return WAL_RETRY, which will + ** cause the heap-memory WAL-index to be discarded and the actual + ** shared memory to be used in its place. + ** + ** This step is important because, even though this connection is holding + ** the WAL_READ_LOCK(0) which prevents a checkpoint, a writer might + ** have already checkpointed the WAL file and, while the current + ** is active, wrap the WAL and start overwriting frames that this + ** process wants to use. + ** + ** Once sqlite3OsShmMap() has been called for an sqlite3_file and has + ** returned any SQLITE_READONLY value, it must return only SQLITE_READONLY + ** or SQLITE_READONLY_CANTINIT or some error for all subsequent invocations, + ** even if some external agent does a "chmod" to make the shared-memory + ** writable by us, until sqlite3OsShmUnmap() has been called. + ** This is a requirement on the VFS implementation. + */ + rc = sqlite3OsShmMap(pWal->pDbFd, 0, WALINDEX_PGSZ, 0, &pDummy); + assert( rc!=SQLITE_OK ); /* SQLITE_OK not possible for read-only connection */ + if( rc!=SQLITE_READONLY_CANTINIT ){ + rc = (rc==SQLITE_READONLY ? WAL_RETRY : rc); + goto begin_unreliable_shm_out; + } + + /* We reach this point only if the real shared-memory is still unreliable. + ** Assume the in-memory WAL-index substitute is correct and load it + ** into pWal->hdr. + */ + memcpy(&pWal->hdr, (void*)walIndexHdr(pWal), sizeof(WalIndexHdr)); + + /* Make sure some writer hasn't come in and changed the WAL file out + ** from under us, then disconnected, while we were not looking. + */ + rc = sqlite3OsFileSize(pWal->pWalFd, &szWal); + if( rc!=SQLITE_OK ){ + goto begin_unreliable_shm_out; + } + if( szWalhdr.mxFrame==0 ? SQLITE_OK : WAL_RETRY); + goto begin_unreliable_shm_out; + } + + /* Check the salt keys at the start of the wal file still match. */ + rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0); + if( rc!=SQLITE_OK ){ + goto begin_unreliable_shm_out; + } + if( memcmp(&pWal->hdr.aSalt, &aBuf[16], 8) ){ + /* Some writer has wrapped the WAL file while we were not looking. + ** Return WAL_RETRY which will cause the in-memory WAL-index to be + ** rebuilt. */ + rc = WAL_RETRY; + goto begin_unreliable_shm_out; + } + + /* Allocate a buffer to read frames into */ + szFrame = pWal->hdr.szPage + WAL_FRAME_HDRSIZE; + aFrame = (u8 *)sqlite3_malloc64(szFrame); + if( aFrame==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto begin_unreliable_shm_out; + } + aData = &aFrame[WAL_FRAME_HDRSIZE]; + + /* Check to see if a complete transaction has been appended to the + ** wal file since the heap-memory wal-index was created. If so, the + ** heap-memory wal-index is discarded and WAL_RETRY returned to + ** the caller. */ + aSaveCksum[0] = pWal->hdr.aFrameCksum[0]; + aSaveCksum[1] = pWal->hdr.aFrameCksum[1]; + for(iOffset=walFrameOffset(pWal->hdr.mxFrame+1, pWal->hdr.szPage); + iOffset+szFrame<=szWal; + iOffset+=szFrame + ){ + u32 pgno; /* Database page number for frame */ + u32 nTruncate; /* dbsize field from frame header */ + + /* Read and decode the next log frame. */ + rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset); + if( rc!=SQLITE_OK ) break; + if( !walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame) ) break; + + /* If nTruncate is non-zero, then a complete transaction has been + ** appended to this wal file. Set rc to WAL_RETRY and break out of + ** the loop. */ + if( nTruncate ){ + rc = WAL_RETRY; + break; + } + } + pWal->hdr.aFrameCksum[0] = aSaveCksum[0]; + pWal->hdr.aFrameCksum[1] = aSaveCksum[1]; + + begin_unreliable_shm_out: + sqlite3_free(aFrame); + if( rc!=SQLITE_OK ){ + int i; + for(i=0; inWiData; i++){ + sqlite3_free((void*)pWal->apWiData[i]); + pWal->apWiData[i] = 0; + } + pWal->bShmUnreliable = 0; + sqlite3WalEndReadTransaction(pWal); + *pChanged = 1; + } + return rc; +} + +/* +** Attempt to start a read transaction. This might fail due to a race or +** other transient condition. When that happens, it returns WAL_RETRY to +** indicate to the caller that it is safe to retry immediately. +** +** On success return SQLITE_OK. On a permanent failure (such an +** I/O error or an SQLITE_BUSY because another process is running +** recovery) return a positive error code. +** +** The useWal parameter is true to force the use of the WAL and disable +** the case where the WAL is bypassed because it has been completely +** checkpointed. If useWal==0 then this routine calls walIndexReadHdr() +** to make a copy of the wal-index header into pWal->hdr. If the +** wal-index header has changed, *pChanged is set to 1 (as an indication +** to the caller that the local page cache is obsolete and needs to be +** flushed.) When useWal==1, the wal-index header is assumed to already +** be loaded and the pChanged parameter is unused. +** +** The caller must set the cnt parameter to the number of prior calls to +** this routine during the current read attempt that returned WAL_RETRY. +** This routine will start taking more aggressive measures to clear the +** race conditions after multiple WAL_RETRY returns, and after an excessive +** number of errors will ultimately return SQLITE_PROTOCOL. The +** SQLITE_PROTOCOL return indicates that some other process has gone rogue +** and is not honoring the locking protocol. There is a vanishingly small +** chance that SQLITE_PROTOCOL could be returned because of a run of really +** bad luck when there is lots of contention for the wal-index, but that +** possibility is so small that it can be safely neglected, we believe. +** +** On success, this routine obtains a read lock on +** WAL_READ_LOCK(pWal->readLock). The pWal->readLock integer is +** in the range 0 <= pWal->readLock < WAL_NREADER. If pWal->readLock==(-1) +** that means the Wal does not hold any read lock. The reader must not +** access any database page that is modified by a WAL frame up to and +** including frame number aReadMark[pWal->readLock]. The reader will +** use WAL frames up to and including pWal->hdr.mxFrame if pWal->readLock>0 +** Or if pWal->readLock==0, then the reader will ignore the WAL +** completely and get all content directly from the database file. +** If the useWal parameter is 1 then the WAL will never be ignored and +** this routine will always set pWal->readLock>0 on success. +** When the read transaction is completed, the caller must release the +** lock on WAL_READ_LOCK(pWal->readLock) and set pWal->readLock to -1. +** +** This routine uses the nBackfill and aReadMark[] fields of the header +** to select a particular WAL_READ_LOCK() that strives to let the +** checkpoint process do as much work as possible. This routine might +** update values of the aReadMark[] array in the header, but if it does +** so it takes care to hold an exclusive lock on the corresponding +** WAL_READ_LOCK() while changing values. +*/ +static int walTryBeginRead(Wal *pWal, int *pChanged, int useWal, int cnt){ + volatile WalCkptInfo *pInfo; /* Checkpoint information in wal-index */ + u32 mxReadMark; /* Largest aReadMark[] value */ + int mxI; /* Index of largest aReadMark[] value */ + int i; /* Loop counter */ + int rc = SQLITE_OK; /* Return code */ + u32 mxFrame; /* Wal frame to lock to */ + + assert( pWal->readLock<0 ); /* Not currently locked */ + + /* useWal may only be set for read/write connections */ + assert( (pWal->readOnly & WAL_SHM_RDONLY)==0 || useWal==0 ); + + /* Take steps to avoid spinning forever if there is a protocol error. + ** + ** Circumstances that cause a RETRY should only last for the briefest + ** instances of time. No I/O or other system calls are done while the + ** locks are held, so the locks should not be held for very long. But + ** if we are unlucky, another process that is holding a lock might get + ** paged out or take a page-fault that is time-consuming to resolve, + ** during the few nanoseconds that it is holding the lock. In that case, + ** it might take longer than normal for the lock to free. + ** + ** After 5 RETRYs, we begin calling sqlite3OsSleep(). The first few + ** calls to sqlite3OsSleep() have a delay of 1 microsecond. Really this + ** is more of a scheduler yield than an actual delay. But on the 10th + ** an subsequent retries, the delays start becoming longer and longer, + ** so that on the 100th (and last) RETRY we delay for 323 milliseconds. + ** The total delay time before giving up is less than 10 seconds. + */ + if( cnt>5 ){ + int nDelay = 1; /* Pause time in microseconds */ + if( cnt>100 ){ + VVA_ONLY( pWal->lockError = 1; ) + return SQLITE_PROTOCOL; + } + if( cnt>=10 ) nDelay = (cnt-9)*(cnt-9)*39; + sqlite3OsSleep(pWal->pVfs, nDelay); + } + + if( !useWal ){ + assert( rc==SQLITE_OK ); + if( pWal->bShmUnreliable==0 ){ + rc = walIndexReadHdr(pWal, pChanged); + } + if( rc==SQLITE_BUSY ){ + /* If there is not a recovery running in another thread or process + ** then convert BUSY errors to WAL_RETRY. If recovery is known to + ** be running, convert BUSY to BUSY_RECOVERY. There is a race here + ** which might cause WAL_RETRY to be returned even if BUSY_RECOVERY + ** would be technically correct. But the race is benign since with + ** WAL_RETRY this routine will be called again and will probably be + ** right on the second iteration. + */ + if( pWal->apWiData[0]==0 ){ + /* This branch is taken when the xShmMap() method returns SQLITE_BUSY. + ** We assume this is a transient condition, so return WAL_RETRY. The + ** xShmMap() implementation used by the default unix and win32 VFS + ** modules may return SQLITE_BUSY due to a race condition in the + ** code that determines whether or not the shared-memory region + ** must be zeroed before the requested page is returned. + */ + rc = WAL_RETRY; + }else if( SQLITE_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){ + walUnlockShared(pWal, WAL_RECOVER_LOCK); + rc = WAL_RETRY; + }else if( rc==SQLITE_BUSY ){ + rc = SQLITE_BUSY_RECOVERY; + } + } + if( rc!=SQLITE_OK ){ + return rc; + } + else if( pWal->bShmUnreliable ){ + return walBeginShmUnreliable(pWal, pChanged); + } + } + + assert( pWal->nWiData>0 ); + assert( pWal->apWiData[0]!=0 ); + pInfo = walCkptInfo(pWal); + if( !useWal && AtomicLoad(&pInfo->nBackfill)==pWal->hdr.mxFrame +#ifdef SQLITE_ENABLE_SNAPSHOT + && (pWal->pSnapshot==0 || pWal->hdr.mxFrame==0) +#endif + ){ + /* The WAL has been completely backfilled (or it is empty). + ** and can be safely ignored. + */ + rc = walLockShared(pWal, WAL_READ_LOCK(0)); + walShmBarrier(pWal); + if( rc==SQLITE_OK ){ + if( memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr)) ){ + /* It is not safe to allow the reader to continue here if frames + ** may have been appended to the log before READ_LOCK(0) was obtained. + ** When holding READ_LOCK(0), the reader ignores the entire log file, + ** which implies that the database file contains a trustworthy + ** snapshot. Since holding READ_LOCK(0) prevents a checkpoint from + ** happening, this is usually correct. + ** + ** However, if frames have been appended to the log (or if the log + ** is wrapped and written for that matter) before the READ_LOCK(0) + ** is obtained, that is not necessarily true. A checkpointer may + ** have started to backfill the appended frames but crashed before + ** it finished. Leaving a corrupt image in the database file. + */ + walUnlockShared(pWal, WAL_READ_LOCK(0)); + return WAL_RETRY; + } + pWal->readLock = 0; + return SQLITE_OK; + }else if( rc!=SQLITE_BUSY ){ + return rc; + } + } + + /* If we get this far, it means that the reader will want to use + ** the WAL to get at content from recent commits. The job now is + ** to select one of the aReadMark[] entries that is closest to + ** but not exceeding pWal->hdr.mxFrame and lock that entry. + */ + mxReadMark = 0; + mxI = 0; + mxFrame = pWal->hdr.mxFrame; +#ifdef SQLITE_ENABLE_SNAPSHOT + if( pWal->pSnapshot && pWal->pSnapshot->mxFramepSnapshot->mxFrame; + } +#endif + for(i=1; iaReadMark+i); + if( mxReadMark<=thisMark && thisMark<=mxFrame ){ + assert( thisMark!=READMARK_NOT_USED ); + mxReadMark = thisMark; + mxI = i; + } + } + if( (pWal->readOnly & WAL_SHM_RDONLY)==0 + && (mxReadMarkaReadMark+i,mxFrame); + mxReadMark = mxFrame; + mxI = i; + walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1); + break; + }else if( rc!=SQLITE_BUSY ){ + return rc; + } + } + } + if( mxI==0 ){ + assert( rc==SQLITE_BUSY || (pWal->readOnly & WAL_SHM_RDONLY)!=0 ); + return rc==SQLITE_BUSY ? WAL_RETRY : SQLITE_READONLY_CANTINIT; + } + + rc = walLockShared(pWal, WAL_READ_LOCK(mxI)); + if( rc ){ + return rc==SQLITE_BUSY ? WAL_RETRY : rc; + } + /* Now that the read-lock has been obtained, check that neither the + ** value in the aReadMark[] array or the contents of the wal-index + ** header have changed. + ** + ** It is necessary to check that the wal-index header did not change + ** between the time it was read and when the shared-lock was obtained + ** on WAL_READ_LOCK(mxI) was obtained to account for the possibility + ** that the log file may have been wrapped by a writer, or that frames + ** that occur later in the log than pWal->hdr.mxFrame may have been + ** copied into the database by a checkpointer. If either of these things + ** happened, then reading the database with the current value of + ** pWal->hdr.mxFrame risks reading a corrupted snapshot. So, retry + ** instead. + ** + ** Before checking that the live wal-index header has not changed + ** since it was read, set Wal.minFrame to the first frame in the wal + ** file that has not yet been checkpointed. This client will not need + ** to read any frames earlier than minFrame from the wal file - they + ** can be safely read directly from the database file. + ** + ** Because a ShmBarrier() call is made between taking the copy of + ** nBackfill and checking that the wal-header in shared-memory still + ** matches the one cached in pWal->hdr, it is guaranteed that the + ** checkpointer that set nBackfill was not working with a wal-index + ** header newer than that cached in pWal->hdr. If it were, that could + ** cause a problem. The checkpointer could omit to checkpoint + ** a version of page X that lies before pWal->minFrame (call that version + ** A) on the basis that there is a newer version (version B) of the same + ** page later in the wal file. But if version B happens to like past + ** frame pWal->hdr.mxFrame - then the client would incorrectly assume + ** that it can read version A from the database file. However, since + ** we can guarantee that the checkpointer that set nBackfill could not + ** see any pages past pWal->hdr.mxFrame, this problem does not come up. + */ + pWal->minFrame = AtomicLoad(&pInfo->nBackfill)+1; + walShmBarrier(pWal); + if( AtomicLoad(pInfo->aReadMark+mxI)!=mxReadMark + || memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr)) + ){ + walUnlockShared(pWal, WAL_READ_LOCK(mxI)); + return WAL_RETRY; + }else{ + assert( mxReadMark<=pWal->hdr.mxFrame ); + pWal->readLock = (i16)mxI; + } + return rc; +} + +#ifdef SQLITE_ENABLE_SNAPSHOT +/* +** Attempt to reduce the value of the WalCkptInfo.nBackfillAttempted +** variable so that older snapshots can be accessed. To do this, loop +** through all wal frames from nBackfillAttempted to (nBackfill+1), +** comparing their content to the corresponding page with the database +** file, if any. Set nBackfillAttempted to the frame number of the +** first frame for which the wal file content matches the db file. +** +** This is only really safe if the file-system is such that any page +** writes made by earlier checkpointers were atomic operations, which +** is not always true. It is also possible that nBackfillAttempted +** may be left set to a value larger than expected, if a wal frame +** contains content that duplicate of an earlier version of the same +** page. +** +** SQLITE_OK is returned if successful, or an SQLite error code if an +** error occurs. It is not an error if nBackfillAttempted cannot be +** decreased at all. +*/ +SQLITE_PRIVATE int sqlite3WalSnapshotRecover(Wal *pWal){ + int rc; + + assert( pWal->readLock>=0 ); + rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1); + if( rc==SQLITE_OK ){ + volatile WalCkptInfo *pInfo = walCkptInfo(pWal); + int szPage = (int)pWal->szPage; + i64 szDb; /* Size of db file in bytes */ + + rc = sqlite3OsFileSize(pWal->pDbFd, &szDb); + if( rc==SQLITE_OK ){ + void *pBuf1 = sqlite3_malloc(szPage); + void *pBuf2 = sqlite3_malloc(szPage); + if( pBuf1==0 || pBuf2==0 ){ + rc = SQLITE_NOMEM; + }else{ + u32 i = pInfo->nBackfillAttempted; + for(i=pInfo->nBackfillAttempted; i>AtomicLoad(&pInfo->nBackfill); i--){ + WalHashLoc sLoc; /* Hash table location */ + u32 pgno; /* Page number in db file */ + i64 iDbOff; /* Offset of db file entry */ + i64 iWalOff; /* Offset of wal file entry */ + + rc = walHashGet(pWal, walFramePage(i), &sLoc); + if( rc!=SQLITE_OK ) break; + pgno = sLoc.aPgno[i-sLoc.iZero]; + iDbOff = (i64)(pgno-1) * szPage; + + if( iDbOff+szPage<=szDb ){ + iWalOff = walFrameOffset(i, szPage) + WAL_FRAME_HDRSIZE; + rc = sqlite3OsRead(pWal->pWalFd, pBuf1, szPage, iWalOff); + + if( rc==SQLITE_OK ){ + rc = sqlite3OsRead(pWal->pDbFd, pBuf2, szPage, iDbOff); + } + + if( rc!=SQLITE_OK || 0==memcmp(pBuf1, pBuf2, szPage) ){ + break; + } + } + + pInfo->nBackfillAttempted = i-1; + } + } + + sqlite3_free(pBuf1); + sqlite3_free(pBuf2); + } + walUnlockExclusive(pWal, WAL_CKPT_LOCK, 1); + } + + return rc; +} +#endif /* SQLITE_ENABLE_SNAPSHOT */ + +/* +** Begin a read transaction on the database. +** +** This routine used to be called sqlite3OpenSnapshot() and with good reason: +** it takes a snapshot of the state of the WAL and wal-index for the current +** instant in time. The current thread will continue to use this snapshot. +** Other threads might append new content to the WAL and wal-index but +** that extra content is ignored by the current thread. +** +** If the database contents have changes since the previous read +** transaction, then *pChanged is set to 1 before returning. The +** Pager layer will use this to know that its cache is stale and +** needs to be flushed. +*/ +SQLITE_PRIVATE int sqlite3WalBeginReadTransaction(Wal *pWal, int *pChanged){ + int rc; /* Return code */ + int cnt = 0; /* Number of TryBeginRead attempts */ +#ifdef SQLITE_ENABLE_SNAPSHOT + int bChanged = 0; + WalIndexHdr *pSnapshot = pWal->pSnapshot; +#endif + + assert( pWal->ckptLock==0 ); + +#ifdef SQLITE_ENABLE_SNAPSHOT + if( pSnapshot ){ + if( memcmp(pSnapshot, &pWal->hdr, sizeof(WalIndexHdr))!=0 ){ + bChanged = 1; + } + + /* It is possible that there is a checkpointer thread running + ** concurrent with this code. If this is the case, it may be that the + ** checkpointer has already determined that it will checkpoint + ** snapshot X, where X is later in the wal file than pSnapshot, but + ** has not yet set the pInfo->nBackfillAttempted variable to indicate + ** its intent. To avoid the race condition this leads to, ensure that + ** there is no checkpointer process by taking a shared CKPT lock + ** before checking pInfo->nBackfillAttempted. */ + (void)walEnableBlocking(pWal); + rc = walLockShared(pWal, WAL_CKPT_LOCK); + walDisableBlocking(pWal); + + if( rc!=SQLITE_OK ){ + return rc; + } + pWal->ckptLock = 1; + } +#endif + + do{ + rc = walTryBeginRead(pWal, pChanged, 0, ++cnt); + }while( rc==WAL_RETRY ); + testcase( (rc&0xff)==SQLITE_BUSY ); + testcase( (rc&0xff)==SQLITE_IOERR ); + testcase( rc==SQLITE_PROTOCOL ); + testcase( rc==SQLITE_OK ); + +#ifdef SQLITE_ENABLE_SNAPSHOT + if( rc==SQLITE_OK ){ + if( pSnapshot && memcmp(pSnapshot, &pWal->hdr, sizeof(WalIndexHdr))!=0 ){ + /* At this point the client has a lock on an aReadMark[] slot holding + ** a value equal to or smaller than pSnapshot->mxFrame, but pWal->hdr + ** is populated with the wal-index header corresponding to the head + ** of the wal file. Verify that pSnapshot is still valid before + ** continuing. Reasons why pSnapshot might no longer be valid: + ** + ** (1) The WAL file has been reset since the snapshot was taken. + ** In this case, the salt will have changed. + ** + ** (2) A checkpoint as been attempted that wrote frames past + ** pSnapshot->mxFrame into the database file. Note that the + ** checkpoint need not have completed for this to cause problems. + */ + volatile WalCkptInfo *pInfo = walCkptInfo(pWal); + + assert( pWal->readLock>0 || pWal->hdr.mxFrame==0 ); + assert( pInfo->aReadMark[pWal->readLock]<=pSnapshot->mxFrame ); + + /* Check that the wal file has not been wrapped. Assuming that it has + ** not, also check that no checkpointer has attempted to checkpoint any + ** frames beyond pSnapshot->mxFrame. If either of these conditions are + ** true, return SQLITE_ERROR_SNAPSHOT. Otherwise, overwrite pWal->hdr + ** with *pSnapshot and set *pChanged as appropriate for opening the + ** snapshot. */ + if( !memcmp(pSnapshot->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt)) + && pSnapshot->mxFrame>=pInfo->nBackfillAttempted + ){ + assert( pWal->readLock>0 ); + memcpy(&pWal->hdr, pSnapshot, sizeof(WalIndexHdr)); + *pChanged = bChanged; + }else{ + rc = SQLITE_ERROR_SNAPSHOT; + } + + /* A client using a non-current snapshot may not ignore any frames + ** from the start of the wal file. This is because, for a system + ** where (minFrame < iSnapshot < maxFrame), a checkpointer may + ** have omitted to checkpoint a frame earlier than minFrame in + ** the file because there exists a frame after iSnapshot that + ** is the same database page. */ + pWal->minFrame = 1; + + if( rc!=SQLITE_OK ){ + sqlite3WalEndReadTransaction(pWal); + } + } + } + + /* Release the shared CKPT lock obtained above. */ + if( pWal->ckptLock ){ + assert( pSnapshot ); + walUnlockShared(pWal, WAL_CKPT_LOCK); + pWal->ckptLock = 0; + } +#endif + return rc; +} + +/* +** Finish with a read transaction. All this does is release the +** read-lock. +*/ +SQLITE_PRIVATE void sqlite3WalEndReadTransaction(Wal *pWal){ + sqlite3WalEndWriteTransaction(pWal); + if( pWal->readLock>=0 ){ + walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock)); + pWal->readLock = -1; + } +} + +/* +** Search the wal file for page pgno. If found, set *piRead to the frame that +** contains the page. Otherwise, if pgno is not in the wal file, set *piRead +** to zero. +** +** Return SQLITE_OK if successful, or an error code if an error occurs. If an +** error does occur, the final value of *piRead is undefined. +*/ +SQLITE_PRIVATE int sqlite3WalFindFrame( + Wal *pWal, /* WAL handle */ + Pgno pgno, /* Database page number to read data for */ + u32 *piRead /* OUT: Frame number (or zero) */ +){ + u32 iRead = 0; /* If !=0, WAL frame to return data from */ + u32 iLast = pWal->hdr.mxFrame; /* Last page in WAL for this reader */ + int iHash; /* Used to loop through N hash tables */ + int iMinHash; + + /* This routine is only be called from within a read transaction. */ + assert( pWal->readLock>=0 || pWal->lockError ); + + /* If the "last page" field of the wal-index header snapshot is 0, then + ** no data will be read from the wal under any circumstances. Return early + ** in this case as an optimization. Likewise, if pWal->readLock==0, + ** then the WAL is ignored by the reader so return early, as if the + ** WAL were empty. + */ + if( iLast==0 || (pWal->readLock==0 && pWal->bShmUnreliable==0) ){ + *piRead = 0; + return SQLITE_OK; + } + + /* Search the hash table or tables for an entry matching page number + ** pgno. Each iteration of the following for() loop searches one + ** hash table (each hash table indexes up to HASHTABLE_NPAGE frames). + ** + ** This code might run concurrently to the code in walIndexAppend() + ** that adds entries to the wal-index (and possibly to this hash + ** table). This means the value just read from the hash + ** slot (aHash[iKey]) may have been added before or after the + ** current read transaction was opened. Values added after the + ** read transaction was opened may have been written incorrectly - + ** i.e. these slots may contain garbage data. However, we assume + ** that any slots written before the current read transaction was + ** opened remain unmodified. + ** + ** For the reasons above, the if(...) condition featured in the inner + ** loop of the following block is more stringent that would be required + ** if we had exclusive access to the hash-table: + ** + ** (aPgno[iFrame]==pgno): + ** This condition filters out normal hash-table collisions. + ** + ** (iFrame<=iLast): + ** This condition filters out entries that were added to the hash + ** table after the current read-transaction had started. + */ + iMinHash = walFramePage(pWal->minFrame); + for(iHash=walFramePage(iLast); iHash>=iMinHash; iHash--){ + WalHashLoc sLoc; /* Hash table location */ + int iKey; /* Hash slot index */ + int nCollide; /* Number of hash collisions remaining */ + int rc; /* Error code */ + u32 iH; + + rc = walHashGet(pWal, iHash, &sLoc); + if( rc!=SQLITE_OK ){ + return rc; + } + nCollide = HASHTABLE_NSLOT; + iKey = walHash(pgno); + while( (iH = AtomicLoad(&sLoc.aHash[iKey]))!=0 ){ + u32 iFrame = iH + sLoc.iZero; + if( iFrame<=iLast && iFrame>=pWal->minFrame && sLoc.aPgno[iH]==pgno ){ + assert( iFrame>iRead || CORRUPT_DB ); + iRead = iFrame; + } + if( (nCollide--)==0 ){ + return SQLITE_CORRUPT_BKPT; + } + iKey = walNextHash(iKey); + } + if( iRead ) break; + } + +#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT + /* If expensive assert() statements are available, do a linear search + ** of the wal-index file content. Make sure the results agree with the + ** result obtained using the hash indexes above. */ + { + u32 iRead2 = 0; + u32 iTest; + assert( pWal->bShmUnreliable || pWal->minFrame>0 ); + for(iTest=iLast; iTest>=pWal->minFrame && iTest>0; iTest--){ + if( walFramePgno(pWal, iTest)==pgno ){ + iRead2 = iTest; + break; + } + } + assert( iRead==iRead2 ); + } +#endif + + *piRead = iRead; + return SQLITE_OK; +} + +/* +** Read the contents of frame iRead from the wal file into buffer pOut +** (which is nOut bytes in size). Return SQLITE_OK if successful, or an +** error code otherwise. +*/ +SQLITE_PRIVATE int sqlite3WalReadFrame( + Wal *pWal, /* WAL handle */ + u32 iRead, /* Frame to read */ + int nOut, /* Size of buffer pOut in bytes */ + u8 *pOut /* Buffer to write page data to */ +){ + int sz; + i64 iOffset; + sz = pWal->hdr.szPage; + sz = (sz&0xfe00) + ((sz&0x0001)<<16); + testcase( sz<=32768 ); + testcase( sz>=65536 ); + iOffset = walFrameOffset(iRead, sz) + WAL_FRAME_HDRSIZE; + /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */ + return sqlite3OsRead(pWal->pWalFd, pOut, (nOut>sz ? sz : nOut), iOffset); +} + +/* +** Return the size of the database in pages (or zero, if unknown). +*/ +SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal){ + if( pWal && ALWAYS(pWal->readLock>=0) ){ + return pWal->hdr.nPage; + } + return 0; +} + + +/* +** This function starts a write transaction on the WAL. +** +** A read transaction must have already been started by a prior call +** to sqlite3WalBeginReadTransaction(). +** +** If another thread or process has written into the database since +** the read transaction was started, then it is not possible for this +** thread to write as doing so would cause a fork. So this routine +** returns SQLITE_BUSY in that case and no write transaction is started. +** +** There can only be a single writer active at a time. +*/ +SQLITE_PRIVATE int sqlite3WalBeginWriteTransaction(Wal *pWal){ + int rc; + +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + /* If the write-lock is already held, then it was obtained before the + ** read-transaction was even opened, making this call a no-op. + ** Return early. */ + if( pWal->writeLock ){ + assert( !memcmp(&pWal->hdr,(void *)walIndexHdr(pWal),sizeof(WalIndexHdr)) ); + return SQLITE_OK; + } +#endif + + /* Cannot start a write transaction without first holding a read + ** transaction. */ + assert( pWal->readLock>=0 ); + assert( pWal->writeLock==0 && pWal->iReCksum==0 ); + + if( pWal->readOnly ){ + return SQLITE_READONLY; + } + + /* Only one writer allowed at a time. Get the write lock. Return + ** SQLITE_BUSY if unable. + */ + rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1); + if( rc ){ + return rc; + } + pWal->writeLock = 1; + + /* If another connection has written to the database file since the + ** time the read transaction on this connection was started, then + ** the write is disallowed. + */ + if( memcmp(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr))!=0 ){ + walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1); + pWal->writeLock = 0; + rc = SQLITE_BUSY_SNAPSHOT; + } + + return rc; +} + +/* +** End a write transaction. The commit has already been done. This +** routine merely releases the lock. +*/ +SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal){ + if( pWal->writeLock ){ + walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1); + pWal->writeLock = 0; + pWal->iReCksum = 0; + pWal->truncateOnCommit = 0; + } + return SQLITE_OK; +} + +/* +** If any data has been written (but not committed) to the log file, this +** function moves the write-pointer back to the start of the transaction. +** +** Additionally, the callback function is invoked for each frame written +** to the WAL since the start of the transaction. If the callback returns +** other than SQLITE_OK, it is not invoked again and the error code is +** returned to the caller. +** +** Otherwise, if the callback function does not return an error, this +** function returns SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx){ + int rc = SQLITE_OK; + if( ALWAYS(pWal->writeLock) ){ + Pgno iMax = pWal->hdr.mxFrame; + Pgno iFrame; + + /* Restore the clients cache of the wal-index header to the state it + ** was in before the client began writing to the database. + */ + memcpy(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr)); + + for(iFrame=pWal->hdr.mxFrame+1; + ALWAYS(rc==SQLITE_OK) && iFrame<=iMax; + iFrame++ + ){ + /* This call cannot fail. Unless the page for which the page number + ** is passed as the second argument is (a) in the cache and + ** (b) has an outstanding reference, then xUndo is either a no-op + ** (if (a) is false) or simply expels the page from the cache (if (b) + ** is false). + ** + ** If the upper layer is doing a rollback, it is guaranteed that there + ** are no outstanding references to any page other than page 1. And + ** page 1 is never written to the log until the transaction is + ** committed. As a result, the call to xUndo may not fail. + */ + assert( walFramePgno(pWal, iFrame)!=1 ); + rc = xUndo(pUndoCtx, walFramePgno(pWal, iFrame)); + } + if( iMax!=pWal->hdr.mxFrame ) walCleanupHash(pWal); + } + return rc; +} + +/* +** Argument aWalData must point to an array of WAL_SAVEPOINT_NDATA u32 +** values. This function populates the array with values required to +** "rollback" the write position of the WAL handle back to the current +** point in the event of a savepoint rollback (via WalSavepointUndo()). +*/ +SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData){ + assert( pWal->writeLock ); + aWalData[0] = pWal->hdr.mxFrame; + aWalData[1] = pWal->hdr.aFrameCksum[0]; + aWalData[2] = pWal->hdr.aFrameCksum[1]; + aWalData[3] = pWal->nCkpt; +} + +/* +** Move the write position of the WAL back to the point identified by +** the values in the aWalData[] array. aWalData must point to an array +** of WAL_SAVEPOINT_NDATA u32 values that has been previously populated +** by a call to WalSavepoint(). +*/ +SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData){ + int rc = SQLITE_OK; + + assert( pWal->writeLock ); + assert( aWalData[3]!=pWal->nCkpt || aWalData[0]<=pWal->hdr.mxFrame ); + + if( aWalData[3]!=pWal->nCkpt ){ + /* This savepoint was opened immediately after the write-transaction + ** was started. Right after that, the writer decided to wrap around + ** to the start of the log. Update the savepoint values to match. + */ + aWalData[0] = 0; + aWalData[3] = pWal->nCkpt; + } + + if( aWalData[0]hdr.mxFrame ){ + pWal->hdr.mxFrame = aWalData[0]; + pWal->hdr.aFrameCksum[0] = aWalData[1]; + pWal->hdr.aFrameCksum[1] = aWalData[2]; + walCleanupHash(pWal); + } + + return rc; +} + +/* +** This function is called just before writing a set of frames to the log +** file (see sqlite3WalFrames()). It checks to see if, instead of appending +** to the current log file, it is possible to overwrite the start of the +** existing log file with the new frames (i.e. "reset" the log). If so, +** it sets pWal->hdr.mxFrame to 0. Otherwise, pWal->hdr.mxFrame is left +** unchanged. +** +** SQLITE_OK is returned if no error is encountered (regardless of whether +** or not pWal->hdr.mxFrame is modified). An SQLite error code is returned +** if an error occurs. +*/ +static int walRestartLog(Wal *pWal){ + int rc = SQLITE_OK; + int cnt; + + if( pWal->readLock==0 ){ + volatile WalCkptInfo *pInfo = walCkptInfo(pWal); + assert( pInfo->nBackfill==pWal->hdr.mxFrame ); + if( pInfo->nBackfill>0 ){ + u32 salt1; + sqlite3_randomness(4, &salt1); + rc = walLockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1); + if( rc==SQLITE_OK ){ + /* If all readers are using WAL_READ_LOCK(0) (in other words if no + ** readers are currently using the WAL), then the transactions + ** frames will overwrite the start of the existing log. Update the + ** wal-index header to reflect this. + ** + ** In theory it would be Ok to update the cache of the header only + ** at this point. But updating the actual wal-index header is also + ** safe and means there is no special case for sqlite3WalUndo() + ** to handle if this transaction is rolled back. */ + walRestartHdr(pWal, salt1); + walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1); + }else if( rc!=SQLITE_BUSY ){ + return rc; + } + } + walUnlockShared(pWal, WAL_READ_LOCK(0)); + pWal->readLock = -1; + cnt = 0; + do{ + int notUsed; + rc = walTryBeginRead(pWal, ¬Used, 1, ++cnt); + }while( rc==WAL_RETRY ); + assert( (rc&0xff)!=SQLITE_BUSY ); /* BUSY not possible when useWal==1 */ + testcase( (rc&0xff)==SQLITE_IOERR ); + testcase( rc==SQLITE_PROTOCOL ); + testcase( rc==SQLITE_OK ); + } + return rc; +} + +/* +** Information about the current state of the WAL file and where +** the next fsync should occur - passed from sqlite3WalFrames() into +** walWriteToLog(). +*/ +typedef struct WalWriter { + Wal *pWal; /* The complete WAL information */ + sqlite3_file *pFd; /* The WAL file to which we write */ + sqlite3_int64 iSyncPoint; /* Fsync at this offset */ + int syncFlags; /* Flags for the fsync */ + int szPage; /* Size of one page */ +} WalWriter; + +/* +** Write iAmt bytes of content into the WAL file beginning at iOffset. +** Do a sync when crossing the p->iSyncPoint boundary. +** +** In other words, if iSyncPoint is in between iOffset and iOffset+iAmt, +** first write the part before iSyncPoint, then sync, then write the +** rest. +*/ +static int walWriteToLog( + WalWriter *p, /* WAL to write to */ + void *pContent, /* Content to be written */ + int iAmt, /* Number of bytes to write */ + sqlite3_int64 iOffset /* Start writing at this offset */ +){ + int rc; + if( iOffsetiSyncPoint && iOffset+iAmt>=p->iSyncPoint ){ + int iFirstAmt = (int)(p->iSyncPoint - iOffset); + rc = sqlite3OsWrite(p->pFd, pContent, iFirstAmt, iOffset); + if( rc ) return rc; + iOffset += iFirstAmt; + iAmt -= iFirstAmt; + pContent = (void*)(iFirstAmt + (char*)pContent); + assert( WAL_SYNC_FLAGS(p->syncFlags)!=0 ); + rc = sqlite3OsSync(p->pFd, WAL_SYNC_FLAGS(p->syncFlags)); + if( iAmt==0 || rc ) return rc; + } + rc = sqlite3OsWrite(p->pFd, pContent, iAmt, iOffset); + return rc; +} + +/* +** Write out a single frame of the WAL +*/ +static int walWriteOneFrame( + WalWriter *p, /* Where to write the frame */ + PgHdr *pPage, /* The page of the frame to be written */ + int nTruncate, /* The commit flag. Usually 0. >0 for commit */ + sqlite3_int64 iOffset /* Byte offset at which to write */ +){ + int rc; /* Result code from subfunctions */ + void *pData; /* Data actually written */ + u8 aFrame[WAL_FRAME_HDRSIZE]; /* Buffer to assemble frame-header in */ + pData = pPage->pData; + walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame); + rc = walWriteToLog(p, aFrame, sizeof(aFrame), iOffset); + if( rc ) return rc; + /* Write the page data */ + rc = walWriteToLog(p, pData, p->szPage, iOffset+sizeof(aFrame)); + return rc; +} + +/* +** This function is called as part of committing a transaction within which +** one or more frames have been overwritten. It updates the checksums for +** all frames written to the wal file by the current transaction starting +** with the earliest to have been overwritten. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +static int walRewriteChecksums(Wal *pWal, u32 iLast){ + const int szPage = pWal->szPage;/* Database page size */ + int rc = SQLITE_OK; /* Return code */ + u8 *aBuf; /* Buffer to load data from wal file into */ + u8 aFrame[WAL_FRAME_HDRSIZE]; /* Buffer to assemble frame-headers in */ + u32 iRead; /* Next frame to read from wal file */ + i64 iCksumOff; + + aBuf = sqlite3_malloc(szPage + WAL_FRAME_HDRSIZE); + if( aBuf==0 ) return SQLITE_NOMEM_BKPT; + + /* Find the checksum values to use as input for the recalculating the + ** first checksum. If the first frame is frame 1 (implying that the current + ** transaction restarted the wal file), these values must be read from the + ** wal-file header. Otherwise, read them from the frame header of the + ** previous frame. */ + assert( pWal->iReCksum>0 ); + if( pWal->iReCksum==1 ){ + iCksumOff = 24; + }else{ + iCksumOff = walFrameOffset(pWal->iReCksum-1, szPage) + 16; + } + rc = sqlite3OsRead(pWal->pWalFd, aBuf, sizeof(u32)*2, iCksumOff); + pWal->hdr.aFrameCksum[0] = sqlite3Get4byte(aBuf); + pWal->hdr.aFrameCksum[1] = sqlite3Get4byte(&aBuf[sizeof(u32)]); + + iRead = pWal->iReCksum; + pWal->iReCksum = 0; + for(; rc==SQLITE_OK && iRead<=iLast; iRead++){ + i64 iOff = walFrameOffset(iRead, szPage); + rc = sqlite3OsRead(pWal->pWalFd, aBuf, szPage+WAL_FRAME_HDRSIZE, iOff); + if( rc==SQLITE_OK ){ + u32 iPgno, nDbSize; + iPgno = sqlite3Get4byte(aBuf); + nDbSize = sqlite3Get4byte(&aBuf[4]); + + walEncodeFrame(pWal, iPgno, nDbSize, &aBuf[WAL_FRAME_HDRSIZE], aFrame); + rc = sqlite3OsWrite(pWal->pWalFd, aFrame, sizeof(aFrame), iOff); + } + } + + sqlite3_free(aBuf); + return rc; +} + +/* +** Write a set of frames to the log. The caller must hold the write-lock +** on the log file (obtained using sqlite3WalBeginWriteTransaction()). +*/ +SQLITE_PRIVATE int sqlite3WalFrames( + Wal *pWal, /* Wal handle to write to */ + int szPage, /* Database page-size in bytes */ + PgHdr *pList, /* List of dirty pages to write */ + Pgno nTruncate, /* Database size after this commit */ + int isCommit, /* True if this is a commit */ + int sync_flags /* Flags to pass to OsSync() (or 0) */ +){ + int rc; /* Used to catch return codes */ + u32 iFrame; /* Next frame address */ + PgHdr *p; /* Iterator to run through pList with. */ + PgHdr *pLast = 0; /* Last frame in list */ + int nExtra = 0; /* Number of extra copies of last page */ + int szFrame; /* The size of a single frame */ + i64 iOffset; /* Next byte to write in WAL file */ + WalWriter w; /* The writer */ + u32 iFirst = 0; /* First frame that may be overwritten */ + WalIndexHdr *pLive; /* Pointer to shared header */ + + assert( pList ); + assert( pWal->writeLock ); + + /* If this frame set completes a transaction, then nTruncate>0. If + ** nTruncate==0 then this frame set does not complete the transaction. */ + assert( (isCommit!=0)==(nTruncate!=0) ); + +#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG) + { int cnt; for(cnt=0, p=pList; p; p=p->pDirty, cnt++){} + WALTRACE(("WAL%p: frame write begin. %d frames. mxFrame=%d. %s\n", + pWal, cnt, pWal->hdr.mxFrame, isCommit ? "Commit" : "Spill")); + } +#endif + + pLive = (WalIndexHdr*)walIndexHdr(pWal); + if( memcmp(&pWal->hdr, (void *)pLive, sizeof(WalIndexHdr))!=0 ){ + iFirst = pLive->mxFrame+1; + } + + /* See if it is possible to write these frames into the start of the + ** log file, instead of appending to it at pWal->hdr.mxFrame. + */ + if( SQLITE_OK!=(rc = walRestartLog(pWal)) ){ + return rc; + } + + /* If this is the first frame written into the log, write the WAL + ** header to the start of the WAL file. See comments at the top of + ** this source file for a description of the WAL header format. + */ + iFrame = pWal->hdr.mxFrame; + if( iFrame==0 ){ + u8 aWalHdr[WAL_HDRSIZE]; /* Buffer to assemble wal-header in */ + u32 aCksum[2]; /* Checksum for wal-header */ + + sqlite3Put4byte(&aWalHdr[0], (WAL_MAGIC | SQLITE_BIGENDIAN)); + sqlite3Put4byte(&aWalHdr[4], WAL_MAX_VERSION); + sqlite3Put4byte(&aWalHdr[8], szPage); + sqlite3Put4byte(&aWalHdr[12], pWal->nCkpt); + if( pWal->nCkpt==0 ) sqlite3_randomness(8, pWal->hdr.aSalt); + memcpy(&aWalHdr[16], pWal->hdr.aSalt, 8); + walChecksumBytes(1, aWalHdr, WAL_HDRSIZE-2*4, 0, aCksum); + sqlite3Put4byte(&aWalHdr[24], aCksum[0]); + sqlite3Put4byte(&aWalHdr[28], aCksum[1]); + + pWal->szPage = szPage; + pWal->hdr.bigEndCksum = SQLITE_BIGENDIAN; + pWal->hdr.aFrameCksum[0] = aCksum[0]; + pWal->hdr.aFrameCksum[1] = aCksum[1]; + pWal->truncateOnCommit = 1; + + rc = sqlite3OsWrite(pWal->pWalFd, aWalHdr, sizeof(aWalHdr), 0); + WALTRACE(("WAL%p: wal-header write %s\n", pWal, rc ? "failed" : "ok")); + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Sync the header (unless SQLITE_IOCAP_SEQUENTIAL is true or unless + ** all syncing is turned off by PRAGMA synchronous=OFF). Otherwise + ** an out-of-order write following a WAL restart could result in + ** database corruption. See the ticket: + ** + ** https://sqlite.org/src/info/ff5be73dee + */ + if( pWal->syncHeader ){ + rc = sqlite3OsSync(pWal->pWalFd, CKPT_SYNC_FLAGS(sync_flags)); + if( rc ) return rc; + } + } + assert( (int)pWal->szPage==szPage ); + + /* Setup information needed to write frames into the WAL */ + w.pWal = pWal; + w.pFd = pWal->pWalFd; + w.iSyncPoint = 0; + w.syncFlags = sync_flags; + w.szPage = szPage; + iOffset = walFrameOffset(iFrame+1, szPage); + szFrame = szPage + WAL_FRAME_HDRSIZE; + + /* Write all frames into the log file exactly once */ + for(p=pList; p; p=p->pDirty){ + int nDbSize; /* 0 normally. Positive == commit flag */ + + /* Check if this page has already been written into the wal file by + ** the current transaction. If so, overwrite the existing frame and + ** set Wal.writeLock to WAL_WRITELOCK_RECKSUM - indicating that + ** checksums must be recomputed when the transaction is committed. */ + if( iFirst && (p->pDirty || isCommit==0) ){ + u32 iWrite = 0; + VVA_ONLY(rc =) sqlite3WalFindFrame(pWal, p->pgno, &iWrite); + assert( rc==SQLITE_OK || iWrite==0 ); + if( iWrite>=iFirst ){ + i64 iOff = walFrameOffset(iWrite, szPage) + WAL_FRAME_HDRSIZE; + void *pData; + if( pWal->iReCksum==0 || iWriteiReCksum ){ + pWal->iReCksum = iWrite; + } + pData = p->pData; + rc = sqlite3OsWrite(pWal->pWalFd, pData, szPage, iOff); + if( rc ) return rc; + p->flags &= ~PGHDR_WAL_APPEND; + continue; + } + } + + iFrame++; + assert( iOffset==walFrameOffset(iFrame, szPage) ); + nDbSize = (isCommit && p->pDirty==0) ? nTruncate : 0; + rc = walWriteOneFrame(&w, p, nDbSize, iOffset); + if( rc ) return rc; + pLast = p; + iOffset += szFrame; + p->flags |= PGHDR_WAL_APPEND; + } + + /* Recalculate checksums within the wal file if required. */ + if( isCommit && pWal->iReCksum ){ + rc = walRewriteChecksums(pWal, iFrame); + if( rc ) return rc; + } + + /* If this is the end of a transaction, then we might need to pad + ** the transaction and/or sync the WAL file. + ** + ** Padding and syncing only occur if this set of frames complete a + ** transaction and if PRAGMA synchronous=FULL. If synchronous==NORMAL + ** or synchronous==OFF, then no padding or syncing are needed. + ** + ** If SQLITE_IOCAP_POWERSAFE_OVERWRITE is defined, then padding is not + ** needed and only the sync is done. If padding is needed, then the + ** final frame is repeated (with its commit mark) until the next sector + ** boundary is crossed. Only the part of the WAL prior to the last + ** sector boundary is synced; the part of the last frame that extends + ** past the sector boundary is written after the sync. + */ + if( isCommit && WAL_SYNC_FLAGS(sync_flags)!=0 ){ + int bSync = 1; + if( pWal->padToSectorBoundary ){ + int sectorSize = sqlite3SectorSize(pWal->pWalFd); + w.iSyncPoint = ((iOffset+sectorSize-1)/sectorSize)*sectorSize; + bSync = (w.iSyncPoint==iOffset); + testcase( bSync ); + while( iOffsettruncateOnCommit && pWal->mxWalSize>=0 ){ + i64 sz = pWal->mxWalSize; + if( walFrameOffset(iFrame+nExtra+1, szPage)>pWal->mxWalSize ){ + sz = walFrameOffset(iFrame+nExtra+1, szPage); + } + walLimitSize(pWal, sz); + pWal->truncateOnCommit = 0; + } + + /* Append data to the wal-index. It is not necessary to lock the + ** wal-index to do this as the SQLITE_SHM_WRITE lock held on the wal-index + ** guarantees that there are no other writers, and no data that may + ** be in use by existing readers is being overwritten. + */ + iFrame = pWal->hdr.mxFrame; + for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){ + if( (p->flags & PGHDR_WAL_APPEND)==0 ) continue; + iFrame++; + rc = walIndexAppend(pWal, iFrame, p->pgno); + } + assert( pLast!=0 || nExtra==0 ); + while( rc==SQLITE_OK && nExtra>0 ){ + iFrame++; + nExtra--; + rc = walIndexAppend(pWal, iFrame, pLast->pgno); + } + + if( rc==SQLITE_OK ){ + /* Update the private copy of the header. */ + pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16)); + testcase( szPage<=32768 ); + testcase( szPage>=65536 ); + pWal->hdr.mxFrame = iFrame; + if( isCommit ){ + pWal->hdr.iChange++; + pWal->hdr.nPage = nTruncate; + } + /* If this is a commit, update the wal-index header too. */ + if( isCommit ){ + walIndexWriteHdr(pWal); + pWal->iCallback = iFrame; + } + } + + WALTRACE(("WAL%p: frame write %s\n", pWal, rc ? "failed" : "ok")); + return rc; +} + +/* +** This routine is called to implement sqlite3_wal_checkpoint() and +** related interfaces. +** +** Obtain a CHECKPOINT lock and then backfill as much information as +** we can from WAL into the database. +** +** If parameter xBusy is not NULL, it is a pointer to a busy-handler +** callback. In this case this function runs a blocking checkpoint. +*/ +SQLITE_PRIVATE int sqlite3WalCheckpoint( + Wal *pWal, /* Wal connection */ + sqlite3 *db, /* Check this handle's interrupt flag */ + int eMode, /* PASSIVE, FULL, RESTART, or TRUNCATE */ + int (*xBusy)(void*), /* Function to call when busy */ + void *pBusyArg, /* Context argument for xBusyHandler */ + int sync_flags, /* Flags to sync db file with (or 0) */ + int nBuf, /* Size of temporary buffer */ + u8 *zBuf, /* Temporary buffer to use */ + int *pnLog, /* OUT: Number of frames in WAL */ + int *pnCkpt /* OUT: Number of backfilled frames in WAL */ +){ + int rc; /* Return code */ + int isChanged = 0; /* True if a new wal-index header is loaded */ + int eMode2 = eMode; /* Mode to pass to walCheckpoint() */ + int (*xBusy2)(void*) = xBusy; /* Busy handler for eMode2 */ + + assert( pWal->ckptLock==0 ); + assert( pWal->writeLock==0 ); + + /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked + ** in the SQLITE_CHECKPOINT_PASSIVE mode. */ + assert( eMode!=SQLITE_CHECKPOINT_PASSIVE || xBusy==0 ); + + if( pWal->readOnly ) return SQLITE_READONLY; + WALTRACE(("WAL%p: checkpoint begins\n", pWal)); + + /* Enable blocking locks, if possible. If blocking locks are successfully + ** enabled, set xBusy2=0 so that the busy-handler is never invoked. */ + sqlite3WalDb(pWal, db); + (void)walEnableBlocking(pWal); + + /* IMPLEMENTATION-OF: R-62028-47212 All calls obtain an exclusive + ** "checkpoint" lock on the database file. + ** EVIDENCE-OF: R-10421-19736 If any other process is running a + ** checkpoint operation at the same time, the lock cannot be obtained and + ** SQLITE_BUSY is returned. + ** EVIDENCE-OF: R-53820-33897 Even if there is a busy-handler configured, + ** it will not be invoked in this case. + */ + rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1); + testcase( rc==SQLITE_BUSY ); + testcase( rc!=SQLITE_OK && xBusy2!=0 ); + if( rc==SQLITE_OK ){ + pWal->ckptLock = 1; + + /* IMPLEMENTATION-OF: R-59782-36818 The SQLITE_CHECKPOINT_FULL, RESTART and + ** TRUNCATE modes also obtain the exclusive "writer" lock on the database + ** file. + ** + ** EVIDENCE-OF: R-60642-04082 If the writer lock cannot be obtained + ** immediately, and a busy-handler is configured, it is invoked and the + ** writer lock retried until either the busy-handler returns 0 or the + ** lock is successfully obtained. + */ + if( eMode!=SQLITE_CHECKPOINT_PASSIVE ){ + rc = walBusyLock(pWal, xBusy2, pBusyArg, WAL_WRITE_LOCK, 1); + if( rc==SQLITE_OK ){ + pWal->writeLock = 1; + }else if( rc==SQLITE_BUSY ){ + eMode2 = SQLITE_CHECKPOINT_PASSIVE; + xBusy2 = 0; + rc = SQLITE_OK; + } + } + } + + + /* Read the wal-index header. */ + if( rc==SQLITE_OK ){ + walDisableBlocking(pWal); + rc = walIndexReadHdr(pWal, &isChanged); + (void)walEnableBlocking(pWal); + if( isChanged && pWal->pDbFd->pMethods->iVersion>=3 ){ + sqlite3OsUnfetch(pWal->pDbFd, 0, 0); + } + } + + /* Copy data from the log to the database file. */ + if( rc==SQLITE_OK ){ + + if( pWal->hdr.mxFrame && walPagesize(pWal)!=nBuf ){ + rc = SQLITE_CORRUPT_BKPT; + }else{ + rc = walCheckpoint(pWal, db, eMode2, xBusy2, pBusyArg, sync_flags, zBuf); + } + + /* If no error occurred, set the output variables. */ + if( rc==SQLITE_OK || rc==SQLITE_BUSY ){ + if( pnLog ) *pnLog = (int)pWal->hdr.mxFrame; + if( pnCkpt ) *pnCkpt = (int)(walCkptInfo(pWal)->nBackfill); + } + } + + if( isChanged ){ + /* If a new wal-index header was loaded before the checkpoint was + ** performed, then the pager-cache associated with pWal is now + ** out of date. So zero the cached wal-index header to ensure that + ** next time the pager opens a snapshot on this database it knows that + ** the cache needs to be reset. + */ + memset(&pWal->hdr, 0, sizeof(WalIndexHdr)); + } + + walDisableBlocking(pWal); + sqlite3WalDb(pWal, 0); + + /* Release the locks. */ + sqlite3WalEndWriteTransaction(pWal); + if( pWal->ckptLock ){ + walUnlockExclusive(pWal, WAL_CKPT_LOCK, 1); + pWal->ckptLock = 0; + } + WALTRACE(("WAL%p: checkpoint %s\n", pWal, rc ? "failed" : "ok")); +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + if( rc==SQLITE_BUSY_TIMEOUT ) rc = SQLITE_BUSY; +#endif + return (rc==SQLITE_OK && eMode!=eMode2 ? SQLITE_BUSY : rc); +} + +/* Return the value to pass to a sqlite3_wal_hook callback, the +** number of frames in the WAL at the point of the last commit since +** sqlite3WalCallback() was called. If no commits have occurred since +** the last call, then return 0. +*/ +SQLITE_PRIVATE int sqlite3WalCallback(Wal *pWal){ + u32 ret = 0; + if( pWal ){ + ret = pWal->iCallback; + pWal->iCallback = 0; + } + return (int)ret; +} + +/* +** This function is called to change the WAL subsystem into or out +** of locking_mode=EXCLUSIVE. +** +** If op is zero, then attempt to change from locking_mode=EXCLUSIVE +** into locking_mode=NORMAL. This means that we must acquire a lock +** on the pWal->readLock byte. If the WAL is already in locking_mode=NORMAL +** or if the acquisition of the lock fails, then return 0. If the +** transition out of exclusive-mode is successful, return 1. This +** operation must occur while the pager is still holding the exclusive +** lock on the main database file. +** +** If op is one, then change from locking_mode=NORMAL into +** locking_mode=EXCLUSIVE. This means that the pWal->readLock must +** be released. Return 1 if the transition is made and 0 if the +** WAL is already in exclusive-locking mode - meaning that this +** routine is a no-op. The pager must already hold the exclusive lock +** on the main database file before invoking this operation. +** +** If op is negative, then do a dry-run of the op==1 case but do +** not actually change anything. The pager uses this to see if it +** should acquire the database exclusive lock prior to invoking +** the op==1 case. +*/ +SQLITE_PRIVATE int sqlite3WalExclusiveMode(Wal *pWal, int op){ + int rc; + assert( pWal->writeLock==0 ); + assert( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE || op==-1 ); + + /* pWal->readLock is usually set, but might be -1 if there was a + ** prior error while attempting to acquire are read-lock. This cannot + ** happen if the connection is actually in exclusive mode (as no xShmLock + ** locks are taken in this case). Nor should the pager attempt to + ** upgrade to exclusive-mode following such an error. + */ + assert( pWal->readLock>=0 || pWal->lockError ); + assert( pWal->readLock>=0 || (op<=0 && pWal->exclusiveMode==0) ); + + if( op==0 ){ + if( pWal->exclusiveMode!=WAL_NORMAL_MODE ){ + pWal->exclusiveMode = WAL_NORMAL_MODE; + if( walLockShared(pWal, WAL_READ_LOCK(pWal->readLock))!=SQLITE_OK ){ + pWal->exclusiveMode = WAL_EXCLUSIVE_MODE; + } + rc = pWal->exclusiveMode==WAL_NORMAL_MODE; + }else{ + /* Already in locking_mode=NORMAL */ + rc = 0; + } + }else if( op>0 ){ + assert( pWal->exclusiveMode==WAL_NORMAL_MODE ); + assert( pWal->readLock>=0 ); + walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock)); + pWal->exclusiveMode = WAL_EXCLUSIVE_MODE; + rc = 1; + }else{ + rc = pWal->exclusiveMode==WAL_NORMAL_MODE; + } + return rc; +} + +/* +** Return true if the argument is non-NULL and the WAL module is using +** heap-memory for the wal-index. Otherwise, if the argument is NULL or the +** WAL module is using shared-memory, return false. +*/ +SQLITE_PRIVATE int sqlite3WalHeapMemory(Wal *pWal){ + return (pWal && pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ); +} + +#ifdef SQLITE_ENABLE_SNAPSHOT +/* Create a snapshot object. The content of a snapshot is opaque to +** every other subsystem, so the WAL module can put whatever it needs +** in the object. +*/ +SQLITE_PRIVATE int sqlite3WalSnapshotGet(Wal *pWal, sqlite3_snapshot **ppSnapshot){ + int rc = SQLITE_OK; + WalIndexHdr *pRet; + static const u32 aZero[4] = { 0, 0, 0, 0 }; + + assert( pWal->readLock>=0 && pWal->writeLock==0 ); + + if( memcmp(&pWal->hdr.aFrameCksum[0],aZero,16)==0 ){ + *ppSnapshot = 0; + return SQLITE_ERROR; + } + pRet = (WalIndexHdr*)sqlite3_malloc(sizeof(WalIndexHdr)); + if( pRet==0 ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + memcpy(pRet, &pWal->hdr, sizeof(WalIndexHdr)); + *ppSnapshot = (sqlite3_snapshot*)pRet; + } + + return rc; +} + +/* Try to open on pSnapshot when the next read-transaction starts +*/ +SQLITE_PRIVATE void sqlite3WalSnapshotOpen( + Wal *pWal, + sqlite3_snapshot *pSnapshot +){ + pWal->pSnapshot = (WalIndexHdr*)pSnapshot; +} + +/* +** Return a +ve value if snapshot p1 is newer than p2. A -ve value if +** p1 is older than p2 and zero if p1 and p2 are the same snapshot. +*/ +SQLITE_API int sqlite3_snapshot_cmp(sqlite3_snapshot *p1, sqlite3_snapshot *p2){ + WalIndexHdr *pHdr1 = (WalIndexHdr*)p1; + WalIndexHdr *pHdr2 = (WalIndexHdr*)p2; + + /* aSalt[0] is a copy of the value stored in the wal file header. It + ** is incremented each time the wal file is restarted. */ + if( pHdr1->aSalt[0]aSalt[0] ) return -1; + if( pHdr1->aSalt[0]>pHdr2->aSalt[0] ) return +1; + if( pHdr1->mxFramemxFrame ) return -1; + if( pHdr1->mxFrame>pHdr2->mxFrame ) return +1; + return 0; +} + +/* +** The caller currently has a read transaction open on the database. +** This function takes a SHARED lock on the CHECKPOINTER slot and then +** checks if the snapshot passed as the second argument is still +** available. If so, SQLITE_OK is returned. +** +** If the snapshot is not available, SQLITE_ERROR is returned. Or, if +** the CHECKPOINTER lock cannot be obtained, SQLITE_BUSY. If any error +** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER +** lock is released before returning. +*/ +SQLITE_PRIVATE int sqlite3WalSnapshotCheck(Wal *pWal, sqlite3_snapshot *pSnapshot){ + int rc; + rc = walLockShared(pWal, WAL_CKPT_LOCK); + if( rc==SQLITE_OK ){ + WalIndexHdr *pNew = (WalIndexHdr*)pSnapshot; + if( memcmp(pNew->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt)) + || pNew->mxFramenBackfillAttempted + ){ + rc = SQLITE_ERROR_SNAPSHOT; + walUnlockShared(pWal, WAL_CKPT_LOCK); + } + } + return rc; +} + +/* +** Release a lock obtained by an earlier successful call to +** sqlite3WalSnapshotCheck(). +*/ +SQLITE_PRIVATE void sqlite3WalSnapshotUnlock(Wal *pWal){ + assert( pWal ); + walUnlockShared(pWal, WAL_CKPT_LOCK); +} + + +#endif /* SQLITE_ENABLE_SNAPSHOT */ + +#ifdef SQLITE_ENABLE_ZIPVFS +/* +** If the argument is not NULL, it points to a Wal object that holds a +** read-lock. This function returns the database page-size if it is known, +** or zero if it is not (or if pWal is NULL). +*/ +SQLITE_PRIVATE int sqlite3WalFramesize(Wal *pWal){ + assert( pWal==0 || pWal->readLock>=0 ); + return (pWal ? pWal->szPage : 0); +} +#endif + +/* Return the sqlite3_file object for the WAL file +*/ +SQLITE_PRIVATE sqlite3_file *sqlite3WalFile(Wal *pWal){ + return pWal->pWalFd; +} + +#endif /* #ifndef SQLITE_OMIT_WAL */ + +/************** End of wal.c *************************************************/ +/************** Begin file btmutex.c *****************************************/ +/* +** 2007 August 27 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code used to implement mutexes on Btree objects. +** This code really belongs in btree.c. But btree.c is getting too +** big and we want to break it down some. This packaged seemed like +** a good breakout. +*/ +/************** Include btreeInt.h in the middle of btmutex.c ****************/ +/************** Begin file btreeInt.h ****************************************/ +/* +** 2004 April 6 +** +** 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 an external (disk-based) database using BTrees. +** For a detailed discussion of BTrees, refer to +** +** Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3: +** "Sorting And Searching", pages 473-480. Addison-Wesley +** Publishing Company, Reading, Massachusetts. +** +** The basic idea is that each page of the file contains N database +** entries and N+1 pointers to subpages. +** +** ---------------------------------------------------------------- +** | Ptr(0) | Key(0) | Ptr(1) | Key(1) | ... | Key(N-1) | Ptr(N) | +** ---------------------------------------------------------------- +** +** All of the keys on the page that Ptr(0) points to have values less +** than Key(0). All of the keys on page Ptr(1) and its subpages have +** values greater than Key(0) and less than Key(1). All of the keys +** on Ptr(N) and its subpages have values greater than Key(N-1). And +** so forth. +** +** Finding a particular key requires reading O(log(M)) pages from the +** disk where M is the number of entries in the tree. +** +** In this implementation, a single file can hold one or more separate +** BTrees. Each BTree is identified by the index of its root page. The +** key and data for any entry are combined to form the "payload". A +** fixed amount of payload can be carried directly on the database +** page. If the payload is larger than the preset amount then surplus +** bytes are stored on overflow pages. The payload for an entry +** and the preceding pointer are combined to form a "Cell". Each +** page has a small header which contains the Ptr(N) pointer and other +** information such as the size of key and data. +** +** FORMAT DETAILS +** +** The file is divided into pages. The first page is called page 1, +** the second is page 2, and so forth. A page number of zero indicates +** "no such page". The page size can be any power of 2 between 512 and 65536. +** Each page can be either a btree page, a freelist page, an overflow +** page, or a pointer-map page. +** +** The first page is always a btree page. The first 100 bytes of the first +** page contain a special header (the "file header") that describes the file. +** The format of the file header is as follows: +** +** OFFSET SIZE DESCRIPTION +** 0 16 Header string: "SQLite format 3\000" +** 16 2 Page size in bytes. (1 means 65536) +** 18 1 File format write version +** 19 1 File format read version +** 20 1 Bytes of unused space at the end of each page +** 21 1 Max embedded payload fraction (must be 64) +** 22 1 Min embedded payload fraction (must be 32) +** 23 1 Min leaf payload fraction (must be 32) +** 24 4 File change counter +** 28 4 Reserved for future use +** 32 4 First freelist page +** 36 4 Number of freelist pages in the file +** 40 60 15 4-byte meta values passed to higher layers +** +** 40 4 Schema cookie +** 44 4 File format of schema layer +** 48 4 Size of page cache +** 52 4 Largest root-page (auto/incr_vacuum) +** 56 4 1=UTF-8 2=UTF16le 3=UTF16be +** 60 4 User version +** 64 4 Incremental vacuum mode +** 68 4 Application-ID +** 72 20 unused +** 92 4 The version-valid-for number +** 96 4 SQLITE_VERSION_NUMBER +** +** All of the integer values are big-endian (most significant byte first). +** +** The file change counter is incremented when the database is changed +** This counter allows other processes to know when the file has changed +** and thus when they need to flush their cache. +** +** The max embedded payload fraction is the amount of the total usable +** space in a page that can be consumed by a single cell for standard +** B-tree (non-LEAFDATA) tables. A value of 255 means 100%. The default +** is to limit the maximum cell size so that at least 4 cells will fit +** on one page. Thus the default max embedded payload fraction is 64. +** +** If the payload for a cell is larger than the max payload, then extra +** payload is spilled to overflow pages. Once an overflow page is allocated, +** as many bytes as possible are moved into the overflow pages without letting +** the cell size drop below the min embedded payload fraction. +** +** The min leaf payload fraction is like the min embedded payload fraction +** except that it applies to leaf nodes in a LEAFDATA tree. The maximum +** payload fraction for a LEAFDATA tree is always 100% (or 255) and it +** not specified in the header. +** +** Each btree pages is divided into three sections: The header, the +** cell pointer array, and the cell content area. Page 1 also has a 100-byte +** file header that occurs before the page header. +** +** |----------------| +** | file header | 100 bytes. Page 1 only. +** |----------------| +** | page header | 8 bytes for leaves. 12 bytes for interior nodes +** |----------------| +** | cell pointer | | 2 bytes per cell. Sorted order. +** | array | | Grows downward +** | | v +** |----------------| +** | unallocated | +** | space | +** |----------------| ^ Grows upwards +** | cell content | | Arbitrary order interspersed with freeblocks. +** | area | | and free space fragments. +** |----------------| +** +** The page headers looks like this: +** +** OFFSET SIZE DESCRIPTION +** 0 1 Flags. 1: intkey, 2: zerodata, 4: leafdata, 8: leaf +** 1 2 byte offset to the first freeblock +** 3 2 number of cells on this page +** 5 2 first byte of the cell content area +** 7 1 number of fragmented free bytes +** 8 4 Right child (the Ptr(N) value). Omitted on leaves. +** +** The flags define the format of this btree page. The leaf flag means that +** this page has no children. The zerodata flag means that this page carries +** only keys and no data. The intkey flag means that the key is an integer +** which is stored in the key size entry of the cell header rather than in +** the payload area. +** +** The cell pointer array begins on the first byte after the page header. +** The cell pointer array contains zero or more 2-byte numbers which are +** offsets from the beginning of the page to the cell content in the cell +** content area. The cell pointers occur in sorted order. The system strives +** to keep free space after the last cell pointer so that new cells can +** be easily added without having to defragment the page. +** +** Cell content is stored at the very end of the page and grows toward the +** beginning of the page. +** +** Unused space within the cell content area is collected into a linked list of +** freeblocks. Each freeblock is at least 4 bytes in size. The byte offset +** to the first freeblock is given in the header. Freeblocks occur in +** increasing order. Because a freeblock must be at least 4 bytes in size, +** any group of 3 or fewer unused bytes in the cell content area cannot +** exist on the freeblock chain. A group of 3 or fewer free bytes is called +** a fragment. The total number of bytes in all fragments is recorded. +** in the page header at offset 7. +** +** SIZE DESCRIPTION +** 2 Byte offset of the next freeblock +** 2 Bytes in this freeblock +** +** Cells are of variable length. Cells are stored in the cell content area at +** the end of the page. Pointers to the cells are in the cell pointer array +** that immediately follows the page header. Cells is not necessarily +** contiguous or in order, but cell pointers are contiguous and in order. +** +** Cell content makes use of variable length integers. A variable +** length integer is 1 to 9 bytes where the lower 7 bits of each +** byte are used. The integer consists of all bytes that have bit 8 set and +** the first byte with bit 8 clear. The most significant byte of the integer +** appears first. A variable-length integer may not be more than 9 bytes long. +** As a special case, all 8 bytes of the 9th byte are used as data. This +** allows a 64-bit integer to be encoded in 9 bytes. +** +** 0x00 becomes 0x00000000 +** 0x7f becomes 0x0000007f +** 0x81 0x00 becomes 0x00000080 +** 0x82 0x00 becomes 0x00000100 +** 0x80 0x7f becomes 0x0000007f +** 0x8a 0x91 0xd1 0xac 0x78 becomes 0x12345678 +** 0x81 0x81 0x81 0x81 0x01 becomes 0x10204081 +** +** Variable length integers are used for rowids and to hold the number of +** bytes of key and data in a btree cell. +** +** The content of a cell looks like this: +** +** SIZE DESCRIPTION +** 4 Page number of the left child. Omitted if leaf flag is set. +** var Number of bytes of data. Omitted if the zerodata flag is set. +** var Number of bytes of key. Or the key itself if intkey flag is set. +** * Payload +** 4 First page of the overflow chain. Omitted if no overflow +** +** Overflow pages form a linked list. Each page except the last is completely +** filled with data (pagesize - 4 bytes). The last page can have as little +** as 1 byte of data. +** +** SIZE DESCRIPTION +** 4 Page number of next overflow page +** * Data +** +** Freelist pages come in two subtypes: trunk pages and leaf pages. The +** file header points to the first in a linked list of trunk page. Each trunk +** page points to multiple leaf pages. The content of a leaf page is +** unspecified. A trunk page looks like this: +** +** SIZE DESCRIPTION +** 4 Page number of next trunk page +** 4 Number of leaf pointers on this page +** * zero or more pages numbers of leaves +*/ +/* #include "sqliteInt.h" */ + + +/* The following value is the maximum cell size assuming a maximum page +** size give above. +*/ +#define MX_CELL_SIZE(pBt) ((int)(pBt->pageSize-8)) + +/* The maximum number of cells on a single page of the database. This +** assumes a minimum cell size of 6 bytes (4 bytes for the cell itself +** plus 2 bytes for the index to the cell in the page header). Such +** small cells will be rare, but they are possible. +*/ +#define MX_CELL(pBt) ((pBt->pageSize-8)/6) + +/* Forward declarations */ +typedef struct MemPage MemPage; +typedef struct BtLock BtLock; +typedef struct CellInfo CellInfo; + +/* +** This is a magic string that appears at the beginning of every +** SQLite database in order to identify the file as a real database. +** +** You can change this value at compile-time by specifying a +** -DSQLITE_FILE_HEADER="..." on the compiler command-line. The +** header must be exactly 16 bytes including the zero-terminator so +** the string itself should be 15 characters long. If you change +** the header, then your custom library will not be able to read +** databases generated by the standard tools and the standard tools +** will not be able to read databases created by your custom library. +*/ +#ifndef SQLITE_FILE_HEADER /* 123456789 123456 */ +# define SQLITE_FILE_HEADER "SQLite format 3" +#endif + +/* +** Page type flags. An ORed combination of these flags appear as the +** first byte of on-disk image of every BTree page. +*/ +#define PTF_INTKEY 0x01 +#define PTF_ZERODATA 0x02 +#define PTF_LEAFDATA 0x04 +#define PTF_LEAF 0x08 + +/* +** An instance of this object stores information about each a single database +** page that has been loaded into memory. The information in this object +** is derived from the raw on-disk page content. +** +** As each database page is loaded into memory, the pager allocats an +** instance of this object and zeros the first 8 bytes. (This is the +** "extra" information associated with each page of the pager.) +** +** Access to all fields of this structure is controlled by the mutex +** stored in MemPage.pBt->mutex. +*/ +struct MemPage { + u8 isInit; /* True if previously initialized. MUST BE FIRST! */ + u8 bBusy; /* Prevent endless loops on corrupt database files */ + u8 intKey; /* True if table b-trees. False for index b-trees */ + u8 intKeyLeaf; /* True if the leaf of an intKey table */ + Pgno pgno; /* Page number for this page */ + /* Only the first 8 bytes (above) are zeroed by pager.c when a new page + ** is allocated. All fields that follow must be initialized before use */ + u8 leaf; /* True if a leaf page */ + u8 hdrOffset; /* 100 for page 1. 0 otherwise */ + u8 childPtrSize; /* 0 if leaf==1. 4 if leaf==0 */ + u8 max1bytePayload; /* min(maxLocal,127) */ + u8 nOverflow; /* Number of overflow cell bodies in aCell[] */ + u16 maxLocal; /* Copy of BtShared.maxLocal or BtShared.maxLeaf */ + u16 minLocal; /* Copy of BtShared.minLocal or BtShared.minLeaf */ + u16 cellOffset; /* Index in aData of first cell pointer */ + int nFree; /* Number of free bytes on the page. -1 for unknown */ + u16 nCell; /* Number of cells on this page, local and ovfl */ + u16 maskPage; /* Mask for page offset */ + u16 aiOvfl[4]; /* Insert the i-th overflow cell before the aiOvfl-th + ** non-overflow cell */ + u8 *apOvfl[4]; /* Pointers to the body of overflow cells */ + BtShared *pBt; /* Pointer to BtShared that this page is part of */ + u8 *aData; /* Pointer to disk image of the page data */ + u8 *aDataEnd; /* One byte past the end of usable data */ + u8 *aCellIdx; /* The cell index area */ + u8 *aDataOfst; /* Same as aData for leaves. aData+4 for interior */ + DbPage *pDbPage; /* Pager page handle */ + u16 (*xCellSize)(MemPage*,u8*); /* cellSizePtr method */ + void (*xParseCell)(MemPage*,u8*,CellInfo*); /* btreeParseCell method */ +}; + +/* +** A linked list of the following structures is stored at BtShared.pLock. +** Locks are added (or upgraded from READ_LOCK to WRITE_LOCK) when a cursor +** is opened on the table with root page BtShared.iTable. Locks are removed +** from this list when a transaction is committed or rolled back, or when +** a btree handle is closed. +*/ +struct BtLock { + Btree *pBtree; /* Btree handle holding this lock */ + Pgno iTable; /* Root page of table */ + u8 eLock; /* READ_LOCK or WRITE_LOCK */ + BtLock *pNext; /* Next in BtShared.pLock list */ +}; + +/* Candidate values for BtLock.eLock */ +#define READ_LOCK 1 +#define WRITE_LOCK 2 + +/* A Btree handle +** +** A database connection contains a pointer to an instance of +** this object for every database file that it has open. This structure +** is opaque to the database connection. The database connection cannot +** see the internals of this structure and only deals with pointers to +** this structure. +** +** For some database files, the same underlying database cache might be +** shared between multiple connections. In that case, each connection +** has it own instance of this object. But each instance of this object +** points to the same BtShared object. The database cache and the +** schema associated with the database file are all contained within +** the BtShared object. +** +** All fields in this structure are accessed under sqlite3.mutex. +** The pBt pointer itself may not be changed while there exists cursors +** in the referenced BtShared that point back to this Btree since those +** cursors have to go through this Btree to find their BtShared and +** they often do so without holding sqlite3.mutex. +*/ +struct Btree { + sqlite3 *db; /* The database connection holding this btree */ + BtShared *pBt; /* Sharable content of this btree */ + u8 inTrans; /* TRANS_NONE, TRANS_READ or TRANS_WRITE */ + u8 sharable; /* True if we can share pBt with another db */ + u8 locked; /* True if db currently has pBt locked */ + u8 hasIncrblobCur; /* True if there are one or more Incrblob cursors */ + int wantToLock; /* Number of nested calls to sqlite3BtreeEnter() */ + int nBackup; /* Number of backup operations reading this btree */ + u32 iDataVersion; /* Combines with pBt->pPager->iDataVersion */ + Btree *pNext; /* List of other sharable Btrees from the same db */ + Btree *pPrev; /* Back pointer of the same list */ +#ifdef SQLITE_DEBUG + u64 nSeek; /* Calls to sqlite3BtreeMovetoUnpacked() */ +#endif +#ifndef SQLITE_OMIT_SHARED_CACHE + BtLock lock; /* Object used to lock page 1 */ +#endif +}; + +/* +** Btree.inTrans may take one of the following values. +** +** If the shared-data extension is enabled, there may be multiple users +** of the Btree structure. At most one of these may open a write transaction, +** but any number may have active read transactions. +** +** These values must match SQLITE_TXN_NONE, SQLITE_TXN_READ, and +** SQLITE_TXN_WRITE +*/ +#define TRANS_NONE 0 +#define TRANS_READ 1 +#define TRANS_WRITE 2 + +#if TRANS_NONE!=SQLITE_TXN_NONE +# error wrong numeric code for no-transaction +#endif +#if TRANS_READ!=SQLITE_TXN_READ +# error wrong numeric code for read-transaction +#endif +#if TRANS_WRITE!=SQLITE_TXN_WRITE +# error wrong numeric code for write-transaction +#endif + + +/* +** An instance of this object represents a single database file. +** +** A single database file can be in use at the same time by two +** or more database connections. When two or more connections are +** sharing the same database file, each connection has it own +** private Btree object for the file and each of those Btrees points +** to this one BtShared object. BtShared.nRef is the number of +** connections currently sharing this database file. +** +** Fields in this structure are accessed under the BtShared.mutex +** mutex, except for nRef and pNext which are accessed under the +** global SQLITE_MUTEX_STATIC_MAIN mutex. The pPager field +** may not be modified once it is initially set as long as nRef>0. +** The pSchema field may be set once under BtShared.mutex and +** thereafter is unchanged as long as nRef>0. +** +** isPending: +** +** If a BtShared client fails to obtain a write-lock on a database +** table (because there exists one or more read-locks on the table), +** the shared-cache enters 'pending-lock' state and isPending is +** set to true. +** +** The shared-cache leaves the 'pending lock' state when either of +** the following occur: +** +** 1) The current writer (BtShared.pWriter) concludes its transaction, OR +** 2) The number of locks held by other connections drops to zero. +** +** while in the 'pending-lock' state, no connection may start a new +** transaction. +** +** This feature is included to help prevent writer-starvation. +*/ +struct BtShared { + Pager *pPager; /* The page cache */ + sqlite3 *db; /* Database connection currently using this Btree */ + BtCursor *pCursor; /* A list of all open cursors */ + MemPage *pPage1; /* First page of the database */ + u8 openFlags; /* Flags to sqlite3BtreeOpen() */ +#ifndef SQLITE_OMIT_AUTOVACUUM + u8 autoVacuum; /* True if auto-vacuum is enabled */ + u8 incrVacuum; /* True if incr-vacuum is enabled */ + u8 bDoTruncate; /* True to truncate db on commit */ +#endif + u8 inTransaction; /* Transaction state */ + u8 max1bytePayload; /* Maximum first byte of cell for a 1-byte payload */ + u8 nReserveWanted; /* Desired number of extra bytes per page */ + u16 btsFlags; /* Boolean parameters. See BTS_* macros below */ + u16 maxLocal; /* Maximum local payload in non-LEAFDATA tables */ + u16 minLocal; /* Minimum local payload in non-LEAFDATA tables */ + u16 maxLeaf; /* Maximum local payload in a LEAFDATA table */ + u16 minLeaf; /* Minimum local payload in a LEAFDATA table */ + u32 pageSize; /* Total number of bytes on a page */ + u32 usableSize; /* Number of usable bytes on each page */ + int nTransaction; /* Number of open transactions (read + write) */ + u32 nPage; /* Number of pages in the database */ + void *pSchema; /* Pointer to space allocated by sqlite3BtreeSchema() */ + void (*xFreeSchema)(void*); /* Destructor for BtShared.pSchema */ + sqlite3_mutex *mutex; /* Non-recursive mutex required to access this object */ + Bitvec *pHasContent; /* Set of pages moved to free-list this transaction */ +#ifndef SQLITE_OMIT_SHARED_CACHE + int nRef; /* Number of references to this structure */ + BtShared *pNext; /* Next on a list of sharable BtShared structs */ + BtLock *pLock; /* List of locks held on this shared-btree struct */ + Btree *pWriter; /* Btree with currently open write transaction */ +#endif + u8 *pTmpSpace; /* Temp space sufficient to hold a single cell */ +}; + +/* +** Allowed values for BtShared.btsFlags +*/ +#define BTS_READ_ONLY 0x0001 /* Underlying file is readonly */ +#define BTS_PAGESIZE_FIXED 0x0002 /* Page size can no longer be changed */ +#define BTS_SECURE_DELETE 0x0004 /* PRAGMA secure_delete is enabled */ +#define BTS_OVERWRITE 0x0008 /* Overwrite deleted content with zeros */ +#define BTS_FAST_SECURE 0x000c /* Combination of the previous two */ +#define BTS_INITIALLY_EMPTY 0x0010 /* Database was empty at trans start */ +#define BTS_NO_WAL 0x0020 /* Do not open write-ahead-log files */ +#define BTS_EXCLUSIVE 0x0040 /* pWriter has an exclusive lock */ +#define BTS_PENDING 0x0080 /* Waiting for read-locks to clear */ + +/* +** An instance of the following structure is used to hold information +** about a cell. The parseCellPtr() function fills in this structure +** based on information extract from the raw disk page. +*/ +struct CellInfo { + i64 nKey; /* The key for INTKEY tables, or nPayload otherwise */ + u8 *pPayload; /* Pointer to the start of payload */ + u32 nPayload; /* Bytes of payload */ + u16 nLocal; /* Amount of payload held locally, not on overflow */ + u16 nSize; /* Size of the cell content on the main b-tree page */ +}; + +/* +** Maximum depth of an SQLite B-Tree structure. Any B-Tree deeper than +** this will be declared corrupt. This value is calculated based on a +** maximum database size of 2^31 pages a minimum fanout of 2 for a +** root-node and 3 for all other internal nodes. +** +** If a tree that appears to be taller than this is encountered, it is +** assumed that the database is corrupt. +*/ +#define BTCURSOR_MAX_DEPTH 20 + +/* +** A cursor is a pointer to a particular entry within a particular +** b-tree within a database file. +** +** The entry is identified by its MemPage and the index in +** MemPage.aCell[] of the entry. +** +** A single database file can be shared by two more database connections, +** but cursors cannot be shared. Each cursor is associated with a +** particular database connection identified BtCursor.pBtree.db. +** +** Fields in this structure are accessed under the BtShared.mutex +** found at self->pBt->mutex. +** +** skipNext meaning: +** The meaning of skipNext depends on the value of eState: +** +** eState Meaning of skipNext +** VALID skipNext is meaningless and is ignored +** INVALID skipNext is meaningless and is ignored +** SKIPNEXT sqlite3BtreeNext() is a no-op if skipNext>0 and +** sqlite3BtreePrevious() is no-op if skipNext<0. +** REQUIRESEEK restoreCursorPosition() restores the cursor to +** eState=SKIPNEXT if skipNext!=0 +** FAULT skipNext holds the cursor fault error code. +*/ +struct BtCursor { + u8 eState; /* One of the CURSOR_XXX constants (see below) */ + u8 curFlags; /* zero or more BTCF_* flags defined below */ + u8 curPagerFlags; /* Flags to send to sqlite3PagerGet() */ + u8 hints; /* As configured by CursorSetHints() */ + int skipNext; /* Prev() is noop if negative. Next() is noop if positive. + ** Error code if eState==CURSOR_FAULT */ + Btree *pBtree; /* The Btree to which this cursor belongs */ + Pgno *aOverflow; /* Cache of overflow page locations */ + void *pKey; /* Saved key that was cursor last known position */ + /* All fields above are zeroed when the cursor is allocated. See + ** sqlite3BtreeCursorZero(). Fields that follow must be manually + ** initialized. */ +#define BTCURSOR_FIRST_UNINIT pBt /* Name of first uninitialized field */ + BtShared *pBt; /* The BtShared this cursor points to */ + BtCursor *pNext; /* Forms a linked list of all cursors */ + CellInfo info; /* A parse of the cell we are pointing at */ + i64 nKey; /* Size of pKey, or last integer key */ + Pgno pgnoRoot; /* The root page of this tree */ + i8 iPage; /* Index of current page in apPage */ + u8 curIntKey; /* Value of apPage[0]->intKey */ + u16 ix; /* Current index for apPage[iPage] */ + u16 aiIdx[BTCURSOR_MAX_DEPTH-1]; /* Current index in apPage[i] */ + struct KeyInfo *pKeyInfo; /* Arg passed to comparison function */ + MemPage *pPage; /* Current page */ + MemPage *apPage[BTCURSOR_MAX_DEPTH-1]; /* Stack of parents of current page */ +}; + +/* +** Legal values for BtCursor.curFlags +*/ +#define BTCF_WriteFlag 0x01 /* True if a write cursor */ +#define BTCF_ValidNKey 0x02 /* True if info.nKey is valid */ +#define BTCF_ValidOvfl 0x04 /* True if aOverflow is valid */ +#define BTCF_AtLast 0x08 /* Cursor is pointing ot the last entry */ +#define BTCF_Incrblob 0x10 /* True if an incremental I/O handle */ +#define BTCF_Multiple 0x20 /* Maybe another cursor on the same btree */ +#define BTCF_Pinned 0x40 /* Cursor is busy and cannot be moved */ + +/* +** Potential values for BtCursor.eState. +** +** CURSOR_INVALID: +** Cursor does not point to a valid entry. This can happen (for example) +** because the table is empty or because BtreeCursorFirst() has not been +** called. +** +** CURSOR_VALID: +** Cursor points to a valid entry. getPayload() etc. may be called. +** +** CURSOR_SKIPNEXT: +** Cursor is valid except that the Cursor.skipNext field is non-zero +** indicating that the next sqlite3BtreeNext() or sqlite3BtreePrevious() +** operation should be a no-op. +** +** CURSOR_REQUIRESEEK: +** The table that this cursor was opened on still exists, but has been +** modified since the cursor was last used. The cursor position is saved +** in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in +** this state, restoreCursorPosition() can be called to attempt to +** seek the cursor to the saved position. +** +** CURSOR_FAULT: +** An unrecoverable error (an I/O error or a malloc failure) has occurred +** on a different connection that shares the BtShared cache with this +** cursor. The error has left the cache in an inconsistent state. +** Do nothing else with this cursor. Any attempt to use the cursor +** should return the error code stored in BtCursor.skipNext +*/ +#define CURSOR_VALID 0 +#define CURSOR_INVALID 1 +#define CURSOR_SKIPNEXT 2 +#define CURSOR_REQUIRESEEK 3 +#define CURSOR_FAULT 4 + +/* +** The database page the PENDING_BYTE occupies. This page is never used. +*/ +# define PENDING_BYTE_PAGE(pBt) PAGER_MJ_PGNO(pBt) + +/* +** These macros define the location of the pointer-map entry for a +** database page. The first argument to each is the number of usable +** bytes on each page of the database (often 1024). The second is the +** page number to look up in the pointer map. +** +** PTRMAP_PAGENO returns the database page number of the pointer-map +** page that stores the required pointer. PTRMAP_PTROFFSET returns +** the offset of the requested map entry. +** +** If the pgno argument passed to PTRMAP_PAGENO is a pointer-map page, +** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be +** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements +** this test. +*/ +#define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno) +#define PTRMAP_PTROFFSET(pgptrmap, pgno) (5*(pgno-pgptrmap-1)) +#define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno)) + +/* +** The pointer map is a lookup table that identifies the parent page for +** each child page in the database file. The parent page is the page that +** contains a pointer to the child. Every page in the database contains +** 0 or 1 parent pages. (In this context 'database page' refers +** to any page that is not part of the pointer map itself.) Each pointer map +** entry consists of a single byte 'type' and a 4 byte parent page number. +** The PTRMAP_XXX identifiers below are the valid types. +** +** The purpose of the pointer map is to facility moving pages from one +** position in the file to another as part of autovacuum. When a page +** is moved, the pointer in its parent must be updated to point to the +** new location. The pointer map is used to locate the parent page quickly. +** +** PTRMAP_ROOTPAGE: The database page is a root-page. The page-number is not +** used in this case. +** +** PTRMAP_FREEPAGE: The database page is an unused (free) page. The page-number +** is not used in this case. +** +** PTRMAP_OVERFLOW1: The database page is the first page in a list of +** overflow pages. The page number identifies the page that +** contains the cell with a pointer to this overflow page. +** +** PTRMAP_OVERFLOW2: The database page is the second or later page in a list of +** overflow pages. The page-number identifies the previous +** page in the overflow page list. +** +** PTRMAP_BTREE: The database page is a non-root btree page. The page number +** identifies the parent page in the btree. +*/ +#define PTRMAP_ROOTPAGE 1 +#define PTRMAP_FREEPAGE 2 +#define PTRMAP_OVERFLOW1 3 +#define PTRMAP_OVERFLOW2 4 +#define PTRMAP_BTREE 5 + +/* A bunch of assert() statements to check the transaction state variables +** of handle p (type Btree*) are internally consistent. +*/ +#define btreeIntegrity(p) \ + assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \ + assert( p->pBt->inTransaction>=p->inTrans ); + + +/* +** The ISAUTOVACUUM macro is used within balance_nonroot() to determine +** if the database supports auto-vacuum or not. Because it is used +** within an expression that is an argument to another macro +** (sqliteMallocRaw), it is not possible to use conditional compilation. +** So, this macro is defined instead. +*/ +#ifndef SQLITE_OMIT_AUTOVACUUM +#define ISAUTOVACUUM (pBt->autoVacuum) +#else +#define ISAUTOVACUUM 0 +#endif + + +/* +** This structure is passed around through all the sanity checking routines +** in order to keep track of some global state information. +** +** The aRef[] array is allocated so that there is 1 bit for each page in +** the database. As the integrity-check proceeds, for each page used in +** the database the corresponding bit is set. This allows integrity-check to +** detect pages that are used twice and orphaned pages (both of which +** indicate corruption). +*/ +typedef struct IntegrityCk IntegrityCk; +struct IntegrityCk { + BtShared *pBt; /* The tree being checked out */ + Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */ + u8 *aPgRef; /* 1 bit per page in the db (see above) */ + Pgno nPage; /* Number of pages in the database */ + int mxErr; /* Stop accumulating errors when this reaches zero */ + int nErr; /* Number of messages written to zErrMsg so far */ + int bOomFault; /* A memory allocation error has occurred */ + const char *zPfx; /* Error message prefix */ + Pgno v1; /* Value for first %u substitution in zPfx */ + int v2; /* Value for second %d substitution in zPfx */ + StrAccum errMsg; /* Accumulate the error message text here */ + u32 *heap; /* Min-heap used for analyzing cell coverage */ + sqlite3 *db; /* Database connection running the check */ +}; + +/* +** Routines to read or write a two- and four-byte big-endian integer values. +*/ +#define get2byte(x) ((x)[0]<<8 | (x)[1]) +#define put2byte(p,v) ((p)[0] = (u8)((v)>>8), (p)[1] = (u8)(v)) +#define get4byte sqlite3Get4byte +#define put4byte sqlite3Put4byte + +/* +** get2byteAligned(), unlike get2byte(), requires that its argument point to a +** two-byte aligned address. get2bytea() is only used for accessing the +** cell addresses in a btree header. +*/ +#if SQLITE_BYTEORDER==4321 +# define get2byteAligned(x) (*(u16*)(x)) +#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4008000 +# define get2byteAligned(x) __builtin_bswap16(*(u16*)(x)) +#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 +# define get2byteAligned(x) _byteswap_ushort(*(u16*)(x)) +#else +# define get2byteAligned(x) ((x)[0]<<8 | (x)[1]) +#endif + +/************** End of btreeInt.h ********************************************/ +/************** Continuing where we left off in btmutex.c ********************/ +#ifndef SQLITE_OMIT_SHARED_CACHE +#if SQLITE_THREADSAFE + +/* +** Obtain the BtShared mutex associated with B-Tree handle p. Also, +** set BtShared.db to the database handle associated with p and the +** p->locked boolean to true. +*/ +static void lockBtreeMutex(Btree *p){ + assert( p->locked==0 ); + assert( sqlite3_mutex_notheld(p->pBt->mutex) ); + assert( sqlite3_mutex_held(p->db->mutex) ); + + sqlite3_mutex_enter(p->pBt->mutex); + p->pBt->db = p->db; + p->locked = 1; +} + +/* +** Release the BtShared mutex associated with B-Tree handle p and +** clear the p->locked boolean. +*/ +static void SQLITE_NOINLINE unlockBtreeMutex(Btree *p){ + BtShared *pBt = p->pBt; + assert( p->locked==1 ); + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( sqlite3_mutex_held(p->db->mutex) ); + assert( p->db==pBt->db ); + + sqlite3_mutex_leave(pBt->mutex); + p->locked = 0; +} + +/* Forward reference */ +static void SQLITE_NOINLINE btreeLockCarefully(Btree *p); + +/* +** Enter a mutex on the given BTree object. +** +** If the object is not sharable, then no mutex is ever required +** and this routine is a no-op. The underlying mutex is non-recursive. +** But we keep a reference count in Btree.wantToLock so the behavior +** of this interface is recursive. +** +** To avoid deadlocks, multiple Btrees are locked in the same order +** by all database connections. The p->pNext is a list of other +** Btrees belonging to the same database connection as the p Btree +** which need to be locked after p. If we cannot get a lock on +** p, then first unlock all of the others on p->pNext, then wait +** for the lock to become available on p, then relock all of the +** subsequent Btrees that desire a lock. +*/ +SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){ + /* Some basic sanity checking on the Btree. The list of Btrees + ** connected by pNext and pPrev should be in sorted order by + ** Btree.pBt value. All elements of the list should belong to + ** the same connection. Only shared Btrees are on the list. */ + assert( p->pNext==0 || p->pNext->pBt>p->pBt ); + assert( p->pPrev==0 || p->pPrev->pBtpBt ); + assert( p->pNext==0 || p->pNext->db==p->db ); + assert( p->pPrev==0 || p->pPrev->db==p->db ); + assert( p->sharable || (p->pNext==0 && p->pPrev==0) ); + + /* Check for locking consistency */ + assert( !p->locked || p->wantToLock>0 ); + assert( p->sharable || p->wantToLock==0 ); + + /* We should already hold a lock on the database connection */ + assert( sqlite3_mutex_held(p->db->mutex) ); + + /* Unless the database is sharable and unlocked, then BtShared.db + ** should already be set correctly. */ + assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db ); + + if( !p->sharable ) return; + p->wantToLock++; + if( p->locked ) return; + btreeLockCarefully(p); +} + +/* This is a helper function for sqlite3BtreeLock(). By moving +** complex, but seldom used logic, out of sqlite3BtreeLock() and +** into this routine, we avoid unnecessary stack pointer changes +** and thus help the sqlite3BtreeLock() routine to run much faster +** in the common case. +*/ +static void SQLITE_NOINLINE btreeLockCarefully(Btree *p){ + Btree *pLater; + + /* In most cases, we should be able to acquire the lock we + ** want without having to go through the ascending lock + ** procedure that follows. Just be sure not to block. + */ + if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){ + p->pBt->db = p->db; + p->locked = 1; + return; + } + + /* To avoid deadlock, first release all locks with a larger + ** BtShared address. Then acquire our lock. Then reacquire + ** the other BtShared locks that we used to hold in ascending + ** order. + */ + for(pLater=p->pNext; pLater; pLater=pLater->pNext){ + assert( pLater->sharable ); + assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt ); + assert( !pLater->locked || pLater->wantToLock>0 ); + if( pLater->locked ){ + unlockBtreeMutex(pLater); + } + } + lockBtreeMutex(p); + for(pLater=p->pNext; pLater; pLater=pLater->pNext){ + if( pLater->wantToLock ){ + lockBtreeMutex(pLater); + } + } +} + + +/* +** Exit the recursive mutex on a Btree. +*/ +SQLITE_PRIVATE void sqlite3BtreeLeave(Btree *p){ + assert( sqlite3_mutex_held(p->db->mutex) ); + if( p->sharable ){ + assert( p->wantToLock>0 ); + p->wantToLock--; + if( p->wantToLock==0 ){ + unlockBtreeMutex(p); + } + } +} + +#ifndef NDEBUG +/* +** Return true if the BtShared mutex is held on the btree, or if the +** B-Tree is not marked as sharable. +** +** This routine is used only from within assert() statements. +*/ +SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree *p){ + assert( p->sharable==0 || p->locked==0 || p->wantToLock>0 ); + assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db ); + assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) ); + assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->db->mutex) ); + + return (p->sharable==0 || p->locked); +} +#endif + + +/* +** Enter the mutex on every Btree associated with a database +** connection. This is needed (for example) prior to parsing +** a statement since we will be comparing table and column names +** against all schemas and we do not want those schemas being +** reset out from under us. +** +** There is a corresponding leave-all procedures. +** +** Enter the mutexes in accending order by BtShared pointer address +** to avoid the possibility of deadlock when two threads with +** two or more btrees in common both try to lock all their btrees +** at the same instant. +*/ +static void SQLITE_NOINLINE btreeEnterAll(sqlite3 *db){ + int i; + int skipOk = 1; + Btree *p; + assert( sqlite3_mutex_held(db->mutex) ); + for(i=0; inDb; i++){ + p = db->aDb[i].pBt; + if( p && p->sharable ){ + sqlite3BtreeEnter(p); + skipOk = 0; + } + } + db->noSharedCache = skipOk; +} +SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){ + if( db->noSharedCache==0 ) btreeEnterAll(db); +} +static void SQLITE_NOINLINE btreeLeaveAll(sqlite3 *db){ + int i; + Btree *p; + assert( sqlite3_mutex_held(db->mutex) ); + for(i=0; inDb; i++){ + p = db->aDb[i].pBt; + if( p ) sqlite3BtreeLeave(p); + } +} +SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3 *db){ + if( db->noSharedCache==0 ) btreeLeaveAll(db); +} + +#ifndef NDEBUG +/* +** Return true if the current thread holds the database connection +** mutex and all required BtShared mutexes. +** +** This routine is used inside assert() statements only. +*/ +SQLITE_PRIVATE int sqlite3BtreeHoldsAllMutexes(sqlite3 *db){ + int i; + if( !sqlite3_mutex_held(db->mutex) ){ + return 0; + } + for(i=0; inDb; i++){ + Btree *p; + p = db->aDb[i].pBt; + if( p && p->sharable && + (p->wantToLock==0 || !sqlite3_mutex_held(p->pBt->mutex)) ){ + return 0; + } + } + return 1; +} +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* +** Return true if the correct mutexes are held for accessing the +** db->aDb[iDb].pSchema structure. The mutexes required for schema +** access are: +** +** (1) The mutex on db +** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt. +** +** If pSchema is not NULL, then iDb is computed from pSchema and +** db using sqlite3SchemaToIndex(). +*/ +SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3 *db, int iDb, Schema *pSchema){ + Btree *p; + assert( db!=0 ); + if( pSchema ) iDb = sqlite3SchemaToIndex(db, pSchema); + assert( iDb>=0 && iDbnDb ); + if( !sqlite3_mutex_held(db->mutex) ) return 0; + if( iDb==1 ) return 1; + p = db->aDb[iDb].pBt; + assert( p!=0 ); + return p->sharable==0 || p->locked==1; +} +#endif /* NDEBUG */ + +#else /* SQLITE_THREADSAFE>0 above. SQLITE_THREADSAFE==0 below */ +/* +** The following are special cases for mutex enter routines for use +** in single threaded applications that use shared cache. Except for +** these two routines, all mutex operations are no-ops in that case and +** are null #defines in btree.h. +** +** If shared cache is disabled, then all btree mutex routines, including +** the ones below, are no-ops and are null #defines in btree.h. +*/ + +SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){ + p->pBt->db = p->db; +} +SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){ + int i; + for(i=0; inDb; i++){ + Btree *p = db->aDb[i].pBt; + if( p ){ + p->pBt->db = p->db; + } + } +} +#endif /* if SQLITE_THREADSAFE */ + +#ifndef SQLITE_OMIT_INCRBLOB +/* +** Enter a mutex on a Btree given a cursor owned by that Btree. +** +** These entry points are used by incremental I/O only. Enter() is required +** any time OMIT_SHARED_CACHE is not defined, regardless of whether or not +** the build is threadsafe. Leave() is only required by threadsafe builds. +*/ +SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){ + sqlite3BtreeEnter(pCur->pBtree); +} +# if SQLITE_THREADSAFE +SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){ + sqlite3BtreeLeave(pCur->pBtree); +} +# endif +#endif /* ifndef SQLITE_OMIT_INCRBLOB */ + +#endif /* ifndef SQLITE_OMIT_SHARED_CACHE */ + +/************** End of btmutex.c *********************************************/ +/************** Begin file btree.c *******************************************/ +/* +** 2004 April 6 +** +** 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 an external (disk-based) database using BTrees. +** See the header comment on "btreeInt.h" for additional information. +** Including a description of file format and an overview of operation. +*/ +/* #include "btreeInt.h" */ + +/* +** The header string that appears at the beginning of every +** SQLite database. +*/ +static const char zMagicHeader[] = SQLITE_FILE_HEADER; + +/* +** Set this global variable to 1 to enable tracing using the TRACE +** macro. +*/ +#if 0 +int sqlite3BtreeTrace=1; /* True to enable tracing */ +# define TRACE(X) if(sqlite3BtreeTrace){printf X;fflush(stdout);} +#else +# define TRACE(X) +#endif + +/* +** Extract a 2-byte big-endian integer from an array of unsigned bytes. +** But if the value is zero, make it 65536. +** +** This routine is used to extract the "offset to cell content area" value +** from the header of a btree page. If the page size is 65536 and the page +** is empty, the offset should be 65536, but the 2-byte value stores zero. +** This routine makes the necessary adjustment to 65536. +*/ +#define get2byteNotZero(X) (((((int)get2byte(X))-1)&0xffff)+1) + +/* +** Values passed as the 5th argument to allocateBtreePage() +*/ +#define BTALLOC_ANY 0 /* Allocate any page */ +#define BTALLOC_EXACT 1 /* Allocate exact page if possible */ +#define BTALLOC_LE 2 /* Allocate any page <= the parameter */ + +/* +** Macro IfNotOmitAV(x) returns (x) if SQLITE_OMIT_AUTOVACUUM is not +** defined, or 0 if it is. For example: +** +** bIncrVacuum = IfNotOmitAV(pBtShared->incrVacuum); +*/ +#ifndef SQLITE_OMIT_AUTOVACUUM +#define IfNotOmitAV(expr) (expr) +#else +#define IfNotOmitAV(expr) 0 +#endif + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** A list of BtShared objects that are eligible for participation +** in shared cache. This variable has file scope during normal builds, +** but the test harness needs to access it so we make it global for +** test builds. +** +** Access to this variable is protected by SQLITE_MUTEX_STATIC_MAIN. +*/ +#ifdef SQLITE_TEST +SQLITE_PRIVATE BtShared *SQLITE_WSD sqlite3SharedCacheList = 0; +#else +static BtShared *SQLITE_WSD sqlite3SharedCacheList = 0; +#endif +#endif /* SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Enable or disable the shared pager and schema features. +** +** This routine has no effect on existing database connections. +** The shared cache setting effects only future calls to +** sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2(). +*/ +SQLITE_API int sqlite3_enable_shared_cache(int enable){ + sqlite3GlobalConfig.sharedCacheEnabled = enable; + return SQLITE_OK; +} +#endif + + + +#ifdef SQLITE_OMIT_SHARED_CACHE + /* + ** The functions querySharedCacheTableLock(), setSharedCacheTableLock(), + ** and clearAllSharedCacheTableLocks() + ** manipulate entries in the BtShared.pLock linked list used to store + ** shared-cache table level locks. If the library is compiled with the + ** shared-cache feature disabled, then there is only ever one user + ** of each BtShared structure and so this locking is not necessary. + ** So define the lock related functions as no-ops. + */ + #define querySharedCacheTableLock(a,b,c) SQLITE_OK + #define setSharedCacheTableLock(a,b,c) SQLITE_OK + #define clearAllSharedCacheTableLocks(a) + #define downgradeAllSharedCacheTableLocks(a) + #define hasSharedCacheTableLock(a,b,c,d) 1 + #define hasReadConflicts(a, b) 0 +#endif + +#ifdef SQLITE_DEBUG +/* +** Return and reset the seek counter for a Btree object. +*/ +SQLITE_PRIVATE sqlite3_uint64 sqlite3BtreeSeekCount(Btree *pBt){ + u64 n = pBt->nSeek; + pBt->nSeek = 0; + return n; +} +#endif + +/* +** Implementation of the SQLITE_CORRUPT_PAGE() macro. Takes a single +** (MemPage*) as an argument. The (MemPage*) must not be NULL. +** +** If SQLITE_DEBUG is not defined, then this macro is equivalent to +** SQLITE_CORRUPT_BKPT. Or, if SQLITE_DEBUG is set, then the log message +** normally produced as a side-effect of SQLITE_CORRUPT_BKPT is augmented +** with the page number and filename associated with the (MemPage*). +*/ +#ifdef SQLITE_DEBUG +int corruptPageError(int lineno, MemPage *p){ + char *zMsg; + sqlite3BeginBenignMalloc(); + zMsg = sqlite3_mprintf("database corruption page %d of %s", + (int)p->pgno, sqlite3PagerFilename(p->pBt->pPager, 0) + ); + sqlite3EndBenignMalloc(); + if( zMsg ){ + sqlite3ReportError(SQLITE_CORRUPT, lineno, zMsg); + } + sqlite3_free(zMsg); + return SQLITE_CORRUPT_BKPT; +} +# define SQLITE_CORRUPT_PAGE(pMemPage) corruptPageError(__LINE__, pMemPage) +#else +# define SQLITE_CORRUPT_PAGE(pMemPage) SQLITE_CORRUPT_PGNO(pMemPage->pgno) +#endif + +#ifndef SQLITE_OMIT_SHARED_CACHE + +#ifdef SQLITE_DEBUG +/* +**** This function is only used as part of an assert() statement. *** +** +** Check to see if pBtree holds the required locks to read or write to the +** table with root page iRoot. Return 1 if it does and 0 if not. +** +** For example, when writing to a table with root-page iRoot via +** Btree connection pBtree: +** +** assert( hasSharedCacheTableLock(pBtree, iRoot, 0, WRITE_LOCK) ); +** +** When writing to an index that resides in a sharable database, the +** caller should have first obtained a lock specifying the root page of +** the corresponding table. This makes things a bit more complicated, +** as this module treats each table as a separate structure. To determine +** the table corresponding to the index being written, this +** function has to search through the database schema. +** +** Instead of a lock on the table/index rooted at page iRoot, the caller may +** hold a write-lock on the schema table (root page 1). This is also +** acceptable. +*/ +static int hasSharedCacheTableLock( + Btree *pBtree, /* Handle that must hold lock */ + Pgno iRoot, /* Root page of b-tree */ + int isIndex, /* True if iRoot is the root of an index b-tree */ + int eLockType /* Required lock type (READ_LOCK or WRITE_LOCK) */ +){ + Schema *pSchema = (Schema *)pBtree->pBt->pSchema; + Pgno iTab = 0; + BtLock *pLock; + + /* If this database is not shareable, or if the client is reading + ** and has the read-uncommitted flag set, then no lock is required. + ** Return true immediately. + */ + if( (pBtree->sharable==0) + || (eLockType==READ_LOCK && (pBtree->db->flags & SQLITE_ReadUncommit)) + ){ + return 1; + } + + /* If the client is reading or writing an index and the schema is + ** not loaded, then it is too difficult to actually check to see if + ** the correct locks are held. So do not bother - just return true. + ** This case does not come up very often anyhow. + */ + if( isIndex && (!pSchema || (pSchema->schemaFlags&DB_SchemaLoaded)==0) ){ + return 1; + } + + /* Figure out the root-page that the lock should be held on. For table + ** b-trees, this is just the root page of the b-tree being read or + ** written. For index b-trees, it is the root page of the associated + ** table. */ + if( isIndex ){ + HashElem *p; + int bSeen = 0; + for(p=sqliteHashFirst(&pSchema->idxHash); p; p=sqliteHashNext(p)){ + Index *pIdx = (Index *)sqliteHashData(p); + if( pIdx->tnum==(int)iRoot ){ + if( bSeen ){ + /* Two or more indexes share the same root page. There must + ** be imposter tables. So just return true. The assert is not + ** useful in that case. */ + return 1; + } + iTab = pIdx->pTable->tnum; + bSeen = 1; + } + } + }else{ + iTab = iRoot; + } + + /* Search for the required lock. Either a write-lock on root-page iTab, a + ** write-lock on the schema table, or (if the client is reading) a + ** read-lock on iTab will suffice. Return 1 if any of these are found. */ + for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){ + if( pLock->pBtree==pBtree + && (pLock->iTable==iTab || (pLock->eLock==WRITE_LOCK && pLock->iTable==1)) + && pLock->eLock>=eLockType + ){ + return 1; + } + } + + /* Failed to find the required lock. */ + return 0; +} +#endif /* SQLITE_DEBUG */ + +#ifdef SQLITE_DEBUG +/* +**** This function may be used as part of assert() statements only. **** +** +** Return true if it would be illegal for pBtree to write into the +** table or index rooted at iRoot because other shared connections are +** simultaneously reading that same table or index. +** +** It is illegal for pBtree to write if some other Btree object that +** shares the same BtShared object is currently reading or writing +** the iRoot table. Except, if the other Btree object has the +** read-uncommitted flag set, then it is OK for the other object to +** have a read cursor. +** +** For example, before writing to any part of the table or index +** rooted at page iRoot, one should call: +** +** assert( !hasReadConflicts(pBtree, iRoot) ); +*/ +static int hasReadConflicts(Btree *pBtree, Pgno iRoot){ + BtCursor *p; + for(p=pBtree->pBt->pCursor; p; p=p->pNext){ + if( p->pgnoRoot==iRoot + && p->pBtree!=pBtree + && 0==(p->pBtree->db->flags & SQLITE_ReadUncommit) + ){ + return 1; + } + } + return 0; +} +#endif /* #ifdef SQLITE_DEBUG */ + +/* +** Query to see if Btree handle p may obtain a lock of type eLock +** (READ_LOCK or WRITE_LOCK) on the table with root-page iTab. Return +** SQLITE_OK if the lock may be obtained (by calling +** setSharedCacheTableLock()), or SQLITE_LOCKED if not. +*/ +static int querySharedCacheTableLock(Btree *p, Pgno iTab, u8 eLock){ + BtShared *pBt = p->pBt; + BtLock *pIter; + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( eLock==READ_LOCK || eLock==WRITE_LOCK ); + assert( p->db!=0 ); + assert( !(p->db->flags&SQLITE_ReadUncommit)||eLock==WRITE_LOCK||iTab==1 ); + + /* If requesting a write-lock, then the Btree must have an open write + ** transaction on this file. And, obviously, for this to be so there + ** must be an open write transaction on the file itself. + */ + assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) ); + assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE ); + + /* This routine is a no-op if the shared-cache is not enabled */ + if( !p->sharable ){ + return SQLITE_OK; + } + + /* If some other connection is holding an exclusive lock, the + ** requested lock may not be obtained. + */ + if( pBt->pWriter!=p && (pBt->btsFlags & BTS_EXCLUSIVE)!=0 ){ + sqlite3ConnectionBlocked(p->db, pBt->pWriter->db); + return SQLITE_LOCKED_SHAREDCACHE; + } + + for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ + /* The condition (pIter->eLock!=eLock) in the following if(...) + ** statement is a simplification of: + ** + ** (eLock==WRITE_LOCK || pIter->eLock==WRITE_LOCK) + ** + ** since we know that if eLock==WRITE_LOCK, then no other connection + ** may hold a WRITE_LOCK on any table in this file (since there can + ** only be a single writer). + */ + assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK ); + assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK); + if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){ + sqlite3ConnectionBlocked(p->db, pIter->pBtree->db); + if( eLock==WRITE_LOCK ){ + assert( p==pBt->pWriter ); + pBt->btsFlags |= BTS_PENDING; + } + return SQLITE_LOCKED_SHAREDCACHE; + } + } + return SQLITE_OK; +} +#endif /* !SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Add a lock on the table with root-page iTable to the shared-btree used +** by Btree handle p. Parameter eLock must be either READ_LOCK or +** WRITE_LOCK. +** +** This function assumes the following: +** +** (a) The specified Btree object p is connected to a sharable +** database (one with the BtShared.sharable flag set), and +** +** (b) No other Btree objects hold a lock that conflicts +** with the requested lock (i.e. querySharedCacheTableLock() has +** already been called and returned SQLITE_OK). +** +** SQLITE_OK is returned if the lock is added successfully. SQLITE_NOMEM +** is returned if a malloc attempt fails. +*/ +static int setSharedCacheTableLock(Btree *p, Pgno iTable, u8 eLock){ + BtShared *pBt = p->pBt; + BtLock *pLock = 0; + BtLock *pIter; + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( eLock==READ_LOCK || eLock==WRITE_LOCK ); + assert( p->db!=0 ); + + /* A connection with the read-uncommitted flag set will never try to + ** obtain a read-lock using this function. The only read-lock obtained + ** by a connection in read-uncommitted mode is on the sqlite_schema + ** table, and that lock is obtained in BtreeBeginTrans(). */ + assert( 0==(p->db->flags&SQLITE_ReadUncommit) || eLock==WRITE_LOCK ); + + /* This function should only be called on a sharable b-tree after it + ** has been determined that no other b-tree holds a conflicting lock. */ + assert( p->sharable ); + assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) ); + + /* First search the list for an existing lock on this table. */ + for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ + if( pIter->iTable==iTable && pIter->pBtree==p ){ + pLock = pIter; + break; + } + } + + /* If the above search did not find a BtLock struct associating Btree p + ** with table iTable, allocate one and link it into the list. + */ + if( !pLock ){ + pLock = (BtLock *)sqlite3MallocZero(sizeof(BtLock)); + if( !pLock ){ + return SQLITE_NOMEM_BKPT; + } + pLock->iTable = iTable; + pLock->pBtree = p; + pLock->pNext = pBt->pLock; + pBt->pLock = pLock; + } + + /* Set the BtLock.eLock variable to the maximum of the current lock + ** and the requested lock. This means if a write-lock was already held + ** and a read-lock requested, we don't incorrectly downgrade the lock. + */ + assert( WRITE_LOCK>READ_LOCK ); + if( eLock>pLock->eLock ){ + pLock->eLock = eLock; + } + + return SQLITE_OK; +} +#endif /* !SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Release all the table locks (locks obtained via calls to +** the setSharedCacheTableLock() procedure) held by Btree object p. +** +** This function assumes that Btree p has an open read or write +** transaction. If it does not, then the BTS_PENDING flag +** may be incorrectly cleared. +*/ +static void clearAllSharedCacheTableLocks(Btree *p){ + BtShared *pBt = p->pBt; + BtLock **ppIter = &pBt->pLock; + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( p->sharable || 0==*ppIter ); + assert( p->inTrans>0 ); + + while( *ppIter ){ + BtLock *pLock = *ppIter; + assert( (pBt->btsFlags & BTS_EXCLUSIVE)==0 || pBt->pWriter==pLock->pBtree ); + assert( pLock->pBtree->inTrans>=pLock->eLock ); + if( pLock->pBtree==p ){ + *ppIter = pLock->pNext; + assert( pLock->iTable!=1 || pLock==&p->lock ); + if( pLock->iTable!=1 ){ + sqlite3_free(pLock); + } + }else{ + ppIter = &pLock->pNext; + } + } + + assert( (pBt->btsFlags & BTS_PENDING)==0 || pBt->pWriter ); + if( pBt->pWriter==p ){ + pBt->pWriter = 0; + pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING); + }else if( pBt->nTransaction==2 ){ + /* This function is called when Btree p is concluding its + ** transaction. If there currently exists a writer, and p is not + ** that writer, then the number of locks held by connections other + ** than the writer must be about to drop to zero. In this case + ** set the BTS_PENDING flag to 0. + ** + ** If there is not currently a writer, then BTS_PENDING must + ** be zero already. So this next line is harmless in that case. + */ + pBt->btsFlags &= ~BTS_PENDING; + } +} + +/* +** This function changes all write-locks held by Btree p into read-locks. +*/ +static void downgradeAllSharedCacheTableLocks(Btree *p){ + BtShared *pBt = p->pBt; + if( pBt->pWriter==p ){ + BtLock *pLock; + pBt->pWriter = 0; + pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING); + for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){ + assert( pLock->eLock==READ_LOCK || pLock->pBtree==p ); + pLock->eLock = READ_LOCK; + } + } +} + +#endif /* SQLITE_OMIT_SHARED_CACHE */ + +static void releasePage(MemPage *pPage); /* Forward reference */ +static void releasePageOne(MemPage *pPage); /* Forward reference */ +static void releasePageNotNull(MemPage *pPage); /* Forward reference */ + +/* +***** This routine is used inside of assert() only **** +** +** Verify that the cursor holds the mutex on its BtShared +*/ +#ifdef SQLITE_DEBUG +static int cursorHoldsMutex(BtCursor *p){ + return sqlite3_mutex_held(p->pBt->mutex); +} + +/* Verify that the cursor and the BtShared agree about what is the current +** database connetion. This is important in shared-cache mode. If the database +** connection pointers get out-of-sync, it is possible for routines like +** btreeInitPage() to reference an stale connection pointer that references a +** a connection that has already closed. This routine is used inside assert() +** statements only and for the purpose of double-checking that the btree code +** does keep the database connection pointers up-to-date. +*/ +static int cursorOwnsBtShared(BtCursor *p){ + assert( cursorHoldsMutex(p) ); + return (p->pBtree->db==p->pBt->db); +} +#endif + +/* +** Invalidate the overflow cache of the cursor passed as the first argument. +** on the shared btree structure pBt. +*/ +#define invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl) + +/* +** Invalidate the overflow page-list cache for all cursors opened +** on the shared btree structure pBt. +*/ +static void invalidateAllOverflowCache(BtShared *pBt){ + BtCursor *p; + assert( sqlite3_mutex_held(pBt->mutex) ); + for(p=pBt->pCursor; p; p=p->pNext){ + invalidateOverflowCache(p); + } +} + +#ifndef SQLITE_OMIT_INCRBLOB +/* +** This function is called before modifying the contents of a table +** to invalidate any incrblob cursors that are open on the +** row or one of the rows being modified. +** +** If argument isClearTable is true, then the entire contents of the +** table is about to be deleted. In this case invalidate all incrblob +** cursors open on any row within the table with root-page pgnoRoot. +** +** Otherwise, if argument isClearTable is false, then the row with +** rowid iRow is being replaced or deleted. In this case invalidate +** only those incrblob cursors open on that specific row. +*/ +static void invalidateIncrblobCursors( + Btree *pBtree, /* The database file to check */ + Pgno pgnoRoot, /* The table that might be changing */ + i64 iRow, /* The rowid that might be changing */ + int isClearTable /* True if all rows are being deleted */ +){ + BtCursor *p; + if( pBtree->hasIncrblobCur==0 ) return; + assert( sqlite3BtreeHoldsMutex(pBtree) ); + pBtree->hasIncrblobCur = 0; + for(p=pBtree->pBt->pCursor; p; p=p->pNext){ + if( (p->curFlags & BTCF_Incrblob)!=0 ){ + pBtree->hasIncrblobCur = 1; + if( p->pgnoRoot==pgnoRoot && (isClearTable || p->info.nKey==iRow) ){ + p->eState = CURSOR_INVALID; + } + } + } +} + +#else + /* Stub function when INCRBLOB is omitted */ + #define invalidateIncrblobCursors(w,x,y,z) +#endif /* SQLITE_OMIT_INCRBLOB */ + +/* +** Set bit pgno of the BtShared.pHasContent bitvec. This is called +** when a page that previously contained data becomes a free-list leaf +** page. +** +** The BtShared.pHasContent bitvec exists to work around an obscure +** bug caused by the interaction of two useful IO optimizations surrounding +** free-list leaf pages: +** +** 1) When all data is deleted from a page and the page becomes +** a free-list leaf page, the page is not written to the database +** (as free-list leaf pages contain no meaningful data). Sometimes +** such a page is not even journalled (as it will not be modified, +** why bother journalling it?). +** +** 2) When a free-list leaf page is reused, its content is not read +** from the database or written to the journal file (why should it +** be, if it is not at all meaningful?). +** +** By themselves, these optimizations work fine and provide a handy +** performance boost to bulk delete or insert operations. However, if +** a page is moved to the free-list and then reused within the same +** transaction, a problem comes up. If the page is not journalled when +** it is moved to the free-list and it is also not journalled when it +** is extracted from the free-list and reused, then the original data +** may be lost. In the event of a rollback, it may not be possible +** to restore the database to its original configuration. +** +** The solution is the BtShared.pHasContent bitvec. Whenever a page is +** moved to become a free-list leaf page, the corresponding bit is +** set in the bitvec. Whenever a leaf page is extracted from the free-list, +** optimization 2 above is omitted if the corresponding bit is already +** set in BtShared.pHasContent. The contents of the bitvec are cleared +** at the end of every transaction. +*/ +static int btreeSetHasContent(BtShared *pBt, Pgno pgno){ + int rc = SQLITE_OK; + if( !pBt->pHasContent ){ + assert( pgno<=pBt->nPage ); + pBt->pHasContent = sqlite3BitvecCreate(pBt->nPage); + if( !pBt->pHasContent ){ + rc = SQLITE_NOMEM_BKPT; + } + } + if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){ + rc = sqlite3BitvecSet(pBt->pHasContent, pgno); + } + return rc; +} + +/* +** Query the BtShared.pHasContent vector. +** +** This function is called when a free-list leaf page is removed from the +** free-list for reuse. It returns false if it is safe to retrieve the +** page from the pager layer with the 'no-content' flag set. True otherwise. +*/ +static int btreeGetHasContent(BtShared *pBt, Pgno pgno){ + Bitvec *p = pBt->pHasContent; + return p && (pgno>sqlite3BitvecSize(p) || sqlite3BitvecTestNotNull(p, pgno)); +} + +/* +** Clear (destroy) the BtShared.pHasContent bitvec. This should be +** invoked at the conclusion of each write-transaction. +*/ +static void btreeClearHasContent(BtShared *pBt){ + sqlite3BitvecDestroy(pBt->pHasContent); + pBt->pHasContent = 0; +} + +/* +** Release all of the apPage[] pages for a cursor. +*/ +static void btreeReleaseAllCursorPages(BtCursor *pCur){ + int i; + if( pCur->iPage>=0 ){ + for(i=0; iiPage; i++){ + releasePageNotNull(pCur->apPage[i]); + } + releasePageNotNull(pCur->pPage); + pCur->iPage = -1; + } +} + +/* +** The cursor passed as the only argument must point to a valid entry +** when this function is called (i.e. have eState==CURSOR_VALID). This +** function saves the current cursor key in variables pCur->nKey and +** pCur->pKey. SQLITE_OK is returned if successful or an SQLite error +** code otherwise. +** +** If the cursor is open on an intkey table, then the integer key +** (the rowid) is stored in pCur->nKey and pCur->pKey is left set to +** NULL. If the cursor is open on a non-intkey table, then pCur->pKey is +** set to point to a malloced buffer pCur->nKey bytes in size containing +** the key. +*/ +static int saveCursorKey(BtCursor *pCur){ + int rc = SQLITE_OK; + assert( CURSOR_VALID==pCur->eState ); + assert( 0==pCur->pKey ); + assert( cursorHoldsMutex(pCur) ); + + if( pCur->curIntKey ){ + /* Only the rowid is required for a table btree */ + pCur->nKey = sqlite3BtreeIntegerKey(pCur); + }else{ + /* For an index btree, save the complete key content. It is possible + ** that the current key is corrupt. In that case, it is possible that + ** the sqlite3VdbeRecordUnpack() function may overread the buffer by + ** up to the size of 1 varint plus 1 8-byte value when the cursor + ** position is restored. Hence the 17 bytes of padding allocated + ** below. */ + void *pKey; + pCur->nKey = sqlite3BtreePayloadSize(pCur); + pKey = sqlite3Malloc( pCur->nKey + 9 + 8 ); + if( pKey ){ + rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey); + if( rc==SQLITE_OK ){ + memset(((u8*)pKey)+pCur->nKey, 0, 9+8); + pCur->pKey = pKey; + }else{ + sqlite3_free(pKey); + } + }else{ + rc = SQLITE_NOMEM_BKPT; + } + } + assert( !pCur->curIntKey || !pCur->pKey ); + return rc; +} + +/* +** Save the current cursor position in the variables BtCursor.nKey +** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK. +** +** The caller must ensure that the cursor is valid (has eState==CURSOR_VALID) +** prior to calling this routine. +*/ +static int saveCursorPosition(BtCursor *pCur){ + int rc; + + assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState ); + assert( 0==pCur->pKey ); + assert( cursorHoldsMutex(pCur) ); + + if( pCur->curFlags & BTCF_Pinned ){ + return SQLITE_CONSTRAINT_PINNED; + } + if( pCur->eState==CURSOR_SKIPNEXT ){ + pCur->eState = CURSOR_VALID; + }else{ + pCur->skipNext = 0; + } + + rc = saveCursorKey(pCur); + if( rc==SQLITE_OK ){ + btreeReleaseAllCursorPages(pCur); + pCur->eState = CURSOR_REQUIRESEEK; + } + + pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl|BTCF_AtLast); + return rc; +} + +/* Forward reference */ +static int SQLITE_NOINLINE saveCursorsOnList(BtCursor*,Pgno,BtCursor*); + +/* +** Save the positions of all cursors (except pExcept) that are open on +** the table with root-page iRoot. "Saving the cursor position" means that +** the location in the btree is remembered in such a way that it can be +** moved back to the same spot after the btree has been modified. This +** routine is called just before cursor pExcept is used to modify the +** table, for example in BtreeDelete() or BtreeInsert(). +** +** If there are two or more cursors on the same btree, then all such +** cursors should have their BTCF_Multiple flag set. The btreeCursor() +** routine enforces that rule. This routine only needs to be called in +** the uncommon case when pExpect has the BTCF_Multiple flag set. +** +** If pExpect!=NULL and if no other cursors are found on the same root-page, +** then the BTCF_Multiple flag on pExpect is cleared, to avoid another +** pointless call to this routine. +** +** Implementation note: This routine merely checks to see if any cursors +** need to be saved. It calls out to saveCursorsOnList() in the (unusual) +** event that cursors are in need to being saved. +*/ +static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){ + BtCursor *p; + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pExcept==0 || pExcept->pBt==pBt ); + for(p=pBt->pCursor; p; p=p->pNext){ + if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) ) break; + } + if( p ) return saveCursorsOnList(p, iRoot, pExcept); + if( pExcept ) pExcept->curFlags &= ~BTCF_Multiple; + return SQLITE_OK; +} + +/* This helper routine to saveAllCursors does the actual work of saving +** the cursors if and when a cursor is found that actually requires saving. +** The common case is that no cursors need to be saved, so this routine is +** broken out from its caller to avoid unnecessary stack pointer movement. +*/ +static int SQLITE_NOINLINE saveCursorsOnList( + BtCursor *p, /* The first cursor that needs saving */ + Pgno iRoot, /* Only save cursor with this iRoot. Save all if zero */ + BtCursor *pExcept /* Do not save this cursor */ +){ + do{ + if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) ){ + if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){ + int rc = saveCursorPosition(p); + if( SQLITE_OK!=rc ){ + return rc; + } + }else{ + testcase( p->iPage>=0 ); + btreeReleaseAllCursorPages(p); + } + } + p = p->pNext; + }while( p ); + return SQLITE_OK; +} + +/* +** Clear the current cursor position. +*/ +SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + sqlite3_free(pCur->pKey); + pCur->pKey = 0; + pCur->eState = CURSOR_INVALID; +} + +/* +** In this version of BtreeMoveto, pKey is a packed index record +** such as is generated by the OP_MakeRecord opcode. Unpack the +** record and then call BtreeMovetoUnpacked() to do the work. +*/ +static int btreeMoveto( + BtCursor *pCur, /* Cursor open on the btree to be searched */ + const void *pKey, /* Packed key if the btree is an index */ + i64 nKey, /* Integer key for tables. Size of pKey for indices */ + int bias, /* Bias search to the high end */ + int *pRes /* Write search results here */ +){ + int rc; /* Status code */ + UnpackedRecord *pIdxKey; /* Unpacked index key */ + + if( pKey ){ + KeyInfo *pKeyInfo = pCur->pKeyInfo; + assert( nKey==(i64)(int)nKey ); + pIdxKey = sqlite3VdbeAllocUnpackedRecord(pKeyInfo); + if( pIdxKey==0 ) return SQLITE_NOMEM_BKPT; + sqlite3VdbeRecordUnpack(pKeyInfo, (int)nKey, pKey, pIdxKey); + if( pIdxKey->nField==0 || pIdxKey->nField>pKeyInfo->nAllField ){ + rc = SQLITE_CORRUPT_BKPT; + goto moveto_done; + } + }else{ + pIdxKey = 0; + } + rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes); +moveto_done: + if( pIdxKey ){ + sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey); + } + return rc; +} + +/* +** Restore the cursor to the position it was in (or as close to as possible) +** when saveCursorPosition() was called. Note that this call deletes the +** saved position info stored by saveCursorPosition(), so there can be +** at most one effective restoreCursorPosition() call after each +** saveCursorPosition(). +*/ +static int btreeRestoreCursorPosition(BtCursor *pCur){ + int rc; + int skipNext = 0; + assert( cursorOwnsBtShared(pCur) ); + assert( pCur->eState>=CURSOR_REQUIRESEEK ); + if( pCur->eState==CURSOR_FAULT ){ + return pCur->skipNext; + } + pCur->eState = CURSOR_INVALID; + if( sqlite3FaultSim(410) ){ + rc = SQLITE_IOERR; + }else{ + rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext); + } + if( rc==SQLITE_OK ){ + sqlite3_free(pCur->pKey); + pCur->pKey = 0; + assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID ); + if( skipNext ) pCur->skipNext = skipNext; + if( pCur->skipNext && pCur->eState==CURSOR_VALID ){ + pCur->eState = CURSOR_SKIPNEXT; + } + } + return rc; +} + +#define restoreCursorPosition(p) \ + (p->eState>=CURSOR_REQUIRESEEK ? \ + btreeRestoreCursorPosition(p) : \ + SQLITE_OK) + +/* +** Determine whether or not a cursor has moved from the position where +** it was last placed, or has been invalidated for any other reason. +** Cursors can move when the row they are pointing at is deleted out +** from under them, for example. Cursor might also move if a btree +** is rebalanced. +** +** Calling this routine with a NULL cursor pointer returns false. +** +** Use the separate sqlite3BtreeCursorRestore() routine to restore a cursor +** back to where it ought to be if this routine returns true. +*/ +SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur){ + assert( EIGHT_BYTE_ALIGNMENT(pCur) + || pCur==sqlite3BtreeFakeValidCursor() ); + assert( offsetof(BtCursor, eState)==0 ); + assert( sizeof(pCur->eState)==1 ); + return CURSOR_VALID != *(u8*)pCur; +} + +/* +** Return a pointer to a fake BtCursor object that will always answer +** false to the sqlite3BtreeCursorHasMoved() routine above. The fake +** cursor returned must not be used with any other Btree interface. +*/ +SQLITE_PRIVATE BtCursor *sqlite3BtreeFakeValidCursor(void){ + static u8 fakeCursor = CURSOR_VALID; + assert( offsetof(BtCursor, eState)==0 ); + return (BtCursor*)&fakeCursor; +} + +/* +** This routine restores a cursor back to its original position after it +** has been moved by some outside activity (such as a btree rebalance or +** a row having been deleted out from under the cursor). +** +** On success, the *pDifferentRow parameter is false if the cursor is left +** pointing at exactly the same row. *pDifferntRow is the row the cursor +** was pointing to has been deleted, forcing the cursor to point to some +** nearby row. +** +** This routine should only be called for a cursor that just returned +** TRUE from sqlite3BtreeCursorHasMoved(). +*/ +SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor *pCur, int *pDifferentRow){ + int rc; + + assert( pCur!=0 ); + assert( pCur->eState!=CURSOR_VALID ); + rc = restoreCursorPosition(pCur); + if( rc ){ + *pDifferentRow = 1; + return rc; + } + if( pCur->eState!=CURSOR_VALID ){ + *pDifferentRow = 1; + }else{ + *pDifferentRow = 0; + } + return SQLITE_OK; +} + +#ifdef SQLITE_ENABLE_CURSOR_HINTS +/* +** Provide hints to the cursor. The particular hint given (and the type +** and number of the varargs parameters) is determined by the eHintType +** parameter. See the definitions of the BTREE_HINT_* macros for details. +*/ +SQLITE_PRIVATE void sqlite3BtreeCursorHint(BtCursor *pCur, int eHintType, ...){ + /* Used only by system that substitute their own storage engine */ +} +#endif + +/* +** Provide flag hints to the cursor. +*/ +SQLITE_PRIVATE void sqlite3BtreeCursorHintFlags(BtCursor *pCur, unsigned x){ + assert( x==BTREE_SEEK_EQ || x==BTREE_BULKLOAD || x==0 ); + pCur->hints = x; +} + + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** Given a page number of a regular database page, return the page +** number for the pointer-map page that contains the entry for the +** input page number. +** +** Return 0 (not a valid page) for pgno==1 since there is +** no pointer map associated with page 1. The integrity_check logic +** requires that ptrmapPageno(*,1)!=1. +*/ +static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){ + int nPagesPerMapPage; + Pgno iPtrMap, ret; + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pgno<2 ) return 0; + nPagesPerMapPage = (pBt->usableSize/5)+1; + iPtrMap = (pgno-2)/nPagesPerMapPage; + ret = (iPtrMap*nPagesPerMapPage) + 2; + if( ret==PENDING_BYTE_PAGE(pBt) ){ + ret++; + } + return ret; +} + +/* +** Write an entry into the pointer map. +** +** This routine updates the pointer map entry for page number 'key' +** so that it maps to type 'eType' and parent page number 'pgno'. +** +** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is +** a no-op. If an error occurs, the appropriate error code is written +** into *pRC. +*/ +static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){ + DbPage *pDbPage; /* The pointer map page */ + u8 *pPtrmap; /* The pointer map data */ + Pgno iPtrmap; /* The pointer map page number */ + int offset; /* Offset in pointer map page */ + int rc; /* Return code from subfunctions */ + + if( *pRC ) return; + + assert( sqlite3_mutex_held(pBt->mutex) ); + /* The super-journal page number must never be used as a pointer map page */ + assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) ); + + assert( pBt->autoVacuum ); + if( key==0 ){ + *pRC = SQLITE_CORRUPT_BKPT; + return; + } + iPtrmap = PTRMAP_PAGENO(pBt, key); + rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage, 0); + if( rc!=SQLITE_OK ){ + *pRC = rc; + return; + } + if( ((char*)sqlite3PagerGetExtra(pDbPage))[0]!=0 ){ + /* The first byte of the extra data is the MemPage.isInit byte. + ** If that byte is set, it means this page is also being used + ** as a btree page. */ + *pRC = SQLITE_CORRUPT_BKPT; + goto ptrmap_exit; + } + offset = PTRMAP_PTROFFSET(iPtrmap, key); + if( offset<0 ){ + *pRC = SQLITE_CORRUPT_BKPT; + goto ptrmap_exit; + } + assert( offset <= (int)pBt->usableSize-5 ); + pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage); + + if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){ + TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent)); + *pRC= rc = sqlite3PagerWrite(pDbPage); + if( rc==SQLITE_OK ){ + pPtrmap[offset] = eType; + put4byte(&pPtrmap[offset+1], parent); + } + } + +ptrmap_exit: + sqlite3PagerUnref(pDbPage); +} + +/* +** Read an entry from the pointer map. +** +** This routine retrieves the pointer map entry for page 'key', writing +** the type and parent page number to *pEType and *pPgno respectively. +** An error code is returned if something goes wrong, otherwise SQLITE_OK. +*/ +static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){ + DbPage *pDbPage; /* The pointer map page */ + int iPtrmap; /* Pointer map page index */ + u8 *pPtrmap; /* Pointer map page data */ + int offset; /* Offset of entry in pointer map */ + int rc; + + assert( sqlite3_mutex_held(pBt->mutex) ); + + iPtrmap = PTRMAP_PAGENO(pBt, key); + rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage, 0); + if( rc!=0 ){ + return rc; + } + pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage); + + offset = PTRMAP_PTROFFSET(iPtrmap, key); + if( offset<0 ){ + sqlite3PagerUnref(pDbPage); + return SQLITE_CORRUPT_BKPT; + } + assert( offset <= (int)pBt->usableSize-5 ); + assert( pEType!=0 ); + *pEType = pPtrmap[offset]; + if( pPgno ) *pPgno = get4byte(&pPtrmap[offset+1]); + + sqlite3PagerUnref(pDbPage); + if( *pEType<1 || *pEType>5 ) return SQLITE_CORRUPT_PGNO(iPtrmap); + return SQLITE_OK; +} + +#else /* if defined SQLITE_OMIT_AUTOVACUUM */ + #define ptrmapPut(w,x,y,z,rc) + #define ptrmapGet(w,x,y,z) SQLITE_OK + #define ptrmapPutOvflPtr(x, y, z, rc) +#endif + +/* +** Given a btree page and a cell index (0 means the first cell on +** the page, 1 means the second cell, and so forth) return a pointer +** to the cell content. +** +** findCellPastPtr() does the same except it skips past the initial +** 4-byte child pointer found on interior pages, if there is one. +** +** This routine works only for pages that do not contain overflow cells. +*/ +#define findCell(P,I) \ + ((P)->aData + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)]))) +#define findCellPastPtr(P,I) \ + ((P)->aDataOfst + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)]))) + + +/* +** This is common tail processing for btreeParseCellPtr() and +** btreeParseCellPtrIndex() for the case when the cell does not fit entirely +** on a single B-tree page. Make necessary adjustments to the CellInfo +** structure. +*/ +static SQLITE_NOINLINE void btreeParseCellAdjustSizeForOverflow( + MemPage *pPage, /* Page containing the cell */ + u8 *pCell, /* Pointer to the cell text. */ + CellInfo *pInfo /* Fill in this structure */ +){ + /* If the payload will not fit completely on the local page, we have + ** to decide how much to store locally and how much to spill onto + ** overflow pages. The strategy is to minimize the amount of unused + ** space on overflow pages while keeping the amount of local storage + ** in between minLocal and maxLocal. + ** + ** Warning: changing the way overflow payload is distributed in any + ** way will result in an incompatible file format. + */ + int minLocal; /* Minimum amount of payload held locally */ + int maxLocal; /* Maximum amount of payload held locally */ + int surplus; /* Overflow payload available for local storage */ + + minLocal = pPage->minLocal; + maxLocal = pPage->maxLocal; + surplus = minLocal + (pInfo->nPayload - minLocal)%(pPage->pBt->usableSize-4); + testcase( surplus==maxLocal ); + testcase( surplus==maxLocal+1 ); + if( surplus <= maxLocal ){ + pInfo->nLocal = (u16)surplus; + }else{ + pInfo->nLocal = (u16)minLocal; + } + pInfo->nSize = (u16)(&pInfo->pPayload[pInfo->nLocal] - pCell) + 4; +} + +/* +** The following routines are implementations of the MemPage.xParseCell() +** method. +** +** Parse a cell content block and fill in the CellInfo structure. +** +** btreeParseCellPtr() => table btree leaf nodes +** btreeParseCellNoPayload() => table btree internal nodes +** btreeParseCellPtrIndex() => index btree nodes +** +** There is also a wrapper function btreeParseCell() that works for +** all MemPage types and that references the cell by index rather than +** by pointer. +*/ +static void btreeParseCellPtrNoPayload( + MemPage *pPage, /* Page containing the cell */ + u8 *pCell, /* Pointer to the cell text. */ + CellInfo *pInfo /* Fill in this structure */ +){ + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->leaf==0 ); + assert( pPage->childPtrSize==4 ); +#ifndef SQLITE_DEBUG + UNUSED_PARAMETER(pPage); +#endif + pInfo->nSize = 4 + getVarint(&pCell[4], (u64*)&pInfo->nKey); + pInfo->nPayload = 0; + pInfo->nLocal = 0; + pInfo->pPayload = 0; + return; +} +static void btreeParseCellPtr( + MemPage *pPage, /* Page containing the cell */ + u8 *pCell, /* Pointer to the cell text. */ + CellInfo *pInfo /* Fill in this structure */ +){ + u8 *pIter; /* For scanning through pCell */ + u32 nPayload; /* Number of bytes of cell payload */ + u64 iKey; /* Extracted Key value */ + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->leaf==0 || pPage->leaf==1 ); + assert( pPage->intKeyLeaf ); + assert( pPage->childPtrSize==0 ); + pIter = pCell; + + /* The next block of code is equivalent to: + ** + ** pIter += getVarint32(pIter, nPayload); + ** + ** The code is inlined to avoid a function call. + */ + nPayload = *pIter; + if( nPayload>=0x80 ){ + u8 *pEnd = &pIter[8]; + nPayload &= 0x7f; + do{ + nPayload = (nPayload<<7) | (*++pIter & 0x7f); + }while( (*pIter)>=0x80 && pIternKey); + ** + ** The code is inlined to avoid a function call. + */ + iKey = *pIter; + if( iKey>=0x80 ){ + u8 *pEnd = &pIter[7]; + iKey &= 0x7f; + while(1){ + iKey = (iKey<<7) | (*++pIter & 0x7f); + if( (*pIter)<0x80 ) break; + if( pIter>=pEnd ){ + iKey = (iKey<<8) | *++pIter; + break; + } + } + } + pIter++; + + pInfo->nKey = *(i64*)&iKey; + pInfo->nPayload = nPayload; + pInfo->pPayload = pIter; + testcase( nPayload==pPage->maxLocal ); + testcase( nPayload==pPage->maxLocal+1 ); + if( nPayload<=pPage->maxLocal ){ + /* This is the (easy) common case where the entire payload fits + ** on the local page. No overflow is required. + */ + pInfo->nSize = nPayload + (u16)(pIter - pCell); + if( pInfo->nSize<4 ) pInfo->nSize = 4; + pInfo->nLocal = (u16)nPayload; + }else{ + btreeParseCellAdjustSizeForOverflow(pPage, pCell, pInfo); + } +} +static void btreeParseCellPtrIndex( + MemPage *pPage, /* Page containing the cell */ + u8 *pCell, /* Pointer to the cell text. */ + CellInfo *pInfo /* Fill in this structure */ +){ + u8 *pIter; /* For scanning through pCell */ + u32 nPayload; /* Number of bytes of cell payload */ + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->leaf==0 || pPage->leaf==1 ); + assert( pPage->intKeyLeaf==0 ); + pIter = pCell + pPage->childPtrSize; + nPayload = *pIter; + if( nPayload>=0x80 ){ + u8 *pEnd = &pIter[8]; + nPayload &= 0x7f; + do{ + nPayload = (nPayload<<7) | (*++pIter & 0x7f); + }while( *(pIter)>=0x80 && pIternKey = nPayload; + pInfo->nPayload = nPayload; + pInfo->pPayload = pIter; + testcase( nPayload==pPage->maxLocal ); + testcase( nPayload==pPage->maxLocal+1 ); + if( nPayload<=pPage->maxLocal ){ + /* This is the (easy) common case where the entire payload fits + ** on the local page. No overflow is required. + */ + pInfo->nSize = nPayload + (u16)(pIter - pCell); + if( pInfo->nSize<4 ) pInfo->nSize = 4; + pInfo->nLocal = (u16)nPayload; + }else{ + btreeParseCellAdjustSizeForOverflow(pPage, pCell, pInfo); + } +} +static void btreeParseCell( + MemPage *pPage, /* Page containing the cell */ + int iCell, /* The cell index. First cell is 0 */ + CellInfo *pInfo /* Fill in this structure */ +){ + pPage->xParseCell(pPage, findCell(pPage, iCell), pInfo); +} + +/* +** The following routines are implementations of the MemPage.xCellSize +** method. +** +** Compute the total number of bytes that a Cell needs in the cell +** data area of the btree-page. The return number includes the cell +** data header and the local payload, but not any overflow page or +** the space used by the cell pointer. +** +** cellSizePtrNoPayload() => table internal nodes +** cellSizePtr() => all index nodes & table leaf nodes +*/ +static u16 cellSizePtr(MemPage *pPage, u8 *pCell){ + u8 *pIter = pCell + pPage->childPtrSize; /* For looping over bytes of pCell */ + u8 *pEnd; /* End mark for a varint */ + u32 nSize; /* Size value to return */ + +#ifdef SQLITE_DEBUG + /* The value returned by this function should always be the same as + ** the (CellInfo.nSize) value found by doing a full parse of the + ** cell. If SQLITE_DEBUG is defined, an assert() at the bottom of + ** this function verifies that this invariant is not violated. */ + CellInfo debuginfo; + pPage->xParseCell(pPage, pCell, &debuginfo); +#endif + + nSize = *pIter; + if( nSize>=0x80 ){ + pEnd = &pIter[8]; + nSize &= 0x7f; + do{ + nSize = (nSize<<7) | (*++pIter & 0x7f); + }while( *(pIter)>=0x80 && pIterintKey ){ + /* pIter now points at the 64-bit integer key value, a variable length + ** integer. The following block moves pIter to point at the first byte + ** past the end of the key value. */ + pEnd = &pIter[9]; + while( (*pIter++)&0x80 && pItermaxLocal ); + testcase( nSize==pPage->maxLocal+1 ); + if( nSize<=pPage->maxLocal ){ + nSize += (u32)(pIter - pCell); + if( nSize<4 ) nSize = 4; + }else{ + int minLocal = pPage->minLocal; + nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4); + testcase( nSize==pPage->maxLocal ); + testcase( nSize==pPage->maxLocal+1 ); + if( nSize>pPage->maxLocal ){ + nSize = minLocal; + } + nSize += 4 + (u16)(pIter - pCell); + } + assert( nSize==debuginfo.nSize || CORRUPT_DB ); + return (u16)nSize; +} +static u16 cellSizePtrNoPayload(MemPage *pPage, u8 *pCell){ + u8 *pIter = pCell + 4; /* For looping over bytes of pCell */ + u8 *pEnd; /* End mark for a varint */ + +#ifdef SQLITE_DEBUG + /* The value returned by this function should always be the same as + ** the (CellInfo.nSize) value found by doing a full parse of the + ** cell. If SQLITE_DEBUG is defined, an assert() at the bottom of + ** this function verifies that this invariant is not violated. */ + CellInfo debuginfo; + pPage->xParseCell(pPage, pCell, &debuginfo); +#else + UNUSED_PARAMETER(pPage); +#endif + + assert( pPage->childPtrSize==4 ); + pEnd = pIter + 9; + while( (*pIter++)&0x80 && pIterxCellSize(pPage, findCell(pPage, iCell)); +} +#endif + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** The cell pCell is currently part of page pSrc but will ultimately be part +** of pPage. (pSrc and pPager are often the same.) If pCell contains a +** pointer to an overflow page, insert an entry into the pointer-map for +** the overflow page that will be valid after pCell has been moved to pPage. +*/ +static void ptrmapPutOvflPtr(MemPage *pPage, MemPage *pSrc, u8 *pCell,int *pRC){ + CellInfo info; + if( *pRC ) return; + assert( pCell!=0 ); + pPage->xParseCell(pPage, pCell, &info); + if( info.nLocalaDataEnd, pCell, pCell+info.nLocal) ){ + testcase( pSrc!=pPage ); + *pRC = SQLITE_CORRUPT_BKPT; + return; + } + ovfl = get4byte(&pCell[info.nSize-4]); + ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC); + } +} +#endif + + +/* +** Defragment the page given. This routine reorganizes cells within the +** page so that there are no free-blocks on the free-block list. +** +** Parameter nMaxFrag is the maximum amount of fragmented space that may be +** present in the page after this routine returns. +** +** EVIDENCE-OF: R-44582-60138 SQLite may from time to time reorganize a +** b-tree page so that there are no freeblocks or fragment bytes, all +** unused bytes are contained in the unallocated space region, and all +** cells are packed tightly at the end of the page. +*/ +static int defragmentPage(MemPage *pPage, int nMaxFrag){ + int i; /* Loop counter */ + int pc; /* Address of the i-th cell */ + int hdr; /* Offset to the page header */ + int size; /* Size of a cell */ + int usableSize; /* Number of usable bytes on a page */ + int cellOffset; /* Offset to the cell pointer array */ + int cbrk; /* Offset to the cell content area */ + int nCell; /* Number of cells on the page */ + unsigned char *data; /* The page data */ + unsigned char *temp; /* Temp area for cell content */ + unsigned char *src; /* Source of content */ + int iCellFirst; /* First allowable cell index */ + int iCellLast; /* Last possible cell index */ + + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( pPage->pBt!=0 ); + assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE ); + assert( pPage->nOverflow==0 ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + temp = 0; + src = data = pPage->aData; + hdr = pPage->hdrOffset; + cellOffset = pPage->cellOffset; + nCell = pPage->nCell; + assert( nCell==get2byte(&data[hdr+3]) || CORRUPT_DB ); + iCellFirst = cellOffset + 2*nCell; + usableSize = pPage->pBt->usableSize; + + /* This block handles pages with two or fewer free blocks and nMaxFrag + ** or fewer fragmented bytes. In this case it is faster to move the + ** two (or one) blocks of cells using memmove() and add the required + ** offsets to each pointer in the cell-pointer array than it is to + ** reconstruct the entire page. */ + if( (int)data[hdr+7]<=nMaxFrag ){ + int iFree = get2byte(&data[hdr+1]); + if( iFree>usableSize-4 ) return SQLITE_CORRUPT_PAGE(pPage); + if( iFree ){ + int iFree2 = get2byte(&data[iFree]); + if( iFree2>usableSize-4 ) return SQLITE_CORRUPT_PAGE(pPage); + if( 0==iFree2 || (data[iFree2]==0 && data[iFree2+1]==0) ){ + u8 *pEnd = &data[cellOffset + nCell*2]; + u8 *pAddr; + int sz2 = 0; + int sz = get2byte(&data[iFree+2]); + int top = get2byte(&data[hdr+5]); + if( top>=iFree ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + if( iFree2 ){ + if( iFree+sz>iFree2 ) return SQLITE_CORRUPT_PAGE(pPage); + sz2 = get2byte(&data[iFree2+2]); + if( iFree2+sz2 > usableSize ) return SQLITE_CORRUPT_PAGE(pPage); + memmove(&data[iFree+sz+sz2], &data[iFree+sz], iFree2-(iFree+sz)); + sz += sz2; + }else if( NEVER(iFree+sz>usableSize) ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + + cbrk = top+sz; + assert( cbrk+(iFree-top) <= usableSize ); + memmove(&data[cbrk], &data[top], iFree-top); + for(pAddr=&data[cellOffset]; pAddriCellLast ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + assert( pc>=iCellFirst && pc<=iCellLast ); + size = pPage->xCellSize(pPage, &src[pc]); + cbrk -= size; + if( cbrkusableSize ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + assert( cbrk+size<=usableSize && cbrk>=iCellFirst ); + testcase( cbrk+size==usableSize ); + testcase( pc+size==usableSize ); + put2byte(pAddr, cbrk); + if( temp==0 ){ + int x; + if( cbrk==pc ) continue; + temp = sqlite3PagerTempSpace(pPage->pBt->pPager); + x = get2byte(&data[hdr+5]); + memcpy(&temp[x], &data[x], (cbrk+size) - x); + src = temp; + } + memcpy(&data[cbrk], &src[pc], size); + } + data[hdr+7] = 0; + + defragment_out: + assert( pPage->nFree>=0 ); + if( data[hdr+7]+cbrk-iCellFirst!=pPage->nFree ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + assert( cbrk>=iCellFirst ); + put2byte(&data[hdr+5], cbrk); + data[hdr+1] = 0; + data[hdr+2] = 0; + memset(&data[iCellFirst], 0, cbrk-iCellFirst); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + return SQLITE_OK; +} + +/* +** Search the free-list on page pPg for space to store a cell nByte bytes in +** size. If one can be found, return a pointer to the space and remove it +** from the free-list. +** +** If no suitable space can be found on the free-list, return NULL. +** +** This function may detect corruption within pPg. If corruption is +** detected then *pRc is set to SQLITE_CORRUPT and NULL is returned. +** +** Slots on the free list that are between 1 and 3 bytes larger than nByte +** will be ignored if adding the extra space to the fragmentation count +** causes the fragmentation count to exceed 60. +*/ +static u8 *pageFindSlot(MemPage *pPg, int nByte, int *pRc){ + const int hdr = pPg->hdrOffset; /* Offset to page header */ + u8 * const aData = pPg->aData; /* Page data */ + int iAddr = hdr + 1; /* Address of ptr to pc */ + int pc = get2byte(&aData[iAddr]); /* Address of a free slot */ + int x; /* Excess size of the slot */ + int maxPC = pPg->pBt->usableSize - nByte; /* Max address for a usable slot */ + int size; /* Size of the free slot */ + + assert( pc>0 ); + while( pc<=maxPC ){ + /* EVIDENCE-OF: R-22710-53328 The third and fourth bytes of each + ** freeblock form a big-endian integer which is the size of the freeblock + ** in bytes, including the 4-byte header. */ + size = get2byte(&aData[pc+2]); + if( (x = size - nByte)>=0 ){ + testcase( x==4 ); + testcase( x==3 ); + if( x<4 ){ + /* EVIDENCE-OF: R-11498-58022 In a well-formed b-tree page, the total + ** number of bytes in fragments may not exceed 60. */ + if( aData[hdr+7]>57 ) return 0; + + /* Remove the slot from the free-list. Update the number of + ** fragmented bytes within the page. */ + memcpy(&aData[iAddr], &aData[pc], 2); + aData[hdr+7] += (u8)x; + }else if( x+pc > maxPC ){ + /* This slot extends off the end of the usable part of the page */ + *pRc = SQLITE_CORRUPT_PAGE(pPg); + return 0; + }else{ + /* The slot remains on the free-list. Reduce its size to account + ** for the portion used by the new allocation. */ + put2byte(&aData[pc+2], x); + } + return &aData[pc + x]; + } + iAddr = pc; + pc = get2byte(&aData[pc]); + if( pc<=iAddr+size ){ + if( pc ){ + /* The next slot in the chain is not past the end of the current slot */ + *pRc = SQLITE_CORRUPT_PAGE(pPg); + } + return 0; + } + } + if( pc>maxPC+nByte-4 ){ + /* The free slot chain extends off the end of the page */ + *pRc = SQLITE_CORRUPT_PAGE(pPg); + } + return 0; +} + +/* +** Allocate nByte bytes of space from within the B-Tree page passed +** as the first argument. Write into *pIdx the index into pPage->aData[] +** of the first byte of allocated space. Return either SQLITE_OK or +** an error code (usually SQLITE_CORRUPT). +** +** The caller guarantees that there is sufficient space to make the +** allocation. This routine might need to defragment in order to bring +** all the space together, however. This routine will avoid using +** the first two bytes past the cell pointer area since presumably this +** allocation is being made in order to insert a new cell, so we will +** also end up needing a new cell pointer. +*/ +static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){ + const int hdr = pPage->hdrOffset; /* Local cache of pPage->hdrOffset */ + u8 * const data = pPage->aData; /* Local cache of pPage->aData */ + int top; /* First byte of cell content area */ + int rc = SQLITE_OK; /* Integer return code */ + int gap; /* First byte of gap between cell pointers and cell content */ + + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( pPage->pBt ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( nByte>=0 ); /* Minimum cell size is 4 */ + assert( pPage->nFree>=nByte ); + assert( pPage->nOverflow==0 ); + assert( nByte < (int)(pPage->pBt->usableSize-8) ); + + assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf ); + gap = pPage->cellOffset + 2*pPage->nCell; + assert( gap<=65536 ); + /* EVIDENCE-OF: R-29356-02391 If the database uses a 65536-byte page size + ** and the reserved space is zero (the usual value for reserved space) + ** then the cell content offset of an empty page wants to be 65536. + ** However, that integer is too large to be stored in a 2-byte unsigned + ** integer, so a value of 0 is used in its place. */ + top = get2byte(&data[hdr+5]); + assert( top<=(int)pPage->pBt->usableSize ); /* by btreeComputeFreeSpace() */ + if( gap>top ){ + if( top==0 && pPage->pBt->usableSize==65536 ){ + top = 65536; + }else{ + return SQLITE_CORRUPT_PAGE(pPage); + } + } + + /* If there is enough space between gap and top for one more cell pointer, + ** and if the freelist is not empty, then search the + ** freelist looking for a slot big enough to satisfy the request. + */ + testcase( gap+2==top ); + testcase( gap+1==top ); + testcase( gap==top ); + if( (data[hdr+2] || data[hdr+1]) && gap+2<=top ){ + u8 *pSpace = pageFindSlot(pPage, nByte, &rc); + if( pSpace ){ + int g2; + assert( pSpace+nByte<=data+pPage->pBt->usableSize ); + *pIdx = g2 = (int)(pSpace-data); + if( NEVER(g2<=gap) ){ + return SQLITE_CORRUPT_PAGE(pPage); + }else{ + return SQLITE_OK; + } + }else if( rc ){ + return rc; + } + } + + /* The request could not be fulfilled using a freelist slot. Check + ** to see if defragmentation is necessary. + */ + testcase( gap+2+nByte==top ); + if( gap+2+nByte>top ){ + assert( pPage->nCell>0 || CORRUPT_DB ); + assert( pPage->nFree>=0 ); + rc = defragmentPage(pPage, MIN(4, pPage->nFree - (2+nByte))); + if( rc ) return rc; + top = get2byteNotZero(&data[hdr+5]); + assert( gap+2+nByte<=top ); + } + + + /* Allocate memory from the gap in between the cell pointer array + ** and the cell content area. The btreeComputeFreeSpace() call has already + ** validated the freelist. Given that the freelist is valid, there + ** is no way that the allocation can extend off the end of the page. + ** The assert() below verifies the previous sentence. + */ + top -= nByte; + put2byte(&data[hdr+5], top); + assert( top+nByte <= (int)pPage->pBt->usableSize ); + *pIdx = top; + return SQLITE_OK; +} + +/* +** Return a section of the pPage->aData to the freelist. +** The first byte of the new free block is pPage->aData[iStart] +** and the size of the block is iSize bytes. +** +** Adjacent freeblocks are coalesced. +** +** Even though the freeblock list was checked by btreeComputeFreeSpace(), +** that routine will not detect overlap between cells or freeblocks. Nor +** does it detect cells or freeblocks that encrouch into the reserved bytes +** at the end of the page. So do additional corruption checks inside this +** routine and return SQLITE_CORRUPT if any problems are found. +*/ +static int freeSpace(MemPage *pPage, u16 iStart, u16 iSize){ + u16 iPtr; /* Address of ptr to next freeblock */ + u16 iFreeBlk; /* Address of the next freeblock */ + u8 hdr; /* Page header size. 0 or 100 */ + u8 nFrag = 0; /* Reduction in fragmentation */ + u16 iOrigSize = iSize; /* Original value of iSize */ + u16 x; /* Offset to cell content area */ + u32 iEnd = iStart + iSize; /* First byte past the iStart buffer */ + unsigned char *data = pPage->aData; /* Page content */ + + assert( pPage->pBt!=0 ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( CORRUPT_DB || iStart>=pPage->hdrOffset+6+pPage->childPtrSize ); + assert( CORRUPT_DB || iEnd <= pPage->pBt->usableSize ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( iSize>=4 ); /* Minimum cell size is 4 */ + assert( iStart<=pPage->pBt->usableSize-4 ); + + /* The list of freeblocks must be in ascending order. Find the + ** spot on the list where iStart should be inserted. + */ + hdr = pPage->hdrOffset; + iPtr = hdr + 1; + if( data[iPtr+1]==0 && data[iPtr]==0 ){ + iFreeBlk = 0; /* Shortcut for the case when the freelist is empty */ + }else{ + while( (iFreeBlk = get2byte(&data[iPtr]))pPage->pBt->usableSize-4 ){ /* TH3: corrupt081.100 */ + return SQLITE_CORRUPT_PAGE(pPage); + } + assert( iFreeBlk>iPtr || iFreeBlk==0 ); + + /* At this point: + ** iFreeBlk: First freeblock after iStart, or zero if none + ** iPtr: The address of a pointer to iFreeBlk + ** + ** Check to see if iFreeBlk should be coalesced onto the end of iStart. + */ + if( iFreeBlk && iEnd+3>=iFreeBlk ){ + nFrag = iFreeBlk - iEnd; + if( iEnd>iFreeBlk ) return SQLITE_CORRUPT_PAGE(pPage); + iEnd = iFreeBlk + get2byte(&data[iFreeBlk+2]); + if( iEnd > pPage->pBt->usableSize ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + iSize = iEnd - iStart; + iFreeBlk = get2byte(&data[iFreeBlk]); + } + + /* If iPtr is another freeblock (that is, if iPtr is not the freelist + ** pointer in the page header) then check to see if iStart should be + ** coalesced onto the end of iPtr. + */ + if( iPtr>hdr+1 ){ + int iPtrEnd = iPtr + get2byte(&data[iPtr+2]); + if( iPtrEnd+3>=iStart ){ + if( iPtrEnd>iStart ) return SQLITE_CORRUPT_PAGE(pPage); + nFrag += iStart - iPtrEnd; + iSize = iEnd - iPtr; + iStart = iPtr; + } + } + if( nFrag>data[hdr+7] ) return SQLITE_CORRUPT_PAGE(pPage); + data[hdr+7] -= nFrag; + } + x = get2byte(&data[hdr+5]); + if( iStart<=x ){ + /* The new freeblock is at the beginning of the cell content area, + ** so just extend the cell content area rather than create another + ** freelist entry */ + if( iStartpBt->btsFlags & BTS_FAST_SECURE ){ + /* Overwrite deleted information with zeros when the secure_delete + ** option is enabled */ + memset(&data[iStart], 0, iSize); + } + put2byte(&data[iStart], iFreeBlk); + put2byte(&data[iStart+2], iSize); + pPage->nFree += iOrigSize; + return SQLITE_OK; +} + +/* +** Decode the flags byte (the first byte of the header) for a page +** and initialize fields of the MemPage structure accordingly. +** +** Only the following combinations are supported. Anything different +** indicates a corrupt database files: +** +** PTF_ZERODATA +** PTF_ZERODATA | PTF_LEAF +** PTF_LEAFDATA | PTF_INTKEY +** PTF_LEAFDATA | PTF_INTKEY | PTF_LEAF +*/ +static int decodeFlags(MemPage *pPage, int flagByte){ + BtShared *pBt; /* A copy of pPage->pBt */ + + assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + pPage->leaf = (u8)(flagByte>>3); assert( PTF_LEAF == 1<<3 ); + flagByte &= ~PTF_LEAF; + pPage->childPtrSize = 4-4*pPage->leaf; + pPage->xCellSize = cellSizePtr; + pBt = pPage->pBt; + if( flagByte==(PTF_LEAFDATA | PTF_INTKEY) ){ + /* EVIDENCE-OF: R-07291-35328 A value of 5 (0x05) means the page is an + ** interior table b-tree page. */ + assert( (PTF_LEAFDATA|PTF_INTKEY)==5 ); + /* EVIDENCE-OF: R-26900-09176 A value of 13 (0x0d) means the page is a + ** leaf table b-tree page. */ + assert( (PTF_LEAFDATA|PTF_INTKEY|PTF_LEAF)==13 ); + pPage->intKey = 1; + if( pPage->leaf ){ + pPage->intKeyLeaf = 1; + pPage->xParseCell = btreeParseCellPtr; + }else{ + pPage->intKeyLeaf = 0; + pPage->xCellSize = cellSizePtrNoPayload; + pPage->xParseCell = btreeParseCellPtrNoPayload; + } + pPage->maxLocal = pBt->maxLeaf; + pPage->minLocal = pBt->minLeaf; + }else if( flagByte==PTF_ZERODATA ){ + /* EVIDENCE-OF: R-43316-37308 A value of 2 (0x02) means the page is an + ** interior index b-tree page. */ + assert( (PTF_ZERODATA)==2 ); + /* EVIDENCE-OF: R-59615-42828 A value of 10 (0x0a) means the page is a + ** leaf index b-tree page. */ + assert( (PTF_ZERODATA|PTF_LEAF)==10 ); + pPage->intKey = 0; + pPage->intKeyLeaf = 0; + pPage->xParseCell = btreeParseCellPtrIndex; + pPage->maxLocal = pBt->maxLocal; + pPage->minLocal = pBt->minLocal; + }else{ + /* EVIDENCE-OF: R-47608-56469 Any other value for the b-tree page type is + ** an error. */ + return SQLITE_CORRUPT_PAGE(pPage); + } + pPage->max1bytePayload = pBt->max1bytePayload; + return SQLITE_OK; +} + +/* +** Compute the amount of freespace on the page. In other words, fill +** in the pPage->nFree field. +*/ +static int btreeComputeFreeSpace(MemPage *pPage){ + int pc; /* Address of a freeblock within pPage->aData[] */ + u8 hdr; /* Offset to beginning of page header */ + u8 *data; /* Equal to pPage->aData */ + int usableSize; /* Amount of usable space on each page */ + int nFree; /* Number of unused bytes on the page */ + int top; /* First byte of the cell content area */ + int iCellFirst; /* First allowable cell or freeblock offset */ + int iCellLast; /* Last possible cell or freeblock offset */ + + assert( pPage->pBt!=0 ); + assert( pPage->pBt->db!=0 ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) ); + assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) ); + assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) ); + assert( pPage->isInit==1 ); + assert( pPage->nFree<0 ); + + usableSize = pPage->pBt->usableSize; + hdr = pPage->hdrOffset; + data = pPage->aData; + /* EVIDENCE-OF: R-58015-48175 The two-byte integer at offset 5 designates + ** the start of the cell content area. A zero value for this integer is + ** interpreted as 65536. */ + top = get2byteNotZero(&data[hdr+5]); + iCellFirst = hdr + 8 + pPage->childPtrSize + 2*pPage->nCell; + iCellLast = usableSize - 4; + + /* Compute the total free space on the page + ** EVIDENCE-OF: R-23588-34450 The two-byte integer at offset 1 gives the + ** start of the first freeblock on the page, or is zero if there are no + ** freeblocks. */ + pc = get2byte(&data[hdr+1]); + nFree = data[hdr+7] + top; /* Init nFree to non-freeblock free space */ + if( pc>0 ){ + u32 next, size; + if( pciCellLast ){ + /* Freeblock off the end of the page */ + return SQLITE_CORRUPT_PAGE(pPage); + } + next = get2byte(&data[pc]); + size = get2byte(&data[pc+2]); + nFree = nFree + size; + if( next<=pc+size+3 ) break; + pc = next; + } + if( next>0 ){ + /* Freeblock not in ascending order */ + return SQLITE_CORRUPT_PAGE(pPage); + } + if( pc+size>(unsigned int)usableSize ){ + /* Last freeblock extends past page end */ + return SQLITE_CORRUPT_PAGE(pPage); + } + } + + /* At this point, nFree contains the sum of the offset to the start + ** of the cell-content area plus the number of free bytes within + ** the cell-content area. If this is greater than the usable-size + ** of the page, then the page must be corrupted. This check also + ** serves to verify that the offset to the start of the cell-content + ** area, according to the page header, lies within the page. + */ + if( nFree>usableSize || nFreenFree = (u16)(nFree - iCellFirst); + return SQLITE_OK; +} + +/* +** Do additional sanity check after btreeInitPage() if +** PRAGMA cell_size_check=ON +*/ +static SQLITE_NOINLINE int btreeCellSizeCheck(MemPage *pPage){ + int iCellFirst; /* First allowable cell or freeblock offset */ + int iCellLast; /* Last possible cell or freeblock offset */ + int i; /* Index into the cell pointer array */ + int sz; /* Size of a cell */ + int pc; /* Address of a freeblock within pPage->aData[] */ + u8 *data; /* Equal to pPage->aData */ + int usableSize; /* Maximum usable space on the page */ + int cellOffset; /* Start of cell content area */ + + iCellFirst = pPage->cellOffset + 2*pPage->nCell; + usableSize = pPage->pBt->usableSize; + iCellLast = usableSize - 4; + data = pPage->aData; + cellOffset = pPage->cellOffset; + if( !pPage->leaf ) iCellLast--; + for(i=0; inCell; i++){ + pc = get2byteAligned(&data[cellOffset+i*2]); + testcase( pc==iCellFirst ); + testcase( pc==iCellLast ); + if( pciCellLast ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + sz = pPage->xCellSize(pPage, &data[pc]); + testcase( pc+sz==usableSize ); + if( pc+sz>usableSize ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + } + return SQLITE_OK; +} + +/* +** Initialize the auxiliary information for a disk block. +** +** Return SQLITE_OK on success. If we see that the page does +** not contain a well-formed database page, then return +** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not +** guarantee that the page is well-formed. It only shows that +** we failed to detect any corruption. +*/ +static int btreeInitPage(MemPage *pPage){ + u8 *data; /* Equal to pPage->aData */ + BtShared *pBt; /* The main btree structure */ + + assert( pPage->pBt!=0 ); + assert( pPage->pBt->db!=0 ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) ); + assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) ); + assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) ); + assert( pPage->isInit==0 ); + + pBt = pPage->pBt; + data = pPage->aData + pPage->hdrOffset; + /* EVIDENCE-OF: R-28594-02890 The one-byte flag at offset 0 indicating + ** the b-tree page type. */ + if( decodeFlags(pPage, data[0]) ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + assert( pBt->pageSize>=512 && pBt->pageSize<=65536 ); + pPage->maskPage = (u16)(pBt->pageSize - 1); + pPage->nOverflow = 0; + pPage->cellOffset = pPage->hdrOffset + 8 + pPage->childPtrSize; + pPage->aCellIdx = data + pPage->childPtrSize + 8; + pPage->aDataEnd = pPage->aData + pBt->usableSize; + pPage->aDataOfst = pPage->aData + pPage->childPtrSize; + /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the + ** number of cells on the page. */ + pPage->nCell = get2byte(&data[3]); + if( pPage->nCell>MX_CELL(pBt) ){ + /* To many cells for a single page. The page must be corrupt */ + return SQLITE_CORRUPT_PAGE(pPage); + } + testcase( pPage->nCell==MX_CELL(pBt) ); + /* EVIDENCE-OF: R-24089-57979 If a page contains no cells (which is only + ** possible for a root page of a table that contains no rows) then the + ** offset to the cell content area will equal the page size minus the + ** bytes of reserved space. */ + assert( pPage->nCell>0 + || get2byteNotZero(&data[5])==(int)pBt->usableSize + || CORRUPT_DB ); + pPage->nFree = -1; /* Indicate that this value is yet uncomputed */ + pPage->isInit = 1; + if( pBt->db->flags & SQLITE_CellSizeCk ){ + return btreeCellSizeCheck(pPage); + } + return SQLITE_OK; +} + +/* +** Set up a raw page so that it looks like a database page holding +** no entries. +*/ +static void zeroPage(MemPage *pPage, int flags){ + unsigned char *data = pPage->aData; + BtShared *pBt = pPage->pBt; + u8 hdr = pPage->hdrOffset; + u16 first; + + assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno ); + assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage ); + assert( sqlite3PagerGetData(pPage->pDbPage) == data ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pBt->btsFlags & BTS_FAST_SECURE ){ + memset(&data[hdr], 0, pBt->usableSize - hdr); + } + data[hdr] = (char)flags; + first = hdr + ((flags&PTF_LEAF)==0 ? 12 : 8); + memset(&data[hdr+1], 0, 4); + data[hdr+7] = 0; + put2byte(&data[hdr+5], pBt->usableSize); + pPage->nFree = (u16)(pBt->usableSize - first); + decodeFlags(pPage, flags); + pPage->cellOffset = first; + pPage->aDataEnd = &data[pBt->usableSize]; + pPage->aCellIdx = &data[first]; + pPage->aDataOfst = &data[pPage->childPtrSize]; + pPage->nOverflow = 0; + assert( pBt->pageSize>=512 && pBt->pageSize<=65536 ); + pPage->maskPage = (u16)(pBt->pageSize - 1); + pPage->nCell = 0; + pPage->isInit = 1; +} + + +/* +** Convert a DbPage obtained from the pager into a MemPage used by +** the btree layer. +*/ +static MemPage *btreePageFromDbPage(DbPage *pDbPage, Pgno pgno, BtShared *pBt){ + MemPage *pPage = (MemPage*)sqlite3PagerGetExtra(pDbPage); + if( pgno!=pPage->pgno ){ + pPage->aData = sqlite3PagerGetData(pDbPage); + pPage->pDbPage = pDbPage; + pPage->pBt = pBt; + pPage->pgno = pgno; + pPage->hdrOffset = pgno==1 ? 100 : 0; + } + assert( pPage->aData==sqlite3PagerGetData(pDbPage) ); + return pPage; +} + +/* +** Get a page from the pager. Initialize the MemPage.pBt and +** MemPage.aData elements if needed. See also: btreeGetUnusedPage(). +** +** If the PAGER_GET_NOCONTENT flag is set, it means that we do not care +** about the content of the page at this time. So do not go to the disk +** to fetch the content. Just fill in the content with zeros for now. +** If in the future we call sqlite3PagerWrite() on this page, that +** means we have started to be concerned about content and the disk +** read should occur at that point. +*/ +static int btreeGetPage( + BtShared *pBt, /* The btree */ + Pgno pgno, /* Number of the page to fetch */ + MemPage **ppPage, /* Return the page in this parameter */ + int flags /* PAGER_GET_NOCONTENT or PAGER_GET_READONLY */ +){ + int rc; + DbPage *pDbPage; + + assert( flags==0 || flags==PAGER_GET_NOCONTENT || flags==PAGER_GET_READONLY ); + assert( sqlite3_mutex_held(pBt->mutex) ); + rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, flags); + if( rc ) return rc; + *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt); + return SQLITE_OK; +} + +/* +** Retrieve a page from the pager cache. If the requested page is not +** already in the pager cache return NULL. Initialize the MemPage.pBt and +** MemPage.aData elements if needed. +*/ +static MemPage *btreePageLookup(BtShared *pBt, Pgno pgno){ + DbPage *pDbPage; + assert( sqlite3_mutex_held(pBt->mutex) ); + pDbPage = sqlite3PagerLookup(pBt->pPager, pgno); + if( pDbPage ){ + return btreePageFromDbPage(pDbPage, pgno, pBt); + } + return 0; +} + +/* +** Return the size of the database file in pages. If there is any kind of +** error, return ((unsigned int)-1). +*/ +static Pgno btreePagecount(BtShared *pBt){ + return pBt->nPage; +} +SQLITE_PRIVATE Pgno sqlite3BtreeLastPage(Btree *p){ + assert( sqlite3BtreeHoldsMutex(p) ); + return btreePagecount(p->pBt); +} + +/* +** Get a page from the pager and initialize it. +** +** If pCur!=0 then the page is being fetched as part of a moveToChild() +** call. Do additional sanity checking on the page in this case. +** And if the fetch fails, this routine must decrement pCur->iPage. +** +** The page is fetched as read-write unless pCur is not NULL and is +** a read-only cursor. +** +** If an error occurs, then *ppPage is undefined. It +** may remain unchanged, or it may be set to an invalid value. +*/ +static int getAndInitPage( + BtShared *pBt, /* The database file */ + Pgno pgno, /* Number of the page to get */ + MemPage **ppPage, /* Write the page pointer here */ + BtCursor *pCur, /* Cursor to receive the page, or NULL */ + int bReadOnly /* True for a read-only page */ +){ + int rc; + DbPage *pDbPage; + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pCur==0 || ppPage==&pCur->pPage ); + assert( pCur==0 || bReadOnly==pCur->curPagerFlags ); + assert( pCur==0 || pCur->iPage>0 ); + + if( pgno>btreePagecount(pBt) ){ + rc = SQLITE_CORRUPT_BKPT; + goto getAndInitPage_error1; + } + rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly); + if( rc ){ + goto getAndInitPage_error1; + } + *ppPage = (MemPage*)sqlite3PagerGetExtra(pDbPage); + if( (*ppPage)->isInit==0 ){ + btreePageFromDbPage(pDbPage, pgno, pBt); + rc = btreeInitPage(*ppPage); + if( rc!=SQLITE_OK ){ + goto getAndInitPage_error2; + } + } + assert( (*ppPage)->pgno==pgno ); + assert( (*ppPage)->aData==sqlite3PagerGetData(pDbPage) ); + + /* If obtaining a child page for a cursor, we must verify that the page is + ** compatible with the root page. */ + if( pCur && ((*ppPage)->nCell<1 || (*ppPage)->intKey!=pCur->curIntKey) ){ + rc = SQLITE_CORRUPT_PGNO(pgno); + goto getAndInitPage_error2; + } + return SQLITE_OK; + +getAndInitPage_error2: + releasePage(*ppPage); +getAndInitPage_error1: + if( pCur ){ + pCur->iPage--; + pCur->pPage = pCur->apPage[pCur->iPage]; + } + testcase( pgno==0 ); + assert( pgno!=0 || rc==SQLITE_CORRUPT ); + return rc; +} + +/* +** Release a MemPage. This should be called once for each prior +** call to btreeGetPage. +** +** Page1 is a special case and must be released using releasePageOne(). +*/ +static void releasePageNotNull(MemPage *pPage){ + assert( pPage->aData ); + assert( pPage->pBt ); + assert( pPage->pDbPage!=0 ); + assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage ); + assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + sqlite3PagerUnrefNotNull(pPage->pDbPage); +} +static void releasePage(MemPage *pPage){ + if( pPage ) releasePageNotNull(pPage); +} +static void releasePageOne(MemPage *pPage){ + assert( pPage!=0 ); + assert( pPage->aData ); + assert( pPage->pBt ); + assert( pPage->pDbPage!=0 ); + assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage ); + assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + sqlite3PagerUnrefPageOne(pPage->pDbPage); +} + +/* +** Get an unused page. +** +** This works just like btreeGetPage() with the addition: +** +** * If the page is already in use for some other purpose, immediately +** release it and return an SQLITE_CURRUPT error. +** * Make sure the isInit flag is clear +*/ +static int btreeGetUnusedPage( + BtShared *pBt, /* The btree */ + Pgno pgno, /* Number of the page to fetch */ + MemPage **ppPage, /* Return the page in this parameter */ + int flags /* PAGER_GET_NOCONTENT or PAGER_GET_READONLY */ +){ + int rc = btreeGetPage(pBt, pgno, ppPage, flags); + if( rc==SQLITE_OK ){ + if( sqlite3PagerPageRefcount((*ppPage)->pDbPage)>1 ){ + releasePage(*ppPage); + *ppPage = 0; + return SQLITE_CORRUPT_BKPT; + } + (*ppPage)->isInit = 0; + }else{ + *ppPage = 0; + } + return rc; +} + + +/* +** During a rollback, when the pager reloads information into the cache +** so that the cache is restored to its original state at the start of +** the transaction, for each page restored this routine is called. +** +** This routine needs to reset the extra data section at the end of the +** page to agree with the restored data. +*/ +static void pageReinit(DbPage *pData){ + MemPage *pPage; + pPage = (MemPage *)sqlite3PagerGetExtra(pData); + assert( sqlite3PagerPageRefcount(pData)>0 ); + if( pPage->isInit ){ + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + pPage->isInit = 0; + if( sqlite3PagerPageRefcount(pData)>1 ){ + /* pPage might not be a btree page; it might be an overflow page + ** or ptrmap page or a free page. In those cases, the following + ** call to btreeInitPage() will likely return SQLITE_CORRUPT. + ** But no harm is done by this. And it is very important that + ** btreeInitPage() be called on every btree page so we make + ** the call for every page that comes in for re-initing. */ + btreeInitPage(pPage); + } + } +} + +/* +** Invoke the busy handler for a btree. +*/ +static int btreeInvokeBusyHandler(void *pArg){ + BtShared *pBt = (BtShared*)pArg; + assert( pBt->db ); + assert( sqlite3_mutex_held(pBt->db->mutex) ); + return sqlite3InvokeBusyHandler(&pBt->db->busyHandler); +} + +/* +** Open a database file. +** +** zFilename is the name of the database file. If zFilename is NULL +** then an ephemeral database is created. The ephemeral database might +** be exclusively in memory, or it might use a disk-based memory cache. +** Either way, the ephemeral database will be automatically deleted +** when sqlite3BtreeClose() is called. +** +** If zFilename is ":memory:" then an in-memory database is created +** that is automatically destroyed when it is closed. +** +** The "flags" parameter is a bitmask that might contain bits like +** BTREE_OMIT_JOURNAL and/or BTREE_MEMORY. +** +** If the database is already opened in the same database connection +** and we are in shared cache mode, then the open will fail with an +** SQLITE_CONSTRAINT error. We cannot allow two or more BtShared +** objects in the same database connection since doing so will lead +** to problems with locking. +*/ +SQLITE_PRIVATE int sqlite3BtreeOpen( + sqlite3_vfs *pVfs, /* VFS to use for this b-tree */ + const char *zFilename, /* Name of the file containing the BTree database */ + sqlite3 *db, /* Associated database handle */ + Btree **ppBtree, /* Pointer to new Btree object written here */ + int flags, /* Options */ + int vfsFlags /* Flags passed through to sqlite3_vfs.xOpen() */ +){ + BtShared *pBt = 0; /* Shared part of btree structure */ + Btree *p; /* Handle to return */ + sqlite3_mutex *mutexOpen = 0; /* Prevents a race condition. Ticket #3537 */ + int rc = SQLITE_OK; /* Result code from this function */ + u8 nReserve; /* Byte of unused space on each page */ + unsigned char zDbHeader[100]; /* Database header content */ + + /* True if opening an ephemeral, temporary database */ + const int isTempDb = zFilename==0 || zFilename[0]==0; + + /* Set the variable isMemdb to true for an in-memory database, or + ** false for a file-based database. + */ +#ifdef SQLITE_OMIT_MEMORYDB + const int isMemdb = 0; +#else + const int isMemdb = (zFilename && strcmp(zFilename, ":memory:")==0) + || (isTempDb && sqlite3TempInMemory(db)) + || (vfsFlags & SQLITE_OPEN_MEMORY)!=0; +#endif + + assert( db!=0 ); + assert( pVfs!=0 ); + assert( sqlite3_mutex_held(db->mutex) ); + assert( (flags&0xff)==flags ); /* flags fit in 8 bits */ + + /* Only a BTREE_SINGLE database can be BTREE_UNORDERED */ + assert( (flags & BTREE_UNORDERED)==0 || (flags & BTREE_SINGLE)!=0 ); + + /* A BTREE_SINGLE database is always a temporary and/or ephemeral */ + assert( (flags & BTREE_SINGLE)==0 || isTempDb ); + + if( isMemdb ){ + flags |= BTREE_MEMORY; + } + if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (isMemdb || isTempDb) ){ + vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB; + } + p = sqlite3MallocZero(sizeof(Btree)); + if( !p ){ + return SQLITE_NOMEM_BKPT; + } + p->inTrans = TRANS_NONE; + p->db = db; +#ifndef SQLITE_OMIT_SHARED_CACHE + p->lock.pBtree = p; + p->lock.iTable = 1; +#endif + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) + /* + ** If this Btree is a candidate for shared cache, try to find an + ** existing BtShared object that we can share with + */ + if( isTempDb==0 && (isMemdb==0 || (vfsFlags&SQLITE_OPEN_URI)!=0) ){ + if( vfsFlags & SQLITE_OPEN_SHAREDCACHE ){ + int nFilename = sqlite3Strlen30(zFilename)+1; + int nFullPathname = pVfs->mxPathname+1; + char *zFullPathname = sqlite3Malloc(MAX(nFullPathname,nFilename)); + MUTEX_LOGIC( sqlite3_mutex *mutexShared; ) + + p->sharable = 1; + if( !zFullPathname ){ + sqlite3_free(p); + return SQLITE_NOMEM_BKPT; + } + if( isMemdb ){ + memcpy(zFullPathname, zFilename, nFilename); + }else{ + rc = sqlite3OsFullPathname(pVfs, zFilename, + nFullPathname, zFullPathname); + if( rc ){ + if( rc==SQLITE_OK_SYMLINK ){ + rc = SQLITE_OK; + }else{ + sqlite3_free(zFullPathname); + sqlite3_free(p); + return rc; + } + } + } +#if SQLITE_THREADSAFE + mutexOpen = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_OPEN); + sqlite3_mutex_enter(mutexOpen); + mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); + sqlite3_mutex_enter(mutexShared); +#endif + for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){ + assert( pBt->nRef>0 ); + if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager, 0)) + && sqlite3PagerVfs(pBt->pPager)==pVfs ){ + int iDb; + for(iDb=db->nDb-1; iDb>=0; iDb--){ + Btree *pExisting = db->aDb[iDb].pBt; + if( pExisting && pExisting->pBt==pBt ){ + sqlite3_mutex_leave(mutexShared); + sqlite3_mutex_leave(mutexOpen); + sqlite3_free(zFullPathname); + sqlite3_free(p); + return SQLITE_CONSTRAINT; + } + } + p->pBt = pBt; + pBt->nRef++; + break; + } + } + sqlite3_mutex_leave(mutexShared); + sqlite3_free(zFullPathname); + } +#ifdef SQLITE_DEBUG + else{ + /* In debug mode, we mark all persistent databases as sharable + ** even when they are not. This exercises the locking code and + ** gives more opportunity for asserts(sqlite3_mutex_held()) + ** statements to find locking problems. + */ + p->sharable = 1; + } +#endif + } +#endif + if( pBt==0 ){ + /* + ** The following asserts make sure that structures used by the btree are + ** the right size. This is to guard against size changes that result + ** when compiling on a different architecture. + */ + assert( sizeof(i64)==8 ); + assert( sizeof(u64)==8 ); + assert( sizeof(u32)==4 ); + assert( sizeof(u16)==2 ); + assert( sizeof(Pgno)==4 ); + + pBt = sqlite3MallocZero( sizeof(*pBt) ); + if( pBt==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto btree_open_out; + } + rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename, + sizeof(MemPage), flags, vfsFlags, pageReinit); + if( rc==SQLITE_OK ){ + sqlite3PagerSetMmapLimit(pBt->pPager, db->szMmap); + rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader); + } + if( rc!=SQLITE_OK ){ + goto btree_open_out; + } + pBt->openFlags = (u8)flags; + pBt->db = db; + sqlite3PagerSetBusyHandler(pBt->pPager, btreeInvokeBusyHandler, pBt); + p->pBt = pBt; + + pBt->pCursor = 0; + pBt->pPage1 = 0; + if( sqlite3PagerIsreadonly(pBt->pPager) ) pBt->btsFlags |= BTS_READ_ONLY; +#if defined(SQLITE_SECURE_DELETE) + pBt->btsFlags |= BTS_SECURE_DELETE; +#elif defined(SQLITE_FAST_SECURE_DELETE) + pBt->btsFlags |= BTS_OVERWRITE; +#endif + /* EVIDENCE-OF: R-51873-39618 The page size for a database file is + ** determined by the 2-byte integer located at an offset of 16 bytes from + ** the beginning of the database file. */ + pBt->pageSize = (zDbHeader[16]<<8) | (zDbHeader[17]<<16); + if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE + || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){ + pBt->pageSize = 0; +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If the magic name ":memory:" will create an in-memory database, then + ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if + ** SQLITE_DEFAULT_AUTOVACUUM is true. On the other hand, if + ** SQLITE_OMIT_MEMORYDB has been defined, then ":memory:" is just a + ** regular file-name. In this case the auto-vacuum applies as per normal. + */ + if( zFilename && !isMemdb ){ + pBt->autoVacuum = (SQLITE_DEFAULT_AUTOVACUUM ? 1 : 0); + pBt->incrVacuum = (SQLITE_DEFAULT_AUTOVACUUM==2 ? 1 : 0); + } +#endif + nReserve = 0; + }else{ + /* EVIDENCE-OF: R-37497-42412 The size of the reserved region is + ** determined by the one-byte unsigned integer found at an offset of 20 + ** into the database file header. */ + nReserve = zDbHeader[20]; + pBt->btsFlags |= BTS_PAGESIZE_FIXED; +#ifndef SQLITE_OMIT_AUTOVACUUM + pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0); + pBt->incrVacuum = (get4byte(&zDbHeader[36 + 7*4])?1:0); +#endif + } + rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve); + if( rc ) goto btree_open_out; + pBt->usableSize = pBt->pageSize - nReserve; + assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */ + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) + /* Add the new BtShared object to the linked list sharable BtShareds. + */ + pBt->nRef = 1; + if( p->sharable ){ + MUTEX_LOGIC( sqlite3_mutex *mutexShared; ) + MUTEX_LOGIC( mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);) + if( SQLITE_THREADSAFE && sqlite3GlobalConfig.bCoreMutex ){ + pBt->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_FAST); + if( pBt->mutex==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto btree_open_out; + } + } + sqlite3_mutex_enter(mutexShared); + pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList); + GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt; + sqlite3_mutex_leave(mutexShared); + } +#endif + } + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) + /* If the new Btree uses a sharable pBtShared, then link the new + ** Btree into the list of all sharable Btrees for the same connection. + ** The list is kept in ascending order by pBt address. + */ + if( p->sharable ){ + int i; + Btree *pSib; + for(i=0; inDb; i++){ + if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){ + while( pSib->pPrev ){ pSib = pSib->pPrev; } + if( (uptr)p->pBt<(uptr)pSib->pBt ){ + p->pNext = pSib; + p->pPrev = 0; + pSib->pPrev = p; + }else{ + while( pSib->pNext && (uptr)pSib->pNext->pBt<(uptr)p->pBt ){ + pSib = pSib->pNext; + } + p->pNext = pSib->pNext; + p->pPrev = pSib; + if( p->pNext ){ + p->pNext->pPrev = p; + } + pSib->pNext = p; + } + break; + } + } + } +#endif + *ppBtree = p; + +btree_open_out: + if( rc!=SQLITE_OK ){ + if( pBt && pBt->pPager ){ + sqlite3PagerClose(pBt->pPager, 0); + } + sqlite3_free(pBt); + sqlite3_free(p); + *ppBtree = 0; + }else{ + sqlite3_file *pFile; + + /* If the B-Tree was successfully opened, set the pager-cache size to the + ** default value. Except, when opening on an existing shared pager-cache, + ** do not change the pager-cache size. + */ + if( sqlite3BtreeSchema(p, 0, 0)==0 ){ + sqlite3BtreeSetCacheSize(p, SQLITE_DEFAULT_CACHE_SIZE); + } + + pFile = sqlite3PagerFile(pBt->pPager); + if( pFile->pMethods ){ + sqlite3OsFileControlHint(pFile, SQLITE_FCNTL_PDB, (void*)&pBt->db); + } + } + if( mutexOpen ){ + assert( sqlite3_mutex_held(mutexOpen) ); + sqlite3_mutex_leave(mutexOpen); + } + assert( rc!=SQLITE_OK || sqlite3BtreeConnectionCount(*ppBtree)>0 ); + return rc; +} + +/* +** Decrement the BtShared.nRef counter. When it reaches zero, +** remove the BtShared structure from the sharing list. Return +** true if the BtShared.nRef counter reaches zero and return +** false if it is still positive. +*/ +static int removeFromSharingList(BtShared *pBt){ +#ifndef SQLITE_OMIT_SHARED_CACHE + MUTEX_LOGIC( sqlite3_mutex *pMainMtx; ) + BtShared *pList; + int removed = 0; + + assert( sqlite3_mutex_notheld(pBt->mutex) ); + MUTEX_LOGIC( pMainMtx = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); ) + sqlite3_mutex_enter(pMainMtx); + pBt->nRef--; + if( pBt->nRef<=0 ){ + if( GLOBAL(BtShared*,sqlite3SharedCacheList)==pBt ){ + GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext; + }else{ + pList = GLOBAL(BtShared*,sqlite3SharedCacheList); + while( ALWAYS(pList) && pList->pNext!=pBt ){ + pList=pList->pNext; + } + if( ALWAYS(pList) ){ + pList->pNext = pBt->pNext; + } + } + if( SQLITE_THREADSAFE ){ + sqlite3_mutex_free(pBt->mutex); + } + removed = 1; + } + sqlite3_mutex_leave(pMainMtx); + return removed; +#else + return 1; +#endif +} + +/* +** Make sure pBt->pTmpSpace points to an allocation of +** MX_CELL_SIZE(pBt) bytes with a 4-byte prefix for a left-child +** pointer. +*/ +static void allocateTempSpace(BtShared *pBt){ + if( !pBt->pTmpSpace ){ + pBt->pTmpSpace = sqlite3PageMalloc( pBt->pageSize ); + + /* One of the uses of pBt->pTmpSpace is to format cells before + ** inserting them into a leaf page (function fillInCell()). If + ** a cell is less than 4 bytes in size, it is rounded up to 4 bytes + ** by the various routines that manipulate binary cells. Which + ** can mean that fillInCell() only initializes the first 2 or 3 + ** bytes of pTmpSpace, but that the first 4 bytes are copied from + ** it into a database page. This is not actually a problem, but it + ** does cause a valgrind error when the 1 or 2 bytes of unitialized + ** data is passed to system call write(). So to avoid this error, + ** zero the first 4 bytes of temp space here. + ** + ** Also: Provide four bytes of initialized space before the + ** beginning of pTmpSpace as an area available to prepend the + ** left-child pointer to the beginning of a cell. + */ + if( pBt->pTmpSpace ){ + memset(pBt->pTmpSpace, 0, 8); + pBt->pTmpSpace += 4; + } + } +} + +/* +** Free the pBt->pTmpSpace allocation +*/ +static void freeTempSpace(BtShared *pBt){ + if( pBt->pTmpSpace ){ + pBt->pTmpSpace -= 4; + sqlite3PageFree(pBt->pTmpSpace); + pBt->pTmpSpace = 0; + } +} + +/* +** Close an open database and invalidate all cursors. +*/ +SQLITE_PRIVATE int sqlite3BtreeClose(Btree *p){ + BtShared *pBt = p->pBt; + BtCursor *pCur; + + /* Close all cursors opened via this handle. */ + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + pCur = pBt->pCursor; + while( pCur ){ + BtCursor *pTmp = pCur; + pCur = pCur->pNext; + if( pTmp->pBtree==p ){ + sqlite3BtreeCloseCursor(pTmp); + } + } + + /* Rollback any active transaction and free the handle structure. + ** The call to sqlite3BtreeRollback() drops any table-locks held by + ** this handle. + */ + sqlite3BtreeRollback(p, SQLITE_OK, 0); + sqlite3BtreeLeave(p); + + /* If there are still other outstanding references to the shared-btree + ** structure, return now. The remainder of this procedure cleans + ** up the shared-btree. + */ + assert( p->wantToLock==0 && p->locked==0 ); + if( !p->sharable || removeFromSharingList(pBt) ){ + /* The pBt is no longer on the sharing list, so we can access + ** it without having to hold the mutex. + ** + ** Clean out and delete the BtShared object. + */ + assert( !pBt->pCursor ); + sqlite3PagerClose(pBt->pPager, p->db); + if( pBt->xFreeSchema && pBt->pSchema ){ + pBt->xFreeSchema(pBt->pSchema); + } + sqlite3DbFree(0, pBt->pSchema); + freeTempSpace(pBt); + sqlite3_free(pBt); + } + +#ifndef SQLITE_OMIT_SHARED_CACHE + assert( p->wantToLock==0 ); + assert( p->locked==0 ); + if( p->pPrev ) p->pPrev->pNext = p->pNext; + if( p->pNext ) p->pNext->pPrev = p->pPrev; +#endif + + sqlite3_free(p); + return SQLITE_OK; +} + +/* +** Change the "soft" limit on the number of pages in the cache. +** Unused and unmodified pages will be recycled when the number of +** pages in the cache exceeds this soft limit. But the size of the +** cache is allowed to grow larger than this limit if it contains +** dirty pages or pages still in active use. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree *p, int mxPage){ + BtShared *pBt = p->pBt; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + sqlite3PagerSetCachesize(pBt->pPager, mxPage); + sqlite3BtreeLeave(p); + return SQLITE_OK; +} + +/* +** Change the "spill" limit on the number of pages in the cache. +** If the number of pages exceeds this limit during a write transaction, +** the pager might attempt to "spill" pages to the journal early in +** order to free up memory. +** +** The value returned is the current spill size. If zero is passed +** as an argument, no changes are made to the spill size setting, so +** using mxPage of 0 is a way to query the current spill size. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetSpillSize(Btree *p, int mxPage){ + BtShared *pBt = p->pBt; + int res; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + res = sqlite3PagerSetSpillsize(pBt->pPager, mxPage); + sqlite3BtreeLeave(p); + return res; +} + +#if SQLITE_MAX_MMAP_SIZE>0 +/* +** Change the limit on the amount of the database file that may be +** memory mapped. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetMmapLimit(Btree *p, sqlite3_int64 szMmap){ + BtShared *pBt = p->pBt; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + sqlite3PagerSetMmapLimit(pBt->pPager, szMmap); + sqlite3BtreeLeave(p); + return SQLITE_OK; +} +#endif /* SQLITE_MAX_MMAP_SIZE>0 */ + +/* +** Change the way data is synced to disk in order to increase or decrease +** how well the database resists damage due to OS crashes and power +** failures. Level 1 is the same as asynchronous (no syncs() occur and +** there is a high probability of damage) Level 2 is the default. There +** is a very low but non-zero probability of damage. Level 3 reduces the +** probability of damage to near zero but with a write performance reduction. +*/ +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +SQLITE_PRIVATE int sqlite3BtreeSetPagerFlags( + Btree *p, /* The btree to set the safety level on */ + unsigned pgFlags /* Various PAGER_* flags */ +){ + BtShared *pBt = p->pBt; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + sqlite3PagerSetFlags(pBt->pPager, pgFlags); + sqlite3BtreeLeave(p); + return SQLITE_OK; +} +#endif + +/* +** Change the default pages size and the number of reserved bytes per page. +** Or, if the page size has already been fixed, return SQLITE_READONLY +** without changing anything. +** +** The page size must be a power of 2 between 512 and 65536. If the page +** size supplied does not meet this constraint then the page size is not +** changed. +** +** Page sizes are constrained to be a power of two so that the region +** of the database file used for locking (beginning at PENDING_BYTE, +** the first byte past the 1GB boundary, 0x40000000) needs to occur +** at the beginning of a page. +** +** If parameter nReserve is less than zero, then the number of reserved +** bytes per page is left unchanged. +** +** If the iFix!=0 then the BTS_PAGESIZE_FIXED flag is set so that the page size +** and autovacuum mode can no longer be changed. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve, int iFix){ + int rc = SQLITE_OK; + int x; + BtShared *pBt = p->pBt; + assert( nReserve>=0 && nReserve<=255 ); + sqlite3BtreeEnter(p); + pBt->nReserveWanted = nReserve; + x = pBt->pageSize - pBt->usableSize; + if( nReservebtsFlags & BTS_PAGESIZE_FIXED ){ + sqlite3BtreeLeave(p); + return SQLITE_READONLY; + } + assert( nReserve>=0 && nReserve<=255 ); + if( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE && + ((pageSize-1)&pageSize)==0 ){ + assert( (pageSize & 7)==0 ); + assert( !pBt->pCursor ); + pBt->pageSize = (u32)pageSize; + freeTempSpace(pBt); + } + rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve); + pBt->usableSize = pBt->pageSize - (u16)nReserve; + if( iFix ) pBt->btsFlags |= BTS_PAGESIZE_FIXED; + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Return the currently defined page size +*/ +SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree *p){ + return p->pBt->pageSize; +} + +/* +** This function is similar to sqlite3BtreeGetReserve(), except that it +** may only be called if it is guaranteed that the b-tree mutex is already +** held. +** +** This is useful in one special case in the backup API code where it is +** known that the shared b-tree mutex is held, but the mutex on the +** database handle that owns *p is not. In this case if sqlite3BtreeEnter() +** were to be called, it might collide with some other operation on the +** database handle that owns *p, causing undefined behavior. +*/ +SQLITE_PRIVATE int sqlite3BtreeGetReserveNoMutex(Btree *p){ + int n; + assert( sqlite3_mutex_held(p->pBt->mutex) ); + n = p->pBt->pageSize - p->pBt->usableSize; + return n; +} + +/* +** Return the number of bytes of space at the end of every page that +** are intentually left unused. This is the "reserved" space that is +** sometimes used by extensions. +** +** The value returned is the larger of the current reserve size and +** the latest reserve size requested by SQLITE_FILECTRL_RESERVE_BYTES. +** The amount of reserve can only grow - never shrink. +*/ +SQLITE_PRIVATE int sqlite3BtreeGetRequestedReserve(Btree *p){ + int n1, n2; + sqlite3BtreeEnter(p); + n1 = (int)p->pBt->nReserveWanted; + n2 = sqlite3BtreeGetReserveNoMutex(p); + sqlite3BtreeLeave(p); + return n1>n2 ? n1 : n2; +} + + +/* +** Set the maximum page count for a database if mxPage is positive. +** No changes are made if mxPage is 0 or negative. +** Regardless of the value of mxPage, return the maximum page count. +*/ +SQLITE_PRIVATE Pgno sqlite3BtreeMaxPageCount(Btree *p, Pgno mxPage){ + Pgno n; + sqlite3BtreeEnter(p); + n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage); + sqlite3BtreeLeave(p); + return n; +} + +/* +** Change the values for the BTS_SECURE_DELETE and BTS_OVERWRITE flags: +** +** newFlag==0 Both BTS_SECURE_DELETE and BTS_OVERWRITE are cleared +** newFlag==1 BTS_SECURE_DELETE set and BTS_OVERWRITE is cleared +** newFlag==2 BTS_SECURE_DELETE cleared and BTS_OVERWRITE is set +** newFlag==(-1) No changes +** +** This routine acts as a query if newFlag is less than zero +** +** With BTS_OVERWRITE set, deleted content is overwritten by zeros, but +** freelist leaf pages are not written back to the database. Thus in-page +** deleted content is cleared, but freelist deleted content is not. +** +** With BTS_SECURE_DELETE, operation is like BTS_OVERWRITE with the addition +** that freelist leaf pages are written back into the database, increasing +** the amount of disk I/O. +*/ +SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree *p, int newFlag){ + int b; + if( p==0 ) return 0; + sqlite3BtreeEnter(p); + assert( BTS_OVERWRITE==BTS_SECURE_DELETE*2 ); + assert( BTS_FAST_SECURE==(BTS_OVERWRITE|BTS_SECURE_DELETE) ); + if( newFlag>=0 ){ + p->pBt->btsFlags &= ~BTS_FAST_SECURE; + p->pBt->btsFlags |= BTS_SECURE_DELETE*newFlag; + } + b = (p->pBt->btsFlags & BTS_FAST_SECURE)/BTS_SECURE_DELETE; + sqlite3BtreeLeave(p); + return b; +} + +/* +** Change the 'auto-vacuum' property of the database. If the 'autoVacuum' +** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it +** is disabled. The default value for the auto-vacuum property is +** determined by the SQLITE_DEFAULT_AUTOVACUUM macro. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *p, int autoVacuum){ +#ifdef SQLITE_OMIT_AUTOVACUUM + return SQLITE_READONLY; +#else + BtShared *pBt = p->pBt; + int rc = SQLITE_OK; + u8 av = (u8)autoVacuum; + + sqlite3BtreeEnter(p); + if( (pBt->btsFlags & BTS_PAGESIZE_FIXED)!=0 && (av ?1:0)!=pBt->autoVacuum ){ + rc = SQLITE_READONLY; + }else{ + pBt->autoVacuum = av ?1:0; + pBt->incrVacuum = av==2 ?1:0; + } + sqlite3BtreeLeave(p); + return rc; +#endif +} + +/* +** Return the value of the 'auto-vacuum' property. If auto-vacuum is +** enabled 1 is returned. Otherwise 0. +*/ +SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *p){ +#ifdef SQLITE_OMIT_AUTOVACUUM + return BTREE_AUTOVACUUM_NONE; +#else + int rc; + sqlite3BtreeEnter(p); + rc = ( + (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE: + (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL: + BTREE_AUTOVACUUM_INCR + ); + sqlite3BtreeLeave(p); + return rc; +#endif +} + +/* +** If the user has not set the safety-level for this database connection +** using "PRAGMA synchronous", and if the safety-level is not already +** set to the value passed to this function as the second parameter, +** set it so. +*/ +#if SQLITE_DEFAULT_SYNCHRONOUS!=SQLITE_DEFAULT_WAL_SYNCHRONOUS \ + && !defined(SQLITE_OMIT_WAL) +static void setDefaultSyncFlag(BtShared *pBt, u8 safety_level){ + sqlite3 *db; + Db *pDb; + if( (db=pBt->db)!=0 && (pDb=db->aDb)!=0 ){ + while( pDb->pBt==0 || pDb->pBt->pBt!=pBt ){ pDb++; } + if( pDb->bSyncSet==0 + && pDb->safety_level!=safety_level + && pDb!=&db->aDb[1] + ){ + pDb->safety_level = safety_level; + sqlite3PagerSetFlags(pBt->pPager, + pDb->safety_level | (db->flags & PAGER_FLAGS_MASK)); + } + } +} +#else +# define setDefaultSyncFlag(pBt,safety_level) +#endif + +/* Forward declaration */ +static int newDatabase(BtShared*); + + +/* +** Get a reference to pPage1 of the database file. This will +** also acquire a readlock on that file. +** +** SQLITE_OK is returned on success. If the file is not a +** well-formed database file, then SQLITE_CORRUPT is returned. +** SQLITE_BUSY is returned if the database is locked. SQLITE_NOMEM +** is returned if we run out of memory. +*/ +static int lockBtree(BtShared *pBt){ + int rc; /* Result code from subfunctions */ + MemPage *pPage1; /* Page 1 of the database file */ + u32 nPage; /* Number of pages in the database */ + u32 nPageFile = 0; /* Number of pages in the database file */ + u32 nPageHeader; /* Number of pages in the database according to hdr */ + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pBt->pPage1==0 ); + rc = sqlite3PagerSharedLock(pBt->pPager); + if( rc!=SQLITE_OK ) return rc; + rc = btreeGetPage(pBt, 1, &pPage1, 0); + if( rc!=SQLITE_OK ) return rc; + + /* Do some checking to help insure the file we opened really is + ** a valid database file. + */ + nPage = nPageHeader = get4byte(28+(u8*)pPage1->aData); + sqlite3PagerPagecount(pBt->pPager, (int*)&nPageFile); + if( nPage==0 || memcmp(24+(u8*)pPage1->aData, 92+(u8*)pPage1->aData,4)!=0 ){ + nPage = nPageFile; + } + if( (pBt->db->flags & SQLITE_ResetDatabase)!=0 ){ + nPage = 0; + } + if( nPage>0 ){ + u32 pageSize; + u32 usableSize; + u8 *page1 = pPage1->aData; + rc = SQLITE_NOTADB; + /* EVIDENCE-OF: R-43737-39999 Every valid SQLite database file begins + ** with the following 16 bytes (in hex): 53 51 4c 69 74 65 20 66 6f 72 6d + ** 61 74 20 33 00. */ + if( memcmp(page1, zMagicHeader, 16)!=0 ){ + goto page1_init_failed; + } + +#ifdef SQLITE_OMIT_WAL + if( page1[18]>1 ){ + pBt->btsFlags |= BTS_READ_ONLY; + } + if( page1[19]>1 ){ + goto page1_init_failed; + } +#else + if( page1[18]>2 ){ + pBt->btsFlags |= BTS_READ_ONLY; + } + if( page1[19]>2 ){ + goto page1_init_failed; + } + + /* If the write version is set to 2, this database should be accessed + ** in WAL mode. If the log is not already open, open it now. Then + ** return SQLITE_OK and return without populating BtShared.pPage1. + ** The caller detects this and calls this function again. This is + ** required as the version of page 1 currently in the page1 buffer + ** may not be the latest version - there may be a newer one in the log + ** file. + */ + if( page1[19]==2 && (pBt->btsFlags & BTS_NO_WAL)==0 ){ + int isOpen = 0; + rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen); + if( rc!=SQLITE_OK ){ + goto page1_init_failed; + }else{ + setDefaultSyncFlag(pBt, SQLITE_DEFAULT_WAL_SYNCHRONOUS+1); + if( isOpen==0 ){ + releasePageOne(pPage1); + return SQLITE_OK; + } + } + rc = SQLITE_NOTADB; + }else{ + setDefaultSyncFlag(pBt, SQLITE_DEFAULT_SYNCHRONOUS+1); + } +#endif + + /* EVIDENCE-OF: R-15465-20813 The maximum and minimum embedded payload + ** fractions and the leaf payload fraction values must be 64, 32, and 32. + ** + ** The original design allowed these amounts to vary, but as of + ** version 3.6.0, we require them to be fixed. + */ + if( memcmp(&page1[21], "\100\040\040",3)!=0 ){ + goto page1_init_failed; + } + /* EVIDENCE-OF: R-51873-39618 The page size for a database file is + ** determined by the 2-byte integer located at an offset of 16 bytes from + ** the beginning of the database file. */ + pageSize = (page1[16]<<8) | (page1[17]<<16); + /* EVIDENCE-OF: R-25008-21688 The size of a page is a power of two + ** between 512 and 65536 inclusive. */ + if( ((pageSize-1)&pageSize)!=0 + || pageSize>SQLITE_MAX_PAGE_SIZE + || pageSize<=256 + ){ + goto page1_init_failed; + } + pBt->btsFlags |= BTS_PAGESIZE_FIXED; + assert( (pageSize & 7)==0 ); + /* EVIDENCE-OF: R-59310-51205 The "reserved space" size in the 1-byte + ** integer at offset 20 is the number of bytes of space at the end of + ** each page to reserve for extensions. + ** + ** EVIDENCE-OF: R-37497-42412 The size of the reserved region is + ** determined by the one-byte unsigned integer found at an offset of 20 + ** into the database file header. */ + usableSize = pageSize - page1[20]; + if( (u32)pageSize!=pBt->pageSize ){ + /* After reading the first page of the database assuming a page size + ** of BtShared.pageSize, we have discovered that the page-size is + ** actually pageSize. Unlock the database, leave pBt->pPage1 at + ** zero and return SQLITE_OK. The caller will call this function + ** again with the correct page-size. + */ + releasePageOne(pPage1); + pBt->usableSize = usableSize; + pBt->pageSize = pageSize; + freeTempSpace(pBt); + rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, + pageSize-usableSize); + return rc; + } + if( sqlite3WritableSchema(pBt->db)==0 && nPage>nPageFile ){ + rc = SQLITE_CORRUPT_BKPT; + goto page1_init_failed; + } + /* EVIDENCE-OF: R-28312-64704 However, the usable size is not allowed to + ** be less than 480. In other words, if the page size is 512, then the + ** reserved space size cannot exceed 32. */ + if( usableSize<480 ){ + goto page1_init_failed; + } + pBt->pageSize = pageSize; + pBt->usableSize = usableSize; +#ifndef SQLITE_OMIT_AUTOVACUUM + pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0); + pBt->incrVacuum = (get4byte(&page1[36 + 7*4])?1:0); +#endif + } + + /* maxLocal is the maximum amount of payload to store locally for + ** a cell. Make sure it is small enough so that at least minFanout + ** cells can will fit on one page. We assume a 10-byte page header. + ** Besides the payload, the cell must store: + ** 2-byte pointer to the cell + ** 4-byte child pointer + ** 9-byte nKey value + ** 4-byte nData value + ** 4-byte overflow page pointer + ** So a cell consists of a 2-byte pointer, a header which is as much as + ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow + ** page pointer. + */ + pBt->maxLocal = (u16)((pBt->usableSize-12)*64/255 - 23); + pBt->minLocal = (u16)((pBt->usableSize-12)*32/255 - 23); + pBt->maxLeaf = (u16)(pBt->usableSize - 35); + pBt->minLeaf = (u16)((pBt->usableSize-12)*32/255 - 23); + if( pBt->maxLocal>127 ){ + pBt->max1bytePayload = 127; + }else{ + pBt->max1bytePayload = (u8)pBt->maxLocal; + } + assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) ); + pBt->pPage1 = pPage1; + pBt->nPage = nPage; + return SQLITE_OK; + +page1_init_failed: + releasePageOne(pPage1); + pBt->pPage1 = 0; + return rc; +} + +#ifndef NDEBUG +/* +** Return the number of cursors open on pBt. This is for use +** in assert() expressions, so it is only compiled if NDEBUG is not +** defined. +** +** Only write cursors are counted if wrOnly is true. If wrOnly is +** false then all cursors are counted. +** +** For the purposes of this routine, a cursor is any cursor that +** is capable of reading or writing to the database. Cursors that +** have been tripped into the CURSOR_FAULT state are not counted. +*/ +static int countValidCursors(BtShared *pBt, int wrOnly){ + BtCursor *pCur; + int r = 0; + for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ + if( (wrOnly==0 || (pCur->curFlags & BTCF_WriteFlag)!=0) + && pCur->eState!=CURSOR_FAULT ) r++; + } + return r; +} +#endif + +/* +** If there are no outstanding cursors and we are not in the middle +** of a transaction but there is a read lock on the database, then +** this routine unrefs the first page of the database file which +** has the effect of releasing the read lock. +** +** If there is a transaction in progress, this routine is a no-op. +*/ +static void unlockBtreeIfUnused(BtShared *pBt){ + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( countValidCursors(pBt,0)==0 || pBt->inTransaction>TRANS_NONE ); + if( pBt->inTransaction==TRANS_NONE && pBt->pPage1!=0 ){ + MemPage *pPage1 = pBt->pPage1; + assert( pPage1->aData ); + assert( sqlite3PagerRefcount(pBt->pPager)==1 ); + pBt->pPage1 = 0; + releasePageOne(pPage1); + } +} + +/* +** If pBt points to an empty file then convert that empty file +** into a new empty database by initializing the first page of +** the database. +*/ +static int newDatabase(BtShared *pBt){ + MemPage *pP1; + unsigned char *data; + int rc; + + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pBt->nPage>0 ){ + return SQLITE_OK; + } + pP1 = pBt->pPage1; + assert( pP1!=0 ); + data = pP1->aData; + rc = sqlite3PagerWrite(pP1->pDbPage); + if( rc ) return rc; + memcpy(data, zMagicHeader, sizeof(zMagicHeader)); + assert( sizeof(zMagicHeader)==16 ); + data[16] = (u8)((pBt->pageSize>>8)&0xff); + data[17] = (u8)((pBt->pageSize>>16)&0xff); + data[18] = 1; + data[19] = 1; + assert( pBt->usableSize<=pBt->pageSize && pBt->usableSize+255>=pBt->pageSize); + data[20] = (u8)(pBt->pageSize - pBt->usableSize); + data[21] = 64; + data[22] = 32; + data[23] = 32; + memset(&data[24], 0, 100-24); + zeroPage(pP1, PTF_INTKEY|PTF_LEAF|PTF_LEAFDATA ); + pBt->btsFlags |= BTS_PAGESIZE_FIXED; +#ifndef SQLITE_OMIT_AUTOVACUUM + assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 ); + assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 ); + put4byte(&data[36 + 4*4], pBt->autoVacuum); + put4byte(&data[36 + 7*4], pBt->incrVacuum); +#endif + pBt->nPage = 1; + data[31] = 1; + return SQLITE_OK; +} + +/* +** Initialize the first page of the database file (creating a database +** consisting of a single page and no schema objects). Return SQLITE_OK +** if successful, or an SQLite error code otherwise. +*/ +SQLITE_PRIVATE int sqlite3BtreeNewDb(Btree *p){ + int rc; + sqlite3BtreeEnter(p); + p->pBt->nPage = 0; + rc = newDatabase(p->pBt); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Attempt to start a new transaction. A write-transaction +** is started if the second argument is nonzero, otherwise a read- +** transaction. If the second argument is 2 or more and exclusive +** transaction is started, meaning that no other process is allowed +** to access the database. A preexisting transaction may not be +** upgraded to exclusive by calling this routine a second time - the +** exclusivity flag only works for a new transaction. +** +** A write-transaction must be started before attempting any +** changes to the database. None of the following routines +** will work unless a transaction is started first: +** +** sqlite3BtreeCreateTable() +** sqlite3BtreeCreateIndex() +** sqlite3BtreeClearTable() +** sqlite3BtreeDropTable() +** sqlite3BtreeInsert() +** sqlite3BtreeDelete() +** sqlite3BtreeUpdateMeta() +** +** If an initial attempt to acquire the lock fails because of lock contention +** and the database was previously unlocked, then invoke the busy handler +** if there is one. But if there was previously a read-lock, do not +** invoke the busy handler - just return SQLITE_BUSY. SQLITE_BUSY is +** returned when there is already a read-lock in order to avoid a deadlock. +** +** Suppose there are two processes A and B. A has a read lock and B has +** a reserved lock. B tries to promote to exclusive but is blocked because +** of A's read lock. A tries to promote to reserved but is blocked by B. +** One or the other of the two processes must give way or there can be +** no progress. By returning SQLITE_BUSY and not invoking the busy callback +** when A already has a read lock, we encourage A to give up and let B +** proceed. +*/ +SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree *p, int wrflag, int *pSchemaVersion){ + BtShared *pBt = p->pBt; + Pager *pPager = pBt->pPager; + int rc = SQLITE_OK; + + sqlite3BtreeEnter(p); + btreeIntegrity(p); + + /* If the btree is already in a write-transaction, or it + ** is already in a read-transaction and a read-transaction + ** is requested, this is a no-op. + */ + if( p->inTrans==TRANS_WRITE || (p->inTrans==TRANS_READ && !wrflag) ){ + goto trans_begun; + } + assert( pBt->inTransaction==TRANS_WRITE || IfNotOmitAV(pBt->bDoTruncate)==0 ); + + if( (p->db->flags & SQLITE_ResetDatabase) + && sqlite3PagerIsreadonly(pPager)==0 + ){ + pBt->btsFlags &= ~BTS_READ_ONLY; + } + + /* Write transactions are not possible on a read-only database */ + if( (pBt->btsFlags & BTS_READ_ONLY)!=0 && wrflag ){ + rc = SQLITE_READONLY; + goto trans_begun; + } + +#ifndef SQLITE_OMIT_SHARED_CACHE + { + sqlite3 *pBlock = 0; + /* If another database handle has already opened a write transaction + ** on this shared-btree structure and a second write transaction is + ** requested, return SQLITE_LOCKED. + */ + if( (wrflag && pBt->inTransaction==TRANS_WRITE) + || (pBt->btsFlags & BTS_PENDING)!=0 + ){ + pBlock = pBt->pWriter->db; + }else if( wrflag>1 ){ + BtLock *pIter; + for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ + if( pIter->pBtree!=p ){ + pBlock = pIter->pBtree->db; + break; + } + } + } + if( pBlock ){ + sqlite3ConnectionBlocked(p->db, pBlock); + rc = SQLITE_LOCKED_SHAREDCACHE; + goto trans_begun; + } + } +#endif + + /* Any read-only or read-write transaction implies a read-lock on + ** page 1. So if some other shared-cache client already has a write-lock + ** on page 1, the transaction cannot be opened. */ + rc = querySharedCacheTableLock(p, SCHEMA_ROOT, READ_LOCK); + if( SQLITE_OK!=rc ) goto trans_begun; + + pBt->btsFlags &= ~BTS_INITIALLY_EMPTY; + if( pBt->nPage==0 ) pBt->btsFlags |= BTS_INITIALLY_EMPTY; + do { + sqlite3PagerWalDb(pPager, p->db); + +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + /* If transitioning from no transaction directly to a write transaction, + ** block for the WRITER lock first if possible. */ + if( pBt->pPage1==0 && wrflag ){ + assert( pBt->inTransaction==TRANS_NONE ); + rc = sqlite3PagerWalWriteLock(pPager, 1); + if( rc!=SQLITE_BUSY && rc!=SQLITE_OK ) break; + } +#endif + + /* Call lockBtree() until either pBt->pPage1 is populated or + ** lockBtree() returns something other than SQLITE_OK. lockBtree() + ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after + ** reading page 1 it discovers that the page-size of the database + ** file is not pBt->pageSize. In this case lockBtree() will update + ** pBt->pageSize to the page-size of the file on disk. + */ + while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) ); + + if( rc==SQLITE_OK && wrflag ){ + if( (pBt->btsFlags & BTS_READ_ONLY)!=0 ){ + rc = SQLITE_READONLY; + }else{ + rc = sqlite3PagerBegin(pPager, wrflag>1, sqlite3TempInMemory(p->db)); + if( rc==SQLITE_OK ){ + rc = newDatabase(pBt); + }else if( rc==SQLITE_BUSY_SNAPSHOT && pBt->inTransaction==TRANS_NONE ){ + /* if there was no transaction opened when this function was + ** called and SQLITE_BUSY_SNAPSHOT is returned, change the error + ** code to SQLITE_BUSY. */ + rc = SQLITE_BUSY; + } + } + } + + if( rc!=SQLITE_OK ){ + (void)sqlite3PagerWalWriteLock(pPager, 0); + unlockBtreeIfUnused(pBt); + } + }while( (rc&0xFF)==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE && + btreeInvokeBusyHandler(pBt) ); + sqlite3PagerWalDb(pPager, 0); +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + if( rc==SQLITE_BUSY_TIMEOUT ) rc = SQLITE_BUSY; +#endif + + if( rc==SQLITE_OK ){ + if( p->inTrans==TRANS_NONE ){ + pBt->nTransaction++; +#ifndef SQLITE_OMIT_SHARED_CACHE + if( p->sharable ){ + assert( p->lock.pBtree==p && p->lock.iTable==1 ); + p->lock.eLock = READ_LOCK; + p->lock.pNext = pBt->pLock; + pBt->pLock = &p->lock; + } +#endif + } + p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ); + if( p->inTrans>pBt->inTransaction ){ + pBt->inTransaction = p->inTrans; + } + if( wrflag ){ + MemPage *pPage1 = pBt->pPage1; +#ifndef SQLITE_OMIT_SHARED_CACHE + assert( !pBt->pWriter ); + pBt->pWriter = p; + pBt->btsFlags &= ~BTS_EXCLUSIVE; + if( wrflag>1 ) pBt->btsFlags |= BTS_EXCLUSIVE; +#endif + + /* If the db-size header field is incorrect (as it may be if an old + ** client has been writing the database file), update it now. Doing + ** this sooner rather than later means the database size can safely + ** re-read the database size from page 1 if a savepoint or transaction + ** rollback occurs within the transaction. + */ + if( pBt->nPage!=get4byte(&pPage1->aData[28]) ){ + rc = sqlite3PagerWrite(pPage1->pDbPage); + if( rc==SQLITE_OK ){ + put4byte(&pPage1->aData[28], pBt->nPage); + } + } + } + } + +trans_begun: + if( rc==SQLITE_OK ){ + if( pSchemaVersion ){ + *pSchemaVersion = get4byte(&pBt->pPage1->aData[40]); + } + if( wrflag ){ + /* This call makes sure that the pager has the correct number of + ** open savepoints. If the second parameter is greater than 0 and + ** the sub-journal is not already open, then it will be opened here. + */ + rc = sqlite3PagerOpenSavepoint(pPager, p->db->nSavepoint); + } + } + + btreeIntegrity(p); + sqlite3BtreeLeave(p); + return rc; +} + +#ifndef SQLITE_OMIT_AUTOVACUUM + +/* +** Set the pointer-map entries for all children of page pPage. Also, if +** pPage contains cells that point to overflow pages, set the pointer +** map entries for the overflow pages as well. +*/ +static int setChildPtrmaps(MemPage *pPage){ + int i; /* Counter variable */ + int nCell; /* Number of cells in page pPage */ + int rc; /* Return code */ + BtShared *pBt = pPage->pBt; + Pgno pgno = pPage->pgno; + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + rc = pPage->isInit ? SQLITE_OK : btreeInitPage(pPage); + if( rc!=SQLITE_OK ) return rc; + nCell = pPage->nCell; + + for(i=0; ileaf ){ + Pgno childPgno = get4byte(pCell); + ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc); + } + } + + if( !pPage->leaf ){ + Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]); + ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc); + } + + return rc; +} + +/* +** Somewhere on pPage is a pointer to page iFrom. Modify this pointer so +** that it points to iTo. Parameter eType describes the type of pointer to +** be modified, as follows: +** +** PTRMAP_BTREE: pPage is a btree-page. The pointer points at a child +** page of pPage. +** +** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow +** page pointed to by one of the cells on pPage. +** +** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next +** overflow page in the list. +*/ +static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){ + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + if( eType==PTRMAP_OVERFLOW2 ){ + /* The pointer is always the first 4 bytes of the page in this case. */ + if( get4byte(pPage->aData)!=iFrom ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + put4byte(pPage->aData, iTo); + }else{ + int i; + int nCell; + int rc; + + rc = pPage->isInit ? SQLITE_OK : btreeInitPage(pPage); + if( rc ) return rc; + nCell = pPage->nCell; + + for(i=0; ixParseCell(pPage, pCell, &info); + if( info.nLocal pPage->aData+pPage->pBt->usableSize ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + if( iFrom==get4byte(pCell+info.nSize-4) ){ + put4byte(pCell+info.nSize-4, iTo); + break; + } + } + }else{ + if( get4byte(pCell)==iFrom ){ + put4byte(pCell, iTo); + break; + } + } + } + + if( i==nCell ){ + if( eType!=PTRMAP_BTREE || + get4byte(&pPage->aData[pPage->hdrOffset+8])!=iFrom ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + put4byte(&pPage->aData[pPage->hdrOffset+8], iTo); + } + } + return SQLITE_OK; +} + + +/* +** Move the open database page pDbPage to location iFreePage in the +** database. The pDbPage reference remains valid. +** +** The isCommit flag indicates that there is no need to remember that +** the journal needs to be sync()ed before database page pDbPage->pgno +** can be written to. The caller has already promised not to write to that +** page. +*/ +static int relocatePage( + BtShared *pBt, /* Btree */ + MemPage *pDbPage, /* Open page to move */ + u8 eType, /* Pointer map 'type' entry for pDbPage */ + Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */ + Pgno iFreePage, /* The location to move pDbPage to */ + int isCommit /* isCommit flag passed to sqlite3PagerMovepage */ +){ + MemPage *pPtrPage; /* The page that contains a pointer to pDbPage */ + Pgno iDbPage = pDbPage->pgno; + Pager *pPager = pBt->pPager; + int rc; + + assert( eType==PTRMAP_OVERFLOW2 || eType==PTRMAP_OVERFLOW1 || + eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ); + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pDbPage->pBt==pBt ); + if( iDbPage<3 ) return SQLITE_CORRUPT_BKPT; + + /* Move page iDbPage from its current location to page number iFreePage */ + TRACE(("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n", + iDbPage, iFreePage, iPtrPage, eType)); + rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage, isCommit); + if( rc!=SQLITE_OK ){ + return rc; + } + pDbPage->pgno = iFreePage; + + /* If pDbPage was a btree-page, then it may have child pages and/or cells + ** that point to overflow pages. The pointer map entries for all these + ** pages need to be changed. + ** + ** If pDbPage is an overflow page, then the first 4 bytes may store a + ** pointer to a subsequent overflow page. If this is the case, then + ** the pointer map needs to be updated for the subsequent overflow page. + */ + if( eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ){ + rc = setChildPtrmaps(pDbPage); + if( rc!=SQLITE_OK ){ + return rc; + } + }else{ + Pgno nextOvfl = get4byte(pDbPage->aData); + if( nextOvfl!=0 ){ + ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage, &rc); + if( rc!=SQLITE_OK ){ + return rc; + } + } + } + + /* Fix the database pointer on page iPtrPage that pointed at iDbPage so + ** that it points at iFreePage. Also fix the pointer map entry for + ** iPtrPage. + */ + if( eType!=PTRMAP_ROOTPAGE ){ + rc = btreeGetPage(pBt, iPtrPage, &pPtrPage, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = sqlite3PagerWrite(pPtrPage->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(pPtrPage); + return rc; + } + rc = modifyPagePointer(pPtrPage, iDbPage, iFreePage, eType); + releasePage(pPtrPage); + if( rc==SQLITE_OK ){ + ptrmapPut(pBt, iFreePage, eType, iPtrPage, &rc); + } + } + return rc; +} + +/* Forward declaration required by incrVacuumStep(). */ +static int allocateBtreePage(BtShared *, MemPage **, Pgno *, Pgno, u8); + +/* +** Perform a single step of an incremental-vacuum. If successful, return +** SQLITE_OK. If there is no work to do (and therefore no point in +** calling this function again), return SQLITE_DONE. Or, if an error +** occurs, return some other error code. +** +** More specifically, this function attempts to re-organize the database so +** that the last page of the file currently in use is no longer in use. +** +** Parameter nFin is the number of pages that this database would contain +** were this function called until it returns SQLITE_DONE. +** +** If the bCommit parameter is non-zero, this function assumes that the +** caller will keep calling incrVacuumStep() until it returns SQLITE_DONE +** or an error. bCommit is passed true for an auto-vacuum-on-commit +** operation, or false for an incremental vacuum. +*/ +static int incrVacuumStep(BtShared *pBt, Pgno nFin, Pgno iLastPg, int bCommit){ + Pgno nFreeList; /* Number of pages still on the free-list */ + int rc; + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( iLastPg>nFin ); + + if( !PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg!=PENDING_BYTE_PAGE(pBt) ){ + u8 eType; + Pgno iPtrPage; + + nFreeList = get4byte(&pBt->pPage1->aData[36]); + if( nFreeList==0 ){ + return SQLITE_DONE; + } + + rc = ptrmapGet(pBt, iLastPg, &eType, &iPtrPage); + if( rc!=SQLITE_OK ){ + return rc; + } + if( eType==PTRMAP_ROOTPAGE ){ + return SQLITE_CORRUPT_BKPT; + } + + if( eType==PTRMAP_FREEPAGE ){ + if( bCommit==0 ){ + /* Remove the page from the files free-list. This is not required + ** if bCommit is non-zero. In that case, the free-list will be + ** truncated to zero after this function returns, so it doesn't + ** matter if it still contains some garbage entries. + */ + Pgno iFreePg; + MemPage *pFreePg; + rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iLastPg, BTALLOC_EXACT); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( iFreePg==iLastPg ); + releasePage(pFreePg); + } + } else { + Pgno iFreePg; /* Index of free page to move pLastPg to */ + MemPage *pLastPg; + u8 eMode = BTALLOC_ANY; /* Mode parameter for allocateBtreePage() */ + Pgno iNear = 0; /* nearby parameter for allocateBtreePage() */ + + rc = btreeGetPage(pBt, iLastPg, &pLastPg, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + + /* If bCommit is zero, this loop runs exactly once and page pLastPg + ** is swapped with the first free page pulled off the free list. + ** + ** On the other hand, if bCommit is greater than zero, then keep + ** looping until a free-page located within the first nFin pages + ** of the file is found. + */ + if( bCommit==0 ){ + eMode = BTALLOC_LE; + iNear = nFin; + } + do { + MemPage *pFreePg; + rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iNear, eMode); + if( rc!=SQLITE_OK ){ + releasePage(pLastPg); + return rc; + } + releasePage(pFreePg); + }while( bCommit && iFreePg>nFin ); + assert( iFreePgbDoTruncate = 1; + pBt->nPage = iLastPg; + } + return SQLITE_OK; +} + +/* +** The database opened by the first argument is an auto-vacuum database +** nOrig pages in size containing nFree free pages. Return the expected +** size of the database in pages following an auto-vacuum operation. +*/ +static Pgno finalDbSize(BtShared *pBt, Pgno nOrig, Pgno nFree){ + int nEntry; /* Number of entries on one ptrmap page */ + Pgno nPtrmap; /* Number of PtrMap pages to be freed */ + Pgno nFin; /* Return value */ + + nEntry = pBt->usableSize/5; + nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+nEntry)/nEntry; + nFin = nOrig - nFree - nPtrmap; + if( nOrig>PENDING_BYTE_PAGE(pBt) && nFinpBt; + + sqlite3BtreeEnter(p); + assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE ); + if( !pBt->autoVacuum ){ + rc = SQLITE_DONE; + }else{ + Pgno nOrig = btreePagecount(pBt); + Pgno nFree = get4byte(&pBt->pPage1->aData[36]); + Pgno nFin = finalDbSize(pBt, nOrig, nFree); + + if( nOrig=nOrig ){ + rc = SQLITE_CORRUPT_BKPT; + }else if( nFree>0 ){ + rc = saveAllCursors(pBt, 0, 0); + if( rc==SQLITE_OK ){ + invalidateAllOverflowCache(pBt); + rc = incrVacuumStep(pBt, nFin, nOrig, 0); + } + if( rc==SQLITE_OK ){ + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + put4byte(&pBt->pPage1->aData[28], pBt->nPage); + } + }else{ + rc = SQLITE_DONE; + } + } + sqlite3BtreeLeave(p); + return rc; +} + +/* +** This routine is called prior to sqlite3PagerCommit when a transaction +** is committed for an auto-vacuum database. +** +** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages +** the database file should be truncated to during the commit process. +** i.e. the database has been reorganized so that only the first *pnTrunc +** pages are in use. +*/ +static int autoVacuumCommit(BtShared *pBt){ + int rc = SQLITE_OK; + Pager *pPager = pBt->pPager; + VVA_ONLY( int nRef = sqlite3PagerRefcount(pPager); ) + + assert( sqlite3_mutex_held(pBt->mutex) ); + invalidateAllOverflowCache(pBt); + assert(pBt->autoVacuum); + if( !pBt->incrVacuum ){ + Pgno nFin; /* Number of pages in database after autovacuuming */ + Pgno nFree; /* Number of pages on the freelist initially */ + Pgno iFree; /* The next page to be freed */ + Pgno nOrig; /* Database size before freeing */ + + nOrig = btreePagecount(pBt); + if( PTRMAP_ISPAGE(pBt, nOrig) || nOrig==PENDING_BYTE_PAGE(pBt) ){ + /* It is not possible to create a database for which the final page + ** is either a pointer-map page or the pending-byte page. If one + ** is encountered, this indicates corruption. + */ + return SQLITE_CORRUPT_BKPT; + } + + nFree = get4byte(&pBt->pPage1->aData[36]); + nFin = finalDbSize(pBt, nOrig, nFree); + if( nFin>nOrig ) return SQLITE_CORRUPT_BKPT; + if( nFinnFin && rc==SQLITE_OK; iFree--){ + rc = incrVacuumStep(pBt, nFin, iFree, 1); + } + if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){ + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + put4byte(&pBt->pPage1->aData[32], 0); + put4byte(&pBt->pPage1->aData[36], 0); + put4byte(&pBt->pPage1->aData[28], nFin); + pBt->bDoTruncate = 1; + pBt->nPage = nFin; + } + if( rc!=SQLITE_OK ){ + sqlite3PagerRollback(pPager); + } + } + + assert( nRef>=sqlite3PagerRefcount(pPager) ); + return rc; +} + +#else /* ifndef SQLITE_OMIT_AUTOVACUUM */ +# define setChildPtrmaps(x) SQLITE_OK +#endif + +/* +** This routine does the first phase of a two-phase commit. This routine +** causes a rollback journal to be created (if it does not already exist) +** and populated with enough information so that if a power loss occurs +** the database can be restored to its original state by playing back +** the journal. Then the contents of the journal are flushed out to +** the disk. After the journal is safely on oxide, the changes to the +** database are written into the database file and flushed to oxide. +** At the end of this call, the rollback journal still exists on the +** disk and we are still holding all locks, so the transaction has not +** committed. See sqlite3BtreeCommitPhaseTwo() for the second phase of the +** commit process. +** +** This call is a no-op if no write-transaction is currently active on pBt. +** +** Otherwise, sync the database file for the btree pBt. zSuperJrnl points to +** the name of a super-journal file that should be written into the +** individual journal file, or is NULL, indicating no super-journal file +** (single database transaction). +** +** When this is called, the super-journal should already have been +** created, populated with this journal pointer and synced to disk. +** +** Once this is routine has returned, the only thing required to commit +** the write-transaction for this database file is to delete the journal. +*/ +SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree *p, const char *zSuperJrnl){ + int rc = SQLITE_OK; + if( p->inTrans==TRANS_WRITE ){ + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + rc = autoVacuumCommit(pBt); + if( rc!=SQLITE_OK ){ + sqlite3BtreeLeave(p); + return rc; + } + } + if( pBt->bDoTruncate ){ + sqlite3PagerTruncateImage(pBt->pPager, pBt->nPage); + } +#endif + rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zSuperJrnl, 0); + sqlite3BtreeLeave(p); + } + return rc; +} + +/* +** This function is called from both BtreeCommitPhaseTwo() and BtreeRollback() +** at the conclusion of a transaction. +*/ +static void btreeEndTransaction(Btree *p){ + BtShared *pBt = p->pBt; + sqlite3 *db = p->db; + assert( sqlite3BtreeHoldsMutex(p) ); + +#ifndef SQLITE_OMIT_AUTOVACUUM + pBt->bDoTruncate = 0; +#endif + if( p->inTrans>TRANS_NONE && db->nVdbeRead>1 ){ + /* If there are other active statements that belong to this database + ** handle, downgrade to a read-only transaction. The other statements + ** may still be reading from the database. */ + downgradeAllSharedCacheTableLocks(p); + p->inTrans = TRANS_READ; + }else{ + /* If the handle had any kind of transaction open, decrement the + ** transaction count of the shared btree. If the transaction count + ** reaches 0, set the shared state to TRANS_NONE. The unlockBtreeIfUnused() + ** call below will unlock the pager. */ + if( p->inTrans!=TRANS_NONE ){ + clearAllSharedCacheTableLocks(p); + pBt->nTransaction--; + if( 0==pBt->nTransaction ){ + pBt->inTransaction = TRANS_NONE; + } + } + + /* Set the current transaction state to TRANS_NONE and unlock the + ** pager if this call closed the only read or write transaction. */ + p->inTrans = TRANS_NONE; + unlockBtreeIfUnused(pBt); + } + + btreeIntegrity(p); +} + +/* +** Commit the transaction currently in progress. +** +** This routine implements the second phase of a 2-phase commit. The +** sqlite3BtreeCommitPhaseOne() routine does the first phase and should +** be invoked prior to calling this routine. The sqlite3BtreeCommitPhaseOne() +** routine did all the work of writing information out to disk and flushing the +** contents so that they are written onto the disk platter. All this +** routine has to do is delete or truncate or zero the header in the +** the rollback journal (which causes the transaction to commit) and +** drop locks. +** +** Normally, if an error occurs while the pager layer is attempting to +** finalize the underlying journal file, this function returns an error and +** the upper layer will attempt a rollback. However, if the second argument +** is non-zero then this b-tree transaction is part of a multi-file +** transaction. In this case, the transaction has already been committed +** (by deleting a super-journal file) and the caller will ignore this +** functions return code. So, even if an error occurs in the pager layer, +** reset the b-tree objects internal state to indicate that the write +** transaction has been closed. This is quite safe, as the pager will have +** transitioned to the error state. +** +** This will release the write lock on the database file. If there +** are no active cursors, it also releases the read lock. +*/ +SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree *p, int bCleanup){ + + if( p->inTrans==TRANS_NONE ) return SQLITE_OK; + sqlite3BtreeEnter(p); + btreeIntegrity(p); + + /* If the handle has a write-transaction open, commit the shared-btrees + ** transaction and set the shared state to TRANS_READ. + */ + if( p->inTrans==TRANS_WRITE ){ + int rc; + BtShared *pBt = p->pBt; + assert( pBt->inTransaction==TRANS_WRITE ); + assert( pBt->nTransaction>0 ); + rc = sqlite3PagerCommitPhaseTwo(pBt->pPager); + if( rc!=SQLITE_OK && bCleanup==0 ){ + sqlite3BtreeLeave(p); + return rc; + } + p->iDataVersion--; /* Compensate for pPager->iDataVersion++; */ + pBt->inTransaction = TRANS_READ; + btreeClearHasContent(pBt); + } + + btreeEndTransaction(p); + sqlite3BtreeLeave(p); + return SQLITE_OK; +} + +/* +** Do both phases of a commit. +*/ +SQLITE_PRIVATE int sqlite3BtreeCommit(Btree *p){ + int rc; + sqlite3BtreeEnter(p); + rc = sqlite3BtreeCommitPhaseOne(p, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeCommitPhaseTwo(p, 0); + } + sqlite3BtreeLeave(p); + return rc; +} + +/* +** This routine sets the state to CURSOR_FAULT and the error +** code to errCode for every cursor on any BtShared that pBtree +** references. Or if the writeOnly flag is set to 1, then only +** trip write cursors and leave read cursors unchanged. +** +** Every cursor is a candidate to be tripped, including cursors +** that belong to other database connections that happen to be +** sharing the cache with pBtree. +** +** This routine gets called when a rollback occurs. If the writeOnly +** flag is true, then only write-cursors need be tripped - read-only +** cursors save their current positions so that they may continue +** following the rollback. Or, if writeOnly is false, all cursors are +** tripped. In general, writeOnly is false if the transaction being +** rolled back modified the database schema. In this case b-tree root +** pages may be moved or deleted from the database altogether, making +** it unsafe for read cursors to continue. +** +** If the writeOnly flag is true and an error is encountered while +** saving the current position of a read-only cursor, all cursors, +** including all read-cursors are tripped. +** +** SQLITE_OK is returned if successful, or if an error occurs while +** saving a cursor position, an SQLite error code. +*/ +SQLITE_PRIVATE int sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode, int writeOnly){ + BtCursor *p; + int rc = SQLITE_OK; + + assert( (writeOnly==0 || writeOnly==1) && BTCF_WriteFlag==1 ); + if( pBtree ){ + sqlite3BtreeEnter(pBtree); + for(p=pBtree->pBt->pCursor; p; p=p->pNext){ + if( writeOnly && (p->curFlags & BTCF_WriteFlag)==0 ){ + if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){ + rc = saveCursorPosition(p); + if( rc!=SQLITE_OK ){ + (void)sqlite3BtreeTripAllCursors(pBtree, rc, 0); + break; + } + } + }else{ + sqlite3BtreeClearCursor(p); + p->eState = CURSOR_FAULT; + p->skipNext = errCode; + } + btreeReleaseAllCursorPages(p); + } + sqlite3BtreeLeave(pBtree); + } + return rc; +} + +/* +** Set the pBt->nPage field correctly, according to the current +** state of the database. Assume pBt->pPage1 is valid. +*/ +static void btreeSetNPage(BtShared *pBt, MemPage *pPage1){ + int nPage = get4byte(&pPage1->aData[28]); + testcase( nPage==0 ); + if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage); + testcase( pBt->nPage!=nPage ); + pBt->nPage = nPage; +} + +/* +** Rollback the transaction in progress. +** +** If tripCode is not SQLITE_OK then cursors will be invalidated (tripped). +** Only write cursors are tripped if writeOnly is true but all cursors are +** tripped if writeOnly is false. Any attempt to use +** a tripped cursor will result in an error. +** +** This will release the write lock on the database file. If there +** are no active cursors, it also releases the read lock. +*/ +SQLITE_PRIVATE int sqlite3BtreeRollback(Btree *p, int tripCode, int writeOnly){ + int rc; + BtShared *pBt = p->pBt; + MemPage *pPage1; + + assert( writeOnly==1 || writeOnly==0 ); + assert( tripCode==SQLITE_ABORT_ROLLBACK || tripCode==SQLITE_OK ); + sqlite3BtreeEnter(p); + if( tripCode==SQLITE_OK ){ + rc = tripCode = saveAllCursors(pBt, 0, 0); + if( rc ) writeOnly = 0; + }else{ + rc = SQLITE_OK; + } + if( tripCode ){ + int rc2 = sqlite3BtreeTripAllCursors(p, tripCode, writeOnly); + assert( rc==SQLITE_OK || (writeOnly==0 && rc2==SQLITE_OK) ); + if( rc2!=SQLITE_OK ) rc = rc2; + } + btreeIntegrity(p); + + if( p->inTrans==TRANS_WRITE ){ + int rc2; + + assert( TRANS_WRITE==pBt->inTransaction ); + rc2 = sqlite3PagerRollback(pBt->pPager); + if( rc2!=SQLITE_OK ){ + rc = rc2; + } + + /* The rollback may have destroyed the pPage1->aData value. So + ** call btreeGetPage() on page 1 again to make + ** sure pPage1->aData is set correctly. */ + if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){ + btreeSetNPage(pBt, pPage1); + releasePageOne(pPage1); + } + assert( countValidCursors(pBt, 1)==0 ); + pBt->inTransaction = TRANS_READ; + btreeClearHasContent(pBt); + } + + btreeEndTransaction(p); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Start a statement subtransaction. The subtransaction can be rolled +** back independently of the main transaction. You must start a transaction +** before starting a subtransaction. The subtransaction is ended automatically +** if the main transaction commits or rolls back. +** +** Statement subtransactions are used around individual SQL statements +** that are contained within a BEGIN...COMMIT block. If a constraint +** error occurs within the statement, the effect of that one statement +** can be rolled back without having to rollback the entire transaction. +** +** A statement sub-transaction is implemented as an anonymous savepoint. The +** value passed as the second parameter is the total number of savepoints, +** including the new anonymous savepoint, open on the B-Tree. i.e. if there +** are no active savepoints and no other statement-transactions open, +** iStatement is 1. This anonymous savepoint can be released or rolled back +** using the sqlite3BtreeSavepoint() function. +*/ +SQLITE_PRIVATE int sqlite3BtreeBeginStmt(Btree *p, int iStatement){ + int rc; + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + assert( p->inTrans==TRANS_WRITE ); + assert( (pBt->btsFlags & BTS_READ_ONLY)==0 ); + assert( iStatement>0 ); + assert( iStatement>p->db->nSavepoint ); + assert( pBt->inTransaction==TRANS_WRITE ); + /* At the pager level, a statement transaction is a savepoint with + ** an index greater than all savepoints created explicitly using + ** SQL statements. It is illegal to open, release or rollback any + ** such savepoints while the statement transaction savepoint is active. + */ + rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** The second argument to this function, op, is always SAVEPOINT_ROLLBACK +** or SAVEPOINT_RELEASE. This function either releases or rolls back the +** savepoint identified by parameter iSavepoint, depending on the value +** of op. +** +** Normally, iSavepoint is greater than or equal to zero. However, if op is +** SAVEPOINT_ROLLBACK, then iSavepoint may also be -1. In this case the +** contents of the entire transaction are rolled back. This is different +** from a normal transaction rollback, as no locks are released and the +** transaction remains open. +*/ +SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *p, int op, int iSavepoint){ + int rc = SQLITE_OK; + if( p && p->inTrans==TRANS_WRITE ){ + BtShared *pBt = p->pBt; + assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK ); + assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) ); + sqlite3BtreeEnter(p); + if( op==SAVEPOINT_ROLLBACK ){ + rc = saveAllCursors(pBt, 0, 0); + } + if( rc==SQLITE_OK ){ + rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint); + } + if( rc==SQLITE_OK ){ + if( iSavepoint<0 && (pBt->btsFlags & BTS_INITIALLY_EMPTY)!=0 ){ + pBt->nPage = 0; + } + rc = newDatabase(pBt); + btreeSetNPage(pBt, pBt->pPage1); + + /* pBt->nPage might be zero if the database was corrupt when + ** the transaction was started. Otherwise, it must be at least 1. */ + assert( CORRUPT_DB || pBt->nPage>0 ); + } + sqlite3BtreeLeave(p); + } + return rc; +} + +/* +** Create a new cursor for the BTree whose root is on the page +** iTable. If a read-only cursor is requested, it is assumed that +** the caller already has at least a read-only transaction open +** on the database already. If a write-cursor is requested, then +** the caller is assumed to have an open write transaction. +** +** If the BTREE_WRCSR bit of wrFlag is clear, then the cursor can only +** be used for reading. If the BTREE_WRCSR bit is set, then the cursor +** can be used for reading or for writing if other conditions for writing +** are also met. These are the conditions that must be met in order +** for writing to be allowed: +** +** 1: The cursor must have been opened with wrFlag containing BTREE_WRCSR +** +** 2: Other database connections that share the same pager cache +** but which are not in the READ_UNCOMMITTED state may not have +** cursors open with wrFlag==0 on the same table. Otherwise +** the changes made by this write cursor would be visible to +** the read cursors in the other database connection. +** +** 3: The database must be writable (not on read-only media) +** +** 4: There must be an active transaction. +** +** The BTREE_FORDELETE bit of wrFlag may optionally be set if BTREE_WRCSR +** is set. If FORDELETE is set, that is a hint to the implementation that +** this cursor will only be used to seek to and delete entries of an index +** as part of a larger DELETE statement. The FORDELETE hint is not used by +** this implementation. But in a hypothetical alternative storage engine +** in which index entries are automatically deleted when corresponding table +** rows are deleted, the FORDELETE flag is a hint that all SEEK and DELETE +** operations on this cursor can be no-ops and all READ operations can +** return a null row (2-bytes: 0x01 0x00). +** +** No checking is done to make sure that page iTable really is the +** root page of a b-tree. If it is not, then the cursor acquired +** will not work correctly. +** +** It is assumed that the sqlite3BtreeCursorZero() has been called +** on pCur to initialize the memory space prior to invoking this routine. +*/ +static int btreeCursor( + Btree *p, /* The btree */ + Pgno iTable, /* Root page of table to open */ + int wrFlag, /* 1 to write. 0 read-only */ + struct KeyInfo *pKeyInfo, /* First arg to comparison function */ + BtCursor *pCur /* Space for new cursor */ +){ + BtShared *pBt = p->pBt; /* Shared b-tree handle */ + BtCursor *pX; /* Looping over other all cursors */ + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( wrFlag==0 + || wrFlag==BTREE_WRCSR + || wrFlag==(BTREE_WRCSR|BTREE_FORDELETE) + ); + + /* The following assert statements verify that if this is a sharable + ** b-tree database, the connection is holding the required table locks, + ** and that no other connection has any open cursor that conflicts with + ** this lock. The iTable<1 term disables the check for corrupt schemas. */ + assert( hasSharedCacheTableLock(p, iTable, pKeyInfo!=0, (wrFlag?2:1)) + || iTable<1 ); + assert( wrFlag==0 || !hasReadConflicts(p, iTable) ); + + /* Assert that the caller has opened the required transaction. */ + assert( p->inTrans>TRANS_NONE ); + assert( wrFlag==0 || p->inTrans==TRANS_WRITE ); + assert( pBt->pPage1 && pBt->pPage1->aData ); + assert( wrFlag==0 || (pBt->btsFlags & BTS_READ_ONLY)==0 ); + + if( wrFlag ){ + allocateTempSpace(pBt); + if( pBt->pTmpSpace==0 ) return SQLITE_NOMEM_BKPT; + } + if( iTable<=1 ){ + if( iTable<1 ){ + return SQLITE_CORRUPT_BKPT; + }else if( btreePagecount(pBt)==0 ){ + assert( wrFlag==0 ); + iTable = 0; + } + } + + /* Now that no other errors can occur, finish filling in the BtCursor + ** variables and link the cursor into the BtShared list. */ + pCur->pgnoRoot = iTable; + pCur->iPage = -1; + pCur->pKeyInfo = pKeyInfo; + pCur->pBtree = p; + pCur->pBt = pBt; + pCur->curFlags = wrFlag ? BTCF_WriteFlag : 0; + pCur->curPagerFlags = wrFlag ? 0 : PAGER_GET_READONLY; + /* If there are two or more cursors on the same btree, then all such + ** cursors *must* have the BTCF_Multiple flag set. */ + for(pX=pBt->pCursor; pX; pX=pX->pNext){ + if( pX->pgnoRoot==iTable ){ + pX->curFlags |= BTCF_Multiple; + pCur->curFlags |= BTCF_Multiple; + } + } + pCur->pNext = pBt->pCursor; + pBt->pCursor = pCur; + pCur->eState = CURSOR_INVALID; + return SQLITE_OK; +} +static int btreeCursorWithLock( + Btree *p, /* The btree */ + Pgno iTable, /* Root page of table to open */ + int wrFlag, /* 1 to write. 0 read-only */ + struct KeyInfo *pKeyInfo, /* First arg to comparison function */ + BtCursor *pCur /* Space for new cursor */ +){ + int rc; + sqlite3BtreeEnter(p); + rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur); + sqlite3BtreeLeave(p); + return rc; +} +SQLITE_PRIVATE int sqlite3BtreeCursor( + Btree *p, /* The btree */ + Pgno iTable, /* Root page of table to open */ + int wrFlag, /* 1 to write. 0 read-only */ + struct KeyInfo *pKeyInfo, /* First arg to xCompare() */ + BtCursor *pCur /* Write new cursor here */ +){ + if( p->sharable ){ + return btreeCursorWithLock(p, iTable, wrFlag, pKeyInfo, pCur); + }else{ + return btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur); + } +} + +/* +** Return the size of a BtCursor object in bytes. +** +** This interfaces is needed so that users of cursors can preallocate +** sufficient storage to hold a cursor. The BtCursor object is opaque +** to users so they cannot do the sizeof() themselves - they must call +** this routine. +*/ +SQLITE_PRIVATE int sqlite3BtreeCursorSize(void){ + return ROUND8(sizeof(BtCursor)); +} + +/* +** Initialize memory that will be converted into a BtCursor object. +** +** The simple approach here would be to memset() the entire object +** to zero. But it turns out that the apPage[] and aiIdx[] arrays +** do not need to be zeroed and they are large, so we can save a lot +** of run-time by skipping the initialization of those elements. +*/ +SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor *p){ + memset(p, 0, offsetof(BtCursor, BTCURSOR_FIRST_UNINIT)); +} + +/* +** Close a cursor. The read lock on the database file is released +** when the last cursor is closed. +*/ +SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){ + Btree *pBtree = pCur->pBtree; + if( pBtree ){ + BtShared *pBt = pCur->pBt; + sqlite3BtreeEnter(pBtree); + assert( pBt->pCursor!=0 ); + if( pBt->pCursor==pCur ){ + pBt->pCursor = pCur->pNext; + }else{ + BtCursor *pPrev = pBt->pCursor; + do{ + if( pPrev->pNext==pCur ){ + pPrev->pNext = pCur->pNext; + break; + } + pPrev = pPrev->pNext; + }while( ALWAYS(pPrev) ); + } + btreeReleaseAllCursorPages(pCur); + unlockBtreeIfUnused(pBt); + sqlite3_free(pCur->aOverflow); + sqlite3_free(pCur->pKey); + sqlite3BtreeLeave(pBtree); + pCur->pBtree = 0; + } + return SQLITE_OK; +} + +/* +** Make sure the BtCursor* given in the argument has a valid +** BtCursor.info structure. If it is not already valid, call +** btreeParseCell() to fill it in. +** +** BtCursor.info is a cache of the information in the current cell. +** Using this cache reduces the number of calls to btreeParseCell(). +*/ +#ifndef NDEBUG + static int cellInfoEqual(CellInfo *a, CellInfo *b){ + if( a->nKey!=b->nKey ) return 0; + if( a->pPayload!=b->pPayload ) return 0; + if( a->nPayload!=b->nPayload ) return 0; + if( a->nLocal!=b->nLocal ) return 0; + if( a->nSize!=b->nSize ) return 0; + return 1; + } + static void assertCellInfo(BtCursor *pCur){ + CellInfo info; + memset(&info, 0, sizeof(info)); + btreeParseCell(pCur->pPage, pCur->ix, &info); + assert( CORRUPT_DB || cellInfoEqual(&info, &pCur->info) ); + } +#else + #define assertCellInfo(x) +#endif +static SQLITE_NOINLINE void getCellInfo(BtCursor *pCur){ + if( pCur->info.nSize==0 ){ + pCur->curFlags |= BTCF_ValidNKey; + btreeParseCell(pCur->pPage,pCur->ix,&pCur->info); + }else{ + assertCellInfo(pCur); + } +} + +#ifndef NDEBUG /* The next routine used only within assert() statements */ +/* +** Return true if the given BtCursor is valid. A valid cursor is one +** that is currently pointing to a row in a (non-empty) table. +** This is a verification routine is used only within assert() statements. +*/ +SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){ + return pCur && pCur->eState==CURSOR_VALID; +} +#endif /* NDEBUG */ +SQLITE_PRIVATE int sqlite3BtreeCursorIsValidNN(BtCursor *pCur){ + assert( pCur!=0 ); + return pCur->eState==CURSOR_VALID; +} + +/* +** Return the value of the integer key or "rowid" for a table btree. +** This routine is only valid for a cursor that is pointing into a +** ordinary table btree. If the cursor points to an index btree or +** is invalid, the result of this routine is undefined. +*/ +SQLITE_PRIVATE i64 sqlite3BtreeIntegerKey(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->curIntKey ); + getCellInfo(pCur); + return pCur->info.nKey; +} + +/* +** Pin or unpin a cursor. +*/ +SQLITE_PRIVATE void sqlite3BtreeCursorPin(BtCursor *pCur){ + assert( (pCur->curFlags & BTCF_Pinned)==0 ); + pCur->curFlags |= BTCF_Pinned; +} +SQLITE_PRIVATE void sqlite3BtreeCursorUnpin(BtCursor *pCur){ + assert( (pCur->curFlags & BTCF_Pinned)!=0 ); + pCur->curFlags &= ~BTCF_Pinned; +} + +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC +/* +** Return the offset into the database file for the start of the +** payload to which the cursor is pointing. +*/ +SQLITE_PRIVATE i64 sqlite3BtreeOffset(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + getCellInfo(pCur); + return (i64)pCur->pBt->pageSize*((i64)pCur->pPage->pgno - 1) + + (i64)(pCur->info.pPayload - pCur->pPage->aData); +} +#endif /* SQLITE_ENABLE_OFFSET_SQL_FUNC */ + +/* +** Return the number of bytes of payload for the entry that pCur is +** currently pointing to. For table btrees, this will be the amount +** of data. For index btrees, this will be the size of the key. +** +** The caller must guarantee that the cursor is pointing to a non-NULL +** valid entry. In other words, the calling procedure must guarantee +** that the cursor has Cursor.eState==CURSOR_VALID. +*/ +SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + getCellInfo(pCur); + return pCur->info.nPayload; +} + +/* +** Return an upper bound on the size of any record for the table +** that the cursor is pointing into. +** +** This is an optimization. Everything will still work if this +** routine always returns 2147483647 (which is the largest record +** that SQLite can handle) or more. But returning a smaller value might +** prevent large memory allocations when trying to interpret a +** corrupt datrabase. +** +** The current implementation merely returns the size of the underlying +** database file. +*/ +SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeMaxRecordSize(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + return pCur->pBt->pageSize * (sqlite3_int64)pCur->pBt->nPage; +} + +/* +** Given the page number of an overflow page in the database (parameter +** ovfl), this function finds the page number of the next page in the +** linked list of overflow pages. If possible, it uses the auto-vacuum +** pointer-map data instead of reading the content of page ovfl to do so. +** +** If an error occurs an SQLite error code is returned. Otherwise: +** +** The page number of the next overflow page in the linked list is +** written to *pPgnoNext. If page ovfl is the last page in its linked +** list, *pPgnoNext is set to zero. +** +** If ppPage is not NULL, and a reference to the MemPage object corresponding +** to page number pOvfl was obtained, then *ppPage is set to point to that +** reference. It is the responsibility of the caller to call releasePage() +** on *ppPage to free the reference. In no reference was obtained (because +** the pointer-map was used to obtain the value for *pPgnoNext), then +** *ppPage is set to zero. +*/ +static int getOverflowPage( + BtShared *pBt, /* The database file */ + Pgno ovfl, /* Current overflow page number */ + MemPage **ppPage, /* OUT: MemPage handle (may be NULL) */ + Pgno *pPgnoNext /* OUT: Next overflow page number */ +){ + Pgno next = 0; + MemPage *pPage = 0; + int rc = SQLITE_OK; + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert(pPgnoNext); + +#ifndef SQLITE_OMIT_AUTOVACUUM + /* Try to find the next page in the overflow list using the + ** autovacuum pointer-map pages. Guess that the next page in + ** the overflow list is page number (ovfl+1). If that guess turns + ** out to be wrong, fall back to loading the data of page + ** number ovfl to determine the next page number. + */ + if( pBt->autoVacuum ){ + Pgno pgno; + Pgno iGuess = ovfl+1; + u8 eType; + + while( PTRMAP_ISPAGE(pBt, iGuess) || iGuess==PENDING_BYTE_PAGE(pBt) ){ + iGuess++; + } + + if( iGuess<=btreePagecount(pBt) ){ + rc = ptrmapGet(pBt, iGuess, &eType, &pgno); + if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){ + next = iGuess; + rc = SQLITE_DONE; + } + } + } +#endif + + assert( next==0 || rc==SQLITE_DONE ); + if( rc==SQLITE_OK ){ + rc = btreeGetPage(pBt, ovfl, &pPage, (ppPage==0) ? PAGER_GET_READONLY : 0); + assert( rc==SQLITE_OK || pPage==0 ); + if( rc==SQLITE_OK ){ + next = get4byte(pPage->aData); + } + } + + *pPgnoNext = next; + if( ppPage ){ + *ppPage = pPage; + }else{ + releasePage(pPage); + } + return (rc==SQLITE_DONE ? SQLITE_OK : rc); +} + +/* +** Copy data from a buffer to a page, or from a page to a buffer. +** +** pPayload is a pointer to data stored on database page pDbPage. +** If argument eOp is false, then nByte bytes of data are copied +** from pPayload to the buffer pointed at by pBuf. If eOp is true, +** then sqlite3PagerWrite() is called on pDbPage and nByte bytes +** of data are copied from the buffer pBuf to pPayload. +** +** SQLITE_OK is returned on success, otherwise an error code. +*/ +static int copyPayload( + void *pPayload, /* Pointer to page data */ + void *pBuf, /* Pointer to buffer */ + int nByte, /* Number of bytes to copy */ + int eOp, /* 0 -> copy from page, 1 -> copy to page */ + DbPage *pDbPage /* Page containing pPayload */ +){ + if( eOp ){ + /* Copy data from buffer to page (a write operation) */ + int rc = sqlite3PagerWrite(pDbPage); + if( rc!=SQLITE_OK ){ + return rc; + } + memcpy(pPayload, pBuf, nByte); + }else{ + /* Copy data from page to buffer (a read operation) */ + memcpy(pBuf, pPayload, nByte); + } + return SQLITE_OK; +} + +/* +** This function is used to read or overwrite payload information +** for the entry that the pCur cursor is pointing to. The eOp +** argument is interpreted as follows: +** +** 0: The operation is a read. Populate the overflow cache. +** 1: The operation is a write. Populate the overflow cache. +** +** A total of "amt" bytes are read or written beginning at "offset". +** Data is read to or from the buffer pBuf. +** +** The content being read or written might appear on the main page +** or be scattered out on multiple overflow pages. +** +** If the current cursor entry uses one or more overflow pages +** this function may allocate space for and lazily populate +** the overflow page-list cache array (BtCursor.aOverflow). +** Subsequent calls use this cache to make seeking to the supplied offset +** more efficient. +** +** Once an overflow page-list cache has been allocated, it must be +** invalidated if some other cursor writes to the same table, or if +** the cursor is moved to a different row. Additionally, in auto-vacuum +** mode, the following events may invalidate an overflow page-list cache. +** +** * An incremental vacuum, +** * A commit in auto_vacuum="full" mode, +** * Creating a table (may require moving an overflow page). +*/ +static int accessPayload( + BtCursor *pCur, /* Cursor pointing to entry to read from */ + u32 offset, /* Begin reading this far into payload */ + u32 amt, /* Read this many bytes */ + unsigned char *pBuf, /* Write the bytes into this buffer */ + int eOp /* zero to read. non-zero to write. */ +){ + unsigned char *aPayload; + int rc = SQLITE_OK; + int iIdx = 0; + MemPage *pPage = pCur->pPage; /* Btree page of current entry */ + BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */ +#ifdef SQLITE_DIRECT_OVERFLOW_READ + unsigned char * const pBufStart = pBuf; /* Start of original out buffer */ +#endif + + assert( pPage ); + assert( eOp==0 || eOp==1 ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->ixnCell ); + assert( cursorHoldsMutex(pCur) ); + + getCellInfo(pCur); + aPayload = pCur->info.pPayload; + assert( offset+amt <= pCur->info.nPayload ); + + assert( aPayload > pPage->aData ); + if( (uptr)(aPayload - pPage->aData) > (pBt->usableSize - pCur->info.nLocal) ){ + /* Trying to read or write past the end of the data is an error. The + ** conditional above is really: + ** &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize] + ** but is recast into its current form to avoid integer overflow problems + */ + return SQLITE_CORRUPT_PAGE(pPage); + } + + /* Check if data must be read/written to/from the btree page itself. */ + if( offsetinfo.nLocal ){ + int a = amt; + if( a+offset>pCur->info.nLocal ){ + a = pCur->info.nLocal - offset; + } + rc = copyPayload(&aPayload[offset], pBuf, a, eOp, pPage->pDbPage); + offset = 0; + pBuf += a; + amt -= a; + }else{ + offset -= pCur->info.nLocal; + } + + + if( rc==SQLITE_OK && amt>0 ){ + const u32 ovflSize = pBt->usableSize - 4; /* Bytes content per ovfl page */ + Pgno nextPage; + + nextPage = get4byte(&aPayload[pCur->info.nLocal]); + + /* If the BtCursor.aOverflow[] has not been allocated, allocate it now. + ** + ** The aOverflow[] array is sized at one entry for each overflow page + ** in the overflow chain. The page number of the first overflow page is + ** stored in aOverflow[0], etc. A value of 0 in the aOverflow[] array + ** means "not yet known" (the cache is lazily populated). + */ + if( (pCur->curFlags & BTCF_ValidOvfl)==0 ){ + int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize; + if( pCur->aOverflow==0 + || nOvfl*(int)sizeof(Pgno) > sqlite3MallocSize(pCur->aOverflow) + ){ + Pgno *aNew = (Pgno*)sqlite3Realloc( + pCur->aOverflow, nOvfl*2*sizeof(Pgno) + ); + if( aNew==0 ){ + return SQLITE_NOMEM_BKPT; + }else{ + pCur->aOverflow = aNew; + } + } + memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno)); + pCur->curFlags |= BTCF_ValidOvfl; + }else{ + /* If the overflow page-list cache has been allocated and the + ** entry for the first required overflow page is valid, skip + ** directly to it. + */ + if( pCur->aOverflow[offset/ovflSize] ){ + iIdx = (offset/ovflSize); + nextPage = pCur->aOverflow[iIdx]; + offset = (offset%ovflSize); + } + } + + assert( rc==SQLITE_OK && amt>0 ); + while( nextPage ){ + /* If required, populate the overflow page-list cache. */ + if( nextPage > pBt->nPage ) return SQLITE_CORRUPT_BKPT; + assert( pCur->aOverflow[iIdx]==0 + || pCur->aOverflow[iIdx]==nextPage + || CORRUPT_DB ); + pCur->aOverflow[iIdx] = nextPage; + + if( offset>=ovflSize ){ + /* The only reason to read this page is to obtain the page + ** number for the next page in the overflow chain. The page + ** data is not required. So first try to lookup the overflow + ** page-list cache, if any, then fall back to the getOverflowPage() + ** function. + */ + assert( pCur->curFlags & BTCF_ValidOvfl ); + assert( pCur->pBtree->db==pBt->db ); + if( pCur->aOverflow[iIdx+1] ){ + nextPage = pCur->aOverflow[iIdx+1]; + }else{ + rc = getOverflowPage(pBt, nextPage, 0, &nextPage); + } + offset -= ovflSize; + }else{ + /* Need to read this page properly. It contains some of the + ** range of data that is being read (eOp==0) or written (eOp!=0). + */ + int a = amt; + if( a + offset > ovflSize ){ + a = ovflSize - offset; + } + +#ifdef SQLITE_DIRECT_OVERFLOW_READ + /* If all the following are true: + ** + ** 1) this is a read operation, and + ** 2) data is required from the start of this overflow page, and + ** 3) there are no dirty pages in the page-cache + ** 4) the database is file-backed, and + ** 5) the page is not in the WAL file + ** 6) at least 4 bytes have already been read into the output buffer + ** + ** then data can be read directly from the database file into the + ** output buffer, bypassing the page-cache altogether. This speeds + ** up loading large records that span many overflow pages. + */ + if( eOp==0 /* (1) */ + && offset==0 /* (2) */ + && sqlite3PagerDirectReadOk(pBt->pPager, nextPage) /* (3,4,5) */ + && &pBuf[-4]>=pBufStart /* (6) */ + ){ + sqlite3_file *fd = sqlite3PagerFile(pBt->pPager); + u8 aSave[4]; + u8 *aWrite = &pBuf[-4]; + assert( aWrite>=pBufStart ); /* due to (6) */ + memcpy(aSave, aWrite, 4); + rc = sqlite3OsRead(fd, aWrite, a+4, (i64)pBt->pageSize*(nextPage-1)); + if( rc && nextPage>pBt->nPage ) rc = SQLITE_CORRUPT_BKPT; + nextPage = get4byte(aWrite); + memcpy(aWrite, aSave, 4); + }else +#endif + + { + DbPage *pDbPage; + rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage, + (eOp==0 ? PAGER_GET_READONLY : 0) + ); + if( rc==SQLITE_OK ){ + aPayload = sqlite3PagerGetData(pDbPage); + nextPage = get4byte(aPayload); + rc = copyPayload(&aPayload[offset+4], pBuf, a, eOp, pDbPage); + sqlite3PagerUnref(pDbPage); + offset = 0; + } + } + amt -= a; + if( amt==0 ) return rc; + pBuf += a; + } + if( rc ) break; + iIdx++; + } + } + + if( rc==SQLITE_OK && amt>0 ){ + /* Overflow chain ends prematurely */ + return SQLITE_CORRUPT_PAGE(pPage); + } + return rc; +} + +/* +** Read part of the payload for the row at which that cursor pCur is currently +** pointing. "amt" bytes will be transferred into pBuf[]. The transfer +** begins at "offset". +** +** pCur can be pointing to either a table or an index b-tree. +** If pointing to a table btree, then the content section is read. If +** pCur is pointing to an index b-tree then the key section is read. +** +** For sqlite3BtreePayload(), the caller must ensure that pCur is pointing +** to a valid row in the table. For sqlite3BtreePayloadChecked(), the +** cursor might be invalid or might need to be restored before being read. +** +** Return SQLITE_OK on success or an error code if anything goes +** wrong. An error is returned if "offset+amt" is larger than +** the available payload. +*/ +SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){ + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->iPage>=0 && pCur->pPage ); + assert( pCur->ixpPage->nCell ); + return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0); +} + +/* +** This variant of sqlite3BtreePayload() works even if the cursor has not +** in the CURSOR_VALID state. It is only used by the sqlite3_blob_read() +** interface. +*/ +#ifndef SQLITE_OMIT_INCRBLOB +static SQLITE_NOINLINE int accessPayloadChecked( + BtCursor *pCur, + u32 offset, + u32 amt, + void *pBuf +){ + int rc; + if ( pCur->eState==CURSOR_INVALID ){ + return SQLITE_ABORT; + } + assert( cursorOwnsBtShared(pCur) ); + rc = btreeRestoreCursorPosition(pCur); + return rc ? rc : accessPayload(pCur, offset, amt, pBuf, 0); +} +SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){ + if( pCur->eState==CURSOR_VALID ){ + assert( cursorOwnsBtShared(pCur) ); + return accessPayload(pCur, offset, amt, pBuf, 0); + }else{ + return accessPayloadChecked(pCur, offset, amt, pBuf); + } +} +#endif /* SQLITE_OMIT_INCRBLOB */ + +/* +** Return a pointer to payload information from the entry that the +** pCur cursor is pointing to. The pointer is to the beginning of +** the key if index btrees (pPage->intKey==0) and is the data for +** table btrees (pPage->intKey==1). The number of bytes of available +** key/data is written into *pAmt. If *pAmt==0, then the value +** returned will not be a valid pointer. +** +** This routine is an optimization. It is common for the entire key +** and data to fit on the local page and for there to be no overflow +** pages. When that is so, this routine can be used to access the +** key and data without making a copy. If the key and/or data spills +** onto overflow pages, then accessPayload() must be used to reassemble +** the key/data and copy it into a preallocated buffer. +** +** The pointer returned by this routine looks directly into the cached +** page of the database. The data might change or move the next time +** any btree routine is called. +*/ +static const void *fetchPayload( + BtCursor *pCur, /* Cursor pointing to entry to read from */ + u32 *pAmt /* Write the number of available bytes here */ +){ + int amt; + assert( pCur!=0 && pCur->iPage>=0 && pCur->pPage); + assert( pCur->eState==CURSOR_VALID ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + assert( cursorOwnsBtShared(pCur) ); + assert( pCur->ixpPage->nCell ); + assert( pCur->info.nSize>0 ); + assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB ); + assert( pCur->info.pPayloadpPage->aDataEnd ||CORRUPT_DB); + amt = pCur->info.nLocal; + if( amt>(int)(pCur->pPage->aDataEnd - pCur->info.pPayload) ){ + /* There is too little space on the page for the expected amount + ** of local content. Database must be corrupt. */ + assert( CORRUPT_DB ); + amt = MAX(0, (int)(pCur->pPage->aDataEnd - pCur->info.pPayload)); + } + *pAmt = (u32)amt; + return (void*)pCur->info.pPayload; +} + + +/* +** For the entry that cursor pCur is point to, return as +** many bytes of the key or data as are available on the local +** b-tree page. Write the number of available bytes into *pAmt. +** +** The pointer returned is ephemeral. The key/data may move +** or be destroyed on the next call to any Btree routine, +** including calls from other threads against the same cache. +** Hence, a mutex on the BtShared should be held prior to calling +** this routine. +** +** These routines is used to get quick access to key and data +** in the common case where no overflow pages are used. +*/ +SQLITE_PRIVATE const void *sqlite3BtreePayloadFetch(BtCursor *pCur, u32 *pAmt){ + return fetchPayload(pCur, pAmt); +} + + +/* +** Move the cursor down to a new child page. The newPgno argument is the +** page number of the child page to move to. +** +** This function returns SQLITE_CORRUPT if the page-header flags field of +** the new child page does not match the flags field of the parent (i.e. +** if an intkey page appears to be the parent of a non-intkey page, or +** vice-versa). +*/ +static int moveToChild(BtCursor *pCur, u32 newPgno){ + BtShared *pBt = pCur->pBt; + + assert( cursorOwnsBtShared(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->iPageiPage>=0 ); + if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){ + return SQLITE_CORRUPT_BKPT; + } + pCur->info.nSize = 0; + pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl); + pCur->aiIdx[pCur->iPage] = pCur->ix; + pCur->apPage[pCur->iPage] = pCur->pPage; + pCur->ix = 0; + pCur->iPage++; + return getAndInitPage(pBt, newPgno, &pCur->pPage, pCur, pCur->curPagerFlags); +} + +#ifdef SQLITE_DEBUG +/* +** Page pParent is an internal (non-leaf) tree page. This function +** asserts that page number iChild is the left-child if the iIdx'th +** cell in page pParent. Or, if iIdx is equal to the total number of +** cells in pParent, that page number iChild is the right-child of +** the page. +*/ +static void assertParentIndex(MemPage *pParent, int iIdx, Pgno iChild){ + if( CORRUPT_DB ) return; /* The conditions tested below might not be true + ** in a corrupt database */ + assert( iIdx<=pParent->nCell ); + if( iIdx==pParent->nCell ){ + assert( get4byte(&pParent->aData[pParent->hdrOffset+8])==iChild ); + }else{ + assert( get4byte(findCell(pParent, iIdx))==iChild ); + } +} +#else +# define assertParentIndex(x,y,z) +#endif + +/* +** Move the cursor up to the parent page. +** +** pCur->idx is set to the cell index that contains the pointer +** to the page we are coming from. If we are coming from the +** right-most child page then pCur->idx is set to one more than +** the largest cell index. +*/ +static void moveToParent(BtCursor *pCur){ + MemPage *pLeaf; + assert( cursorOwnsBtShared(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->iPage>0 ); + assert( pCur->pPage ); + assertParentIndex( + pCur->apPage[pCur->iPage-1], + pCur->aiIdx[pCur->iPage-1], + pCur->pPage->pgno + ); + testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell ); + pCur->info.nSize = 0; + pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl); + pCur->ix = pCur->aiIdx[pCur->iPage-1]; + pLeaf = pCur->pPage; + pCur->pPage = pCur->apPage[--pCur->iPage]; + releasePageNotNull(pLeaf); +} + +/* +** Move the cursor to point to the root page of its b-tree structure. +** +** If the table has a virtual root page, then the cursor is moved to point +** to the virtual root page instead of the actual root page. A table has a +** virtual root page when the actual root page contains no cells and a +** single child page. This can only happen with the table rooted at page 1. +** +** If the b-tree structure is empty, the cursor state is set to +** CURSOR_INVALID and this routine returns SQLITE_EMPTY. Otherwise, +** the cursor is set to point to the first cell located on the root +** (or virtual root) page and the cursor state is set to CURSOR_VALID. +** +** If this function returns successfully, it may be assumed that the +** page-header flags indicate that the [virtual] root-page is the expected +** kind of b-tree page (i.e. if when opening the cursor the caller did not +** specify a KeyInfo structure the flags byte is set to 0x05 or 0x0D, +** indicating a table b-tree, or if the caller did specify a KeyInfo +** structure the flags byte is set to 0x02 or 0x0A, indicating an index +** b-tree). +*/ +static int moveToRoot(BtCursor *pCur){ + MemPage *pRoot; + int rc = SQLITE_OK; + + assert( cursorOwnsBtShared(pCur) ); + assert( CURSOR_INVALID < CURSOR_REQUIRESEEK ); + assert( CURSOR_VALID < CURSOR_REQUIRESEEK ); + assert( CURSOR_FAULT > CURSOR_REQUIRESEEK ); + assert( pCur->eState < CURSOR_REQUIRESEEK || pCur->iPage<0 ); + assert( pCur->pgnoRoot>0 || pCur->iPage<0 ); + + if( pCur->iPage>=0 ){ + if( pCur->iPage ){ + releasePageNotNull(pCur->pPage); + while( --pCur->iPage ){ + releasePageNotNull(pCur->apPage[pCur->iPage]); + } + pCur->pPage = pCur->apPage[0]; + goto skip_init; + } + }else if( pCur->pgnoRoot==0 ){ + pCur->eState = CURSOR_INVALID; + return SQLITE_EMPTY; + }else{ + assert( pCur->iPage==(-1) ); + if( pCur->eState>=CURSOR_REQUIRESEEK ){ + if( pCur->eState==CURSOR_FAULT ){ + assert( pCur->skipNext!=SQLITE_OK ); + return pCur->skipNext; + } + sqlite3BtreeClearCursor(pCur); + } + rc = getAndInitPage(pCur->pBtree->pBt, pCur->pgnoRoot, &pCur->pPage, + 0, pCur->curPagerFlags); + if( rc!=SQLITE_OK ){ + pCur->eState = CURSOR_INVALID; + return rc; + } + pCur->iPage = 0; + pCur->curIntKey = pCur->pPage->intKey; + } + pRoot = pCur->pPage; + assert( pRoot->pgno==pCur->pgnoRoot ); + + /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor + ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is + ** NULL, the caller expects a table b-tree. If this is not the case, + ** return an SQLITE_CORRUPT error. + ** + ** Earlier versions of SQLite assumed that this test could not fail + ** if the root page was already loaded when this function was called (i.e. + ** if pCur->iPage>=0). But this is not so if the database is corrupted + ** in such a way that page pRoot is linked into a second b-tree table + ** (or the freelist). */ + assert( pRoot->intKey==1 || pRoot->intKey==0 ); + if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){ + return SQLITE_CORRUPT_PAGE(pCur->pPage); + } + +skip_init: + pCur->ix = 0; + pCur->info.nSize = 0; + pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidNKey|BTCF_ValidOvfl); + + pRoot = pCur->pPage; + if( pRoot->nCell>0 ){ + pCur->eState = CURSOR_VALID; + }else if( !pRoot->leaf ){ + Pgno subpage; + if( pRoot->pgno!=1 ) return SQLITE_CORRUPT_BKPT; + subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]); + pCur->eState = CURSOR_VALID; + rc = moveToChild(pCur, subpage); + }else{ + pCur->eState = CURSOR_INVALID; + rc = SQLITE_EMPTY; + } + return rc; +} + +/* +** Move the cursor down to the left-most leaf entry beneath the +** entry to which it is currently pointing. +** +** The left-most leaf is the one with the smallest key - the first +** in ascending order. +*/ +static int moveToLeftmost(BtCursor *pCur){ + Pgno pgno; + int rc = SQLITE_OK; + MemPage *pPage; + + assert( cursorOwnsBtShared(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){ + assert( pCur->ixnCell ); + pgno = get4byte(findCell(pPage, pCur->ix)); + rc = moveToChild(pCur, pgno); + } + return rc; +} + +/* +** Move the cursor down to the right-most leaf entry beneath the +** page to which it is currently pointing. Notice the difference +** between moveToLeftmost() and moveToRightmost(). moveToLeftmost() +** finds the left-most entry beneath the *entry* whereas moveToRightmost() +** finds the right-most entry beneath the *page*. +** +** The right-most entry is the one with the largest key - the last +** key in ascending order. +*/ +static int moveToRightmost(BtCursor *pCur){ + Pgno pgno; + int rc = SQLITE_OK; + MemPage *pPage = 0; + + assert( cursorOwnsBtShared(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + while( !(pPage = pCur->pPage)->leaf ){ + pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]); + pCur->ix = pPage->nCell; + rc = moveToChild(pCur, pgno); + if( rc ) return rc; + } + pCur->ix = pPage->nCell-1; + assert( pCur->info.nSize==0 ); + assert( (pCur->curFlags & BTCF_ValidNKey)==0 ); + return SQLITE_OK; +} + +/* Move the cursor to the first entry in the table. Return SQLITE_OK +** on success. Set *pRes to 0 if the cursor actually points to something +** or set *pRes to 1 if the table is empty. +*/ +SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){ + int rc; + + assert( cursorOwnsBtShared(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + rc = moveToRoot(pCur); + if( rc==SQLITE_OK ){ + assert( pCur->pPage->nCell>0 ); + *pRes = 0; + rc = moveToLeftmost(pCur); + }else if( rc==SQLITE_EMPTY ){ + assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 ); + *pRes = 1; + rc = SQLITE_OK; + } + return rc; +} + +/* Move the cursor to the last entry in the table. Return SQLITE_OK +** on success. Set *pRes to 0 if the cursor actually points to something +** or set *pRes to 1 if the table is empty. +*/ +SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){ + int rc; + + assert( cursorOwnsBtShared(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + + /* If the cursor already points to the last entry, this is a no-op. */ + if( CURSOR_VALID==pCur->eState && (pCur->curFlags & BTCF_AtLast)!=0 ){ +#ifdef SQLITE_DEBUG + /* This block serves to assert() that the cursor really does point + ** to the last entry in the b-tree. */ + int ii; + for(ii=0; iiiPage; ii++){ + assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell ); + } + assert( pCur->ix==pCur->pPage->nCell-1 ); + assert( pCur->pPage->leaf ); +#endif + *pRes = 0; + return SQLITE_OK; + } + + rc = moveToRoot(pCur); + if( rc==SQLITE_OK ){ + assert( pCur->eState==CURSOR_VALID ); + *pRes = 0; + rc = moveToRightmost(pCur); + if( rc==SQLITE_OK ){ + pCur->curFlags |= BTCF_AtLast; + }else{ + pCur->curFlags &= ~BTCF_AtLast; + } + }else if( rc==SQLITE_EMPTY ){ + assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 ); + *pRes = 1; + rc = SQLITE_OK; + } + return rc; +} + +/* Move the cursor so that it points to an entry near the key +** specified by pIdxKey or intKey. Return a success code. +** +** For INTKEY tables, the intKey parameter is used. pIdxKey +** must be NULL. For index tables, pIdxKey is used and intKey +** is ignored. +** +** If an exact match is not found, then the cursor is always +** left pointing at a leaf page which would hold the entry if it +** were present. The cursor might point to an entry that comes +** before or after the key. +** +** An integer is written into *pRes which is the result of +** comparing the key with the entry to which the cursor is +** pointing. The meaning of the integer written into +** *pRes is as follows: +** +** *pRes<0 The cursor is left pointing at an entry that +** is smaller than intKey/pIdxKey or if the table is empty +** and the cursor is therefore left point to nothing. +** +** *pRes==0 The cursor is left pointing at an entry that +** exactly matches intKey/pIdxKey. +** +** *pRes>0 The cursor is left pointing at an entry that +** is larger than intKey/pIdxKey. +** +** For index tables, the pIdxKey->eqSeen field is set to 1 if there +** exists an entry in the table that exactly matches pIdxKey. +*/ +SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked( + BtCursor *pCur, /* The cursor to be moved */ + UnpackedRecord *pIdxKey, /* Unpacked index key */ + i64 intKey, /* The table key */ + int biasRight, /* If true, bias the search to the high end */ + int *pRes /* Write search results here */ +){ + int rc; + RecordCompare xRecordCompare; + + assert( cursorOwnsBtShared(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + assert( pRes ); + assert( (pIdxKey==0)==(pCur->pKeyInfo==0) ); + assert( pCur->eState!=CURSOR_VALID || (pIdxKey==0)==(pCur->curIntKey!=0) ); + + /* If the cursor is already positioned at the point we are trying + ** to move to, then just return without doing any work */ + if( pIdxKey==0 + && pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0 + ){ + if( pCur->info.nKey==intKey ){ + *pRes = 0; + return SQLITE_OK; + } + if( pCur->info.nKeycurFlags & BTCF_AtLast)!=0 ){ + *pRes = -1; + return SQLITE_OK; + } + /* If the requested key is one more than the previous key, then + ** try to get there using sqlite3BtreeNext() rather than a full + ** binary search. This is an optimization only. The correct answer + ** is still obtained without this case, only a little more slowely */ + if( pCur->info.nKey+1==intKey ){ + *pRes = 0; + rc = sqlite3BtreeNext(pCur, 0); + if( rc==SQLITE_OK ){ + getCellInfo(pCur); + if( pCur->info.nKey==intKey ){ + return SQLITE_OK; + } + }else if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + }else{ + return rc; + } + } + } + } + +#ifdef SQLITE_DEBUG + pCur->pBtree->nSeek++; /* Performance measurement during testing */ +#endif + + if( pIdxKey ){ + xRecordCompare = sqlite3VdbeFindCompare(pIdxKey); + pIdxKey->errCode = 0; + assert( pIdxKey->default_rc==1 + || pIdxKey->default_rc==0 + || pIdxKey->default_rc==-1 + ); + }else{ + xRecordCompare = 0; /* All keys are integers */ + } + + rc = moveToRoot(pCur); + if( rc ){ + if( rc==SQLITE_EMPTY ){ + assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 ); + *pRes = -1; + return SQLITE_OK; + } + return rc; + } + assert( pCur->pPage ); + assert( pCur->pPage->isInit ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->pPage->nCell > 0 ); + assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey ); + assert( pCur->curIntKey || pIdxKey ); + for(;;){ + int lwr, upr, idx, c; + Pgno chldPg; + MemPage *pPage = pCur->pPage; + u8 *pCell; /* Pointer to current cell in pPage */ + + /* pPage->nCell must be greater than zero. If this is the root-page + ** the cursor would have been INVALID above and this for(;;) loop + ** not run. If this is not the root-page, then the moveToChild() routine + ** would have already detected db corruption. Similarly, pPage must + ** be the right kind (index or table) of b-tree page. Otherwise + ** a moveToChild() or moveToRoot() call would have detected corruption. */ + assert( pPage->nCell>0 ); + assert( pPage->intKey==(pIdxKey==0) ); + lwr = 0; + upr = pPage->nCell-1; + assert( biasRight==0 || biasRight==1 ); + idx = upr>>(1-biasRight); /* idx = biasRight ? upr : (lwr+upr)/2; */ + pCur->ix = (u16)idx; + if( xRecordCompare==0 ){ + for(;;){ + i64 nCellKey; + pCell = findCellPastPtr(pPage, idx); + if( pPage->intKeyLeaf ){ + while( 0x80 <= *(pCell++) ){ + if( pCell>=pPage->aDataEnd ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + } + } + getVarint(pCell, (u64*)&nCellKey); + if( nCellKeyupr ){ c = -1; break; } + }else if( nCellKey>intKey ){ + upr = idx-1; + if( lwr>upr ){ c = +1; break; } + }else{ + assert( nCellKey==intKey ); + pCur->ix = (u16)idx; + if( !pPage->leaf ){ + lwr = idx; + goto moveto_next_layer; + }else{ + pCur->curFlags |= BTCF_ValidNKey; + pCur->info.nKey = nCellKey; + pCur->info.nSize = 0; + *pRes = 0; + return SQLITE_OK; + } + } + assert( lwr+upr>=0 ); + idx = (lwr+upr)>>1; /* idx = (lwr+upr)/2; */ + } + }else{ + for(;;){ + int nCell; /* Size of the pCell cell in bytes */ + pCell = findCellPastPtr(pPage, idx); + + /* The maximum supported page-size is 65536 bytes. This means that + ** the maximum number of record bytes stored on an index B-Tree + ** page is less than 16384 bytes and may be stored as a 2-byte + ** varint. This information is used to attempt to avoid parsing + ** the entire cell by checking for the cases where the record is + ** stored entirely within the b-tree page by inspecting the first + ** 2 bytes of the cell. + */ + nCell = pCell[0]; + if( nCell<=pPage->max1bytePayload ){ + /* This branch runs if the record-size field of the cell is a + ** single byte varint and the record fits entirely on the main + ** b-tree page. */ + testcase( pCell+nCell+1==pPage->aDataEnd ); + c = xRecordCompare(nCell, (void*)&pCell[1], pIdxKey); + }else if( !(pCell[1] & 0x80) + && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal + ){ + /* The record-size field is a 2 byte varint and the record + ** fits entirely on the main b-tree page. */ + testcase( pCell+nCell+2==pPage->aDataEnd ); + c = xRecordCompare(nCell, (void*)&pCell[2], pIdxKey); + }else{ + /* The record flows over onto one or more overflow pages. In + ** this case the whole cell needs to be parsed, a buffer allocated + ** and accessPayload() used to retrieve the record into the + ** buffer before VdbeRecordCompare() can be called. + ** + ** If the record is corrupt, the xRecordCompare routine may read + ** up to two varints past the end of the buffer. An extra 18 + ** bytes of padding is allocated at the end of the buffer in + ** case this happens. */ + void *pCellKey; + u8 * const pCellBody = pCell - pPage->childPtrSize; + const int nOverrun = 18; /* Size of the overrun padding */ + pPage->xParseCell(pPage, pCellBody, &pCur->info); + nCell = (int)pCur->info.nKey; + testcase( nCell<0 ); /* True if key size is 2^32 or more */ + testcase( nCell==0 ); /* Invalid key size: 0x80 0x80 0x00 */ + testcase( nCell==1 ); /* Invalid key size: 0x80 0x80 0x01 */ + testcase( nCell==2 ); /* Minimum legal index key size */ + if( nCell<2 || nCell/pCur->pBt->usableSize>pCur->pBt->nPage ){ + rc = SQLITE_CORRUPT_PAGE(pPage); + goto moveto_finish; + } + pCellKey = sqlite3Malloc( nCell+nOverrun ); + if( pCellKey==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto moveto_finish; + } + pCur->ix = (u16)idx; + rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0); + memset(((u8*)pCellKey)+nCell,0,nOverrun); /* Fix uninit warnings */ + pCur->curFlags &= ~BTCF_ValidOvfl; + if( rc ){ + sqlite3_free(pCellKey); + goto moveto_finish; + } + c = sqlite3VdbeRecordCompare(nCell, pCellKey, pIdxKey); + sqlite3_free(pCellKey); + } + assert( + (pIdxKey->errCode!=SQLITE_CORRUPT || c==0) + && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed) + ); + if( c<0 ){ + lwr = idx+1; + }else if( c>0 ){ + upr = idx-1; + }else{ + assert( c==0 ); + *pRes = 0; + rc = SQLITE_OK; + pCur->ix = (u16)idx; + if( pIdxKey->errCode ) rc = SQLITE_CORRUPT_BKPT; + goto moveto_finish; + } + if( lwr>upr ) break; + assert( lwr+upr>=0 ); + idx = (lwr+upr)>>1; /* idx = (lwr+upr)/2 */ + } + } + assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) ); + assert( pPage->isInit ); + if( pPage->leaf ){ + assert( pCur->ixpPage->nCell ); + pCur->ix = (u16)idx; + *pRes = c; + rc = SQLITE_OK; + goto moveto_finish; + } +moveto_next_layer: + if( lwr>=pPage->nCell ){ + chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]); + }else{ + chldPg = get4byte(findCell(pPage, lwr)); + } + pCur->ix = (u16)lwr; + rc = moveToChild(pCur, chldPg); + if( rc ) break; + } +moveto_finish: + pCur->info.nSize = 0; + assert( (pCur->curFlags & BTCF_ValidOvfl)==0 ); + return rc; +} + + +/* +** Return TRUE if the cursor is not pointing at an entry of the table. +** +** TRUE will be returned after a call to sqlite3BtreeNext() moves +** past the last entry in the table or sqlite3BtreePrev() moves past +** the first entry. TRUE is also returned if the table is empty. +*/ +SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){ + /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries + ** have been deleted? This API will need to change to return an error code + ** as well as the boolean result value. + */ + return (CURSOR_VALID!=pCur->eState); +} + +/* +** Return an estimate for the number of rows in the table that pCur is +** pointing to. Return a negative number if no estimate is currently +** available. +*/ +SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor *pCur){ + i64 n; + u8 i; + + assert( cursorOwnsBtShared(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + + /* Currently this interface is only called by the OP_IfSmaller + ** opcode, and it that case the cursor will always be valid and + ** will always point to a leaf node. */ + if( NEVER(pCur->eState!=CURSOR_VALID) ) return -1; + if( NEVER(pCur->pPage->leaf==0) ) return -1; + + n = pCur->pPage->nCell; + for(i=0; iiPage; i++){ + n *= pCur->apPage[i]->nCell; + } + return n; +} + +/* +** Advance the cursor to the next entry in the database. +** Return value: +** +** SQLITE_OK success +** SQLITE_DONE cursor is already pointing at the last element +** otherwise some kind of error occurred +** +** The main entry point is sqlite3BtreeNext(). That routine is optimized +** for the common case of merely incrementing the cell counter BtCursor.aiIdx +** to the next cell on the current page. The (slower) btreeNext() helper +** routine is called when it is necessary to move to a different page or +** to restore the cursor. +** +** If bit 0x01 of the F argument in sqlite3BtreeNext(C,F) is 1, then the +** cursor corresponds to an SQL index and this routine could have been +** skipped if the SQL index had been a unique index. The F argument +** is a hint to the implement. SQLite btree implementation does not use +** this hint, but COMDB2 does. +*/ +static SQLITE_NOINLINE int btreeNext(BtCursor *pCur){ + int rc; + int idx; + MemPage *pPage; + + assert( cursorOwnsBtShared(pCur) ); + if( pCur->eState!=CURSOR_VALID ){ + assert( (pCur->curFlags & BTCF_ValidOvfl)==0 ); + rc = restoreCursorPosition(pCur); + if( rc!=SQLITE_OK ){ + return rc; + } + if( CURSOR_INVALID==pCur->eState ){ + return SQLITE_DONE; + } + if( pCur->eState==CURSOR_SKIPNEXT ){ + pCur->eState = CURSOR_VALID; + if( pCur->skipNext>0 ) return SQLITE_OK; + } + } + + pPage = pCur->pPage; + idx = ++pCur->ix; + if( !pPage->isInit || sqlite3FaultSim(412) ){ + /* The only known way for this to happen is for there to be a + ** recursive SQL function that does a DELETE operation as part of a + ** SELECT which deletes content out from under an active cursor + ** in a corrupt database file where the table being DELETE-ed from + ** has pages in common with the table being queried. See TH3 + ** module cov1/btree78.test testcase 220 (2018-06-08) for an + ** example. */ + return SQLITE_CORRUPT_BKPT; + } + + /* If the database file is corrupt, it is possible for the value of idx + ** to be invalid here. This can only occur if a second cursor modifies + ** the page while cursor pCur is holding a reference to it. Which can + ** only happen if the database is corrupt in such a way as to link the + ** page into more than one b-tree structure. + ** + ** Update 2019-12-23: appears to long longer be possible after the + ** addition of anotherValidCursor() condition on balance_deeper(). */ + harmless( idx>pPage->nCell ); + + if( idx>=pPage->nCell ){ + if( !pPage->leaf ){ + rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8])); + if( rc ) return rc; + return moveToLeftmost(pCur); + } + do{ + if( pCur->iPage==0 ){ + pCur->eState = CURSOR_INVALID; + return SQLITE_DONE; + } + moveToParent(pCur); + pPage = pCur->pPage; + }while( pCur->ix>=pPage->nCell ); + if( pPage->intKey ){ + return sqlite3BtreeNext(pCur, 0); + }else{ + return SQLITE_OK; + } + } + if( pPage->leaf ){ + return SQLITE_OK; + }else{ + return moveToLeftmost(pCur); + } +} +SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int flags){ + MemPage *pPage; + UNUSED_PARAMETER( flags ); /* Used in COMDB2 but not native SQLite */ + assert( cursorOwnsBtShared(pCur) ); + assert( flags==0 || flags==1 ); + pCur->info.nSize = 0; + pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl); + if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur); + pPage = pCur->pPage; + if( (++pCur->ix)>=pPage->nCell ){ + pCur->ix--; + return btreeNext(pCur); + } + if( pPage->leaf ){ + return SQLITE_OK; + }else{ + return moveToLeftmost(pCur); + } +} + +/* +** Step the cursor to the back to the previous entry in the database. +** Return values: +** +** SQLITE_OK success +** SQLITE_DONE the cursor is already on the first element of the table +** otherwise some kind of error occurred +** +** The main entry point is sqlite3BtreePrevious(). That routine is optimized +** for the common case of merely decrementing the cell counter BtCursor.aiIdx +** to the previous cell on the current page. The (slower) btreePrevious() +** helper routine is called when it is necessary to move to a different page +** or to restore the cursor. +** +** If bit 0x01 of the F argument to sqlite3BtreePrevious(C,F) is 1, then +** the cursor corresponds to an SQL index and this routine could have been +** skipped if the SQL index had been a unique index. The F argument is a +** hint to the implement. The native SQLite btree implementation does not +** use this hint, but COMDB2 does. +*/ +static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur){ + int rc; + MemPage *pPage; + + assert( cursorOwnsBtShared(pCur) ); + assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 ); + assert( pCur->info.nSize==0 ); + if( pCur->eState!=CURSOR_VALID ){ + rc = restoreCursorPosition(pCur); + if( rc!=SQLITE_OK ){ + return rc; + } + if( CURSOR_INVALID==pCur->eState ){ + return SQLITE_DONE; + } + if( CURSOR_SKIPNEXT==pCur->eState ){ + pCur->eState = CURSOR_VALID; + if( pCur->skipNext<0 ) return SQLITE_OK; + } + } + + pPage = pCur->pPage; + assert( pPage->isInit ); + if( !pPage->leaf ){ + int idx = pCur->ix; + rc = moveToChild(pCur, get4byte(findCell(pPage, idx))); + if( rc ) return rc; + rc = moveToRightmost(pCur); + }else{ + while( pCur->ix==0 ){ + if( pCur->iPage==0 ){ + pCur->eState = CURSOR_INVALID; + return SQLITE_DONE; + } + moveToParent(pCur); + } + assert( pCur->info.nSize==0 ); + assert( (pCur->curFlags & (BTCF_ValidOvfl))==0 ); + + pCur->ix--; + pPage = pCur->pPage; + if( pPage->intKey && !pPage->leaf ){ + rc = sqlite3BtreePrevious(pCur, 0); + }else{ + rc = SQLITE_OK; + } + } + return rc; +} +SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int flags){ + assert( cursorOwnsBtShared(pCur) ); + assert( flags==0 || flags==1 ); + UNUSED_PARAMETER( flags ); /* Used in COMDB2 but not native SQLite */ + pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey); + pCur->info.nSize = 0; + if( pCur->eState!=CURSOR_VALID + || pCur->ix==0 + || pCur->pPage->leaf==0 + ){ + return btreePrevious(pCur); + } + pCur->ix--; + return SQLITE_OK; +} + +/* +** Allocate a new page from the database file. +** +** The new page is marked as dirty. (In other words, sqlite3PagerWrite() +** has already been called on the new page.) The new page has also +** been referenced and the calling routine is responsible for calling +** sqlite3PagerUnref() on the new page when it is done. +** +** SQLITE_OK is returned on success. Any other return value indicates +** an error. *ppPage is set to NULL in the event of an error. +** +** If the "nearby" parameter is not 0, then an effort is made to +** locate a page close to the page number "nearby". This can be used in an +** attempt to keep related pages close to each other in the database file, +** which in turn can make database access faster. +** +** If the eMode parameter is BTALLOC_EXACT and the nearby page exists +** anywhere on the free-list, then it is guaranteed to be returned. If +** eMode is BTALLOC_LT then the page returned will be less than or equal +** to nearby if any such page exists. If eMode is BTALLOC_ANY then there +** are no restrictions on which page is returned. +*/ +static int allocateBtreePage( + BtShared *pBt, /* The btree */ + MemPage **ppPage, /* Store pointer to the allocated page here */ + Pgno *pPgno, /* Store the page number here */ + Pgno nearby, /* Search for a page near this one */ + u8 eMode /* BTALLOC_EXACT, BTALLOC_LT, or BTALLOC_ANY */ +){ + MemPage *pPage1; + int rc; + u32 n; /* Number of pages on the freelist */ + u32 k; /* Number of leaves on the trunk of the freelist */ + MemPage *pTrunk = 0; + MemPage *pPrevTrunk = 0; + Pgno mxPage; /* Total size of the database file */ + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( eMode==BTALLOC_ANY || (nearby>0 && IfNotOmitAV(pBt->autoVacuum)) ); + pPage1 = pBt->pPage1; + mxPage = btreePagecount(pBt); + /* EVIDENCE-OF: R-05119-02637 The 4-byte big-endian integer at offset 36 + ** stores stores the total number of pages on the freelist. */ + n = get4byte(&pPage1->aData[36]); + testcase( n==mxPage-1 ); + if( n>=mxPage ){ + return SQLITE_CORRUPT_BKPT; + } + if( n>0 ){ + /* There are pages on the freelist. Reuse one of those pages. */ + Pgno iTrunk; + u8 searchList = 0; /* If the free-list must be searched for 'nearby' */ + u32 nSearch = 0; /* Count of the number of search attempts */ + + /* If eMode==BTALLOC_EXACT and a query of the pointer-map + ** shows that the page 'nearby' is somewhere on the free-list, then + ** the entire-list will be searched for that page. + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + if( eMode==BTALLOC_EXACT ){ + if( nearby<=mxPage ){ + u8 eType; + assert( nearby>0 ); + assert( pBt->autoVacuum ); + rc = ptrmapGet(pBt, nearby, &eType, 0); + if( rc ) return rc; + if( eType==PTRMAP_FREEPAGE ){ + searchList = 1; + } + } + }else if( eMode==BTALLOC_LE ){ + searchList = 1; + } +#endif + + /* Decrement the free-list count by 1. Set iTrunk to the index of the + ** first free-list trunk page. iPrevTrunk is initially 1. + */ + rc = sqlite3PagerWrite(pPage1->pDbPage); + if( rc ) return rc; + put4byte(&pPage1->aData[36], n-1); + + /* The code within this loop is run only once if the 'searchList' variable + ** is not true. Otherwise, it runs once for each trunk-page on the + ** free-list until the page 'nearby' is located (eMode==BTALLOC_EXACT) + ** or until a page less than 'nearby' is located (eMode==BTALLOC_LT) + */ + do { + pPrevTrunk = pTrunk; + if( pPrevTrunk ){ + /* EVIDENCE-OF: R-01506-11053 The first integer on a freelist trunk page + ** is the page number of the next freelist trunk page in the list or + ** zero if this is the last freelist trunk page. */ + iTrunk = get4byte(&pPrevTrunk->aData[0]); + }else{ + /* EVIDENCE-OF: R-59841-13798 The 4-byte big-endian integer at offset 32 + ** stores the page number of the first page of the freelist, or zero if + ** the freelist is empty. */ + iTrunk = get4byte(&pPage1->aData[32]); + } + testcase( iTrunk==mxPage ); + if( iTrunk>mxPage || nSearch++ > n ){ + rc = SQLITE_CORRUPT_PGNO(pPrevTrunk ? pPrevTrunk->pgno : 1); + }else{ + rc = btreeGetUnusedPage(pBt, iTrunk, &pTrunk, 0); + } + if( rc ){ + pTrunk = 0; + goto end_allocate_page; + } + assert( pTrunk!=0 ); + assert( pTrunk->aData!=0 ); + /* EVIDENCE-OF: R-13523-04394 The second integer on a freelist trunk page + ** is the number of leaf page pointers to follow. */ + k = get4byte(&pTrunk->aData[4]); + if( k==0 && !searchList ){ + /* The trunk has no leaves and the list is not being searched. + ** So extract the trunk page itself and use it as the newly + ** allocated page */ + assert( pPrevTrunk==0 ); + rc = sqlite3PagerWrite(pTrunk->pDbPage); + if( rc ){ + goto end_allocate_page; + } + *pPgno = iTrunk; + memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4); + *ppPage = pTrunk; + pTrunk = 0; + TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1)); + }else if( k>(u32)(pBt->usableSize/4 - 2) ){ + /* Value of k is out of range. Database corruption */ + rc = SQLITE_CORRUPT_PGNO(iTrunk); + goto end_allocate_page; +#ifndef SQLITE_OMIT_AUTOVACUUM + }else if( searchList + && (nearby==iTrunk || (iTrunkpDbPage); + if( rc ){ + goto end_allocate_page; + } + if( k==0 ){ + if( !pPrevTrunk ){ + memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4); + }else{ + rc = sqlite3PagerWrite(pPrevTrunk->pDbPage); + if( rc!=SQLITE_OK ){ + goto end_allocate_page; + } + memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4); + } + }else{ + /* The trunk page is required by the caller but it contains + ** pointers to free-list leaves. The first leaf becomes a trunk + ** page in this case. + */ + MemPage *pNewTrunk; + Pgno iNewTrunk = get4byte(&pTrunk->aData[8]); + if( iNewTrunk>mxPage ){ + rc = SQLITE_CORRUPT_PGNO(iTrunk); + goto end_allocate_page; + } + testcase( iNewTrunk==mxPage ); + rc = btreeGetUnusedPage(pBt, iNewTrunk, &pNewTrunk, 0); + if( rc!=SQLITE_OK ){ + goto end_allocate_page; + } + rc = sqlite3PagerWrite(pNewTrunk->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(pNewTrunk); + goto end_allocate_page; + } + memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4); + put4byte(&pNewTrunk->aData[4], k-1); + memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4); + releasePage(pNewTrunk); + if( !pPrevTrunk ){ + assert( sqlite3PagerIswriteable(pPage1->pDbPage) ); + put4byte(&pPage1->aData[32], iNewTrunk); + }else{ + rc = sqlite3PagerWrite(pPrevTrunk->pDbPage); + if( rc ){ + goto end_allocate_page; + } + put4byte(&pPrevTrunk->aData[0], iNewTrunk); + } + } + pTrunk = 0; + TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1)); +#endif + }else if( k>0 ){ + /* Extract a leaf from the trunk */ + u32 closest; + Pgno iPage; + unsigned char *aData = pTrunk->aData; + if( nearby>0 ){ + u32 i; + closest = 0; + if( eMode==BTALLOC_LE ){ + for(i=0; imxPage ){ + rc = SQLITE_CORRUPT_PGNO(iTrunk); + goto end_allocate_page; + } + testcase( iPage==mxPage ); + if( !searchList + || (iPage==nearby || (iPagepgno, n-1)); + rc = sqlite3PagerWrite(pTrunk->pDbPage); + if( rc ) goto end_allocate_page; + if( closestpDbPage); + if( rc!=SQLITE_OK ){ + releasePage(*ppPage); + *ppPage = 0; + } + } + searchList = 0; + } + } + releasePage(pPrevTrunk); + pPrevTrunk = 0; + }while( searchList ); + }else{ + /* There are no pages on the freelist, so append a new page to the + ** database image. + ** + ** Normally, new pages allocated by this block can be requested from the + ** pager layer with the 'no-content' flag set. This prevents the pager + ** from trying to read the pages content from disk. However, if the + ** current transaction has already run one or more incremental-vacuum + ** steps, then the page we are about to allocate may contain content + ** that is required in the event of a rollback. In this case, do + ** not set the no-content flag. This causes the pager to load and journal + ** the current page content before overwriting it. + ** + ** Note that the pager will not actually attempt to load or journal + ** content for any page that really does lie past the end of the database + ** file on disk. So the effects of disabling the no-content optimization + ** here are confined to those pages that lie between the end of the + ** database image and the end of the database file. + */ + int bNoContent = (0==IfNotOmitAV(pBt->bDoTruncate))? PAGER_GET_NOCONTENT:0; + + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + if( rc ) return rc; + pBt->nPage++; + if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ) pBt->nPage++; + +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, pBt->nPage) ){ + /* If *pPgno refers to a pointer-map page, allocate two new pages + ** at the end of the file instead of one. The first allocated page + ** becomes a new pointer-map page, the second is used by the caller. + */ + MemPage *pPg = 0; + TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", pBt->nPage)); + assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) ); + rc = btreeGetUnusedPage(pBt, pBt->nPage, &pPg, bNoContent); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerWrite(pPg->pDbPage); + releasePage(pPg); + } + if( rc ) return rc; + pBt->nPage++; + if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ){ pBt->nPage++; } + } +#endif + put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage); + *pPgno = pBt->nPage; + + assert( *pPgno!=PENDING_BYTE_PAGE(pBt) ); + rc = btreeGetUnusedPage(pBt, *pPgno, ppPage, bNoContent); + if( rc ) return rc; + rc = sqlite3PagerWrite((*ppPage)->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(*ppPage); + *ppPage = 0; + } + TRACE(("ALLOCATE: %d from end of file\n", *pPgno)); + } + + assert( CORRUPT_DB || *pPgno!=PENDING_BYTE_PAGE(pBt) ); + +end_allocate_page: + releasePage(pTrunk); + releasePage(pPrevTrunk); + assert( rc!=SQLITE_OK || sqlite3PagerPageRefcount((*ppPage)->pDbPage)<=1 ); + assert( rc!=SQLITE_OK || (*ppPage)->isInit==0 ); + return rc; +} + +/* +** This function is used to add page iPage to the database file free-list. +** It is assumed that the page is not already a part of the free-list. +** +** The value passed as the second argument to this function is optional. +** If the caller happens to have a pointer to the MemPage object +** corresponding to page iPage handy, it may pass it as the second value. +** Otherwise, it may pass NULL. +** +** If a pointer to a MemPage object is passed as the second argument, +** its reference count is not altered by this function. +*/ +static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){ + MemPage *pTrunk = 0; /* Free-list trunk page */ + Pgno iTrunk = 0; /* Page number of free-list trunk page */ + MemPage *pPage1 = pBt->pPage1; /* Local reference to page 1 */ + MemPage *pPage; /* Page being freed. May be NULL. */ + int rc; /* Return Code */ + u32 nFree; /* Initial number of pages on free-list */ + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( CORRUPT_DB || iPage>1 ); + assert( !pMemPage || pMemPage->pgno==iPage ); + + if( iPage<2 || iPage>pBt->nPage ){ + return SQLITE_CORRUPT_BKPT; + } + if( pMemPage ){ + pPage = pMemPage; + sqlite3PagerRef(pPage->pDbPage); + }else{ + pPage = btreePageLookup(pBt, iPage); + } + + /* Increment the free page count on pPage1 */ + rc = sqlite3PagerWrite(pPage1->pDbPage); + if( rc ) goto freepage_out; + nFree = get4byte(&pPage1->aData[36]); + put4byte(&pPage1->aData[36], nFree+1); + + if( pBt->btsFlags & BTS_SECURE_DELETE ){ + /* If the secure_delete option is enabled, then + ** always fully overwrite deleted information with zeros. + */ + if( (!pPage && ((rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0) ) + || ((rc = sqlite3PagerWrite(pPage->pDbPage))!=0) + ){ + goto freepage_out; + } + memset(pPage->aData, 0, pPage->pBt->pageSize); + } + + /* If the database supports auto-vacuum, write an entry in the pointer-map + ** to indicate that the page is free. + */ + if( ISAUTOVACUUM ){ + ptrmapPut(pBt, iPage, PTRMAP_FREEPAGE, 0, &rc); + if( rc ) goto freepage_out; + } + + /* Now manipulate the actual database free-list structure. There are two + ** possibilities. If the free-list is currently empty, or if the first + ** trunk page in the free-list is full, then this page will become a + ** new free-list trunk page. Otherwise, it will become a leaf of the + ** first trunk page in the current free-list. This block tests if it + ** is possible to add the page as a new free-list leaf. + */ + if( nFree!=0 ){ + u32 nLeaf; /* Initial number of leaf cells on trunk page */ + + iTrunk = get4byte(&pPage1->aData[32]); + if( iTrunk>btreePagecount(pBt) ){ + rc = SQLITE_CORRUPT_BKPT; + goto freepage_out; + } + rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0); + if( rc!=SQLITE_OK ){ + goto freepage_out; + } + + nLeaf = get4byte(&pTrunk->aData[4]); + assert( pBt->usableSize>32 ); + if( nLeaf > (u32)pBt->usableSize/4 - 2 ){ + rc = SQLITE_CORRUPT_BKPT; + goto freepage_out; + } + if( nLeaf < (u32)pBt->usableSize/4 - 8 ){ + /* In this case there is room on the trunk page to insert the page + ** being freed as a new leaf. + ** + ** Note that the trunk page is not really full until it contains + ** usableSize/4 - 2 entries, not usableSize/4 - 8 entries as we have + ** coded. But due to a coding error in versions of SQLite prior to + ** 3.6.0, databases with freelist trunk pages holding more than + ** usableSize/4 - 8 entries will be reported as corrupt. In order + ** to maintain backwards compatibility with older versions of SQLite, + ** we will continue to restrict the number of entries to usableSize/4 - 8 + ** for now. At some point in the future (once everyone has upgraded + ** to 3.6.0 or later) we should consider fixing the conditional above + ** to read "usableSize/4-2" instead of "usableSize/4-8". + ** + ** EVIDENCE-OF: R-19920-11576 However, newer versions of SQLite still + ** avoid using the last six entries in the freelist trunk page array in + ** order that database files created by newer versions of SQLite can be + ** read by older versions of SQLite. + */ + rc = sqlite3PagerWrite(pTrunk->pDbPage); + if( rc==SQLITE_OK ){ + put4byte(&pTrunk->aData[4], nLeaf+1); + put4byte(&pTrunk->aData[8+nLeaf*4], iPage); + if( pPage && (pBt->btsFlags & BTS_SECURE_DELETE)==0 ){ + sqlite3PagerDontWrite(pPage->pDbPage); + } + rc = btreeSetHasContent(pBt, iPage); + } + TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno)); + goto freepage_out; + } + } + + /* If control flows to this point, then it was not possible to add the + ** the page being freed as a leaf page of the first trunk in the free-list. + ** Possibly because the free-list is empty, or possibly because the + ** first trunk in the free-list is full. Either way, the page being freed + ** will become the new first trunk page in the free-list. + */ + if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){ + goto freepage_out; + } + rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc!=SQLITE_OK ){ + goto freepage_out; + } + put4byte(pPage->aData, iTrunk); + put4byte(&pPage->aData[4], 0); + put4byte(&pPage1->aData[32], iPage); + TRACE(("FREE-PAGE: %d new trunk page replacing %d\n", pPage->pgno, iTrunk)); + +freepage_out: + if( pPage ){ + pPage->isInit = 0; + } + releasePage(pPage); + releasePage(pTrunk); + return rc; +} +static void freePage(MemPage *pPage, int *pRC){ + if( (*pRC)==SQLITE_OK ){ + *pRC = freePage2(pPage->pBt, pPage, pPage->pgno); + } +} + +/* +** Free any overflow pages associated with the given Cell. Store +** size information about the cell in pInfo. +*/ +static int clearCell( + MemPage *pPage, /* The page that contains the Cell */ + unsigned char *pCell, /* First byte of the Cell */ + CellInfo *pInfo /* Size information about the cell */ +){ + BtShared *pBt; + Pgno ovflPgno; + int rc; + int nOvfl; + u32 ovflPageSize; + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + pPage->xParseCell(pPage, pCell, pInfo); + if( pInfo->nLocal==pInfo->nPayload ){ + return SQLITE_OK; /* No overflow pages. Return without doing anything */ + } + testcase( pCell + pInfo->nSize == pPage->aDataEnd ); + testcase( pCell + (pInfo->nSize-1) == pPage->aDataEnd ); + if( pCell + pInfo->nSize > pPage->aDataEnd ){ + /* Cell extends past end of page */ + return SQLITE_CORRUPT_PAGE(pPage); + } + ovflPgno = get4byte(pCell + pInfo->nSize - 4); + pBt = pPage->pBt; + assert( pBt->usableSize > 4 ); + ovflPageSize = pBt->usableSize - 4; + nOvfl = (pInfo->nPayload - pInfo->nLocal + ovflPageSize - 1)/ovflPageSize; + assert( nOvfl>0 || + (CORRUPT_DB && (pInfo->nPayload + ovflPageSize)btreePagecount(pBt) ){ + /* 0 is not a legal page number and page 1 cannot be an + ** overflow page. Therefore if ovflPgno<2 or past the end of the + ** file the database must be corrupt. */ + return SQLITE_CORRUPT_BKPT; + } + if( nOvfl ){ + rc = getOverflowPage(pBt, ovflPgno, &pOvfl, &iNext); + if( rc ) return rc; + } + + if( ( pOvfl || ((pOvfl = btreePageLookup(pBt, ovflPgno))!=0) ) + && sqlite3PagerPageRefcount(pOvfl->pDbPage)!=1 + ){ + /* There is no reason any cursor should have an outstanding reference + ** to an overflow page belonging to a cell that is being deleted/updated. + ** So if there exists more than one reference to this page, then it + ** must not really be an overflow page and the database must be corrupt. + ** It is helpful to detect this before calling freePage2(), as + ** freePage2() may zero the page contents if secure-delete mode is + ** enabled. If this 'overflow' page happens to be a page that the + ** caller is iterating through or using in some other way, this + ** can be problematic. + */ + rc = SQLITE_CORRUPT_BKPT; + }else{ + rc = freePage2(pBt, pOvfl, ovflPgno); + } + + if( pOvfl ){ + sqlite3PagerUnref(pOvfl->pDbPage); + } + if( rc ) return rc; + ovflPgno = iNext; + } + return SQLITE_OK; +} + +/* +** Create the byte sequence used to represent a cell on page pPage +** and write that byte sequence into pCell[]. Overflow pages are +** allocated and filled in as necessary. The calling procedure +** is responsible for making sure sufficient space has been allocated +** for pCell[]. +** +** Note that pCell does not necessary need to point to the pPage->aData +** area. pCell might point to some temporary storage. The cell will +** be constructed in this temporary area then copied into pPage->aData +** later. +*/ +static int fillInCell( + MemPage *pPage, /* The page that contains the cell */ + unsigned char *pCell, /* Complete text of the cell */ + const BtreePayload *pX, /* Payload with which to construct the cell */ + int *pnSize /* Write cell size here */ +){ + int nPayload; + const u8 *pSrc; + int nSrc, n, rc, mn; + int spaceLeft; + MemPage *pToRelease; + unsigned char *pPrior; + unsigned char *pPayload; + BtShared *pBt; + Pgno pgnoOvfl; + int nHeader; + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + + /* pPage is not necessarily writeable since pCell might be auxiliary + ** buffer space that is separate from the pPage buffer area */ + assert( pCellaData || pCell>=&pPage->aData[pPage->pBt->pageSize] + || sqlite3PagerIswriteable(pPage->pDbPage) ); + + /* Fill in the header. */ + nHeader = pPage->childPtrSize; + if( pPage->intKey ){ + nPayload = pX->nData + pX->nZero; + pSrc = pX->pData; + nSrc = pX->nData; + assert( pPage->intKeyLeaf ); /* fillInCell() only called for leaves */ + nHeader += putVarint32(&pCell[nHeader], nPayload); + nHeader += putVarint(&pCell[nHeader], *(u64*)&pX->nKey); + }else{ + assert( pX->nKey<=0x7fffffff && pX->pKey!=0 ); + nSrc = nPayload = (int)pX->nKey; + pSrc = pX->pKey; + nHeader += putVarint32(&pCell[nHeader], nPayload); + } + + /* Fill in the payload */ + pPayload = &pCell[nHeader]; + if( nPayload<=pPage->maxLocal ){ + /* This is the common case where everything fits on the btree page + ** and no overflow pages are required. */ + n = nHeader + nPayload; + testcase( n==3 ); + testcase( n==4 ); + if( n<4 ) n = 4; + *pnSize = n; + assert( nSrc<=nPayload ); + testcase( nSrcminLocal; + n = mn + (nPayload - mn) % (pPage->pBt->usableSize - 4); + testcase( n==pPage->maxLocal ); + testcase( n==pPage->maxLocal+1 ); + if( n > pPage->maxLocal ) n = mn; + spaceLeft = n; + *pnSize = n + nHeader + 4; + pPrior = &pCell[nHeader+n]; + pToRelease = 0; + pgnoOvfl = 0; + pBt = pPage->pBt; + + /* At this point variables should be set as follows: + ** + ** nPayload Total payload size in bytes + ** pPayload Begin writing payload here + ** spaceLeft Space available at pPayload. If nPayload>spaceLeft, + ** that means content must spill into overflow pages. + ** *pnSize Size of the local cell (not counting overflow pages) + ** pPrior Where to write the pgno of the first overflow page + ** + ** Use a call to btreeParseCellPtr() to verify that the values above + ** were computed correctly. + */ +#ifdef SQLITE_DEBUG + { + CellInfo info; + pPage->xParseCell(pPage, pCell, &info); + assert( nHeader==(int)(info.pPayload - pCell) ); + assert( info.nKey==pX->nKey ); + assert( *pnSize == info.nSize ); + assert( spaceLeft == info.nLocal ); + } +#endif + + /* Write the payload into the local Cell and any extra into overflow pages */ + while( 1 ){ + n = nPayload; + if( n>spaceLeft ) n = spaceLeft; + + /* If pToRelease is not zero than pPayload points into the data area + ** of pToRelease. Make sure pToRelease is still writeable. */ + assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) ); + + /* If pPayload is part of the data area of pPage, then make sure pPage + ** is still writeable */ + assert( pPayloadaData || pPayload>=&pPage->aData[pBt->pageSize] + || sqlite3PagerIswriteable(pPage->pDbPage) ); + + if( nSrc>=n ){ + memcpy(pPayload, pSrc, n); + }else if( nSrc>0 ){ + n = nSrc; + memcpy(pPayload, pSrc, n); + }else{ + memset(pPayload, 0, n); + } + nPayload -= n; + if( nPayload<=0 ) break; + pPayload += n; + pSrc += n; + nSrc -= n; + spaceLeft -= n; + if( spaceLeft==0 ){ + MemPage *pOvfl = 0; +#ifndef SQLITE_OMIT_AUTOVACUUM + Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */ + if( pBt->autoVacuum ){ + do{ + pgnoOvfl++; + } while( + PTRMAP_ISPAGE(pBt, pgnoOvfl) || pgnoOvfl==PENDING_BYTE_PAGE(pBt) + ); + } +#endif + rc = allocateBtreePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, 0); +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If the database supports auto-vacuum, and the second or subsequent + ** overflow page is being allocated, add an entry to the pointer-map + ** for that page now. + ** + ** If this is the first overflow page, then write a partial entry + ** to the pointer-map. If we write nothing to this pointer-map slot, + ** then the optimistic overflow chain processing in clearCell() + ** may misinterpret the uninitialized values and delete the + ** wrong pages from the database. + */ + if( pBt->autoVacuum && rc==SQLITE_OK ){ + u8 eType = (pgnoPtrmap?PTRMAP_OVERFLOW2:PTRMAP_OVERFLOW1); + ptrmapPut(pBt, pgnoOvfl, eType, pgnoPtrmap, &rc); + if( rc ){ + releasePage(pOvfl); + } + } +#endif + if( rc ){ + releasePage(pToRelease); + return rc; + } + + /* If pToRelease is not zero than pPrior points into the data area + ** of pToRelease. Make sure pToRelease is still writeable. */ + assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) ); + + /* If pPrior is part of the data area of pPage, then make sure pPage + ** is still writeable */ + assert( pPrioraData || pPrior>=&pPage->aData[pBt->pageSize] + || sqlite3PagerIswriteable(pPage->pDbPage) ); + + put4byte(pPrior, pgnoOvfl); + releasePage(pToRelease); + pToRelease = pOvfl; + pPrior = pOvfl->aData; + put4byte(pPrior, 0); + pPayload = &pOvfl->aData[4]; + spaceLeft = pBt->usableSize - 4; + } + } + releasePage(pToRelease); + return SQLITE_OK; +} + +/* +** Remove the i-th cell from pPage. This routine effects pPage only. +** The cell content is not freed or deallocated. It is assumed that +** the cell content has been copied someplace else. This routine just +** removes the reference to the cell from pPage. +** +** "sz" must be the number of bytes in the cell. +*/ +static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){ + u32 pc; /* Offset to cell content of cell being deleted */ + u8 *data; /* pPage->aData */ + u8 *ptr; /* Used to move bytes around within data[] */ + int rc; /* The return code */ + int hdr; /* Beginning of the header. 0 most pages. 100 page 1 */ + + if( *pRC ) return; + assert( idx>=0 && idxnCell ); + assert( CORRUPT_DB || sz==cellSize(pPage, idx) ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->nFree>=0 ); + data = pPage->aData; + ptr = &pPage->aCellIdx[2*idx]; + pc = get2byte(ptr); + hdr = pPage->hdrOffset; + testcase( pc==get2byte(&data[hdr+5]) ); + testcase( pc+sz==pPage->pBt->usableSize ); + if( pc+sz > pPage->pBt->usableSize ){ + *pRC = SQLITE_CORRUPT_BKPT; + return; + } + rc = freeSpace(pPage, pc, sz); + if( rc ){ + *pRC = rc; + return; + } + pPage->nCell--; + if( pPage->nCell==0 ){ + memset(&data[hdr+1], 0, 4); + data[hdr+7] = 0; + put2byte(&data[hdr+5], pPage->pBt->usableSize); + pPage->nFree = pPage->pBt->usableSize - pPage->hdrOffset + - pPage->childPtrSize - 8; + }else{ + memmove(ptr, ptr+2, 2*(pPage->nCell - idx)); + put2byte(&data[hdr+3], pPage->nCell); + pPage->nFree += 2; + } +} + +/* +** Insert a new cell on pPage at cell index "i". pCell points to the +** content of the cell. +** +** If the cell content will fit on the page, then put it there. If it +** will not fit, then make a copy of the cell content into pTemp if +** pTemp is not null. Regardless of pTemp, allocate a new entry +** in pPage->apOvfl[] and make it point to the cell content (either +** in pTemp or the original pCell) and also record its index. +** Allocating a new entry in pPage->aCell[] implies that +** pPage->nOverflow is incremented. +** +** *pRC must be SQLITE_OK when this routine is called. +*/ +static void insertCell( + MemPage *pPage, /* Page into which we are copying */ + int i, /* New cell becomes the i-th cell of the page */ + u8 *pCell, /* Content of the new cell */ + int sz, /* Bytes of content in pCell */ + u8 *pTemp, /* Temp storage space for pCell, if needed */ + Pgno iChild, /* If non-zero, replace first 4 bytes with this value */ + int *pRC /* Read and write return code from here */ +){ + int idx = 0; /* Where to write new cell content in data[] */ + int j; /* Loop counter */ + u8 *data; /* The content of the whole page */ + u8 *pIns; /* The point in pPage->aCellIdx[] where no cell inserted */ + + assert( *pRC==SQLITE_OK ); + assert( i>=0 && i<=pPage->nCell+pPage->nOverflow ); + assert( MX_CELL(pPage->pBt)<=10921 ); + assert( pPage->nCell<=MX_CELL(pPage->pBt) || CORRUPT_DB ); + assert( pPage->nOverflow<=ArraySize(pPage->apOvfl) ); + assert( ArraySize(pPage->apOvfl)==ArraySize(pPage->aiOvfl) ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( sz==pPage->xCellSize(pPage, pCell) || CORRUPT_DB ); + assert( pPage->nFree>=0 ); + if( pPage->nOverflow || sz+2>pPage->nFree ){ + if( pTemp ){ + memcpy(pTemp, pCell, sz); + pCell = pTemp; + } + if( iChild ){ + put4byte(pCell, iChild); + } + j = pPage->nOverflow++; + /* Comparison against ArraySize-1 since we hold back one extra slot + ** as a contingency. In other words, never need more than 3 overflow + ** slots but 4 are allocated, just to be safe. */ + assert( j < ArraySize(pPage->apOvfl)-1 ); + pPage->apOvfl[j] = pCell; + pPage->aiOvfl[j] = (u16)i; + + /* When multiple overflows occur, they are always sequential and in + ** sorted order. This invariants arise because multiple overflows can + ** only occur when inserting divider cells into the parent page during + ** balancing, and the dividers are adjacent and sorted. + */ + assert( j==0 || pPage->aiOvfl[j-1]<(u16)i ); /* Overflows in sorted order */ + assert( j==0 || i==pPage->aiOvfl[j-1]+1 ); /* Overflows are sequential */ + }else{ + int rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc!=SQLITE_OK ){ + *pRC = rc; + return; + } + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + data = pPage->aData; + assert( &data[pPage->cellOffset]==pPage->aCellIdx ); + rc = allocateSpace(pPage, sz, &idx); + if( rc ){ *pRC = rc; return; } + /* The allocateSpace() routine guarantees the following properties + ** if it returns successfully */ + assert( idx >= 0 ); + assert( idx >= pPage->cellOffset+2*pPage->nCell+2 || CORRUPT_DB ); + assert( idx+sz <= (int)pPage->pBt->usableSize ); + pPage->nFree -= (u16)(2 + sz); + if( iChild ){ + /* In a corrupt database where an entry in the cell index section of + ** a btree page has a value of 3 or less, the pCell value might point + ** as many as 4 bytes in front of the start of the aData buffer for + ** the source page. Make sure this does not cause problems by not + ** reading the first 4 bytes */ + memcpy(&data[idx+4], pCell+4, sz-4); + put4byte(&data[idx], iChild); + }else{ + memcpy(&data[idx], pCell, sz); + } + pIns = pPage->aCellIdx + i*2; + memmove(pIns+2, pIns, 2*(pPage->nCell - i)); + put2byte(pIns, idx); + pPage->nCell++; + /* increment the cell count */ + if( (++data[pPage->hdrOffset+4])==0 ) data[pPage->hdrOffset+3]++; + assert( get2byte(&data[pPage->hdrOffset+3])==pPage->nCell || CORRUPT_DB ); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pPage->pBt->autoVacuum ){ + /* The cell may contain a pointer to an overflow page. If so, write + ** the entry for the overflow page into the pointer map. + */ + ptrmapPutOvflPtr(pPage, pPage, pCell, pRC); + } +#endif + } +} + +/* +** The following parameters determine how many adjacent pages get involved +** in a balancing operation. NN is the number of neighbors on either side +** of the page that participate in the balancing operation. NB is the +** total number of pages that participate, including the target page and +** NN neighbors on either side. +** +** The minimum value of NN is 1 (of course). Increasing NN above 1 +** (to 2 or 3) gives a modest improvement in SELECT and DELETE performance +** in exchange for a larger degradation in INSERT and UPDATE performance. +** The value of NN appears to give the best results overall. +** +** (Later:) The description above makes it seem as if these values are +** tunable - as if you could change them and recompile and it would all work. +** But that is unlikely. NB has been 3 since the inception of SQLite and +** we have never tested any other value. +*/ +#define NN 1 /* Number of neighbors on either side of pPage */ +#define NB 3 /* (NN*2+1): Total pages involved in the balance */ + +/* +** A CellArray object contains a cache of pointers and sizes for a +** consecutive sequence of cells that might be held on multiple pages. +** +** The cells in this array are the divider cell or cells from the pParent +** page plus up to three child pages. There are a total of nCell cells. +** +** pRef is a pointer to one of the pages that contributes cells. This is +** used to access information such as MemPage.intKey and MemPage.pBt->pageSize +** which should be common to all pages that contribute cells to this array. +** +** apCell[] and szCell[] hold, respectively, pointers to the start of each +** cell and the size of each cell. Some of the apCell[] pointers might refer +** to overflow cells. In other words, some apCel[] pointers might not point +** to content area of the pages. +** +** A szCell[] of zero means the size of that cell has not yet been computed. +** +** The cells come from as many as four different pages: +** +** ----------- +** | Parent | +** ----------- +** / | \ +** / | \ +** --------- --------- --------- +** |Child-1| |Child-2| |Child-3| +** --------- --------- --------- +** +** The order of cells is in the array is for an index btree is: +** +** 1. All cells from Child-1 in order +** 2. The first divider cell from Parent +** 3. All cells from Child-2 in order +** 4. The second divider cell from Parent +** 5. All cells from Child-3 in order +** +** For a table-btree (with rowids) the items 2 and 4 are empty because +** content exists only in leaves and there are no divider cells. +** +** For an index btree, the apEnd[] array holds pointer to the end of page +** for Child-1, the Parent, Child-2, the Parent (again), and Child-3, +** respectively. The ixNx[] array holds the number of cells contained in +** each of these 5 stages, and all stages to the left. Hence: +** +** ixNx[0] = Number of cells in Child-1. +** ixNx[1] = Number of cells in Child-1 plus 1 for first divider. +** ixNx[2] = Number of cells in Child-1 and Child-2 + 1 for 1st divider. +** ixNx[3] = Number of cells in Child-1 and Child-2 + both divider cells +** ixNx[4] = Total number of cells. +** +** For a table-btree, the concept is similar, except only apEnd[0]..apEnd[2] +** are used and they point to the leaf pages only, and the ixNx value are: +** +** ixNx[0] = Number of cells in Child-1. +** ixNx[1] = Number of cells in Child-1 and Child-2. +** ixNx[2] = Total number of cells. +** +** Sometimes when deleting, a child page can have zero cells. In those +** cases, ixNx[] entries with higher indexes, and the corresponding apEnd[] +** entries, shift down. The end result is that each ixNx[] entry should +** be larger than the previous +*/ +typedef struct CellArray CellArray; +struct CellArray { + int nCell; /* Number of cells in apCell[] */ + MemPage *pRef; /* Reference page */ + u8 **apCell; /* All cells begin balanced */ + u16 *szCell; /* Local size of all cells in apCell[] */ + u8 *apEnd[NB*2]; /* MemPage.aDataEnd values */ + int ixNx[NB*2]; /* Index of at which we move to the next apEnd[] */ +}; + +/* +** Make sure the cell sizes at idx, idx+1, ..., idx+N-1 have been +** computed. +*/ +static void populateCellCache(CellArray *p, int idx, int N){ + assert( idx>=0 && idx+N<=p->nCell ); + while( N>0 ){ + assert( p->apCell[idx]!=0 ); + if( p->szCell[idx]==0 ){ + p->szCell[idx] = p->pRef->xCellSize(p->pRef, p->apCell[idx]); + }else{ + assert( CORRUPT_DB || + p->szCell[idx]==p->pRef->xCellSize(p->pRef, p->apCell[idx]) ); + } + idx++; + N--; + } +} + +/* +** Return the size of the Nth element of the cell array +*/ +static SQLITE_NOINLINE u16 computeCellSize(CellArray *p, int N){ + assert( N>=0 && NnCell ); + assert( p->szCell[N]==0 ); + p->szCell[N] = p->pRef->xCellSize(p->pRef, p->apCell[N]); + return p->szCell[N]; +} +static u16 cachedCellSize(CellArray *p, int N){ + assert( N>=0 && NnCell ); + if( p->szCell[N] ) return p->szCell[N]; + return computeCellSize(p, N); +} + +/* +** Array apCell[] contains pointers to nCell b-tree page cells. The +** szCell[] array contains the size in bytes of each cell. This function +** replaces the current contents of page pPg with the contents of the cell +** array. +** +** Some of the cells in apCell[] may currently be stored in pPg. This +** function works around problems caused by this by making a copy of any +** such cells before overwriting the page data. +** +** The MemPage.nFree field is invalidated by this function. It is the +** responsibility of the caller to set it correctly. +*/ +static int rebuildPage( + CellArray *pCArray, /* Content to be added to page pPg */ + int iFirst, /* First cell in pCArray to use */ + int nCell, /* Final number of cells on page */ + MemPage *pPg /* The page to be reconstructed */ +){ + const int hdr = pPg->hdrOffset; /* Offset of header on pPg */ + u8 * const aData = pPg->aData; /* Pointer to data for pPg */ + const int usableSize = pPg->pBt->usableSize; + u8 * const pEnd = &aData[usableSize]; + int i = iFirst; /* Which cell to copy from pCArray*/ + u32 j; /* Start of cell content area */ + int iEnd = i+nCell; /* Loop terminator */ + u8 *pCellptr = pPg->aCellIdx; + u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager); + u8 *pData; + int k; /* Current slot in pCArray->apEnd[] */ + u8 *pSrcEnd; /* Current pCArray->apEnd[k] value */ + + assert( i(u32)usableSize) ){ j = 0; } + memcpy(&pTmp[j], &aData[j], usableSize - j); + + for(k=0; pCArray->ixNx[k]<=i && ALWAYS(kapEnd[k]; + + pData = pEnd; + while( 1/*exit by break*/ ){ + u8 *pCell = pCArray->apCell[i]; + u16 sz = pCArray->szCell[i]; + assert( sz>0 ); + if( SQLITE_WITHIN(pCell,aData,pEnd) ){ + if( ((uptr)(pCell+sz))>(uptr)pEnd ) return SQLITE_CORRUPT_BKPT; + pCell = &pTmp[pCell - aData]; + }else if( (uptr)(pCell+sz)>(uptr)pSrcEnd + && (uptr)(pCell)<(uptr)pSrcEnd + ){ + return SQLITE_CORRUPT_BKPT; + } + + pData -= sz; + put2byte(pCellptr, (pData - aData)); + pCellptr += 2; + if( pData < pCellptr ) return SQLITE_CORRUPT_BKPT; + memcpy(pData, pCell, sz); + assert( sz==pPg->xCellSize(pPg, pCell) || CORRUPT_DB ); + testcase( sz!=pPg->xCellSize(pPg,pCell) ) + i++; + if( i>=iEnd ) break; + if( pCArray->ixNx[k]<=i ){ + k++; + pSrcEnd = pCArray->apEnd[k]; + } + } + + /* The pPg->nFree field is now set incorrectly. The caller will fix it. */ + pPg->nCell = nCell; + pPg->nOverflow = 0; + + put2byte(&aData[hdr+1], 0); + put2byte(&aData[hdr+3], pPg->nCell); + put2byte(&aData[hdr+5], pData - aData); + aData[hdr+7] = 0x00; + return SQLITE_OK; +} + +/* +** The pCArray objects contains pointers to b-tree cells and the cell sizes. +** This function attempts to add the cells stored in the array to page pPg. +** If it cannot (because the page needs to be defragmented before the cells +** will fit), non-zero is returned. Otherwise, if the cells are added +** successfully, zero is returned. +** +** Argument pCellptr points to the first entry in the cell-pointer array +** (part of page pPg) to populate. After cell apCell[0] is written to the +** page body, a 16-bit offset is written to pCellptr. And so on, for each +** cell in the array. It is the responsibility of the caller to ensure +** that it is safe to overwrite this part of the cell-pointer array. +** +** When this function is called, *ppData points to the start of the +** content area on page pPg. If the size of the content area is extended, +** *ppData is updated to point to the new start of the content area +** before returning. +** +** Finally, argument pBegin points to the byte immediately following the +** end of the space required by this page for the cell-pointer area (for +** all cells - not just those inserted by the current call). If the content +** area must be extended to before this point in order to accomodate all +** cells in apCell[], then the cells do not fit and non-zero is returned. +*/ +static int pageInsertArray( + MemPage *pPg, /* Page to add cells to */ + u8 *pBegin, /* End of cell-pointer array */ + u8 **ppData, /* IN/OUT: Page content-area pointer */ + u8 *pCellptr, /* Pointer to cell-pointer area */ + int iFirst, /* Index of first cell to add */ + int nCell, /* Number of cells to add to pPg */ + CellArray *pCArray /* Array of cells */ +){ + int i = iFirst; /* Loop counter - cell index to insert */ + u8 *aData = pPg->aData; /* Complete page */ + u8 *pData = *ppData; /* Content area. A subset of aData[] */ + int iEnd = iFirst + nCell; /* End of loop. One past last cell to ins */ + int k; /* Current slot in pCArray->apEnd[] */ + u8 *pEnd; /* Maximum extent of cell data */ + assert( CORRUPT_DB || pPg->hdrOffset==0 ); /* Never called on page 1 */ + if( iEnd<=iFirst ) return 0; + for(k=0; pCArray->ixNx[k]<=i && ALWAYS(kapEnd[k]; + while( 1 /*Exit by break*/ ){ + int sz, rc; + u8 *pSlot; + assert( pCArray->szCell[i]!=0 ); + sz = pCArray->szCell[i]; + if( (aData[1]==0 && aData[2]==0) || (pSlot = pageFindSlot(pPg,sz,&rc))==0 ){ + if( (pData - pBegin)apCell[i] will never overlap on a well-formed + ** database. But they might for a corrupt database. Hence use memmove() + ** since memcpy() sends SIGABORT with overlapping buffers on OpenBSD */ + assert( (pSlot+sz)<=pCArray->apCell[i] + || pSlot>=(pCArray->apCell[i]+sz) + || CORRUPT_DB ); + if( (uptr)(pCArray->apCell[i]+sz)>(uptr)pEnd + && (uptr)(pCArray->apCell[i])<(uptr)pEnd + ){ + assert( CORRUPT_DB ); + (void)SQLITE_CORRUPT_BKPT; + return 1; + } + memmove(pSlot, pCArray->apCell[i], sz); + put2byte(pCellptr, (pSlot - aData)); + pCellptr += 2; + i++; + if( i>=iEnd ) break; + if( pCArray->ixNx[k]<=i ){ + k++; + pEnd = pCArray->apEnd[k]; + } + } + *ppData = pData; + return 0; +} + +/* +** The pCArray object contains pointers to b-tree cells and their sizes. +** +** This function adds the space associated with each cell in the array +** that is currently stored within the body of pPg to the pPg free-list. +** The cell-pointers and other fields of the page are not updated. +** +** This function returns the total number of cells added to the free-list. +*/ +static int pageFreeArray( + MemPage *pPg, /* Page to edit */ + int iFirst, /* First cell to delete */ + int nCell, /* Cells to delete */ + CellArray *pCArray /* Array of cells */ +){ + u8 * const aData = pPg->aData; + u8 * const pEnd = &aData[pPg->pBt->usableSize]; + u8 * const pStart = &aData[pPg->hdrOffset + 8 + pPg->childPtrSize]; + int nRet = 0; + int i; + int iEnd = iFirst + nCell; + u8 *pFree = 0; + int szFree = 0; + + for(i=iFirst; iapCell[i]; + if( SQLITE_WITHIN(pCell, pStart, pEnd) ){ + int sz; + /* No need to use cachedCellSize() here. The sizes of all cells that + ** are to be freed have already been computing while deciding which + ** cells need freeing */ + sz = pCArray->szCell[i]; assert( sz>0 ); + if( pFree!=(pCell + sz) ){ + if( pFree ){ + assert( pFree>aData && (pFree - aData)<65536 ); + freeSpace(pPg, (u16)(pFree - aData), szFree); + } + pFree = pCell; + szFree = sz; + if( pFree+sz>pEnd ) return 0; + }else{ + pFree = pCell; + szFree += sz; + } + nRet++; + } + } + if( pFree ){ + assert( pFree>aData && (pFree - aData)<65536 ); + freeSpace(pPg, (u16)(pFree - aData), szFree); + } + return nRet; +} + +/* +** pCArray contains pointers to and sizes of all cells in the page being +** balanced. The current page, pPg, has pPg->nCell cells starting with +** pCArray->apCell[iOld]. After balancing, this page should hold nNew cells +** starting at apCell[iNew]. +** +** This routine makes the necessary adjustments to pPg so that it contains +** the correct cells after being balanced. +** +** The pPg->nFree field is invalid when this function returns. It is the +** responsibility of the caller to set it correctly. +*/ +static int editPage( + MemPage *pPg, /* Edit this page */ + int iOld, /* Index of first cell currently on page */ + int iNew, /* Index of new first cell on page */ + int nNew, /* Final number of cells on page */ + CellArray *pCArray /* Array of cells and sizes */ +){ + u8 * const aData = pPg->aData; + const int hdr = pPg->hdrOffset; + u8 *pBegin = &pPg->aCellIdx[nNew * 2]; + int nCell = pPg->nCell; /* Cells stored on pPg */ + u8 *pData; + u8 *pCellptr; + int i; + int iOldEnd = iOld + pPg->nCell + pPg->nOverflow; + int iNewEnd = iNew + nNew; + +#ifdef SQLITE_DEBUG + u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager); + memcpy(pTmp, aData, pPg->pBt->usableSize); +#endif + + /* Remove cells from the start and end of the page */ + assert( nCell>=0 ); + if( iOldnCell) ) return SQLITE_CORRUPT_BKPT; + memmove(pPg->aCellIdx, &pPg->aCellIdx[nShift*2], nCell*2); + nCell -= nShift; + } + if( iNewEnd < iOldEnd ){ + int nTail = pageFreeArray(pPg, iNewEnd, iOldEnd - iNewEnd, pCArray); + assert( nCell>=nTail ); + nCell -= nTail; + } + + pData = &aData[get2byteNotZero(&aData[hdr+5])]; + if( pData=0 ); + pCellptr = pPg->aCellIdx; + memmove(&pCellptr[nAdd*2], pCellptr, nCell*2); + if( pageInsertArray( + pPg, pBegin, &pData, pCellptr, + iNew, nAdd, pCArray + ) ) goto editpage_fail; + nCell += nAdd; + } + + /* Add any overflow cells */ + for(i=0; inOverflow; i++){ + int iCell = (iOld + pPg->aiOvfl[i]) - iNew; + if( iCell>=0 && iCellaCellIdx[iCell * 2]; + if( nCell>iCell ){ + memmove(&pCellptr[2], pCellptr, (nCell - iCell) * 2); + } + nCell++; + cachedCellSize(pCArray, iCell+iNew); + if( pageInsertArray( + pPg, pBegin, &pData, pCellptr, + iCell+iNew, 1, pCArray + ) ) goto editpage_fail; + } + } + + /* Append cells to the end of the page */ + assert( nCell>=0 ); + pCellptr = &pPg->aCellIdx[nCell*2]; + if( pageInsertArray( + pPg, pBegin, &pData, pCellptr, + iNew+nCell, nNew-nCell, pCArray + ) ) goto editpage_fail; + + pPg->nCell = nNew; + pPg->nOverflow = 0; + + put2byte(&aData[hdr+3], pPg->nCell); + put2byte(&aData[hdr+5], pData - aData); + +#ifdef SQLITE_DEBUG + for(i=0; iapCell[i+iNew]; + int iOff = get2byteAligned(&pPg->aCellIdx[i*2]); + if( SQLITE_WITHIN(pCell, aData, &aData[pPg->pBt->usableSize]) ){ + pCell = &pTmp[pCell - aData]; + } + assert( 0==memcmp(pCell, &aData[iOff], + pCArray->pRef->xCellSize(pCArray->pRef, pCArray->apCell[i+iNew])) ); + } +#endif + + return SQLITE_OK; + editpage_fail: + /* Unable to edit this page. Rebuild it from scratch instead. */ + populateCellCache(pCArray, iNew, nNew); + return rebuildPage(pCArray, iNew, nNew, pPg); +} + + +#ifndef SQLITE_OMIT_QUICKBALANCE +/* +** This version of balance() handles the common special case where +** a new entry is being inserted on the extreme right-end of the +** tree, in other words, when the new entry will become the largest +** entry in the tree. +** +** Instead of trying to balance the 3 right-most leaf pages, just add +** a new page to the right-hand side and put the one new entry in +** that page. This leaves the right side of the tree somewhat +** unbalanced. But odds are that we will be inserting new entries +** at the end soon afterwards so the nearly empty page will quickly +** fill up. On average. +** +** pPage is the leaf page which is the right-most page in the tree. +** pParent is its parent. pPage must have a single overflow entry +** which is also the right-most entry on the page. +** +** The pSpace buffer is used to store a temporary copy of the divider +** cell that will be inserted into pParent. Such a cell consists of a 4 +** byte page number followed by a variable length integer. In other +** words, at most 13 bytes. Hence the pSpace buffer must be at +** least 13 bytes in size. +*/ +static int balance_quick(MemPage *pParent, MemPage *pPage, u8 *pSpace){ + BtShared *const pBt = pPage->pBt; /* B-Tree Database */ + MemPage *pNew; /* Newly allocated page */ + int rc; /* Return Code */ + Pgno pgnoNew; /* Page number of pNew */ + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( sqlite3PagerIswriteable(pParent->pDbPage) ); + assert( pPage->nOverflow==1 ); + + if( pPage->nCell==0 ) return SQLITE_CORRUPT_BKPT; /* dbfuzz001.test */ + assert( pPage->nFree>=0 ); + assert( pParent->nFree>=0 ); + + /* Allocate a new page. This page will become the right-sibling of + ** pPage. Make the parent page writable, so that the new divider cell + ** may be inserted. If both these operations are successful, proceed. + */ + rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0); + + if( rc==SQLITE_OK ){ + + u8 *pOut = &pSpace[4]; + u8 *pCell = pPage->apOvfl[0]; + u16 szCell = pPage->xCellSize(pPage, pCell); + u8 *pStop; + CellArray b; + + assert( sqlite3PagerIswriteable(pNew->pDbPage) ); + assert( CORRUPT_DB || pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) ); + zeroPage(pNew, PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF); + b.nCell = 1; + b.pRef = pPage; + b.apCell = &pCell; + b.szCell = &szCell; + b.apEnd[0] = pPage->aDataEnd; + b.ixNx[0] = 2; + rc = rebuildPage(&b, 0, 1, pNew); + if( NEVER(rc) ){ + releasePage(pNew); + return rc; + } + pNew->nFree = pBt->usableSize - pNew->cellOffset - 2 - szCell; + + /* If this is an auto-vacuum database, update the pointer map + ** with entries for the new page, and any pointer from the + ** cell on the page to an overflow page. If either of these + ** operations fails, the return code is set, but the contents + ** of the parent page are still manipulated by thh code below. + ** That is Ok, at this point the parent page is guaranteed to + ** be marked as dirty. Returning an error code will cause a + ** rollback, undoing any changes made to the parent page. + */ + if( ISAUTOVACUUM ){ + ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc); + if( szCell>pNew->minLocal ){ + ptrmapPutOvflPtr(pNew, pNew, pCell, &rc); + } + } + + /* Create a divider cell to insert into pParent. The divider cell + ** consists of a 4-byte page number (the page number of pPage) and + ** a variable length key value (which must be the same value as the + ** largest key on pPage). + ** + ** To find the largest key value on pPage, first find the right-most + ** cell on pPage. The first two fields of this cell are the + ** record-length (a variable length integer at most 32-bits in size) + ** and the key value (a variable length integer, may have any value). + ** The first of the while(...) loops below skips over the record-length + ** field. The second while(...) loop copies the key value from the + ** cell on pPage into the pSpace buffer. + */ + pCell = findCell(pPage, pPage->nCell-1); + pStop = &pCell[9]; + while( (*(pCell++)&0x80) && pCellnCell, pSpace, (int)(pOut-pSpace), + 0, pPage->pgno, &rc); + } + + /* Set the right-child pointer of pParent to point to the new page. */ + put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew); + + /* Release the reference to the new page. */ + releasePage(pNew); + } + + return rc; +} +#endif /* SQLITE_OMIT_QUICKBALANCE */ + +#if 0 +/* +** This function does not contribute anything to the operation of SQLite. +** it is sometimes activated temporarily while debugging code responsible +** for setting pointer-map entries. +*/ +static int ptrmapCheckPages(MemPage **apPage, int nPage){ + int i, j; + for(i=0; ipBt; + assert( pPage->isInit ); + + for(j=0; jnCell; j++){ + CellInfo info; + u8 *z; + + z = findCell(pPage, j); + pPage->xParseCell(pPage, z, &info); + if( info.nLocalpgno && e==PTRMAP_OVERFLOW1 ); + } + if( !pPage->leaf ){ + Pgno child = get4byte(z); + ptrmapGet(pBt, child, &e, &n); + assert( n==pPage->pgno && e==PTRMAP_BTREE ); + } + } + if( !pPage->leaf ){ + Pgno child = get4byte(&pPage->aData[pPage->hdrOffset+8]); + ptrmapGet(pBt, child, &e, &n); + assert( n==pPage->pgno && e==PTRMAP_BTREE ); + } + } + return 1; +} +#endif + +/* +** This function is used to copy the contents of the b-tree node stored +** on page pFrom to page pTo. If page pFrom was not a leaf page, then +** the pointer-map entries for each child page are updated so that the +** parent page stored in the pointer map is page pTo. If pFrom contained +** any cells with overflow page pointers, then the corresponding pointer +** map entries are also updated so that the parent page is page pTo. +** +** If pFrom is currently carrying any overflow cells (entries in the +** MemPage.apOvfl[] array), they are not copied to pTo. +** +** Before returning, page pTo is reinitialized using btreeInitPage(). +** +** The performance of this function is not critical. It is only used by +** the balance_shallower() and balance_deeper() procedures, neither of +** which are called often under normal circumstances. +*/ +static void copyNodeContent(MemPage *pFrom, MemPage *pTo, int *pRC){ + if( (*pRC)==SQLITE_OK ){ + BtShared * const pBt = pFrom->pBt; + u8 * const aFrom = pFrom->aData; + u8 * const aTo = pTo->aData; + int const iFromHdr = pFrom->hdrOffset; + int const iToHdr = ((pTo->pgno==1) ? 100 : 0); + int rc; + int iData; + + + assert( pFrom->isInit ); + assert( pFrom->nFree>=iToHdr ); + assert( get2byte(&aFrom[iFromHdr+5]) <= (int)pBt->usableSize ); + + /* Copy the b-tree node content from page pFrom to page pTo. */ + iData = get2byte(&aFrom[iFromHdr+5]); + memcpy(&aTo[iData], &aFrom[iData], pBt->usableSize-iData); + memcpy(&aTo[iToHdr], &aFrom[iFromHdr], pFrom->cellOffset + 2*pFrom->nCell); + + /* Reinitialize page pTo so that the contents of the MemPage structure + ** match the new data. The initialization of pTo can actually fail under + ** fairly obscure circumstances, even though it is a copy of initialized + ** page pFrom. + */ + pTo->isInit = 0; + rc = btreeInitPage(pTo); + if( rc==SQLITE_OK ) rc = btreeComputeFreeSpace(pTo); + if( rc!=SQLITE_OK ){ + *pRC = rc; + return; + } + + /* If this is an auto-vacuum database, update the pointer-map entries + ** for any b-tree or overflow pages that pTo now contains the pointers to. + */ + if( ISAUTOVACUUM ){ + *pRC = setChildPtrmaps(pTo); + } + } +} + +/* +** This routine redistributes cells on the iParentIdx'th child of pParent +** (hereafter "the page") and up to 2 siblings so that all pages have about the +** same amount of free space. Usually a single sibling on either side of the +** page are used in the balancing, though both siblings might come from one +** side if the page is the first or last child of its parent. If the page +** has fewer than 2 siblings (something which can only happen if the page +** is a root page or a child of a root page) then all available siblings +** participate in the balancing. +** +** The number of siblings of the page might be increased or decreased by +** one or two in an effort to keep pages nearly full but not over full. +** +** Note that when this routine is called, some of the cells on the page +** might not actually be stored in MemPage.aData[]. This can happen +** if the page is overfull. This routine ensures that all cells allocated +** to the page and its siblings fit into MemPage.aData[] before returning. +** +** In the course of balancing the page and its siblings, cells may be +** inserted into or removed from the parent page (pParent). Doing so +** may cause the parent page to become overfull or underfull. If this +** happens, it is the responsibility of the caller to invoke the correct +** balancing routine to fix this problem (see the balance() routine). +** +** If this routine fails for any reason, it might leave the database +** in a corrupted state. So if this routine fails, the database should +** be rolled back. +** +** The third argument to this function, aOvflSpace, is a pointer to a +** buffer big enough to hold one page. If while inserting cells into the parent +** page (pParent) the parent page becomes overfull, this buffer is +** used to store the parent's overflow cells. Because this function inserts +** a maximum of four divider cells into the parent page, and the maximum +** size of a cell stored within an internal node is always less than 1/4 +** of the page-size, the aOvflSpace[] buffer is guaranteed to be large +** enough for all overflow cells. +** +** If aOvflSpace is set to a null pointer, this function returns +** SQLITE_NOMEM. +*/ +static int balance_nonroot( + MemPage *pParent, /* Parent page of siblings being balanced */ + int iParentIdx, /* Index of "the page" in pParent */ + u8 *aOvflSpace, /* page-size bytes of space for parent ovfl */ + int isRoot, /* True if pParent is a root-page */ + int bBulk /* True if this call is part of a bulk load */ +){ + BtShared *pBt; /* The whole database */ + int nMaxCells = 0; /* Allocated size of apCell, szCell, aFrom. */ + int nNew = 0; /* Number of pages in apNew[] */ + int nOld; /* Number of pages in apOld[] */ + int i, j, k; /* Loop counters */ + int nxDiv; /* Next divider slot in pParent->aCell[] */ + int rc = SQLITE_OK; /* The return code */ + u16 leafCorrection; /* 4 if pPage is a leaf. 0 if not */ + int leafData; /* True if pPage is a leaf of a LEAFDATA tree */ + int usableSpace; /* Bytes in pPage beyond the header */ + int pageFlags; /* Value of pPage->aData[0] */ + int iSpace1 = 0; /* First unused byte of aSpace1[] */ + int iOvflSpace = 0; /* First unused byte of aOvflSpace[] */ + int szScratch; /* Size of scratch memory requested */ + MemPage *apOld[NB]; /* pPage and up to two siblings */ + MemPage *apNew[NB+2]; /* pPage and up to NB siblings after balancing */ + u8 *pRight; /* Location in parent of right-sibling pointer */ + u8 *apDiv[NB-1]; /* Divider cells in pParent */ + int cntNew[NB+2]; /* Index in b.paCell[] of cell after i-th page */ + int cntOld[NB+2]; /* Old index in b.apCell[] */ + int szNew[NB+2]; /* Combined size of cells placed on i-th page */ + u8 *aSpace1; /* Space for copies of dividers cells */ + Pgno pgno; /* Temp var to store a page number in */ + u8 abDone[NB+2]; /* True after i'th new page is populated */ + Pgno aPgno[NB+2]; /* Page numbers of new pages before shuffling */ + Pgno aPgOrder[NB+2]; /* Copy of aPgno[] used for sorting pages */ + u16 aPgFlags[NB+2]; /* flags field of new pages before shuffling */ + CellArray b; /* Parsed information on cells being balanced */ + + memset(abDone, 0, sizeof(abDone)); + b.nCell = 0; + b.apCell = 0; + pBt = pParent->pBt; + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( sqlite3PagerIswriteable(pParent->pDbPage) ); + + /* At this point pParent may have at most one overflow cell. And if + ** this overflow cell is present, it must be the cell with + ** index iParentIdx. This scenario comes about when this function + ** is called (indirectly) from sqlite3BtreeDelete(). + */ + assert( pParent->nOverflow==0 || pParent->nOverflow==1 ); + assert( pParent->nOverflow==0 || pParent->aiOvfl[0]==iParentIdx ); + + if( !aOvflSpace ){ + return SQLITE_NOMEM_BKPT; + } + assert( pParent->nFree>=0 ); + + /* Find the sibling pages to balance. Also locate the cells in pParent + ** that divide the siblings. An attempt is made to find NN siblings on + ** either side of pPage. More siblings are taken from one side, however, + ** if there are fewer than NN siblings on the other side. If pParent + ** has NB or fewer children then all children of pParent are taken. + ** + ** This loop also drops the divider cells from the parent page. This + ** way, the remainder of the function does not have to deal with any + ** overflow cells in the parent page, since if any existed they will + ** have already been removed. + */ + i = pParent->nOverflow + pParent->nCell; + if( i<2 ){ + nxDiv = 0; + }else{ + assert( bBulk==0 || bBulk==1 ); + if( iParentIdx==0 ){ + nxDiv = 0; + }else if( iParentIdx==i ){ + nxDiv = i-2+bBulk; + }else{ + nxDiv = iParentIdx-1; + } + i = 2-bBulk; + } + nOld = i+1; + if( (i+nxDiv-pParent->nOverflow)==pParent->nCell ){ + pRight = &pParent->aData[pParent->hdrOffset+8]; + }else{ + pRight = findCell(pParent, i+nxDiv-pParent->nOverflow); + } + pgno = get4byte(pRight); + while( 1 ){ + rc = getAndInitPage(pBt, pgno, &apOld[i], 0, 0); + if( rc ){ + memset(apOld, 0, (i+1)*sizeof(MemPage*)); + goto balance_cleanup; + } + if( apOld[i]->nFree<0 ){ + rc = btreeComputeFreeSpace(apOld[i]); + if( rc ){ + memset(apOld, 0, (i)*sizeof(MemPage*)); + goto balance_cleanup; + } + } + if( (i--)==0 ) break; + + if( pParent->nOverflow && i+nxDiv==pParent->aiOvfl[0] ){ + apDiv[i] = pParent->apOvfl[0]; + pgno = get4byte(apDiv[i]); + szNew[i] = pParent->xCellSize(pParent, apDiv[i]); + pParent->nOverflow = 0; + }else{ + apDiv[i] = findCell(pParent, i+nxDiv-pParent->nOverflow); + pgno = get4byte(apDiv[i]); + szNew[i] = pParent->xCellSize(pParent, apDiv[i]); + + /* Drop the cell from the parent page. apDiv[i] still points to + ** the cell within the parent, even though it has been dropped. + ** This is safe because dropping a cell only overwrites the first + ** four bytes of it, and this function does not need the first + ** four bytes of the divider cell. So the pointer is safe to use + ** later on. + ** + ** But not if we are in secure-delete mode. In secure-delete mode, + ** the dropCell() routine will overwrite the entire cell with zeroes. + ** In this case, temporarily copy the cell into the aOvflSpace[] + ** buffer. It will be copied out again as soon as the aSpace[] buffer + ** is allocated. */ + if( pBt->btsFlags & BTS_FAST_SECURE ){ + int iOff; + + iOff = SQLITE_PTR_TO_INT(apDiv[i]) - SQLITE_PTR_TO_INT(pParent->aData); + if( (iOff+szNew[i])>(int)pBt->usableSize ){ + rc = SQLITE_CORRUPT_BKPT; + memset(apOld, 0, (i+1)*sizeof(MemPage*)); + goto balance_cleanup; + }else{ + memcpy(&aOvflSpace[iOff], apDiv[i], szNew[i]); + apDiv[i] = &aOvflSpace[apDiv[i]-pParent->aData]; + } + } + dropCell(pParent, i+nxDiv-pParent->nOverflow, szNew[i], &rc); + } + } + + /* Make nMaxCells a multiple of 4 in order to preserve 8-byte + ** alignment */ + nMaxCells = nOld*(MX_CELL(pBt) + ArraySize(pParent->apOvfl)); + nMaxCells = (nMaxCells + 3)&~3; + + /* + ** Allocate space for memory structures + */ + szScratch = + nMaxCells*sizeof(u8*) /* b.apCell */ + + nMaxCells*sizeof(u16) /* b.szCell */ + + pBt->pageSize; /* aSpace1 */ + + assert( szScratch<=7*(int)pBt->pageSize ); + b.apCell = sqlite3StackAllocRaw(0, szScratch ); + if( b.apCell==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto balance_cleanup; + } + b.szCell = (u16*)&b.apCell[nMaxCells]; + aSpace1 = (u8*)&b.szCell[nMaxCells]; + assert( EIGHT_BYTE_ALIGNMENT(aSpace1) ); + + /* + ** Load pointers to all cells on sibling pages and the divider cells + ** into the local b.apCell[] array. Make copies of the divider cells + ** into space obtained from aSpace1[]. The divider cells have already + ** been removed from pParent. + ** + ** If the siblings are on leaf pages, then the child pointers of the + ** divider cells are stripped from the cells before they are copied + ** into aSpace1[]. In this way, all cells in b.apCell[] are without + ** child pointers. If siblings are not leaves, then all cell in + ** b.apCell[] include child pointers. Either way, all cells in b.apCell[] + ** are alike. + ** + ** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf. + ** leafData: 1 if pPage holds key+data and pParent holds only keys. + */ + b.pRef = apOld[0]; + leafCorrection = b.pRef->leaf*4; + leafData = b.pRef->intKeyLeaf; + for(i=0; inCell; + u8 *aData = pOld->aData; + u16 maskPage = pOld->maskPage; + u8 *piCell = aData + pOld->cellOffset; + u8 *piEnd; + VVA_ONLY( int nCellAtStart = b.nCell; ) + + /* Verify that all sibling pages are of the same "type" (table-leaf, + ** table-interior, index-leaf, or index-interior). + */ + if( pOld->aData[0]!=apOld[0]->aData[0] ){ + rc = SQLITE_CORRUPT_BKPT; + goto balance_cleanup; + } + + /* Load b.apCell[] with pointers to all cells in pOld. If pOld + ** contains overflow cells, include them in the b.apCell[] array + ** in the correct spot. + ** + ** Note that when there are multiple overflow cells, it is always the + ** case that they are sequential and adjacent. This invariant arises + ** because multiple overflows can only occurs when inserting divider + ** cells into a parent on a prior balance, and divider cells are always + ** adjacent and are inserted in order. There is an assert() tagged + ** with "NOTE 1" in the overflow cell insertion loop to prove this + ** invariant. + ** + ** This must be done in advance. Once the balance starts, the cell + ** offset section of the btree page will be overwritten and we will no + ** long be able to find the cells if a pointer to each cell is not saved + ** first. + */ + memset(&b.szCell[b.nCell], 0, sizeof(b.szCell[0])*(limit+pOld->nOverflow)); + if( pOld->nOverflow>0 ){ + if( NEVER(limitaiOvfl[0]) ){ + rc = SQLITE_CORRUPT_BKPT; + goto balance_cleanup; + } + limit = pOld->aiOvfl[0]; + for(j=0; jnOverflow; k++){ + assert( k==0 || pOld->aiOvfl[k-1]+1==pOld->aiOvfl[k] );/* NOTE 1 */ + b.apCell[b.nCell] = pOld->apOvfl[k]; + b.nCell++; + } + } + piEnd = aData + pOld->cellOffset + 2*pOld->nCell; + while( piCellnCell+pOld->nOverflow) ); + + cntOld[i] = b.nCell; + if( imaxLocal+23 ); + assert( iSpace1 <= (int)pBt->pageSize ); + memcpy(pTemp, apDiv[i], sz); + b.apCell[b.nCell] = pTemp+leafCorrection; + assert( leafCorrection==0 || leafCorrection==4 ); + b.szCell[b.nCell] = b.szCell[b.nCell] - leafCorrection; + if( !pOld->leaf ){ + assert( leafCorrection==0 ); + assert( pOld->hdrOffset==0 ); + /* The right pointer of the child page pOld becomes the left + ** pointer of the divider cell */ + memcpy(b.apCell[b.nCell], &pOld->aData[8], 4); + }else{ + assert( leafCorrection==4 ); + while( b.szCell[b.nCell]<4 ){ + /* Do not allow any cells smaller than 4 bytes. If a smaller cell + ** does exist, pad it with 0x00 bytes. */ + assert( b.szCell[b.nCell]==3 || CORRUPT_DB ); + assert( b.apCell[b.nCell]==&aSpace1[iSpace1-3] || CORRUPT_DB ); + aSpace1[iSpace1++] = 0x00; + b.szCell[b.nCell]++; + } + } + b.nCell++; + } + } + + /* + ** Figure out the number of pages needed to hold all b.nCell cells. + ** Store this number in "k". Also compute szNew[] which is the total + ** size of all cells on the i-th page and cntNew[] which is the index + ** in b.apCell[] of the cell that divides page i from page i+1. + ** cntNew[k] should equal b.nCell. + ** + ** Values computed by this block: + ** + ** k: The total number of sibling pages + ** szNew[i]: Spaced used on the i-th sibling page. + ** cntNew[i]: Index in b.apCell[] and b.szCell[] for the first cell to + ** the right of the i-th sibling page. + ** usableSpace: Number of bytes of space available on each sibling. + ** + */ + usableSpace = pBt->usableSize - 12 + leafCorrection; + for(i=k=0; iaDataEnd; + b.ixNx[k] = cntOld[i]; + if( k && b.ixNx[k]==b.ixNx[k-1] ){ + k--; /* Omit b.ixNx[] entry for child pages with no cells */ + } + if( !leafData ){ + k++; + b.apEnd[k] = pParent->aDataEnd; + b.ixNx[k] = cntOld[i]+1; + } + assert( p->nFree>=0 ); + szNew[i] = usableSpace - p->nFree; + for(j=0; jnOverflow; j++){ + szNew[i] += 2 + p->xCellSize(p, p->apOvfl[j]); + } + cntNew[i] = cntOld[i]; + } + k = nOld; + for(i=0; iusableSpace ){ + if( i+1>=k ){ + k = i+2; + if( k>NB+2 ){ rc = SQLITE_CORRUPT_BKPT; goto balance_cleanup; } + szNew[k-1] = 0; + cntNew[k-1] = b.nCell; + } + sz = 2 + cachedCellSize(&b, cntNew[i]-1); + szNew[i] -= sz; + if( !leafData ){ + if( cntNew[i]usableSpace ) break; + szNew[i] += sz; + cntNew[i]++; + if( !leafData ){ + if( cntNew[i]=b.nCell ){ + k = i+1; + }else if( cntNew[i] <= (i>0 ? cntNew[i-1] : 0) ){ + rc = SQLITE_CORRUPT_BKPT; + goto balance_cleanup; + } + } + + /* + ** The packing computed by the previous block is biased toward the siblings + ** on the left side (siblings with smaller keys). The left siblings are + ** always nearly full, while the right-most sibling might be nearly empty. + ** The next block of code attempts to adjust the packing of siblings to + ** get a better balance. + ** + ** This adjustment is more than an optimization. The packing above might + ** be so out of balance as to be illegal. For example, the right-most + ** sibling might be completely empty. This adjustment is not optional. + */ + for(i=k-1; i>0; i--){ + int szRight = szNew[i]; /* Size of sibling on the right */ + int szLeft = szNew[i-1]; /* Size of sibling on the left */ + int r; /* Index of right-most cell in left sibling */ + int d; /* Index of first cell to the left of right sibling */ + + r = cntNew[i-1] - 1; + d = r + 1 - leafData; + (void)cachedCellSize(&b, d); + do{ + assert( d szLeft-(b.szCell[r]+(i==k-1?0:2)))){ + break; + } + szRight += b.szCell[d] + 2; + szLeft -= b.szCell[r] + 2; + cntNew[i-1] = r; + r--; + d--; + }while( r>=0 ); + szNew[i] = szRight; + szNew[i-1] = szLeft; + if( cntNew[i-1] <= (i>1 ? cntNew[i-2] : 0) ){ + rc = SQLITE_CORRUPT_BKPT; + goto balance_cleanup; + } + } + + /* Sanity check: For a non-corrupt database file one of the follwing + ** must be true: + ** (1) We found one or more cells (cntNew[0])>0), or + ** (2) pPage is a virtual root page. A virtual root page is when + ** the real root page is page 1 and we are the only child of + ** that page. + */ + assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) || CORRUPT_DB); + TRACE(("BALANCE: old: %d(nc=%d) %d(nc=%d) %d(nc=%d)\n", + apOld[0]->pgno, apOld[0]->nCell, + nOld>=2 ? apOld[1]->pgno : 0, nOld>=2 ? apOld[1]->nCell : 0, + nOld>=3 ? apOld[2]->pgno : 0, nOld>=3 ? apOld[2]->nCell : 0 + )); + + /* + ** Allocate k new pages. Reuse old pages where possible. + */ + pageFlags = apOld[0]->aData[0]; + for(i=0; ipDbPage); + nNew++; + if( rc ) goto balance_cleanup; + }else{ + assert( i>0 ); + rc = allocateBtreePage(pBt, &pNew, &pgno, (bBulk ? 1 : pgno), 0); + if( rc ) goto balance_cleanup; + zeroPage(pNew, pageFlags); + apNew[i] = pNew; + nNew++; + cntOld[i] = b.nCell; + + /* Set the pointer-map entry for the new sibling page. */ + if( ISAUTOVACUUM ){ + ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc); + if( rc!=SQLITE_OK ){ + goto balance_cleanup; + } + } + } + } + + /* + ** Reassign page numbers so that the new pages are in ascending order. + ** This helps to keep entries in the disk file in order so that a scan + ** of the table is closer to a linear scan through the file. That in turn + ** helps the operating system to deliver pages from the disk more rapidly. + ** + ** An O(n^2) insertion sort algorithm is used, but since n is never more + ** than (NB+2) (a small constant), that should not be a problem. + ** + ** When NB==3, this one optimization makes the database about 25% faster + ** for large insertions and deletions. + */ + for(i=0; ipgno; + aPgFlags[i] = apNew[i]->pDbPage->flags; + for(j=0; ji ){ + sqlite3PagerRekey(apNew[iBest]->pDbPage, pBt->nPage+iBest+1, 0); + } + sqlite3PagerRekey(apNew[i]->pDbPage, pgno, aPgFlags[iBest]); + apNew[i]->pgno = pgno; + } + } + + TRACE(("BALANCE: new: %d(%d nc=%d) %d(%d nc=%d) %d(%d nc=%d) " + "%d(%d nc=%d) %d(%d nc=%d)\n", + apNew[0]->pgno, szNew[0], cntNew[0], + nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0, + nNew>=2 ? cntNew[1] - cntNew[0] - !leafData : 0, + nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0, + nNew>=3 ? cntNew[2] - cntNew[1] - !leafData : 0, + nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0, + nNew>=4 ? cntNew[3] - cntNew[2] - !leafData : 0, + nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0, + nNew>=5 ? cntNew[4] - cntNew[3] - !leafData : 0 + )); + + assert( sqlite3PagerIswriteable(pParent->pDbPage) ); + assert( nNew>=1 && nNew<=ArraySize(apNew) ); + assert( apNew[nNew-1]!=0 ); + put4byte(pRight, apNew[nNew-1]->pgno); + + /* If the sibling pages are not leaves, ensure that the right-child pointer + ** of the right-most new sibling page is set to the value that was + ** originally in the same field of the right-most old sibling page. */ + if( (pageFlags & PTF_LEAF)==0 && nOld!=nNew ){ + MemPage *pOld = (nNew>nOld ? apNew : apOld)[nOld-1]; + memcpy(&apNew[nNew-1]->aData[8], &pOld->aData[8], 4); + } + + /* Make any required updates to pointer map entries associated with + ** cells stored on sibling pages following the balance operation. Pointer + ** map entries associated with divider cells are set by the insertCell() + ** routine. The associated pointer map entries are: + ** + ** a) if the cell contains a reference to an overflow chain, the + ** entry associated with the first page in the overflow chain, and + ** + ** b) if the sibling pages are not leaves, the child page associated + ** with the cell. + ** + ** If the sibling pages are not leaves, then the pointer map entry + ** associated with the right-child of each sibling may also need to be + ** updated. This happens below, after the sibling pages have been + ** populated, not here. + */ + if( ISAUTOVACUUM ){ + MemPage *pOld; + MemPage *pNew = pOld = apNew[0]; + int cntOldNext = pNew->nCell + pNew->nOverflow; + int iNew = 0; + int iOld = 0; + + for(i=0; i=0 && iOldnCell + pOld->nOverflow + !leafData; + } + if( i==cntNew[iNew] ){ + pNew = apNew[++iNew]; + if( !leafData ) continue; + } + + /* Cell pCell is destined for new sibling page pNew. Originally, it + ** was either part of sibling page iOld (possibly an overflow cell), + ** or else the divider cell to the left of sibling page iOld. So, + ** if sibling page iOld had the same page number as pNew, and if + ** pCell really was a part of sibling page iOld (not a divider or + ** overflow cell), we can skip updating the pointer map entries. */ + if( iOld>=nNew + || pNew->pgno!=aPgno[iOld] + || !SQLITE_WITHIN(pCell,pOld->aData,pOld->aDataEnd) + ){ + if( !leafCorrection ){ + ptrmapPut(pBt, get4byte(pCell), PTRMAP_BTREE, pNew->pgno, &rc); + } + if( cachedCellSize(&b,i)>pNew->minLocal ){ + ptrmapPutOvflPtr(pNew, pOld, pCell, &rc); + } + if( rc ) goto balance_cleanup; + } + } + } + + /* Insert new divider cells into pParent. */ + for(i=0; ileaf ){ + memcpy(&pNew->aData[8], pCell, 4); + }else if( leafData ){ + /* If the tree is a leaf-data tree, and the siblings are leaves, + ** then there is no divider cell in b.apCell[]. Instead, the divider + ** cell consists of the integer key for the right-most cell of + ** the sibling-page assembled above only. + */ + CellInfo info; + j--; + pNew->xParseCell(pNew, b.apCell[j], &info); + pCell = pTemp; + sz = 4 + putVarint(&pCell[4], info.nKey); + pTemp = 0; + }else{ + pCell -= 4; + /* Obscure case for non-leaf-data trees: If the cell at pCell was + ** previously stored on a leaf node, and its reported size was 4 + ** bytes, then it may actually be smaller than this + ** (see btreeParseCellPtr(), 4 bytes is the minimum size of + ** any cell). But it is important to pass the correct size to + ** insertCell(), so reparse the cell now. + ** + ** This can only happen for b-trees used to evaluate "IN (SELECT ...)" + ** and WITHOUT ROWID tables with exactly one column which is the + ** primary key. + */ + if( b.szCell[j]==4 ){ + assert(leafCorrection==4); + sz = pParent->xCellSize(pParent, pCell); + } + } + iOvflSpace += sz; + assert( sz<=pBt->maxLocal+23 ); + assert( iOvflSpace <= (int)pBt->pageSize ); + insertCell(pParent, nxDiv+i, pCell, sz, pTemp, pNew->pgno, &rc); + if( rc!=SQLITE_OK ) goto balance_cleanup; + assert( sqlite3PagerIswriteable(pParent->pDbPage) ); + } + + /* Now update the actual sibling pages. The order in which they are updated + ** is important, as this code needs to avoid disrupting any page from which + ** cells may still to be read. In practice, this means: + ** + ** (1) If cells are moving left (from apNew[iPg] to apNew[iPg-1]) + ** then it is not safe to update page apNew[iPg] until after + ** the left-hand sibling apNew[iPg-1] has been updated. + ** + ** (2) If cells are moving right (from apNew[iPg] to apNew[iPg+1]) + ** then it is not safe to update page apNew[iPg] until after + ** the right-hand sibling apNew[iPg+1] has been updated. + ** + ** If neither of the above apply, the page is safe to update. + ** + ** The iPg value in the following loop starts at nNew-1 goes down + ** to 0, then back up to nNew-1 again, thus making two passes over + ** the pages. On the initial downward pass, only condition (1) above + ** needs to be tested because (2) will always be true from the previous + ** step. On the upward pass, both conditions are always true, so the + ** upwards pass simply processes pages that were missed on the downward + ** pass. + */ + for(i=1-nNew; i=0 && iPg=0 /* On the upwards pass, or... */ + || cntOld[iPg-1]>=cntNew[iPg-1] /* Condition (1) is true */ + ){ + int iNew; + int iOld; + int nNewCell; + + /* Verify condition (1): If cells are moving left, update iPg + ** only after iPg-1 has already been updated. */ + assert( iPg==0 || cntOld[iPg-1]>=cntNew[iPg-1] || abDone[iPg-1] ); + + /* Verify condition (2): If cells are moving right, update iPg + ** only after iPg+1 has already been updated. */ + assert( cntNew[iPg]>=cntOld[iPg] || abDone[iPg+1] ); + + if( iPg==0 ){ + iNew = iOld = 0; + nNewCell = cntNew[0]; + }else{ + iOld = iPgnFree = usableSpace-szNew[iPg]; + assert( apNew[iPg]->nOverflow==0 ); + assert( apNew[iPg]->nCell==nNewCell ); + } + } + + /* All pages have been processed exactly once */ + assert( memcmp(abDone, "\01\01\01\01\01", nNew)==0 ); + + assert( nOld>0 ); + assert( nNew>0 ); + + if( isRoot && pParent->nCell==0 && pParent->hdrOffset<=apNew[0]->nFree ){ + /* The root page of the b-tree now contains no cells. The only sibling + ** page is the right-child of the parent. Copy the contents of the + ** child page into the parent, decreasing the overall height of the + ** b-tree structure by one. This is described as the "balance-shallower" + ** sub-algorithm in some documentation. + ** + ** If this is an auto-vacuum database, the call to copyNodeContent() + ** sets all pointer-map entries corresponding to database image pages + ** for which the pointer is stored within the content being copied. + ** + ** It is critical that the child page be defragmented before being + ** copied into the parent, because if the parent is page 1 then it will + ** by smaller than the child due to the database header, and so all the + ** free space needs to be up front. + */ + assert( nNew==1 || CORRUPT_DB ); + rc = defragmentPage(apNew[0], -1); + testcase( rc!=SQLITE_OK ); + assert( apNew[0]->nFree == + (get2byteNotZero(&apNew[0]->aData[5]) - apNew[0]->cellOffset + - apNew[0]->nCell*2) + || rc!=SQLITE_OK + ); + copyNodeContent(apNew[0], pParent, &rc); + freePage(apNew[0], &rc); + }else if( ISAUTOVACUUM && !leafCorrection ){ + /* Fix the pointer map entries associated with the right-child of each + ** sibling page. All other pointer map entries have already been taken + ** care of. */ + for(i=0; iaData[8]); + ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc); + } + } + + assert( pParent->isInit ); + TRACE(("BALANCE: finished: old=%d new=%d cells=%d\n", + nOld, nNew, b.nCell)); + + /* Free any old pages that were not reused as new pages. + */ + for(i=nNew; iisInit ){ + /* The ptrmapCheckPages() contains assert() statements that verify that + ** all pointer map pages are set correctly. This is helpful while + ** debugging. This is usually disabled because a corrupt database may + ** cause an assert() statement to fail. */ + ptrmapCheckPages(apNew, nNew); + ptrmapCheckPages(&pParent, 1); + } +#endif + + /* + ** Cleanup before returning. + */ +balance_cleanup: + sqlite3StackFree(0, b.apCell); + for(i=0; ipBt; /* The BTree */ + + assert( pRoot->nOverflow>0 ); + assert( sqlite3_mutex_held(pBt->mutex) ); + + /* Make pRoot, the root page of the b-tree, writable. Allocate a new + ** page that will become the new right-child of pPage. Copy the contents + ** of the node stored on pRoot into the new child page. + */ + rc = sqlite3PagerWrite(pRoot->pDbPage); + if( rc==SQLITE_OK ){ + rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0); + copyNodeContent(pRoot, pChild, &rc); + if( ISAUTOVACUUM ){ + ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc); + } + } + if( rc ){ + *ppChild = 0; + releasePage(pChild); + return rc; + } + assert( sqlite3PagerIswriteable(pChild->pDbPage) ); + assert( sqlite3PagerIswriteable(pRoot->pDbPage) ); + assert( pChild->nCell==pRoot->nCell || CORRUPT_DB ); + + TRACE(("BALANCE: copy root %d into %d\n", pRoot->pgno, pChild->pgno)); + + /* Copy the overflow cells from pRoot to pChild */ + memcpy(pChild->aiOvfl, pRoot->aiOvfl, + pRoot->nOverflow*sizeof(pRoot->aiOvfl[0])); + memcpy(pChild->apOvfl, pRoot->apOvfl, + pRoot->nOverflow*sizeof(pRoot->apOvfl[0])); + pChild->nOverflow = pRoot->nOverflow; + + /* Zero the contents of pRoot. Then install pChild as the right-child. */ + zeroPage(pRoot, pChild->aData[0] & ~PTF_LEAF); + put4byte(&pRoot->aData[pRoot->hdrOffset+8], pgnoChild); + + *ppChild = pChild; + return SQLITE_OK; +} + +/* +** Return SQLITE_CORRUPT if any cursor other than pCur is currently valid +** on the same B-tree as pCur. +** +** This can if a database is corrupt with two or more SQL tables +** pointing to the same b-tree. If an insert occurs on one SQL table +** and causes a BEFORE TRIGGER to do a secondary insert on the other SQL +** table linked to the same b-tree. If the secondary insert causes a +** rebalance, that can change content out from under the cursor on the +** first SQL table, violating invariants on the first insert. +*/ +static int anotherValidCursor(BtCursor *pCur){ + BtCursor *pOther; + for(pOther=pCur->pBt->pCursor; pOther; pOther=pOther->pNext){ + if( pOther!=pCur + && pOther->eState==CURSOR_VALID + && pOther->pPage==pCur->pPage + ){ + return SQLITE_CORRUPT_BKPT; + } + } + return SQLITE_OK; +} + +/* +** The page that pCur currently points to has just been modified in +** some way. This function figures out if this modification means the +** tree needs to be balanced, and if so calls the appropriate balancing +** routine. Balancing routines are: +** +** balance_quick() +** balance_deeper() +** balance_nonroot() +*/ +static int balance(BtCursor *pCur){ + int rc = SQLITE_OK; + const int nMin = pCur->pBt->usableSize * 2 / 3; + u8 aBalanceQuickSpace[13]; + u8 *pFree = 0; + + VVA_ONLY( int balance_quick_called = 0 ); + VVA_ONLY( int balance_deeper_called = 0 ); + + do { + int iPage; + MemPage *pPage = pCur->pPage; + + if( NEVER(pPage->nFree<0) && btreeComputeFreeSpace(pPage) ) break; + if( pPage->nOverflow==0 && pPage->nFree<=nMin ){ + break; + }else if( (iPage = pCur->iPage)==0 ){ + if( pPage->nOverflow && (rc = anotherValidCursor(pCur))==SQLITE_OK ){ + /* The root page of the b-tree is overfull. In this case call the + ** balance_deeper() function to create a new child for the root-page + ** and copy the current contents of the root-page to it. The + ** next iteration of the do-loop will balance the child page. + */ + assert( balance_deeper_called==0 ); + VVA_ONLY( balance_deeper_called++ ); + rc = balance_deeper(pPage, &pCur->apPage[1]); + if( rc==SQLITE_OK ){ + pCur->iPage = 1; + pCur->ix = 0; + pCur->aiIdx[0] = 0; + pCur->apPage[0] = pPage; + pCur->pPage = pCur->apPage[1]; + assert( pCur->pPage->nOverflow ); + } + }else{ + break; + } + }else{ + MemPage * const pParent = pCur->apPage[iPage-1]; + int const iIdx = pCur->aiIdx[iPage-1]; + + rc = sqlite3PagerWrite(pParent->pDbPage); + if( rc==SQLITE_OK && pParent->nFree<0 ){ + rc = btreeComputeFreeSpace(pParent); + } + if( rc==SQLITE_OK ){ +#ifndef SQLITE_OMIT_QUICKBALANCE + if( pPage->intKeyLeaf + && pPage->nOverflow==1 + && pPage->aiOvfl[0]==pPage->nCell + && pParent->pgno!=1 + && pParent->nCell==iIdx + ){ + /* Call balance_quick() to create a new sibling of pPage on which + ** to store the overflow cell. balance_quick() inserts a new cell + ** into pParent, which may cause pParent overflow. If this + ** happens, the next iteration of the do-loop will balance pParent + ** use either balance_nonroot() or balance_deeper(). Until this + ** happens, the overflow cell is stored in the aBalanceQuickSpace[] + ** buffer. + ** + ** The purpose of the following assert() is to check that only a + ** single call to balance_quick() is made for each call to this + ** function. If this were not verified, a subtle bug involving reuse + ** of the aBalanceQuickSpace[] might sneak in. + */ + assert( balance_quick_called==0 ); + VVA_ONLY( balance_quick_called++ ); + rc = balance_quick(pParent, pPage, aBalanceQuickSpace); + }else +#endif + { + /* In this case, call balance_nonroot() to redistribute cells + ** between pPage and up to 2 of its sibling pages. This involves + ** modifying the contents of pParent, which may cause pParent to + ** become overfull or underfull. The next iteration of the do-loop + ** will balance the parent page to correct this. + ** + ** If the parent page becomes overfull, the overflow cell or cells + ** are stored in the pSpace buffer allocated immediately below. + ** A subsequent iteration of the do-loop will deal with this by + ** calling balance_nonroot() (balance_deeper() may be called first, + ** but it doesn't deal with overflow cells - just moves them to a + ** different page). Once this subsequent call to balance_nonroot() + ** has completed, it is safe to release the pSpace buffer used by + ** the previous call, as the overflow cell data will have been + ** copied either into the body of a database page or into the new + ** pSpace buffer passed to the latter call to balance_nonroot(). + */ + u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize); + rc = balance_nonroot(pParent, iIdx, pSpace, iPage==1, + pCur->hints&BTREE_BULKLOAD); + if( pFree ){ + /* If pFree is not NULL, it points to the pSpace buffer used + ** by a previous call to balance_nonroot(). Its contents are + ** now stored either on real database pages or within the + ** new pSpace buffer, so it may be safely freed here. */ + sqlite3PageFree(pFree); + } + + /* The pSpace buffer will be freed after the next call to + ** balance_nonroot(), or just before this function returns, whichever + ** comes first. */ + pFree = pSpace; + } + } + + pPage->nOverflow = 0; + + /* The next iteration of the do-loop balances the parent page. */ + releasePage(pPage); + pCur->iPage--; + assert( pCur->iPage>=0 ); + pCur->pPage = pCur->apPage[pCur->iPage]; + } + }while( rc==SQLITE_OK ); + + if( pFree ){ + sqlite3PageFree(pFree); + } + return rc; +} + +/* Overwrite content from pX into pDest. Only do the write if the +** content is different from what is already there. +*/ +static int btreeOverwriteContent( + MemPage *pPage, /* MemPage on which writing will occur */ + u8 *pDest, /* Pointer to the place to start writing */ + const BtreePayload *pX, /* Source of data to write */ + int iOffset, /* Offset of first byte to write */ + int iAmt /* Number of bytes to be written */ +){ + int nData = pX->nData - iOffset; + if( nData<=0 ){ + /* Overwritting with zeros */ + int i; + for(i=0; ipDbPage); + if( rc ) return rc; + memset(pDest + i, 0, iAmt - i); + } + }else{ + if( nDatapData) + iOffset, iAmt)!=0 ){ + int rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc ) return rc; + /* In a corrupt database, it is possible for the source and destination + ** buffers to overlap. This is harmless since the database is already + ** corrupt but it does cause valgrind and ASAN warnings. So use + ** memmove(). */ + memmove(pDest, ((u8*)pX->pData) + iOffset, iAmt); + } + } + return SQLITE_OK; +} + +/* +** Overwrite the cell that cursor pCur is pointing to with fresh content +** contained in pX. +*/ +static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){ + int iOffset; /* Next byte of pX->pData to write */ + int nTotal = pX->nData + pX->nZero; /* Total bytes of to write */ + int rc; /* Return code */ + MemPage *pPage = pCur->pPage; /* Page being written */ + BtShared *pBt; /* Btree */ + Pgno ovflPgno; /* Next overflow page to write */ + u32 ovflPageSize; /* Size to write on overflow page */ + + if( pCur->info.pPayload + pCur->info.nLocal > pPage->aDataEnd + || pCur->info.pPayload < pPage->aData + pPage->cellOffset + ){ + return SQLITE_CORRUPT_BKPT; + } + /* Overwrite the local portion first */ + rc = btreeOverwriteContent(pPage, pCur->info.pPayload, pX, + 0, pCur->info.nLocal); + if( rc ) return rc; + if( pCur->info.nLocal==nTotal ) return SQLITE_OK; + + /* Now overwrite the overflow pages */ + iOffset = pCur->info.nLocal; + assert( nTotal>=0 ); + assert( iOffset>=0 ); + ovflPgno = get4byte(pCur->info.pPayload + iOffset); + pBt = pPage->pBt; + ovflPageSize = pBt->usableSize - 4; + do{ + rc = btreeGetPage(pBt, ovflPgno, &pPage, 0); + if( rc ) return rc; + if( sqlite3PagerPageRefcount(pPage->pDbPage)!=1 ){ + rc = SQLITE_CORRUPT_BKPT; + }else{ + if( iOffset+ovflPageSize<(u32)nTotal ){ + ovflPgno = get4byte(pPage->aData); + }else{ + ovflPageSize = nTotal - iOffset; + } + rc = btreeOverwriteContent(pPage, pPage->aData+4, pX, + iOffset, ovflPageSize); + } + sqlite3PagerUnref(pPage->pDbPage); + if( rc ) return rc; + iOffset += ovflPageSize; + }while( iOffset0 then pCur points to a cell +** that is larger than (pKey,nKey). +** +** If seekResult==0, that means pCur is pointing at some unknown location. +** In that case, this routine must seek the cursor to the correct insertion +** point for (pKey,nKey) before doing the insertion. For index btrees, +** if pX->nMem is non-zero, then pX->aMem contains pointers to the unpacked +** key values and pX->aMem can be used instead of pX->pKey to avoid having +** to decode the key. +*/ +SQLITE_PRIVATE int sqlite3BtreeInsert( + BtCursor *pCur, /* Insert data into the table of this cursor */ + const BtreePayload *pX, /* Content of the row to be inserted */ + int flags, /* True if this is likely an append */ + int seekResult /* Result of prior MovetoUnpacked() call */ +){ + int rc; + int loc = seekResult; /* -1: before desired location +1: after */ + int szNew = 0; + int idx; + MemPage *pPage; + Btree *p = pCur->pBtree; + BtShared *pBt = p->pBt; + unsigned char *oldCell; + unsigned char *newCell = 0; + + assert( (flags & (BTREE_SAVEPOSITION|BTREE_APPEND))==flags ); + + if( pCur->eState==CURSOR_FAULT ){ + assert( pCur->skipNext!=SQLITE_OK ); + return pCur->skipNext; + } + + assert( cursorOwnsBtShared(pCur) ); + assert( (pCur->curFlags & BTCF_WriteFlag)!=0 + && pBt->inTransaction==TRANS_WRITE + && (pBt->btsFlags & BTS_READ_ONLY)==0 ); + assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) ); + + /* Assert that the caller has been consistent. If this cursor was opened + ** expecting an index b-tree, then the caller should be inserting blob + ** keys with no associated data. If the cursor was opened expecting an + ** intkey table, the caller should be inserting integer keys with a + ** blob of associated data. */ + assert( (pX->pKey==0)==(pCur->pKeyInfo==0) ); + + /* Save the positions of any other cursors open on this table. + ** + ** In some cases, the call to btreeMoveto() below is a no-op. For + ** example, when inserting data into a table with auto-generated integer + ** keys, the VDBE layer invokes sqlite3BtreeLast() to figure out the + ** integer key to use. It then calls this function to actually insert the + ** data into the intkey B-Tree. In this case btreeMoveto() recognizes + ** that the cursor is already where it needs to be and returns without + ** doing any work. To avoid thwarting these optimizations, it is important + ** not to clear the cursor here. + */ + if( pCur->curFlags & BTCF_Multiple ){ + rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur); + if( rc ) return rc; + } + + if( pCur->pKeyInfo==0 ){ + assert( pX->pKey==0 ); + /* If this is an insert into a table b-tree, invalidate any incrblob + ** cursors open on the row being replaced */ + invalidateIncrblobCursors(p, pCur->pgnoRoot, pX->nKey, 0); + + /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing + ** to a row with the same key as the new entry being inserted. + */ +#ifdef SQLITE_DEBUG + if( flags & BTREE_SAVEPOSITION ){ + assert( pCur->curFlags & BTCF_ValidNKey ); + assert( pX->nKey==pCur->info.nKey ); + assert( loc==0 ); + } +#endif + + /* On the other hand, BTREE_SAVEPOSITION==0 does not imply + ** that the cursor is not pointing to a row to be overwritten. + ** So do a complete check. + */ + if( (pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey ){ + /* The cursor is pointing to the entry that is to be + ** overwritten */ + assert( pX->nData>=0 && pX->nZero>=0 ); + if( pCur->info.nSize!=0 + && pCur->info.nPayload==(u32)pX->nData+pX->nZero + ){ + /* New entry is the same size as the old. Do an overwrite */ + return btreeOverwriteCell(pCur, pX); + } + assert( loc==0 ); + }else if( loc==0 ){ + /* The cursor is *not* pointing to the cell to be overwritten, nor + ** to an adjacent cell. Move the cursor so that it is pointing either + ** to the cell to be overwritten or an adjacent cell. + */ + rc = sqlite3BtreeMovetoUnpacked(pCur, 0, pX->nKey, flags!=0, &loc); + if( rc ) return rc; + } + }else{ + /* This is an index or a WITHOUT ROWID table */ + + /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing + ** to a row with the same key as the new entry being inserted. + */ + assert( (flags & BTREE_SAVEPOSITION)==0 || loc==0 ); + + /* If the cursor is not already pointing either to the cell to be + ** overwritten, or if a new cell is being inserted, if the cursor is + ** not pointing to an immediately adjacent cell, then move the cursor + ** so that it does. + */ + if( loc==0 && (flags & BTREE_SAVEPOSITION)==0 ){ + if( pX->nMem ){ + UnpackedRecord r; + r.pKeyInfo = pCur->pKeyInfo; + r.aMem = pX->aMem; + r.nField = pX->nMem; + r.default_rc = 0; + r.errCode = 0; + r.r1 = 0; + r.r2 = 0; + r.eqSeen = 0; + rc = sqlite3BtreeMovetoUnpacked(pCur, &r, 0, flags!=0, &loc); + }else{ + rc = btreeMoveto(pCur, pX->pKey, pX->nKey, flags!=0, &loc); + } + if( rc ) return rc; + } + + /* If the cursor is currently pointing to an entry to be overwritten + ** and the new content is the same as as the old, then use the + ** overwrite optimization. + */ + if( loc==0 ){ + getCellInfo(pCur); + if( pCur->info.nKey==pX->nKey ){ + BtreePayload x2; + x2.pData = pX->pKey; + x2.nData = pX->nKey; + x2.nZero = 0; + return btreeOverwriteCell(pCur, &x2); + } + } + + } + assert( pCur->eState==CURSOR_VALID + || (pCur->eState==CURSOR_INVALID && loc) + || CORRUPT_DB ); + + pPage = pCur->pPage; + assert( pPage->intKey || pX->nKey>=0 ); + assert( pPage->leaf || !pPage->intKey ); + if( pPage->nFree<0 ){ + if( pCur->eState>CURSOR_INVALID ){ + rc = SQLITE_CORRUPT_BKPT; + }else{ + rc = btreeComputeFreeSpace(pPage); + } + if( rc ) return rc; + } + + TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n", + pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno, + loc==0 ? "overwrite" : "new entry")); + assert( pPage->isInit ); + newCell = pBt->pTmpSpace; + assert( newCell!=0 ); + rc = fillInCell(pPage, newCell, pX, &szNew); + if( rc ) goto end_insert; + assert( szNew==pPage->xCellSize(pPage, newCell) ); + assert( szNew <= MX_CELL_SIZE(pBt) ); + idx = pCur->ix; + if( loc==0 ){ + CellInfo info; + assert( idxnCell ); + rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc ){ + goto end_insert; + } + oldCell = findCell(pPage, idx); + if( !pPage->leaf ){ + memcpy(newCell, oldCell, 4); + } + rc = clearCell(pPage, oldCell, &info); + testcase( pCur->curFlags & BTCF_ValidOvfl ); + invalidateOverflowCache(pCur); + if( info.nSize==szNew && info.nLocal==info.nPayload + && (!ISAUTOVACUUM || szNewminLocal) + ){ + /* Overwrite the old cell with the new if they are the same size. + ** We could also try to do this if the old cell is smaller, then add + ** the leftover space to the free list. But experiments show that + ** doing that is no faster then skipping this optimization and just + ** calling dropCell() and insertCell(). + ** + ** This optimization cannot be used on an autovacuum database if the + ** new entry uses overflow pages, as the insertCell() call below is + ** necessary to add the PTRMAP_OVERFLOW1 pointer-map entry. */ + assert( rc==SQLITE_OK ); /* clearCell never fails when nLocal==nPayload */ + if( oldCell < pPage->aData+pPage->hdrOffset+10 ){ + return SQLITE_CORRUPT_BKPT; + } + if( oldCell+szNew > pPage->aDataEnd ){ + return SQLITE_CORRUPT_BKPT; + } + memcpy(oldCell, newCell, szNew); + return SQLITE_OK; + } + dropCell(pPage, idx, info.nSize, &rc); + if( rc ) goto end_insert; + }else if( loc<0 && pPage->nCell>0 ){ + assert( pPage->leaf ); + idx = ++pCur->ix; + pCur->curFlags &= ~BTCF_ValidNKey; + }else{ + assert( pPage->leaf ); + } + insertCell(pPage, idx, newCell, szNew, 0, 0, &rc); + assert( pPage->nOverflow==0 || rc==SQLITE_OK ); + assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 ); + + /* If no error has occurred and pPage has an overflow cell, call balance() + ** to redistribute the cells within the tree. Since balance() may move + ** the cursor, zero the BtCursor.info.nSize and BTCF_ValidNKey + ** variables. + ** + ** Previous versions of SQLite called moveToRoot() to move the cursor + ** back to the root page as balance() used to invalidate the contents + ** of BtCursor.apPage[] and BtCursor.aiIdx[]. Instead of doing that, + ** set the cursor state to "invalid". This makes common insert operations + ** slightly faster. + ** + ** There is a subtle but important optimization here too. When inserting + ** multiple records into an intkey b-tree using a single cursor (as can + ** happen while processing an "INSERT INTO ... SELECT" statement), it + ** is advantageous to leave the cursor pointing to the last entry in + ** the b-tree if possible. If the cursor is left pointing to the last + ** entry in the table, and the next row inserted has an integer key + ** larger than the largest existing key, it is possible to insert the + ** row without seeking the cursor. This can be a big performance boost. + */ + pCur->info.nSize = 0; + if( pPage->nOverflow ){ + assert( rc==SQLITE_OK ); + pCur->curFlags &= ~(BTCF_ValidNKey); + rc = balance(pCur); + + /* Must make sure nOverflow is reset to zero even if the balance() + ** fails. Internal data structure corruption will result otherwise. + ** Also, set the cursor state to invalid. This stops saveCursorPosition() + ** from trying to save the current position of the cursor. */ + pCur->pPage->nOverflow = 0; + pCur->eState = CURSOR_INVALID; + if( (flags & BTREE_SAVEPOSITION) && rc==SQLITE_OK ){ + btreeReleaseAllCursorPages(pCur); + if( pCur->pKeyInfo ){ + assert( pCur->pKey==0 ); + pCur->pKey = sqlite3Malloc( pX->nKey ); + if( pCur->pKey==0 ){ + rc = SQLITE_NOMEM; + }else{ + memcpy(pCur->pKey, pX->pKey, pX->nKey); + } + } + pCur->eState = CURSOR_REQUIRESEEK; + pCur->nKey = pX->nKey; + } + } + assert( pCur->iPage<0 || pCur->pPage->nOverflow==0 ); + +end_insert: + return rc; +} + +/* +** Delete the entry that the cursor is pointing to. +** +** If the BTREE_SAVEPOSITION bit of the flags parameter is zero, then +** the cursor is left pointing at an arbitrary location after the delete. +** But if that bit is set, then the cursor is left in a state such that +** the next call to BtreeNext() or BtreePrev() moves it to the same row +** as it would have been on if the call to BtreeDelete() had been omitted. +** +** The BTREE_AUXDELETE bit of flags indicates that is one of several deletes +** associated with a single table entry and its indexes. Only one of those +** deletes is considered the "primary" delete. The primary delete occurs +** on a cursor that is not a BTREE_FORDELETE cursor. All but one delete +** operation on non-FORDELETE cursors is tagged with the AUXDELETE flag. +** The BTREE_AUXDELETE bit is a hint that is not used by this implementation, +** but which might be used by alternative storage engines. +*/ +SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){ + Btree *p = pCur->pBtree; + BtShared *pBt = p->pBt; + int rc; /* Return code */ + MemPage *pPage; /* Page to delete cell from */ + unsigned char *pCell; /* Pointer to cell to delete */ + int iCellIdx; /* Index of cell to delete */ + int iCellDepth; /* Depth of node containing pCell */ + CellInfo info; /* Size of the cell being deleted */ + int bSkipnext = 0; /* Leaf cursor in SKIPNEXT state */ + u8 bPreserve = flags & BTREE_SAVEPOSITION; /* Keep cursor valid */ + + assert( cursorOwnsBtShared(pCur) ); + assert( pBt->inTransaction==TRANS_WRITE ); + assert( (pBt->btsFlags & BTS_READ_ONLY)==0 ); + assert( pCur->curFlags & BTCF_WriteFlag ); + assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) ); + assert( !hasReadConflicts(p, pCur->pgnoRoot) ); + assert( (flags & ~(BTREE_SAVEPOSITION | BTREE_AUXDELETE))==0 ); + if( pCur->eState==CURSOR_REQUIRESEEK ){ + rc = btreeRestoreCursorPosition(pCur); + if( rc ) return rc; + } + assert( pCur->eState==CURSOR_VALID ); + + iCellDepth = pCur->iPage; + iCellIdx = pCur->ix; + pPage = pCur->pPage; + pCell = findCell(pPage, iCellIdx); + if( pPage->nFree<0 && btreeComputeFreeSpace(pPage) ) return SQLITE_CORRUPT; + + /* If the bPreserve flag is set to true, then the cursor position must + ** be preserved following this delete operation. If the current delete + ** will cause a b-tree rebalance, then this is done by saving the cursor + ** key and leaving the cursor in CURSOR_REQUIRESEEK state before + ** returning. + ** + ** Or, if the current delete will not cause a rebalance, then the cursor + ** will be left in CURSOR_SKIPNEXT state pointing to the entry immediately + ** before or after the deleted entry. In this case set bSkipnext to true. */ + if( bPreserve ){ + if( !pPage->leaf + || (pPage->nFree+cellSizePtr(pPage,pCell)+2)>(int)(pBt->usableSize*2/3) + || pPage->nCell==1 /* See dbfuzz001.test for a test case */ + ){ + /* A b-tree rebalance will be required after deleting this entry. + ** Save the cursor key. */ + rc = saveCursorKey(pCur); + if( rc ) return rc; + }else{ + bSkipnext = 1; + } + } + + /* If the page containing the entry to delete is not a leaf page, move + ** the cursor to the largest entry in the tree that is smaller than + ** the entry being deleted. This cell will replace the cell being deleted + ** from the internal node. The 'previous' entry is used for this instead + ** of the 'next' entry, as the previous entry is always a part of the + ** sub-tree headed by the child page of the cell being deleted. This makes + ** balancing the tree following the delete operation easier. */ + if( !pPage->leaf ){ + rc = sqlite3BtreePrevious(pCur, 0); + assert( rc!=SQLITE_DONE ); + if( rc ) return rc; + } + + /* Save the positions of any other cursors open on this table before + ** making any modifications. */ + if( pCur->curFlags & BTCF_Multiple ){ + rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur); + if( rc ) return rc; + } + + /* If this is a delete operation to remove a row from a table b-tree, + ** invalidate any incrblob cursors open on the row being deleted. */ + if( pCur->pKeyInfo==0 ){ + invalidateIncrblobCursors(p, pCur->pgnoRoot, pCur->info.nKey, 0); + } + + /* Make the page containing the entry to be deleted writable. Then free any + ** overflow pages associated with the entry and finally remove the cell + ** itself from within the page. */ + rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc ) return rc; + rc = clearCell(pPage, pCell, &info); + dropCell(pPage, iCellIdx, info.nSize, &rc); + if( rc ) return rc; + + /* If the cell deleted was not located on a leaf page, then the cursor + ** is currently pointing to the largest entry in the sub-tree headed + ** by the child-page of the cell that was just deleted from an internal + ** node. The cell from the leaf node needs to be moved to the internal + ** node to replace the deleted cell. */ + if( !pPage->leaf ){ + MemPage *pLeaf = pCur->pPage; + int nCell; + Pgno n; + unsigned char *pTmp; + + if( pLeaf->nFree<0 ){ + rc = btreeComputeFreeSpace(pLeaf); + if( rc ) return rc; + } + if( iCellDepthiPage-1 ){ + n = pCur->apPage[iCellDepth+1]->pgno; + }else{ + n = pCur->pPage->pgno; + } + pCell = findCell(pLeaf, pLeaf->nCell-1); + if( pCell<&pLeaf->aData[4] ) return SQLITE_CORRUPT_BKPT; + nCell = pLeaf->xCellSize(pLeaf, pCell); + assert( MX_CELL_SIZE(pBt) >= nCell ); + pTmp = pBt->pTmpSpace; + assert( pTmp!=0 ); + rc = sqlite3PagerWrite(pLeaf->pDbPage); + if( rc==SQLITE_OK ){ + insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc); + } + dropCell(pLeaf, pLeaf->nCell-1, nCell, &rc); + if( rc ) return rc; + } + + /* Balance the tree. If the entry deleted was located on a leaf page, + ** then the cursor still points to that page. In this case the first + ** call to balance() repairs the tree, and the if(...) condition is + ** never true. + ** + ** Otherwise, if the entry deleted was on an internal node page, then + ** pCur is pointing to the leaf page from which a cell was removed to + ** replace the cell deleted from the internal node. This is slightly + ** tricky as the leaf node may be underfull, and the internal node may + ** be either under or overfull. In this case run the balancing algorithm + ** on the leaf node first. If the balance proceeds far enough up the + ** tree that we can be sure that any problem in the internal node has + ** been corrected, so be it. Otherwise, after balancing the leaf node, + ** walk the cursor up the tree to the internal node and balance it as + ** well. */ + rc = balance(pCur); + if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){ + releasePageNotNull(pCur->pPage); + pCur->iPage--; + while( pCur->iPage>iCellDepth ){ + releasePage(pCur->apPage[pCur->iPage--]); + } + pCur->pPage = pCur->apPage[pCur->iPage]; + rc = balance(pCur); + } + + if( rc==SQLITE_OK ){ + if( bSkipnext ){ + assert( bPreserve && (pCur->iPage==iCellDepth || CORRUPT_DB) ); + assert( pPage==pCur->pPage || CORRUPT_DB ); + assert( (pPage->nCell>0 || CORRUPT_DB) && iCellIdx<=pPage->nCell ); + pCur->eState = CURSOR_SKIPNEXT; + if( iCellIdx>=pPage->nCell ){ + pCur->skipNext = -1; + pCur->ix = pPage->nCell-1; + }else{ + pCur->skipNext = 1; + } + }else{ + rc = moveToRoot(pCur); + if( bPreserve ){ + btreeReleaseAllCursorPages(pCur); + pCur->eState = CURSOR_REQUIRESEEK; + } + if( rc==SQLITE_EMPTY ) rc = SQLITE_OK; + } + } + return rc; +} + +/* +** Create a new BTree table. Write into *piTable the page +** number for the root page of the new table. +** +** The type of type is determined by the flags parameter. Only the +** following values of flags are currently in use. Other values for +** flags might not work: +** +** BTREE_INTKEY|BTREE_LEAFDATA Used for SQL tables with rowid keys +** BTREE_ZERODATA Used for SQL indices +*/ +static int btreeCreateTable(Btree *p, Pgno *piTable, int createTabFlags){ + BtShared *pBt = p->pBt; + MemPage *pRoot; + Pgno pgnoRoot; + int rc; + int ptfFlags; /* Page-type flage for the root page of new table */ + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( pBt->inTransaction==TRANS_WRITE ); + assert( (pBt->btsFlags & BTS_READ_ONLY)==0 ); + +#ifdef SQLITE_OMIT_AUTOVACUUM + rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0); + if( rc ){ + return rc; + } +#else + if( pBt->autoVacuum ){ + Pgno pgnoMove; /* Move a page here to make room for the root-page */ + MemPage *pPageMove; /* The page to move to. */ + + /* Creating a new table may probably require moving an existing database + ** to make room for the new tables root page. In case this page turns + ** out to be an overflow page, delete all overflow page-map caches + ** held by open cursors. + */ + invalidateAllOverflowCache(pBt); + + /* Read the value of meta[3] from the database to determine where the + ** root page of the new table should go. meta[3] is the largest root-page + ** created so far, so the new root-page is (meta[3]+1). + */ + sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &pgnoRoot); + if( pgnoRoot>btreePagecount(pBt) ){ + return SQLITE_CORRUPT_BKPT; + } + pgnoRoot++; + + /* The new root-page may not be allocated on a pointer-map page, or the + ** PENDING_BYTE page. + */ + while( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) || + pgnoRoot==PENDING_BYTE_PAGE(pBt) ){ + pgnoRoot++; + } + assert( pgnoRoot>=3 ); + + /* Allocate a page. The page that currently resides at pgnoRoot will + ** be moved to the allocated page (unless the allocated page happens + ** to reside at pgnoRoot). + */ + rc = allocateBtreePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, BTALLOC_EXACT); + if( rc!=SQLITE_OK ){ + return rc; + } + + if( pgnoMove!=pgnoRoot ){ + /* pgnoRoot is the page that will be used for the root-page of + ** the new table (assuming an error did not occur). But we were + ** allocated pgnoMove. If required (i.e. if it was not allocated + ** by extending the file), the current page at position pgnoMove + ** is already journaled. + */ + u8 eType = 0; + Pgno iPtrPage = 0; + + /* Save the positions of any open cursors. This is required in + ** case they are holding a reference to an xFetch reference + ** corresponding to page pgnoRoot. */ + rc = saveAllCursors(pBt, 0, 0); + releasePage(pPageMove); + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Move the page currently at pgnoRoot to pgnoMove. */ + rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage); + if( eType==PTRMAP_ROOTPAGE || eType==PTRMAP_FREEPAGE ){ + rc = SQLITE_CORRUPT_BKPT; + } + if( rc!=SQLITE_OK ){ + releasePage(pRoot); + return rc; + } + assert( eType!=PTRMAP_ROOTPAGE ); + assert( eType!=PTRMAP_FREEPAGE ); + rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove, 0); + releasePage(pRoot); + + /* Obtain the page at pgnoRoot */ + if( rc!=SQLITE_OK ){ + return rc; + } + rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = sqlite3PagerWrite(pRoot->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(pRoot); + return rc; + } + }else{ + pRoot = pPageMove; + } + + /* Update the pointer-map and meta-data with the new root-page number. */ + ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0, &rc); + if( rc ){ + releasePage(pRoot); + return rc; + } + + /* When the new root page was allocated, page 1 was made writable in + ** order either to increase the database filesize, or to decrement the + ** freelist count. Hence, the sqlite3BtreeUpdateMeta() call cannot fail. + */ + assert( sqlite3PagerIswriteable(pBt->pPage1->pDbPage) ); + rc = sqlite3BtreeUpdateMeta(p, 4, pgnoRoot); + if( NEVER(rc) ){ + releasePage(pRoot); + return rc; + } + + }else{ + rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0); + if( rc ) return rc; + } +#endif + assert( sqlite3PagerIswriteable(pRoot->pDbPage) ); + if( createTabFlags & BTREE_INTKEY ){ + ptfFlags = PTF_INTKEY | PTF_LEAFDATA | PTF_LEAF; + }else{ + ptfFlags = PTF_ZERODATA | PTF_LEAF; + } + zeroPage(pRoot, ptfFlags); + sqlite3PagerUnref(pRoot->pDbPage); + assert( (pBt->openFlags & BTREE_SINGLE)==0 || pgnoRoot==2 ); + *piTable = pgnoRoot; + return SQLITE_OK; +} +SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree *p, Pgno *piTable, int flags){ + int rc; + sqlite3BtreeEnter(p); + rc = btreeCreateTable(p, piTable, flags); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Erase the given database page and all its children. Return +** the page to the freelist. +*/ +static int clearDatabasePage( + BtShared *pBt, /* The BTree that contains the table */ + Pgno pgno, /* Page number to clear */ + int freePageFlag, /* Deallocate page if true */ + int *pnChange /* Add number of Cells freed to this counter */ +){ + MemPage *pPage; + int rc; + unsigned char *pCell; + int i; + int hdr; + CellInfo info; + + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pgno>btreePagecount(pBt) ){ + return SQLITE_CORRUPT_BKPT; + } + rc = getAndInitPage(pBt, pgno, &pPage, 0, 0); + if( rc ) return rc; + if( pPage->bBusy ){ + rc = SQLITE_CORRUPT_BKPT; + goto cleardatabasepage_out; + } + pPage->bBusy = 1; + hdr = pPage->hdrOffset; + for(i=0; inCell; i++){ + pCell = findCell(pPage, i); + if( !pPage->leaf ){ + rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange); + if( rc ) goto cleardatabasepage_out; + } + rc = clearCell(pPage, pCell, &info); + if( rc ) goto cleardatabasepage_out; + } + if( !pPage->leaf ){ + rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange); + if( rc ) goto cleardatabasepage_out; + }else if( pnChange ){ + assert( pPage->intKey || CORRUPT_DB ); + testcase( !pPage->intKey ); + *pnChange += pPage->nCell; + } + if( freePageFlag ){ + freePage(pPage, &rc); + }else if( (rc = sqlite3PagerWrite(pPage->pDbPage))==0 ){ + zeroPage(pPage, pPage->aData[hdr] | PTF_LEAF); + } + +cleardatabasepage_out: + pPage->bBusy = 0; + releasePage(pPage); + return rc; +} + +/* +** Delete all information from a single table in the database. iTable is +** the page number of the root of the table. After this routine returns, +** the root page is empty, but still exists. +** +** This routine will fail with SQLITE_LOCKED if there are any open +** read cursors on the table. Open write cursors are moved to the +** root of the table. +** +** If pnChange is not NULL, then table iTable must be an intkey table. The +** integer value pointed to by pnChange is incremented by the number of +** entries in the table. +*/ +SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree *p, int iTable, int *pnChange){ + int rc; + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + assert( p->inTrans==TRANS_WRITE ); + + rc = saveAllCursors(pBt, (Pgno)iTable, 0); + + if( SQLITE_OK==rc ){ + /* Invalidate all incrblob cursors open on table iTable (assuming iTable + ** is the root of a table b-tree - if it is not, the following call is + ** a no-op). */ + invalidateIncrblobCursors(p, (Pgno)iTable, 0, 1); + rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange); + } + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Delete all information from the single table that pCur is open on. +** +** This routine only work for pCur on an ephemeral table. +*/ +SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor *pCur){ + return sqlite3BtreeClearTable(pCur->pBtree, pCur->pgnoRoot, 0); +} + +/* +** Erase all information in a table and add the root of the table to +** the freelist. Except, the root of the principle table (the one on +** page 1) is never added to the freelist. +** +** This routine will fail with SQLITE_LOCKED if there are any open +** cursors on the table. +** +** If AUTOVACUUM is enabled and the page at iTable is not the last +** root page in the database file, then the last root page +** in the database file is moved into the slot formerly occupied by +** iTable and that last slot formerly occupied by the last root page +** is added to the freelist instead of iTable. In this say, all +** root pages are kept at the beginning of the database file, which +** is necessary for AUTOVACUUM to work right. *piMoved is set to the +** page number that used to be the last root page in the file before +** the move. If no page gets moved, *piMoved is set to 0. +** The last root page is recorded in meta[3] and the value of +** meta[3] is updated by this procedure. +*/ +static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){ + int rc; + MemPage *pPage = 0; + BtShared *pBt = p->pBt; + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( p->inTrans==TRANS_WRITE ); + assert( iTable>=2 ); + if( iTable>btreePagecount(pBt) ){ + return SQLITE_CORRUPT_BKPT; + } + + rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0); + if( rc ) return rc; + rc = sqlite3BtreeClearTable(p, iTable, 0); + if( rc ){ + releasePage(pPage); + return rc; + } + + *piMoved = 0; + +#ifdef SQLITE_OMIT_AUTOVACUUM + freePage(pPage, &rc); + releasePage(pPage); +#else + if( pBt->autoVacuum ){ + Pgno maxRootPgno; + sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &maxRootPgno); + + if( iTable==maxRootPgno ){ + /* If the table being dropped is the table with the largest root-page + ** number in the database, put the root page on the free list. + */ + freePage(pPage, &rc); + releasePage(pPage); + if( rc!=SQLITE_OK ){ + return rc; + } + }else{ + /* The table being dropped does not have the largest root-page + ** number in the database. So move the page that does into the + ** gap left by the deleted root-page. + */ + MemPage *pMove; + releasePage(pPage); + rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable, 0); + releasePage(pMove); + if( rc!=SQLITE_OK ){ + return rc; + } + pMove = 0; + rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0); + freePage(pMove, &rc); + releasePage(pMove); + if( rc!=SQLITE_OK ){ + return rc; + } + *piMoved = maxRootPgno; + } + + /* Set the new 'max-root-page' value in the database header. This + ** is the old value less one, less one more if that happens to + ** be a root-page number, less one again if that is the + ** PENDING_BYTE_PAGE. + */ + maxRootPgno--; + while( maxRootPgno==PENDING_BYTE_PAGE(pBt) + || PTRMAP_ISPAGE(pBt, maxRootPgno) ){ + maxRootPgno--; + } + assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) ); + + rc = sqlite3BtreeUpdateMeta(p, 4, maxRootPgno); + }else{ + freePage(pPage, &rc); + releasePage(pPage); + } +#endif + return rc; +} +SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree *p, int iTable, int *piMoved){ + int rc; + sqlite3BtreeEnter(p); + rc = btreeDropTable(p, iTable, piMoved); + sqlite3BtreeLeave(p); + return rc; +} + + +/* +** This function may only be called if the b-tree connection already +** has a read or write transaction open on the database. +** +** Read the meta-information out of a database file. Meta[0] +** is the number of free pages currently in the database. Meta[1] +** through meta[15] are available for use by higher layers. Meta[0] +** is read-only, the others are read/write. +** +** The schema layer numbers meta values differently. At the schema +** layer (and the SetCookie and ReadCookie opcodes) the number of +** free pages is not visible. So Cookie[0] is the same as Meta[1]. +** +** This routine treats Meta[BTREE_DATA_VERSION] as a special case. Instead +** of reading the value out of the header, it instead loads the "DataVersion" +** from the pager. The BTREE_DATA_VERSION value is not actually stored in the +** database file. It is a number computed by the pager. But its access +** pattern is the same as header meta values, and so it is convenient to +** read it from this routine. +*/ +SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){ + BtShared *pBt = p->pBt; + + sqlite3BtreeEnter(p); + assert( p->inTrans>TRANS_NONE ); + assert( SQLITE_OK==querySharedCacheTableLock(p, SCHEMA_ROOT, READ_LOCK) ); + assert( pBt->pPage1 ); + assert( idx>=0 && idx<=15 ); + + if( idx==BTREE_DATA_VERSION ){ + *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iDataVersion; + }else{ + *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]); + } + + /* If auto-vacuum is disabled in this build and this is an auto-vacuum + ** database, mark the database as read-only. */ +#ifdef SQLITE_OMIT_AUTOVACUUM + if( idx==BTREE_LARGEST_ROOT_PAGE && *pMeta>0 ){ + pBt->btsFlags |= BTS_READ_ONLY; + } +#endif + + sqlite3BtreeLeave(p); +} + +/* +** Write meta-information back into the database. Meta[0] is +** read-only and may not be written. +*/ +SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){ + BtShared *pBt = p->pBt; + unsigned char *pP1; + int rc; + assert( idx>=1 && idx<=15 ); + sqlite3BtreeEnter(p); + assert( p->inTrans==TRANS_WRITE ); + assert( pBt->pPage1!=0 ); + pP1 = pBt->pPage1->aData; + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + if( rc==SQLITE_OK ){ + put4byte(&pP1[36 + idx*4], iMeta); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( idx==BTREE_INCR_VACUUM ){ + assert( pBt->autoVacuum || iMeta==0 ); + assert( iMeta==0 || iMeta==1 ); + pBt->incrVacuum = (u8)iMeta; + } +#endif + } + sqlite3BtreeLeave(p); + return rc; +} + +/* +** The first argument, pCur, is a cursor opened on some b-tree. Count the +** number of entries in the b-tree and write the result to *pnEntry. +** +** SQLITE_OK is returned if the operation is successfully executed. +** Otherwise, if an error is encountered (i.e. an IO error or database +** corruption) an SQLite error code is returned. +*/ +SQLITE_PRIVATE int sqlite3BtreeCount(sqlite3 *db, BtCursor *pCur, i64 *pnEntry){ + i64 nEntry = 0; /* Value to return in *pnEntry */ + int rc; /* Return code */ + + rc = moveToRoot(pCur); + if( rc==SQLITE_EMPTY ){ + *pnEntry = 0; + return SQLITE_OK; + } + + /* Unless an error occurs, the following loop runs one iteration for each + ** page in the B-Tree structure (not including overflow pages). + */ + while( rc==SQLITE_OK && !AtomicLoad(&db->u1.isInterrupted) ){ + int iIdx; /* Index of child node in parent */ + MemPage *pPage; /* Current page of the b-tree */ + + /* If this is a leaf page or the tree is not an int-key tree, then + ** this page contains countable entries. Increment the entry counter + ** accordingly. + */ + pPage = pCur->pPage; + if( pPage->leaf || !pPage->intKey ){ + nEntry += pPage->nCell; + } + + /* pPage is a leaf node. This loop navigates the cursor so that it + ** points to the first interior cell that it points to the parent of + ** the next page in the tree that has not yet been visited. The + ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell + ** of the page, or to the number of cells in the page if the next page + ** to visit is the right-child of its parent. + ** + ** If all pages in the tree have been visited, return SQLITE_OK to the + ** caller. + */ + if( pPage->leaf ){ + do { + if( pCur->iPage==0 ){ + /* All pages of the b-tree have been visited. Return successfully. */ + *pnEntry = nEntry; + return moveToRoot(pCur); + } + moveToParent(pCur); + }while ( pCur->ix>=pCur->pPage->nCell ); + + pCur->ix++; + pPage = pCur->pPage; + } + + /* Descend to the child node of the cell that the cursor currently + ** points at. This is the right-child if (iIdx==pPage->nCell). + */ + iIdx = pCur->ix; + if( iIdx==pPage->nCell ){ + rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8])); + }else{ + rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx))); + } + } + + /* An error has occurred. Return an error code. */ + return rc; +} + +/* +** Return the pager associated with a BTree. This routine is used for +** testing and debugging only. +*/ +SQLITE_PRIVATE Pager *sqlite3BtreePager(Btree *p){ + return p->pBt->pPager; +} + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK +/* +** Append a message to the error message string. +*/ +static void checkAppendMsg( + IntegrityCk *pCheck, + const char *zFormat, + ... +){ + va_list ap; + if( !pCheck->mxErr ) return; + pCheck->mxErr--; + pCheck->nErr++; + va_start(ap, zFormat); + if( pCheck->errMsg.nChar ){ + sqlite3_str_append(&pCheck->errMsg, "\n", 1); + } + if( pCheck->zPfx ){ + sqlite3_str_appendf(&pCheck->errMsg, pCheck->zPfx, pCheck->v1, pCheck->v2); + } + sqlite3_str_vappendf(&pCheck->errMsg, zFormat, ap); + va_end(ap); + if( pCheck->errMsg.accError==SQLITE_NOMEM ){ + pCheck->bOomFault = 1; + } +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK + +/* +** Return non-zero if the bit in the IntegrityCk.aPgRef[] array that +** corresponds to page iPg is already set. +*/ +static int getPageReferenced(IntegrityCk *pCheck, Pgno iPg){ + assert( iPg<=pCheck->nPage && sizeof(pCheck->aPgRef[0])==1 ); + return (pCheck->aPgRef[iPg/8] & (1 << (iPg & 0x07))); +} + +/* +** Set the bit in the IntegrityCk.aPgRef[] array that corresponds to page iPg. +*/ +static void setPageReferenced(IntegrityCk *pCheck, Pgno iPg){ + assert( iPg<=pCheck->nPage && sizeof(pCheck->aPgRef[0])==1 ); + pCheck->aPgRef[iPg/8] |= (1 << (iPg & 0x07)); +} + + +/* +** Add 1 to the reference count for page iPage. If this is the second +** reference to the page, add an error message to pCheck->zErrMsg. +** Return 1 if there are 2 or more references to the page and 0 if +** if this is the first reference to the page. +** +** Also check that the page number is in bounds. +*/ +static int checkRef(IntegrityCk *pCheck, Pgno iPage){ + if( iPage>pCheck->nPage || iPage==0 ){ + checkAppendMsg(pCheck, "invalid page number %d", iPage); + return 1; + } + if( getPageReferenced(pCheck, iPage) ){ + checkAppendMsg(pCheck, "2nd reference to page %d", iPage); + return 1; + } + if( AtomicLoad(&pCheck->db->u1.isInterrupted) ) return 1; + setPageReferenced(pCheck, iPage); + return 0; +} + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** Check that the entry in the pointer-map for page iChild maps to +** page iParent, pointer type ptrType. If not, append an error message +** to pCheck. +*/ +static void checkPtrmap( + IntegrityCk *pCheck, /* Integrity check context */ + Pgno iChild, /* Child page number */ + u8 eType, /* Expected pointer map type */ + Pgno iParent /* Expected pointer map parent page number */ +){ + int rc; + u8 ePtrmapType; + Pgno iPtrmapParent; + + rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ) pCheck->bOomFault = 1; + checkAppendMsg(pCheck, "Failed to read ptrmap key=%d", iChild); + return; + } + + if( ePtrmapType!=eType || iPtrmapParent!=iParent ){ + checkAppendMsg(pCheck, + "Bad ptr map entry key=%d expected=(%d,%d) got=(%d,%d)", + iChild, eType, iParent, ePtrmapType, iPtrmapParent); + } +} +#endif + +/* +** Check the integrity of the freelist or of an overflow page list. +** Verify that the number of pages on the list is N. +*/ +static void checkList( + IntegrityCk *pCheck, /* Integrity checking context */ + int isFreeList, /* True for a freelist. False for overflow page list */ + Pgno iPage, /* Page number for first page in the list */ + u32 N /* Expected number of pages in the list */ +){ + int i; + u32 expected = N; + int nErrAtStart = pCheck->nErr; + while( iPage!=0 && pCheck->mxErr ){ + DbPage *pOvflPage; + unsigned char *pOvflData; + if( checkRef(pCheck, iPage) ) break; + N--; + if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage, 0) ){ + checkAppendMsg(pCheck, "failed to get page %d", iPage); + break; + } + pOvflData = (unsigned char *)sqlite3PagerGetData(pOvflPage); + if( isFreeList ){ + u32 n = (u32)get4byte(&pOvflData[4]); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pCheck->pBt->autoVacuum ){ + checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0); + } +#endif + if( n>pCheck->pBt->usableSize/4-2 ){ + checkAppendMsg(pCheck, + "freelist leaf count too big on page %d", iPage); + N--; + }else{ + for(i=0; i<(int)n; i++){ + Pgno iFreePage = get4byte(&pOvflData[8+i*4]); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pCheck->pBt->autoVacuum ){ + checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0); + } +#endif + checkRef(pCheck, iFreePage); + } + N -= n; + } + } +#ifndef SQLITE_OMIT_AUTOVACUUM + else{ + /* If this database supports auto-vacuum and iPage is not the last + ** page in this overflow list, check that the pointer-map entry for + ** the following page matches iPage. + */ + if( pCheck->pBt->autoVacuum && N>0 ){ + i = get4byte(pOvflData); + checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage); + } + } +#endif + iPage = get4byte(pOvflData); + sqlite3PagerUnref(pOvflPage); + } + if( N && nErrAtStart==pCheck->nErr ){ + checkAppendMsg(pCheck, + "%s is %d but should be %d", + isFreeList ? "size" : "overflow list length", + expected-N, expected); + } +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +/* +** An implementation of a min-heap. +** +** aHeap[0] is the number of elements on the heap. aHeap[1] is the +** root element. The daughter nodes of aHeap[N] are aHeap[N*2] +** and aHeap[N*2+1]. +** +** The heap property is this: Every node is less than or equal to both +** of its daughter nodes. A consequence of the heap property is that the +** root node aHeap[1] is always the minimum value currently in the heap. +** +** The btreeHeapInsert() routine inserts an unsigned 32-bit number onto +** the heap, preserving the heap property. The btreeHeapPull() routine +** removes the root element from the heap (the minimum value in the heap) +** and then moves other nodes around as necessary to preserve the heap +** property. +** +** This heap is used for cell overlap and coverage testing. Each u32 +** entry represents the span of a cell or freeblock on a btree page. +** The upper 16 bits are the index of the first byte of a range and the +** lower 16 bits are the index of the last byte of that range. +*/ +static void btreeHeapInsert(u32 *aHeap, u32 x){ + u32 j, i = ++aHeap[0]; + aHeap[i] = x; + while( (j = i/2)>0 && aHeap[j]>aHeap[i] ){ + x = aHeap[j]; + aHeap[j] = aHeap[i]; + aHeap[i] = x; + i = j; + } +} +static int btreeHeapPull(u32 *aHeap, u32 *pOut){ + u32 j, i, x; + if( (x = aHeap[0])==0 ) return 0; + *pOut = aHeap[1]; + aHeap[1] = aHeap[x]; + aHeap[x] = 0xffffffff; + aHeap[0]--; + i = 1; + while( (j = i*2)<=aHeap[0] ){ + if( aHeap[j]>aHeap[j+1] ) j++; + if( aHeap[i]zPfx; + int saved_v1 = pCheck->v1; + int saved_v2 = pCheck->v2; + u8 savedIsInit = 0; + + /* Check that the page exists + */ + pBt = pCheck->pBt; + usableSize = pBt->usableSize; + if( iPage==0 ) return 0; + if( checkRef(pCheck, iPage) ) return 0; + pCheck->zPfx = "Page %u: "; + pCheck->v1 = iPage; + if( (rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0 ){ + checkAppendMsg(pCheck, + "unable to get the page. error code=%d", rc); + goto end_of_check; + } + + /* Clear MemPage.isInit to make sure the corruption detection code in + ** btreeInitPage() is executed. */ + savedIsInit = pPage->isInit; + pPage->isInit = 0; + if( (rc = btreeInitPage(pPage))!=0 ){ + assert( rc==SQLITE_CORRUPT ); /* The only possible error from InitPage */ + checkAppendMsg(pCheck, + "btreeInitPage() returns error code %d", rc); + goto end_of_check; + } + if( (rc = btreeComputeFreeSpace(pPage))!=0 ){ + assert( rc==SQLITE_CORRUPT ); + checkAppendMsg(pCheck, "free space corruption", rc); + goto end_of_check; + } + data = pPage->aData; + hdr = pPage->hdrOffset; + + /* Set up for cell analysis */ + pCheck->zPfx = "On tree page %u cell %d: "; + contentOffset = get2byteNotZero(&data[hdr+5]); + assert( contentOffset<=usableSize ); /* Enforced by btreeInitPage() */ + + /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the + ** number of cells on the page. */ + nCell = get2byte(&data[hdr+3]); + assert( pPage->nCell==nCell ); + + /* EVIDENCE-OF: R-23882-45353 The cell pointer array of a b-tree page + ** immediately follows the b-tree page header. */ + cellStart = hdr + 12 - 4*pPage->leaf; + assert( pPage->aCellIdx==&data[cellStart] ); + pCellIdx = &data[cellStart + 2*(nCell-1)]; + + if( !pPage->leaf ){ + /* Analyze the right-child page of internal pages */ + pgno = get4byte(&data[hdr+8]); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + pCheck->zPfx = "On page %u at right child: "; + checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage); + } +#endif + depth = checkTreePage(pCheck, pgno, &maxKey, maxKey); + keyCanBeEqual = 0; + }else{ + /* For leaf pages, the coverage check will occur in the same loop + ** as the other cell checks, so initialize the heap. */ + heap = pCheck->heap; + heap[0] = 0; + } + + /* EVIDENCE-OF: R-02776-14802 The cell pointer array consists of K 2-byte + ** integer offsets to the cell contents. */ + for(i=nCell-1; i>=0 && pCheck->mxErr; i--){ + CellInfo info; + + /* Check cell size */ + pCheck->v2 = i; + assert( pCellIdx==&data[cellStart + i*2] ); + pc = get2byteAligned(pCellIdx); + pCellIdx -= 2; + if( pcusableSize-4 ){ + checkAppendMsg(pCheck, "Offset %d out of range %d..%d", + pc, contentOffset, usableSize-4); + doCoverageCheck = 0; + continue; + } + pCell = &data[pc]; + pPage->xParseCell(pPage, pCell, &info); + if( pc+info.nSize>usableSize ){ + checkAppendMsg(pCheck, "Extends off end of page"); + doCoverageCheck = 0; + continue; + } + + /* Check for integer primary key out of range */ + if( pPage->intKey ){ + if( keyCanBeEqual ? (info.nKey > maxKey) : (info.nKey >= maxKey) ){ + checkAppendMsg(pCheck, "Rowid %lld out of order", info.nKey); + } + maxKey = info.nKey; + keyCanBeEqual = 0; /* Only the first key on the page may ==maxKey */ + } + + /* Check the content overflow list */ + if( info.nPayload>info.nLocal ){ + u32 nPage; /* Number of pages on the overflow chain */ + Pgno pgnoOvfl; /* First page of the overflow chain */ + assert( pc + info.nSize - 4 <= usableSize ); + nPage = (info.nPayload - info.nLocal + usableSize - 5)/(usableSize - 4); + pgnoOvfl = get4byte(&pCell[info.nSize - 4]); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage); + } +#endif + checkList(pCheck, 0, pgnoOvfl, nPage); + } + + if( !pPage->leaf ){ + /* Check sanity of left child page for internal pages */ + pgno = get4byte(pCell); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage); + } +#endif + d2 = checkTreePage(pCheck, pgno, &maxKey, maxKey); + keyCanBeEqual = 0; + if( d2!=depth ){ + checkAppendMsg(pCheck, "Child page depth differs"); + depth = d2; + } + }else{ + /* Populate the coverage-checking heap for leaf pages */ + btreeHeapInsert(heap, (pc<<16)|(pc+info.nSize-1)); + } + } + *piMinKey = maxKey; + + /* Check for complete coverage of the page + */ + pCheck->zPfx = 0; + if( doCoverageCheck && pCheck->mxErr>0 ){ + /* For leaf pages, the min-heap has already been initialized and the + ** cells have already been inserted. But for internal pages, that has + ** not yet been done, so do it now */ + if( !pPage->leaf ){ + heap = pCheck->heap; + heap[0] = 0; + for(i=nCell-1; i>=0; i--){ + u32 size; + pc = get2byteAligned(&data[cellStart+i*2]); + size = pPage->xCellSize(pPage, &data[pc]); + btreeHeapInsert(heap, (pc<<16)|(pc+size-1)); + } + } + /* Add the freeblocks to the min-heap + ** + ** EVIDENCE-OF: R-20690-50594 The second field of the b-tree page header + ** is the offset of the first freeblock, or zero if there are no + ** freeblocks on the page. + */ + i = get2byte(&data[hdr+1]); + while( i>0 ){ + int size, j; + assert( (u32)i<=usableSize-4 ); /* Enforced by btreeComputeFreeSpace() */ + size = get2byte(&data[i+2]); + assert( (u32)(i+size)<=usableSize ); /* due to btreeComputeFreeSpace() */ + btreeHeapInsert(heap, (((u32)i)<<16)|(i+size-1)); + /* EVIDENCE-OF: R-58208-19414 The first 2 bytes of a freeblock are a + ** big-endian integer which is the offset in the b-tree page of the next + ** freeblock in the chain, or zero if the freeblock is the last on the + ** chain. */ + j = get2byte(&data[i]); + /* EVIDENCE-OF: R-06866-39125 Freeblocks are always connected in order of + ** increasing offset. */ + assert( j==0 || j>i+size ); /* Enforced by btreeComputeFreeSpace() */ + assert( (u32)j<=usableSize-4 ); /* Enforced by btreeComputeFreeSpace() */ + i = j; + } + /* Analyze the min-heap looking for overlap between cells and/or + ** freeblocks, and counting the number of untracked bytes in nFrag. + ** + ** Each min-heap entry is of the form: (start_address<<16)|end_address. + ** There is an implied first entry the covers the page header, the cell + ** pointer index, and the gap between the cell pointer index and the start + ** of cell content. + ** + ** The loop below pulls entries from the min-heap in order and compares + ** the start_address against the previous end_address. If there is an + ** overlap, that means bytes are used multiple times. If there is a gap, + ** that gap is added to the fragmentation count. + */ + nFrag = 0; + prev = contentOffset - 1; /* Implied first min-heap entry */ + while( btreeHeapPull(heap,&x) ){ + if( (prev&0xffff)>=(x>>16) ){ + checkAppendMsg(pCheck, + "Multiple uses for byte %u of page %u", x>>16, iPage); + break; + }else{ + nFrag += (x>>16) - (prev&0xffff) - 1; + prev = x; + } + } + nFrag += usableSize - (prev&0xffff) - 1; + /* EVIDENCE-OF: R-43263-13491 The total number of bytes in all fragments + ** is stored in the fifth field of the b-tree page header. + ** EVIDENCE-OF: R-07161-27322 The one-byte integer at offset 7 gives the + ** number of fragmented free bytes within the cell content area. + */ + if( heap[0]==0 && nFrag!=data[hdr+7] ){ + checkAppendMsg(pCheck, + "Fragmentation of %d bytes reported as %d on page %u", + nFrag, data[hdr+7], iPage); + } + } + +end_of_check: + if( !doCoverageCheck ) pPage->isInit = savedIsInit; + releasePage(pPage); + pCheck->zPfx = saved_zPfx; + pCheck->v1 = saved_v1; + pCheck->v2 = saved_v2; + return depth+1; +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK +/* +** This routine does a complete check of the given BTree file. aRoot[] is +** an array of pages numbers were each page number is the root page of +** a table. nRoot is the number of entries in aRoot. +** +** A read-only or read-write transaction must be opened before calling +** this function. +** +** Write the number of error seen in *pnErr. Except for some memory +** allocation errors, an error message held in memory obtained from +** malloc is returned if *pnErr is non-zero. If *pnErr==0 then NULL is +** returned. If a memory allocation error occurs, NULL is returned. +** +** If the first entry in aRoot[] is 0, that indicates that the list of +** root pages is incomplete. This is a "partial integrity-check". This +** happens when performing an integrity check on a single table. The +** zero is skipped, of course. But in addition, the freelist checks +** and the checks to make sure every page is referenced are also skipped, +** since obviously it is not possible to know which pages are covered by +** the unverified btrees. Except, if aRoot[1] is 1, then the freelist +** checks are still performed. +*/ +SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck( + sqlite3 *db, /* Database connection that is running the check */ + Btree *p, /* The btree to be checked */ + Pgno *aRoot, /* An array of root pages numbers for individual trees */ + int nRoot, /* Number of entries in aRoot[] */ + int mxErr, /* Stop reporting errors after this many */ + int *pnErr /* Write number of errors seen to this variable */ +){ + Pgno i; + IntegrityCk sCheck; + BtShared *pBt = p->pBt; + u64 savedDbFlags = pBt->db->flags; + char zErr[100]; + int bPartial = 0; /* True if not checking all btrees */ + int bCkFreelist = 1; /* True to scan the freelist */ + VVA_ONLY( int nRef ); + assert( nRoot>0 ); + + /* aRoot[0]==0 means this is a partial check */ + if( aRoot[0]==0 ){ + assert( nRoot>1 ); + bPartial = 1; + if( aRoot[1]!=1 ) bCkFreelist = 0; + } + + sqlite3BtreeEnter(p); + assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE ); + VVA_ONLY( nRef = sqlite3PagerRefcount(pBt->pPager) ); + assert( nRef>=0 ); + sCheck.db = db; + sCheck.pBt = pBt; + sCheck.pPager = pBt->pPager; + sCheck.nPage = btreePagecount(sCheck.pBt); + sCheck.mxErr = mxErr; + sCheck.nErr = 0; + sCheck.bOomFault = 0; + sCheck.zPfx = 0; + sCheck.v1 = 0; + sCheck.v2 = 0; + sCheck.aPgRef = 0; + sCheck.heap = 0; + sqlite3StrAccumInit(&sCheck.errMsg, 0, zErr, sizeof(zErr), SQLITE_MAX_LENGTH); + sCheck.errMsg.printfFlags = SQLITE_PRINTF_INTERNAL; + if( sCheck.nPage==0 ){ + goto integrity_ck_cleanup; + } + + sCheck.aPgRef = sqlite3MallocZero((sCheck.nPage / 8)+ 1); + if( !sCheck.aPgRef ){ + sCheck.bOomFault = 1; + goto integrity_ck_cleanup; + } + sCheck.heap = (u32*)sqlite3PageMalloc( pBt->pageSize ); + if( sCheck.heap==0 ){ + sCheck.bOomFault = 1; + goto integrity_ck_cleanup; + } + + i = PENDING_BYTE_PAGE(pBt); + if( i<=sCheck.nPage ) setPageReferenced(&sCheck, i); + + /* Check the integrity of the freelist + */ + if( bCkFreelist ){ + sCheck.zPfx = "Main freelist: "; + checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]), + get4byte(&pBt->pPage1->aData[36])); + sCheck.zPfx = 0; + } + + /* Check all the tables. + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + if( !bPartial ){ + if( pBt->autoVacuum ){ + Pgno mx = 0; + Pgno mxInHdr; + for(i=0; (int)ipPage1->aData[52]); + if( mx!=mxInHdr ){ + checkAppendMsg(&sCheck, + "max rootpage (%d) disagrees with header (%d)", + mx, mxInHdr + ); + } + }else if( get4byte(&pBt->pPage1->aData[64])!=0 ){ + checkAppendMsg(&sCheck, + "incremental_vacuum enabled with a max rootpage of zero" + ); + } + } +#endif + testcase( pBt->db->flags & SQLITE_CellSizeCk ); + pBt->db->flags &= ~(u64)SQLITE_CellSizeCk; + for(i=0; (int)iautoVacuum && aRoot[i]>1 && !bPartial ){ + checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0); + } +#endif + checkTreePage(&sCheck, aRoot[i], ¬Used, LARGEST_INT64); + } + pBt->db->flags = savedDbFlags; + + /* Make sure every page in the file is referenced + */ + if( !bPartial ){ + for(i=1; i<=sCheck.nPage && sCheck.mxErr; i++){ +#ifdef SQLITE_OMIT_AUTOVACUUM + if( getPageReferenced(&sCheck, i)==0 ){ + checkAppendMsg(&sCheck, "Page %d is never used", i); + } +#else + /* If the database supports auto-vacuum, make sure no tables contain + ** references to pointer-map pages. + */ + if( getPageReferenced(&sCheck, i)==0 && + (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){ + checkAppendMsg(&sCheck, "Page %d is never used", i); + } + if( getPageReferenced(&sCheck, i)!=0 && + (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){ + checkAppendMsg(&sCheck, "Pointer map page %d is referenced", i); + } +#endif + } + } + + /* Clean up and report errors. + */ +integrity_ck_cleanup: + sqlite3PageFree(sCheck.heap); + sqlite3_free(sCheck.aPgRef); + if( sCheck.bOomFault ){ + sqlite3_str_reset(&sCheck.errMsg); + sCheck.nErr++; + } + *pnErr = sCheck.nErr; + if( sCheck.nErr==0 ) sqlite3_str_reset(&sCheck.errMsg); + /* Make sure this analysis did not leave any unref() pages. */ + assert( nRef==sqlite3PagerRefcount(pBt->pPager) ); + sqlite3BtreeLeave(p); + return sqlite3StrAccumFinish(&sCheck.errMsg); +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +/* +** Return the full pathname of the underlying database file. Return +** an empty string if the database is in-memory or a TEMP database. +** +** The pager filename is invariant as long as the pager is +** open so it is safe to access without the BtShared mutex. +*/ +SQLITE_PRIVATE const char *sqlite3BtreeGetFilename(Btree *p){ + assert( p->pBt->pPager!=0 ); + return sqlite3PagerFilename(p->pBt->pPager, 1); +} + +/* +** Return the pathname of the journal file for this database. The return +** value of this routine is the same regardless of whether the journal file +** has been created or not. +** +** The pager journal filename is invariant as long as the pager is +** open so it is safe to access without the BtShared mutex. +*/ +SQLITE_PRIVATE const char *sqlite3BtreeGetJournalname(Btree *p){ + assert( p->pBt->pPager!=0 ); + return sqlite3PagerJournalname(p->pBt->pPager); +} + +/* +** Return one of SQLITE_TXN_NONE, SQLITE_TXN_READ, or SQLITE_TXN_WRITE +** to describe the current transaction state of Btree p. +*/ +SQLITE_PRIVATE int sqlite3BtreeTxnState(Btree *p){ + assert( p==0 || sqlite3_mutex_held(p->db->mutex) ); + return p ? p->inTrans : 0; +} + +#ifndef SQLITE_OMIT_WAL +/* +** Run a checkpoint on the Btree passed as the first argument. +** +** Return SQLITE_LOCKED if this or any other connection has an open +** transaction on the shared-cache the argument Btree is connected to. +** +** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART. +*/ +SQLITE_PRIVATE int sqlite3BtreeCheckpoint(Btree *p, int eMode, int *pnLog, int *pnCkpt){ + int rc = SQLITE_OK; + if( p ){ + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + if( pBt->inTransaction!=TRANS_NONE ){ + rc = SQLITE_LOCKED; + }else{ + rc = sqlite3PagerCheckpoint(pBt->pPager, p->db, eMode, pnLog, pnCkpt); + } + sqlite3BtreeLeave(p); + } + return rc; +} +#endif + +/* +** Return true if there is currently a backup running on Btree p. +*/ +SQLITE_PRIVATE int sqlite3BtreeIsInBackup(Btree *p){ + assert( p ); + assert( sqlite3_mutex_held(p->db->mutex) ); + return p->nBackup!=0; +} + +/* +** This function returns a pointer to a blob of memory associated with +** a single shared-btree. The memory is used by client code for its own +** purposes (for example, to store a high-level schema associated with +** the shared-btree). The btree layer manages reference counting issues. +** +** The first time this is called on a shared-btree, nBytes bytes of memory +** are allocated, zeroed, and returned to the caller. For each subsequent +** call the nBytes parameter is ignored and a pointer to the same blob +** of memory returned. +** +** If the nBytes parameter is 0 and the blob of memory has not yet been +** allocated, a null pointer is returned. If the blob has already been +** allocated, it is returned as normal. +** +** Just before the shared-btree is closed, the function passed as the +** xFree argument when the memory allocation was made is invoked on the +** blob of allocated memory. The xFree function should not call sqlite3_free() +** on the memory, the btree layer does that. +*/ +SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){ + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + if( !pBt->pSchema && nBytes ){ + pBt->pSchema = sqlite3DbMallocZero(0, nBytes); + pBt->xFreeSchema = xFree; + } + sqlite3BtreeLeave(p); + return pBt->pSchema; +} + +/* +** Return SQLITE_LOCKED_SHAREDCACHE if another user of the same shared +** btree as the argument handle holds an exclusive lock on the +** sqlite_schema table. Otherwise SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3BtreeSchemaLocked(Btree *p){ + int rc; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + rc = querySharedCacheTableLock(p, SCHEMA_ROOT, READ_LOCK); + assert( rc==SQLITE_OK || rc==SQLITE_LOCKED_SHAREDCACHE ); + sqlite3BtreeLeave(p); + return rc; +} + + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Obtain a lock on the table whose root page is iTab. The +** lock is a write lock if isWritelock is true or a read lock +** if it is false. +*/ +SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){ + int rc = SQLITE_OK; + assert( p->inTrans!=TRANS_NONE ); + if( p->sharable ){ + u8 lockType = READ_LOCK + isWriteLock; + assert( READ_LOCK+1==WRITE_LOCK ); + assert( isWriteLock==0 || isWriteLock==1 ); + + sqlite3BtreeEnter(p); + rc = querySharedCacheTableLock(p, iTab, lockType); + if( rc==SQLITE_OK ){ + rc = setSharedCacheTableLock(p, iTab, lockType); + } + sqlite3BtreeLeave(p); + } + return rc; +} +#endif + +#ifndef SQLITE_OMIT_INCRBLOB +/* +** Argument pCsr must be a cursor opened for writing on an +** INTKEY table currently pointing at a valid table entry. +** This function modifies the data stored as part of that entry. +** +** Only the data content may only be modified, it is not possible to +** change the length of the data stored. If this function is called with +** parameters that attempt to write past the end of the existing data, +** no modifications are made and SQLITE_CORRUPT is returned. +*/ +SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){ + int rc; + assert( cursorOwnsBtShared(pCsr) ); + assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) ); + assert( pCsr->curFlags & BTCF_Incrblob ); + + rc = restoreCursorPosition(pCsr); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( pCsr->eState!=CURSOR_REQUIRESEEK ); + if( pCsr->eState!=CURSOR_VALID ){ + return SQLITE_ABORT; + } + + /* Save the positions of all other cursors open on this table. This is + ** required in case any of them are holding references to an xFetch + ** version of the b-tree page modified by the accessPayload call below. + ** + ** Note that pCsr must be open on a INTKEY table and saveCursorPosition() + ** and hence saveAllCursors() cannot fail on a BTREE_INTKEY table, hence + ** saveAllCursors can only return SQLITE_OK. + */ + VVA_ONLY(rc =) saveAllCursors(pCsr->pBt, pCsr->pgnoRoot, pCsr); + assert( rc==SQLITE_OK ); + + /* Check some assumptions: + ** (a) the cursor is open for writing, + ** (b) there is a read/write transaction open, + ** (c) the connection holds a write-lock on the table (if required), + ** (d) there are no conflicting read-locks, and + ** (e) the cursor points at a valid row of an intKey table. + */ + if( (pCsr->curFlags & BTCF_WriteFlag)==0 ){ + return SQLITE_READONLY; + } + assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0 + && pCsr->pBt->inTransaction==TRANS_WRITE ); + assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) ); + assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) ); + assert( pCsr->pPage->intKey ); + + return accessPayload(pCsr, offset, amt, (unsigned char *)z, 1); +} + +/* +** Mark this cursor as an incremental blob cursor. +*/ +SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *pCur){ + pCur->curFlags |= BTCF_Incrblob; + pCur->pBtree->hasIncrblobCur = 1; +} +#endif + +/* +** Set both the "read version" (single byte at byte offset 18) and +** "write version" (single byte at byte offset 19) fields in the database +** header to iVersion. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBtree, int iVersion){ + BtShared *pBt = pBtree->pBt; + int rc; /* Return code */ + + assert( iVersion==1 || iVersion==2 ); + + /* If setting the version fields to 1, do not automatically open the + ** WAL connection, even if the version fields are currently set to 2. + */ + pBt->btsFlags &= ~BTS_NO_WAL; + if( iVersion==1 ) pBt->btsFlags |= BTS_NO_WAL; + + rc = sqlite3BtreeBeginTrans(pBtree, 0, 0); + if( rc==SQLITE_OK ){ + u8 *aData = pBt->pPage1->aData; + if( aData[18]!=(u8)iVersion || aData[19]!=(u8)iVersion ){ + rc = sqlite3BtreeBeginTrans(pBtree, 2, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + if( rc==SQLITE_OK ){ + aData[18] = (u8)iVersion; + aData[19] = (u8)iVersion; + } + } + } + } + + pBt->btsFlags &= ~BTS_NO_WAL; + return rc; +} + +/* +** Return true if the cursor has a hint specified. This routine is +** only used from within assert() statements +*/ +SQLITE_PRIVATE int sqlite3BtreeCursorHasHint(BtCursor *pCsr, unsigned int mask){ + return (pCsr->hints & mask)!=0; +} + +/* +** Return true if the given Btree is read-only. +*/ +SQLITE_PRIVATE int sqlite3BtreeIsReadonly(Btree *p){ + return (p->pBt->btsFlags & BTS_READ_ONLY)!=0; +} + +/* +** Return the size of the header added to each page by this module. +*/ +SQLITE_PRIVATE int sqlite3HeaderSizeBtree(void){ return ROUND8(sizeof(MemPage)); } + +#if !defined(SQLITE_OMIT_SHARED_CACHE) +/* +** Return true if the Btree passed as the only argument is sharable. +*/ +SQLITE_PRIVATE int sqlite3BtreeSharable(Btree *p){ + return p->sharable; +} + +/* +** Return the number of connections to the BtShared object accessed by +** the Btree handle passed as the only argument. For private caches +** this is always 1. For shared caches it may be 1 or greater. +*/ +SQLITE_PRIVATE int sqlite3BtreeConnectionCount(Btree *p){ + testcase( p->sharable ); + return p->pBt->nRef; +} +#endif + +/************** End of btree.c ***********************************************/ +/************** Begin file backup.c ******************************************/ +/* +** 2009 January 28 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the implementation of the sqlite3_backup_XXX() +** API functions and the related features. +*/ +/* #include "sqliteInt.h" */ +/* #include "btreeInt.h" */ + +/* +** Structure allocated for each backup operation. +*/ +struct sqlite3_backup { + sqlite3* pDestDb; /* Destination database handle */ + Btree *pDest; /* Destination b-tree file */ + u32 iDestSchema; /* Original schema cookie in destination */ + int bDestLocked; /* True once a write-transaction is open on pDest */ + + Pgno iNext; /* Page number of the next source page to copy */ + sqlite3* pSrcDb; /* Source database handle */ + Btree *pSrc; /* Source b-tree file */ + + int rc; /* Backup process error code */ + + /* These two variables are set by every call to backup_step(). They are + ** read by calls to backup_remaining() and backup_pagecount(). + */ + Pgno nRemaining; /* Number of pages left to copy */ + Pgno nPagecount; /* Total number of pages to copy */ + + int isAttached; /* True once backup has been registered with pager */ + sqlite3_backup *pNext; /* Next backup associated with source pager */ +}; + +/* +** THREAD SAFETY NOTES: +** +** Once it has been created using backup_init(), a single sqlite3_backup +** structure may be accessed via two groups of thread-safe entry points: +** +** * Via the sqlite3_backup_XXX() API function backup_step() and +** backup_finish(). Both these functions obtain the source database +** handle mutex and the mutex associated with the source BtShared +** structure, in that order. +** +** * Via the BackupUpdate() and BackupRestart() functions, which are +** invoked by the pager layer to report various state changes in +** the page cache associated with the source database. The mutex +** associated with the source database BtShared structure will always +** be held when either of these functions are invoked. +** +** The other sqlite3_backup_XXX() API functions, backup_remaining() and +** backup_pagecount() are not thread-safe functions. If they are called +** while some other thread is calling backup_step() or backup_finish(), +** the values returned may be invalid. There is no way for a call to +** BackupUpdate() or BackupRestart() to interfere with backup_remaining() +** or backup_pagecount(). +** +** Depending on the SQLite configuration, the database handles and/or +** the Btree objects may have their own mutexes that require locking. +** Non-sharable Btrees (in-memory databases for example), do not have +** associated mutexes. +*/ + +/* +** Return a pointer corresponding to database zDb (i.e. "main", "temp") +** in connection handle pDb. If such a database cannot be found, return +** a NULL pointer and write an error message to pErrorDb. +** +** If the "temp" database is requested, it may need to be opened by this +** function. If an error occurs while doing so, return 0 and write an +** error message to pErrorDb. +*/ +static Btree *findBtree(sqlite3 *pErrorDb, sqlite3 *pDb, const char *zDb){ + int i = sqlite3FindDbName(pDb, zDb); + + if( i==1 ){ + Parse sParse; + int rc = 0; + memset(&sParse, 0, sizeof(sParse)); + sParse.db = pDb; + if( sqlite3OpenTempDatabase(&sParse) ){ + sqlite3ErrorWithMsg(pErrorDb, sParse.rc, "%s", sParse.zErrMsg); + rc = SQLITE_ERROR; + } + sqlite3DbFree(pErrorDb, sParse.zErrMsg); + sqlite3ParserReset(&sParse); + if( rc ){ + return 0; + } + } + + if( i<0 ){ + sqlite3ErrorWithMsg(pErrorDb, SQLITE_ERROR, "unknown database %s", zDb); + return 0; + } + + return pDb->aDb[i].pBt; +} + +/* +** Attempt to set the page size of the destination to match the page size +** of the source. +*/ +static int setDestPgsz(sqlite3_backup *p){ + int rc; + rc = sqlite3BtreeSetPageSize(p->pDest,sqlite3BtreeGetPageSize(p->pSrc),0,0); + return rc; +} + +/* +** Check that there is no open read-transaction on the b-tree passed as the +** second argument. If there is not, return SQLITE_OK. Otherwise, if there +** is an open read-transaction, return SQLITE_ERROR and leave an error +** message in database handle db. +*/ +static int checkReadTransaction(sqlite3 *db, Btree *p){ + if( sqlite3BtreeTxnState(p)!=SQLITE_TXN_NONE ){ + sqlite3ErrorWithMsg(db, SQLITE_ERROR, "destination database is in use"); + return SQLITE_ERROR; + } + return SQLITE_OK; +} + +/* +** Create an sqlite3_backup process to copy the contents of zSrcDb from +** connection handle pSrcDb to zDestDb in pDestDb. If successful, return +** a pointer to the new sqlite3_backup object. +** +** If an error occurs, NULL is returned and an error code and error message +** stored in database handle pDestDb. +*/ +SQLITE_API sqlite3_backup *sqlite3_backup_init( + sqlite3* pDestDb, /* Database to write to */ + const char *zDestDb, /* Name of database within pDestDb */ + sqlite3* pSrcDb, /* Database connection to read from */ + const char *zSrcDb /* Name of database within pSrcDb */ +){ + sqlite3_backup *p; /* Value to return */ + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(pSrcDb)||!sqlite3SafetyCheckOk(pDestDb) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + + /* Lock the source database handle. The destination database + ** handle is not locked in this routine, but it is locked in + ** sqlite3_backup_step(). The user is required to ensure that no + ** other thread accesses the destination handle for the duration + ** of the backup operation. Any attempt to use the destination + ** database connection while a backup is in progress may cause + ** a malfunction or a deadlock. + */ + sqlite3_mutex_enter(pSrcDb->mutex); + sqlite3_mutex_enter(pDestDb->mutex); + + if( pSrcDb==pDestDb ){ + sqlite3ErrorWithMsg( + pDestDb, SQLITE_ERROR, "source and destination must be distinct" + ); + p = 0; + }else { + /* Allocate space for a new sqlite3_backup object... + ** EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a + ** call to sqlite3_backup_init() and is destroyed by a call to + ** sqlite3_backup_finish(). */ + p = (sqlite3_backup *)sqlite3MallocZero(sizeof(sqlite3_backup)); + if( !p ){ + sqlite3Error(pDestDb, SQLITE_NOMEM_BKPT); + } + } + + /* If the allocation succeeded, populate the new object. */ + if( p ){ + p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb); + p->pDest = findBtree(pDestDb, pDestDb, zDestDb); + p->pDestDb = pDestDb; + p->pSrcDb = pSrcDb; + p->iNext = 1; + p->isAttached = 0; + + if( 0==p->pSrc || 0==p->pDest + || checkReadTransaction(pDestDb, p->pDest)!=SQLITE_OK + ){ + /* One (or both) of the named databases did not exist or an OOM + ** error was hit. Or there is a transaction open on the destination + ** database. The error has already been written into the pDestDb + ** handle. All that is left to do here is free the sqlite3_backup + ** structure. */ + sqlite3_free(p); + p = 0; + } + } + if( p ){ + p->pSrc->nBackup++; + } + + sqlite3_mutex_leave(pDestDb->mutex); + sqlite3_mutex_leave(pSrcDb->mutex); + return p; +} + +/* +** Argument rc is an SQLite error code. Return true if this error is +** considered fatal if encountered during a backup operation. All errors +** are considered fatal except for SQLITE_BUSY and SQLITE_LOCKED. +*/ +static int isFatalError(int rc){ + return (rc!=SQLITE_OK && rc!=SQLITE_BUSY && ALWAYS(rc!=SQLITE_LOCKED)); +} + +/* +** Parameter zSrcData points to a buffer containing the data for +** page iSrcPg from the source database. Copy this data into the +** destination database. +*/ +static int backupOnePage( + sqlite3_backup *p, /* Backup handle */ + Pgno iSrcPg, /* Source database page to backup */ + const u8 *zSrcData, /* Source database page data */ + int bUpdate /* True for an update, false otherwise */ +){ + Pager * const pDestPager = sqlite3BtreePager(p->pDest); + const int nSrcPgsz = sqlite3BtreeGetPageSize(p->pSrc); + int nDestPgsz = sqlite3BtreeGetPageSize(p->pDest); + const int nCopy = MIN(nSrcPgsz, nDestPgsz); + const i64 iEnd = (i64)iSrcPg*(i64)nSrcPgsz; + int rc = SQLITE_OK; + i64 iOff; + + assert( sqlite3BtreeGetReserveNoMutex(p->pSrc)>=0 ); + assert( p->bDestLocked ); + assert( !isFatalError(p->rc) ); + assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ); + assert( zSrcData ); + + /* Catch the case where the destination is an in-memory database and the + ** page sizes of the source and destination differ. + */ + if( nSrcPgsz!=nDestPgsz && sqlite3PagerIsMemdb(pDestPager) ){ + rc = SQLITE_READONLY; + } + + /* This loop runs once for each destination page spanned by the source + ** page. For each iteration, variable iOff is set to the byte offset + ** of the destination page. + */ + for(iOff=iEnd-(i64)nSrcPgsz; rc==SQLITE_OK && iOffpDest->pBt) ) continue; + if( SQLITE_OK==(rc = sqlite3PagerGet(pDestPager, iDest, &pDestPg, 0)) + && SQLITE_OK==(rc = sqlite3PagerWrite(pDestPg)) + ){ + const u8 *zIn = &zSrcData[iOff%nSrcPgsz]; + u8 *zDestData = sqlite3PagerGetData(pDestPg); + u8 *zOut = &zDestData[iOff%nDestPgsz]; + + /* Copy the data from the source page into the destination page. + ** Then clear the Btree layer MemPage.isInit flag. Both this module + ** and the pager code use this trick (clearing the first byte + ** of the page 'extra' space to invalidate the Btree layers + ** cached parse of the page). MemPage.isInit is marked + ** "MUST BE FIRST" for this purpose. + */ + memcpy(zOut, zIn, nCopy); + ((u8 *)sqlite3PagerGetExtra(pDestPg))[0] = 0; + if( iOff==0 && bUpdate==0 ){ + sqlite3Put4byte(&zOut[28], sqlite3BtreeLastPage(p->pSrc)); + } + } + sqlite3PagerUnref(pDestPg); + } + + return rc; +} + +/* +** If pFile is currently larger than iSize bytes, then truncate it to +** exactly iSize bytes. If pFile is not larger than iSize bytes, then +** this function is a no-op. +** +** Return SQLITE_OK if everything is successful, or an SQLite error +** code if an error occurs. +*/ +static int backupTruncateFile(sqlite3_file *pFile, i64 iSize){ + i64 iCurrent; + int rc = sqlite3OsFileSize(pFile, &iCurrent); + if( rc==SQLITE_OK && iCurrent>iSize ){ + rc = sqlite3OsTruncate(pFile, iSize); + } + return rc; +} + +/* +** Register this backup object with the associated source pager for +** callbacks when pages are changed or the cache invalidated. +*/ +static void attachBackupObject(sqlite3_backup *p){ + sqlite3_backup **pp; + assert( sqlite3BtreeHoldsMutex(p->pSrc) ); + pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc)); + p->pNext = *pp; + *pp = p; + p->isAttached = 1; +} + +/* +** Copy nPage pages from the source b-tree to the destination. +*/ +SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage){ + int rc; + int destMode; /* Destination journal mode */ + int pgszSrc = 0; /* Source page size */ + int pgszDest = 0; /* Destination page size */ + +#ifdef SQLITE_ENABLE_API_ARMOR + if( p==0 ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(p->pSrcDb->mutex); + sqlite3BtreeEnter(p->pSrc); + if( p->pDestDb ){ + sqlite3_mutex_enter(p->pDestDb->mutex); + } + + rc = p->rc; + if( !isFatalError(rc) ){ + Pager * const pSrcPager = sqlite3BtreePager(p->pSrc); /* Source pager */ + Pager * const pDestPager = sqlite3BtreePager(p->pDest); /* Dest pager */ + int ii; /* Iterator variable */ + int nSrcPage = -1; /* Size of source db in pages */ + int bCloseTrans = 0; /* True if src db requires unlocking */ + + /* If the source pager is currently in a write-transaction, return + ** SQLITE_BUSY immediately. + */ + if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){ + rc = SQLITE_BUSY; + }else{ + rc = SQLITE_OK; + } + + /* If there is no open read-transaction on the source database, open + ** one now. If a transaction is opened here, then it will be closed + ** before this function exits. + */ + if( rc==SQLITE_OK && SQLITE_TXN_NONE==sqlite3BtreeTxnState(p->pSrc) ){ + rc = sqlite3BtreeBeginTrans(p->pSrc, 0, 0); + bCloseTrans = 1; + } + + /* If the destination database has not yet been locked (i.e. if this + ** is the first call to backup_step() for the current backup operation), + ** try to set its page size to the same as the source database. This + ** is especially important on ZipVFS systems, as in that case it is + ** not possible to create a database file that uses one page size by + ** writing to it with another. */ + if( p->bDestLocked==0 && rc==SQLITE_OK && setDestPgsz(p)==SQLITE_NOMEM ){ + rc = SQLITE_NOMEM; + } + + /* Lock the destination database, if it is not locked already. */ + if( SQLITE_OK==rc && p->bDestLocked==0 + && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2, + (int*)&p->iDestSchema)) + ){ + p->bDestLocked = 1; + } + + /* Do not allow backup if the destination database is in WAL mode + ** and the page sizes are different between source and destination */ + pgszSrc = sqlite3BtreeGetPageSize(p->pSrc); + pgszDest = sqlite3BtreeGetPageSize(p->pDest); + destMode = sqlite3PagerGetJournalMode(sqlite3BtreePager(p->pDest)); + if( SQLITE_OK==rc && destMode==PAGER_JOURNALMODE_WAL && pgszSrc!=pgszDest ){ + rc = SQLITE_READONLY; + } + + /* Now that there is a read-lock on the source database, query the + ** source pager for the number of pages in the database. + */ + nSrcPage = (int)sqlite3BtreeLastPage(p->pSrc); + assert( nSrcPage>=0 ); + for(ii=0; (nPage<0 || iiiNext<=(Pgno)nSrcPage && !rc; ii++){ + const Pgno iSrcPg = p->iNext; /* Source page number */ + if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){ + DbPage *pSrcPg; /* Source page object */ + rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg,PAGER_GET_READONLY); + if( rc==SQLITE_OK ){ + rc = backupOnePage(p, iSrcPg, sqlite3PagerGetData(pSrcPg), 0); + sqlite3PagerUnref(pSrcPg); + } + } + p->iNext++; + } + if( rc==SQLITE_OK ){ + p->nPagecount = nSrcPage; + p->nRemaining = nSrcPage+1-p->iNext; + if( p->iNext>(Pgno)nSrcPage ){ + rc = SQLITE_DONE; + }else if( !p->isAttached ){ + attachBackupObject(p); + } + } + + /* Update the schema version field in the destination database. This + ** is to make sure that the schema-version really does change in + ** the case where the source and destination databases have the + ** same schema version. + */ + if( rc==SQLITE_DONE ){ + if( nSrcPage==0 ){ + rc = sqlite3BtreeNewDb(p->pDest); + nSrcPage = 1; + } + if( rc==SQLITE_OK || rc==SQLITE_DONE ){ + rc = sqlite3BtreeUpdateMeta(p->pDest,1,p->iDestSchema+1); + } + if( rc==SQLITE_OK ){ + if( p->pDestDb ){ + sqlite3ResetAllSchemasOfConnection(p->pDestDb); + } + if( destMode==PAGER_JOURNALMODE_WAL ){ + rc = sqlite3BtreeSetVersion(p->pDest, 2); + } + } + if( rc==SQLITE_OK ){ + int nDestTruncate; + /* Set nDestTruncate to the final number of pages in the destination + ** database. The complication here is that the destination page + ** size may be different to the source page size. + ** + ** If the source page size is smaller than the destination page size, + ** round up. In this case the call to sqlite3OsTruncate() below will + ** fix the size of the file. However it is important to call + ** sqlite3PagerTruncateImage() here so that any pages in the + ** destination file that lie beyond the nDestTruncate page mark are + ** journalled by PagerCommitPhaseOne() before they are destroyed + ** by the file truncation. + */ + assert( pgszSrc==sqlite3BtreeGetPageSize(p->pSrc) ); + assert( pgszDest==sqlite3BtreeGetPageSize(p->pDest) ); + if( pgszSrcpDest->pBt) ){ + nDestTruncate--; + } + }else{ + nDestTruncate = nSrcPage * (pgszSrc/pgszDest); + } + assert( nDestTruncate>0 ); + + if( pgszSrc= iSize || ( + nDestTruncate==(int)(PENDING_BYTE_PAGE(p->pDest->pBt)-1) + && iSize>=PENDING_BYTE && iSize<=PENDING_BYTE+pgszDest + )); + + /* This block ensures that all data required to recreate the original + ** database has been stored in the journal for pDestPager and the + ** journal synced to disk. So at this point we may safely modify + ** the database file in any way, knowing that if a power failure + ** occurs, the original database will be reconstructed from the + ** journal file. */ + sqlite3PagerPagecount(pDestPager, &nDstPage); + for(iPg=nDestTruncate; rc==SQLITE_OK && iPg<=(Pgno)nDstPage; iPg++){ + if( iPg!=PENDING_BYTE_PAGE(p->pDest->pBt) ){ + DbPage *pPg; + rc = sqlite3PagerGet(pDestPager, iPg, &pPg, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerWrite(pPg); + sqlite3PagerUnref(pPg); + } + } + } + if( rc==SQLITE_OK ){ + rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 1); + } + + /* Write the extra pages and truncate the database file as required */ + iEnd = MIN(PENDING_BYTE + pgszDest, iSize); + for( + iOff=PENDING_BYTE+pgszSrc; + rc==SQLITE_OK && iOffpDest, 0)) + ){ + rc = SQLITE_DONE; + } + } + } + + /* If bCloseTrans is true, then this function opened a read transaction + ** on the source database. Close the read transaction here. There is + ** no need to check the return values of the btree methods here, as + ** "committing" a read-only transaction cannot fail. + */ + if( bCloseTrans ){ + TESTONLY( int rc2 ); + TESTONLY( rc2 = ) sqlite3BtreeCommitPhaseOne(p->pSrc, 0); + TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p->pSrc, 0); + assert( rc2==SQLITE_OK ); + } + + if( rc==SQLITE_IOERR_NOMEM ){ + rc = SQLITE_NOMEM_BKPT; + } + p->rc = rc; + } + if( p->pDestDb ){ + sqlite3_mutex_leave(p->pDestDb->mutex); + } + sqlite3BtreeLeave(p->pSrc); + sqlite3_mutex_leave(p->pSrcDb->mutex); + return rc; +} + +/* +** Release all resources associated with an sqlite3_backup* handle. +*/ +SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p){ + sqlite3_backup **pp; /* Ptr to head of pagers backup list */ + sqlite3 *pSrcDb; /* Source database connection */ + int rc; /* Value to return */ + + /* Enter the mutexes */ + if( p==0 ) return SQLITE_OK; + pSrcDb = p->pSrcDb; + sqlite3_mutex_enter(pSrcDb->mutex); + sqlite3BtreeEnter(p->pSrc); + if( p->pDestDb ){ + sqlite3_mutex_enter(p->pDestDb->mutex); + } + + /* Detach this backup from the source pager. */ + if( p->pDestDb ){ + p->pSrc->nBackup--; + } + if( p->isAttached ){ + pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc)); + assert( pp!=0 ); + while( *pp!=p ){ + pp = &(*pp)->pNext; + assert( pp!=0 ); + } + *pp = p->pNext; + } + + /* If a transaction is still open on the Btree, roll it back. */ + sqlite3BtreeRollback(p->pDest, SQLITE_OK, 0); + + /* Set the error code of the destination database handle. */ + rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc; + if( p->pDestDb ){ + sqlite3Error(p->pDestDb, rc); + + /* Exit the mutexes and free the backup context structure. */ + sqlite3LeaveMutexAndCloseZombie(p->pDestDb); + } + sqlite3BtreeLeave(p->pSrc); + if( p->pDestDb ){ + /* EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a + ** call to sqlite3_backup_init() and is destroyed by a call to + ** sqlite3_backup_finish(). */ + sqlite3_free(p); + } + sqlite3LeaveMutexAndCloseZombie(pSrcDb); + return rc; +} + +/* +** Return the number of pages still to be backed up as of the most recent +** call to sqlite3_backup_step(). +*/ +SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( p==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return p->nRemaining; +} + +/* +** Return the total number of pages in the source database as of the most +** recent call to sqlite3_backup_step(). +*/ +SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( p==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return p->nPagecount; +} + +/* +** This function is called after the contents of page iPage of the +** source database have been modified. If page iPage has already been +** copied into the destination database, then the data written to the +** destination is now invalidated. The destination copy of iPage needs +** to be updated with the new data before the backup operation is +** complete. +** +** It is assumed that the mutex associated with the BtShared object +** corresponding to the source database is held when this function is +** called. +*/ +static SQLITE_NOINLINE void backupUpdate( + sqlite3_backup *p, + Pgno iPage, + const u8 *aData +){ + assert( p!=0 ); + do{ + assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) ); + if( !isFatalError(p->rc) && iPageiNext ){ + /* The backup process p has already copied page iPage. But now it + ** has been modified by a transaction on the source pager. Copy + ** the new data into the backup. + */ + int rc; + assert( p->pDestDb ); + sqlite3_mutex_enter(p->pDestDb->mutex); + rc = backupOnePage(p, iPage, aData, 1); + sqlite3_mutex_leave(p->pDestDb->mutex); + assert( rc!=SQLITE_BUSY && rc!=SQLITE_LOCKED ); + if( rc!=SQLITE_OK ){ + p->rc = rc; + } + } + }while( (p = p->pNext)!=0 ); +} +SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){ + if( pBackup ) backupUpdate(pBackup, iPage, aData); +} + +/* +** Restart the backup process. This is called when the pager layer +** detects that the database has been modified by an external database +** connection. In this case there is no way of knowing which of the +** pages that have been copied into the destination database are still +** valid and which are not, so the entire process needs to be restarted. +** +** It is assumed that the mutex associated with the BtShared object +** corresponding to the source database is held when this function is +** called. +*/ +SQLITE_PRIVATE void sqlite3BackupRestart(sqlite3_backup *pBackup){ + sqlite3_backup *p; /* Iterator variable */ + for(p=pBackup; p; p=p->pNext){ + assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) ); + p->iNext = 1; + } +} + +#ifndef SQLITE_OMIT_VACUUM +/* +** Copy the complete content of pBtFrom into pBtTo. A transaction +** must be active for both files. +** +** The size of file pTo may be reduced by this operation. If anything +** goes wrong, the transaction on pTo is rolled back. If successful, the +** transaction is committed before returning. +*/ +SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){ + int rc; + sqlite3_file *pFd; /* File descriptor for database pTo */ + sqlite3_backup b; + sqlite3BtreeEnter(pTo); + sqlite3BtreeEnter(pFrom); + + assert( sqlite3BtreeTxnState(pTo)==SQLITE_TXN_WRITE ); + pFd = sqlite3PagerFile(sqlite3BtreePager(pTo)); + if( pFd->pMethods ){ + i64 nByte = sqlite3BtreeGetPageSize(pFrom)*(i64)sqlite3BtreeLastPage(pFrom); + rc = sqlite3OsFileControl(pFd, SQLITE_FCNTL_OVERWRITE, &nByte); + if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK; + if( rc ) goto copy_finished; + } + + /* Set up an sqlite3_backup object. sqlite3_backup.pDestDb must be set + ** to 0. This is used by the implementations of sqlite3_backup_step() + ** and sqlite3_backup_finish() to detect that they are being called + ** from this function, not directly by the user. + */ + memset(&b, 0, sizeof(b)); + b.pSrcDb = pFrom->db; + b.pSrc = pFrom; + b.pDest = pTo; + b.iNext = 1; + + /* 0x7FFFFFFF is the hard limit for the number of pages in a database + ** file. By passing this as the number of pages to copy to + ** sqlite3_backup_step(), we can guarantee that the copy finishes + ** within a single call (unless an error occurs). The assert() statement + ** checks this assumption - (p->rc) should be set to either SQLITE_DONE + ** or an error code. */ + sqlite3_backup_step(&b, 0x7FFFFFFF); + assert( b.rc!=SQLITE_OK ); + + rc = sqlite3_backup_finish(&b); + if( rc==SQLITE_OK ){ + pTo->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED; + }else{ + sqlite3PagerClearCache(sqlite3BtreePager(b.pDest)); + } + + assert( sqlite3BtreeTxnState(pTo)!=SQLITE_TXN_WRITE ); +copy_finished: + sqlite3BtreeLeave(pFrom); + sqlite3BtreeLeave(pTo); + return rc; +} +#endif /* SQLITE_OMIT_VACUUM */ + +/************** End of backup.c **********************************************/ +/************** Begin file vdbemem.c *****************************************/ +/* +** 2004 May 26 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code use to manipulate "Mem" structure. A "Mem" +** stores a single value in the VDBE. Mem is an opaque structure visible +** only within the VDBE. Interface routines refer to a Mem using the +** name sqlite_value +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +/* True if X is a power of two. 0 is considered a power of two here. +** In other words, return true if X has at most one bit set. +*/ +#define ISPOWEROF2(X) (((X)&((X)-1))==0) + +#ifdef SQLITE_DEBUG +/* +** Check invariants on a Mem object. +** +** This routine is intended for use inside of assert() statements, like +** this: assert( sqlite3VdbeCheckMemInvariants(pMem) ); +*/ +SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem *p){ + /* If MEM_Dyn is set then Mem.xDel!=0. + ** Mem.xDel might not be initialized if MEM_Dyn is clear. + */ + assert( (p->flags & MEM_Dyn)==0 || p->xDel!=0 ); + + /* MEM_Dyn may only be set if Mem.szMalloc==0. In this way we + ** ensure that if Mem.szMalloc>0 then it is safe to do + ** Mem.z = Mem.zMalloc without having to check Mem.flags&MEM_Dyn. + ** That saves a few cycles in inner loops. */ + assert( (p->flags & MEM_Dyn)==0 || p->szMalloc==0 ); + + /* Cannot have more than one of MEM_Int, MEM_Real, or MEM_IntReal */ + assert( ISPOWEROF2(p->flags & (MEM_Int|MEM_Real|MEM_IntReal)) ); + + if( p->flags & MEM_Null ){ + /* Cannot be both MEM_Null and some other type */ + assert( (p->flags & (MEM_Int|MEM_Real|MEM_Str|MEM_Blob|MEM_Agg))==0 ); + + /* If MEM_Null is set, then either the value is a pure NULL (the usual + ** case) or it is a pointer set using sqlite3_bind_pointer() or + ** sqlite3_result_pointer(). If a pointer, then MEM_Term must also be + ** set. + */ + if( (p->flags & (MEM_Term|MEM_Subtype))==(MEM_Term|MEM_Subtype) ){ + /* This is a pointer type. There may be a flag to indicate what to + ** do with the pointer. */ + assert( ((p->flags&MEM_Dyn)!=0 ? 1 : 0) + + ((p->flags&MEM_Ephem)!=0 ? 1 : 0) + + ((p->flags&MEM_Static)!=0 ? 1 : 0) <= 1 ); + + /* No other bits set */ + assert( (p->flags & ~(MEM_Null|MEM_Term|MEM_Subtype|MEM_FromBind + |MEM_Dyn|MEM_Ephem|MEM_Static))==0 ); + }else{ + /* A pure NULL might have other flags, such as MEM_Static, MEM_Dyn, + ** MEM_Ephem, MEM_Cleared, or MEM_Subtype */ + } + }else{ + /* The MEM_Cleared bit is only allowed on NULLs */ + assert( (p->flags & MEM_Cleared)==0 ); + } + + /* The szMalloc field holds the correct memory allocation size */ + assert( p->szMalloc==0 + || p->szMalloc==sqlite3DbMallocSize(p->db,p->zMalloc) ); + + /* If p holds a string or blob, the Mem.z must point to exactly + ** one of the following: + ** + ** (1) Memory in Mem.zMalloc and managed by the Mem object + ** (2) Memory to be freed using Mem.xDel + ** (3) An ephemeral string or blob + ** (4) A static string or blob + */ + if( (p->flags & (MEM_Str|MEM_Blob)) && p->n>0 ){ + assert( + ((p->szMalloc>0 && p->z==p->zMalloc)? 1 : 0) + + ((p->flags&MEM_Dyn)!=0 ? 1 : 0) + + ((p->flags&MEM_Ephem)!=0 ? 1 : 0) + + ((p->flags&MEM_Static)!=0 ? 1 : 0) == 1 + ); + } + return 1; +} +#endif + +/* +** Render a Mem object which is one of MEM_Int, MEM_Real, or MEM_IntReal +** into a buffer. +*/ +static void vdbeMemRenderNum(int sz, char *zBuf, Mem *p){ + StrAccum acc; + assert( p->flags & (MEM_Int|MEM_Real|MEM_IntReal) ); + assert( sz>22 ); + if( p->flags & MEM_Int ){ +#if GCC_VERSION>=7000000 + /* Work-around for GCC bug + ** https://gcc.gnu.org/bugzilla/show_bug.cgi?id=96270 */ + i64 x; + assert( (p->flags&MEM_Int)*2==sizeof(x) ); + memcpy(&x, (char*)&p->u, (p->flags&MEM_Int)*2); + sqlite3Int64ToText(x, zBuf); +#else + sqlite3Int64ToText(p->u.i, zBuf); +#endif + }else{ + sqlite3StrAccumInit(&acc, 0, zBuf, sz, 0); + sqlite3_str_appendf(&acc, "%!.15g", + (p->flags & MEM_IntReal)!=0 ? (double)p->u.i : p->u.r); + assert( acc.zText==zBuf && acc.mxAlloc<=0 ); + zBuf[acc.nChar] = 0; /* Fast version of sqlite3StrAccumFinish(&acc) */ + } +} + +#ifdef SQLITE_DEBUG +/* +** Validity checks on pMem. pMem holds a string. +** +** (1) Check that string value of pMem agrees with its integer or real value. +** (2) Check that the string is correctly zero terminated +** +** A single int or real value always converts to the same strings. But +** many different strings can be converted into the same int or real. +** If a table contains a numeric value and an index is based on the +** corresponding string value, then it is important that the string be +** derived from the numeric value, not the other way around, to ensure +** that the index and table are consistent. See ticket +** https://www.sqlite.org/src/info/343634942dd54ab (2018-01-31) for +** an example. +** +** This routine looks at pMem to verify that if it has both a numeric +** representation and a string representation then the string rep has +** been derived from the numeric and not the other way around. It returns +** true if everything is ok and false if there is a problem. +** +** This routine is for use inside of assert() statements only. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemValidStrRep(Mem *p){ + char zBuf[100]; + char *z; + int i, j, incr; + if( (p->flags & MEM_Str)==0 ) return 1; + if( p->flags & MEM_Term ){ + /* Insure that the string is properly zero-terminated. Pay particular + ** attention to the case where p->n is odd */ + if( p->szMalloc>0 && p->z==p->zMalloc ){ + assert( p->enc==SQLITE_UTF8 || p->szMalloc >= ((p->n+1)&~1)+2 ); + assert( p->enc!=SQLITE_UTF8 || p->szMalloc >= p->n+1 ); + } + assert( p->z[p->n]==0 ); + assert( p->enc==SQLITE_UTF8 || p->z[(p->n+1)&~1]==0 ); + assert( p->enc==SQLITE_UTF8 || p->z[((p->n+1)&~1)+1]==0 ); + } + if( (p->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 ) return 1; + vdbeMemRenderNum(sizeof(zBuf), zBuf, p); + z = p->z; + i = j = 0; + incr = 1; + if( p->enc!=SQLITE_UTF8 ){ + incr = 2; + if( p->enc==SQLITE_UTF16BE ) z++; + } + while( zBuf[j] ){ + if( zBuf[j++]!=z[i] ) return 0; + i += incr; + } + return 1; +} +#endif /* SQLITE_DEBUG */ + +/* +** If pMem is an object with a valid string representation, this routine +** ensures the internal encoding for the string representation is +** 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE. +** +** If pMem is not a string object, or the encoding of the string +** representation is already stored using the requested encoding, then this +** routine is a no-op. +** +** SQLITE_OK is returned if the conversion is successful (or not required). +** SQLITE_NOMEM may be returned if a malloc() fails during conversion +** between formats. +*/ +SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){ +#ifndef SQLITE_OMIT_UTF16 + int rc; +#endif + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE + || desiredEnc==SQLITE_UTF16BE ); + if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){ + return SQLITE_OK; + } + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); +#ifdef SQLITE_OMIT_UTF16 + return SQLITE_ERROR; +#else + + /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned, + ** then the encoding of the value may not have changed. + */ + rc = sqlite3VdbeMemTranslate(pMem, (u8)desiredEnc); + assert(rc==SQLITE_OK || rc==SQLITE_NOMEM); + assert(rc==SQLITE_OK || pMem->enc!=desiredEnc); + assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc); + return rc; +#endif +} + +/* +** Make sure pMem->z points to a writable allocation of at least n bytes. +** +** If the bPreserve argument is true, then copy of the content of +** pMem->z into the new allocation. pMem must be either a string or +** blob if bPreserve is true. If bPreserve is false, any prior content +** in pMem->z is discarded. +*/ +SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPreserve){ + assert( sqlite3VdbeCheckMemInvariants(pMem) ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + testcase( pMem->db==0 ); + + /* If the bPreserve flag is set to true, then the memory cell must already + ** contain a valid string or blob value. */ + assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) ); + testcase( bPreserve && pMem->z==0 ); + + assert( pMem->szMalloc==0 + || pMem->szMalloc==sqlite3DbMallocSize(pMem->db, pMem->zMalloc) ); + if( pMem->szMalloc>0 && bPreserve && pMem->z==pMem->zMalloc ){ + if( pMem->db ){ + pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n); + }else{ + pMem->zMalloc = sqlite3Realloc(pMem->z, n); + if( pMem->zMalloc==0 ) sqlite3_free(pMem->z); + pMem->z = pMem->zMalloc; + } + bPreserve = 0; + }else{ + if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc); + pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n); + } + if( pMem->zMalloc==0 ){ + sqlite3VdbeMemSetNull(pMem); + pMem->z = 0; + pMem->szMalloc = 0; + return SQLITE_NOMEM_BKPT; + }else{ + pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc); + } + + if( bPreserve && pMem->z ){ + assert( pMem->z!=pMem->zMalloc ); + memcpy(pMem->zMalloc, pMem->z, pMem->n); + } + if( (pMem->flags&MEM_Dyn)!=0 ){ + assert( pMem->xDel!=0 && pMem->xDel!=SQLITE_DYNAMIC ); + pMem->xDel((void *)(pMem->z)); + } + + pMem->z = pMem->zMalloc; + pMem->flags &= ~(MEM_Dyn|MEM_Ephem|MEM_Static); + return SQLITE_OK; +} + +/* +** Change the pMem->zMalloc allocation to be at least szNew bytes. +** If pMem->zMalloc already meets or exceeds the requested size, this +** routine is a no-op. +** +** Any prior string or blob content in the pMem object may be discarded. +** The pMem->xDel destructor is called, if it exists. Though MEM_Str +** and MEM_Blob values may be discarded, MEM_Int, MEM_Real, MEM_IntReal, +** and MEM_Null values are preserved. +** +** Return SQLITE_OK on success or an error code (probably SQLITE_NOMEM) +** if unable to complete the resizing. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemClearAndResize(Mem *pMem, int szNew){ + assert( CORRUPT_DB || szNew>0 ); + assert( (pMem->flags & MEM_Dyn)==0 || pMem->szMalloc==0 ); + if( pMem->szMallocflags & MEM_Dyn)==0 ); + pMem->z = pMem->zMalloc; + pMem->flags &= (MEM_Null|MEM_Int|MEM_Real|MEM_IntReal); + return SQLITE_OK; +} + +/* +** It is already known that pMem contains an unterminated string. +** Add the zero terminator. +** +** Three bytes of zero are added. In this way, there is guaranteed +** to be a double-zero byte at an even byte boundary in order to +** terminate a UTF16 string, even if the initial size of the buffer +** is an odd number of bytes. +*/ +static SQLITE_NOINLINE int vdbeMemAddTerminator(Mem *pMem){ + if( sqlite3VdbeMemGrow(pMem, pMem->n+3, 1) ){ + return SQLITE_NOMEM_BKPT; + } + pMem->z[pMem->n] = 0; + pMem->z[pMem->n+1] = 0; + pMem->z[pMem->n+2] = 0; + pMem->flags |= MEM_Term; + return SQLITE_OK; +} + +/* +** Change pMem so that its MEM_Str or MEM_Blob value is stored in +** MEM.zMalloc, where it can be safely written. +** +** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){ + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + if( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ){ + if( ExpandBlob(pMem) ) return SQLITE_NOMEM; + if( pMem->szMalloc==0 || pMem->z!=pMem->zMalloc ){ + int rc = vdbeMemAddTerminator(pMem); + if( rc ) return rc; + } + } + pMem->flags &= ~MEM_Ephem; +#ifdef SQLITE_DEBUG + pMem->pScopyFrom = 0; +#endif + + return SQLITE_OK; +} + +/* +** If the given Mem* has a zero-filled tail, turn it into an ordinary +** blob stored in dynamically allocated space. +*/ +#ifndef SQLITE_OMIT_INCRBLOB +SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){ + int nByte; + assert( pMem->flags & MEM_Zero ); + assert( (pMem->flags&MEM_Blob)!=0 || MemNullNochng(pMem) ); + testcase( sqlite3_value_nochange(pMem) ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + + /* Set nByte to the number of bytes required to store the expanded blob. */ + nByte = pMem->n + pMem->u.nZero; + if( nByte<=0 ){ + if( (pMem->flags & MEM_Blob)==0 ) return SQLITE_OK; + nByte = 1; + } + if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){ + return SQLITE_NOMEM_BKPT; + } + + memset(&pMem->z[pMem->n], 0, pMem->u.nZero); + pMem->n += pMem->u.nZero; + pMem->flags &= ~(MEM_Zero|MEM_Term); + return SQLITE_OK; +} +#endif + +/* +** Make sure the given Mem is \u0000 terminated. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem *pMem){ + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) ); + testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 ); + if( (pMem->flags & (MEM_Term|MEM_Str))!=MEM_Str ){ + return SQLITE_OK; /* Nothing to do */ + }else{ + return vdbeMemAddTerminator(pMem); + } +} + +/* +** Add MEM_Str to the set of representations for the given Mem. This +** routine is only called if pMem is a number of some kind, not a NULL +** or a BLOB. +** +** Existing representations MEM_Int, MEM_Real, or MEM_IntReal are invalidated +** if bForce is true but are retained if bForce is false. +** +** A MEM_Null value will never be passed to this function. This function is +** used for converting values to text for returning to the user (i.e. via +** sqlite3_value_text()), or for ensuring that values to be used as btree +** keys are strings. In the former case a NULL pointer is returned the +** user and the latter is an internal programming error. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){ + const int nByte = 32; + + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( !(pMem->flags&MEM_Zero) ); + assert( !(pMem->flags&(MEM_Str|MEM_Blob)) ); + assert( pMem->flags&(MEM_Int|MEM_Real|MEM_IntReal) ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + + + if( sqlite3VdbeMemClearAndResize(pMem, nByte) ){ + pMem->enc = 0; + return SQLITE_NOMEM_BKPT; + } + + vdbeMemRenderNum(nByte, pMem->z, pMem); + assert( pMem->z!=0 ); + pMem->n = sqlite3Strlen30NN(pMem->z); + pMem->enc = SQLITE_UTF8; + pMem->flags |= MEM_Str|MEM_Term; + if( bForce ) pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal); + sqlite3VdbeChangeEncoding(pMem, enc); + return SQLITE_OK; +} + +/* +** Memory cell pMem contains the context of an aggregate function. +** This routine calls the finalize method for that function. The +** result of the aggregate is stored back into pMem. +** +** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK +** otherwise. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){ + sqlite3_context ctx; + Mem t; + assert( pFunc!=0 ); + assert( pFunc->xFinalize!=0 ); + assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + memset(&ctx, 0, sizeof(ctx)); + memset(&t, 0, sizeof(t)); + t.flags = MEM_Null; + t.db = pMem->db; + ctx.pOut = &t; + ctx.pMem = pMem; + ctx.pFunc = pFunc; + pFunc->xFinalize(&ctx); /* IMP: R-24505-23230 */ + assert( (pMem->flags & MEM_Dyn)==0 ); + if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc); + memcpy(pMem, &t, sizeof(t)); + return ctx.isError; +} + +/* +** Memory cell pAccum contains the context of an aggregate function. +** This routine calls the xValue method for that function and stores +** the results in memory cell pMem. +** +** SQLITE_ERROR is returned if xValue() reports an error. SQLITE_OK +** otherwise. +*/ +#ifndef SQLITE_OMIT_WINDOWFUNC +SQLITE_PRIVATE int sqlite3VdbeMemAggValue(Mem *pAccum, Mem *pOut, FuncDef *pFunc){ + sqlite3_context ctx; + assert( pFunc!=0 ); + assert( pFunc->xValue!=0 ); + assert( (pAccum->flags & MEM_Null)!=0 || pFunc==pAccum->u.pDef ); + assert( pAccum->db==0 || sqlite3_mutex_held(pAccum->db->mutex) ); + memset(&ctx, 0, sizeof(ctx)); + sqlite3VdbeMemSetNull(pOut); + ctx.pOut = pOut; + ctx.pMem = pAccum; + ctx.pFunc = pFunc; + pFunc->xValue(&ctx); + return ctx.isError; +} +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +/* +** If the memory cell contains a value that must be freed by +** invoking the external callback in Mem.xDel, then this routine +** will free that value. It also sets Mem.flags to MEM_Null. +** +** This is a helper routine for sqlite3VdbeMemSetNull() and +** for sqlite3VdbeMemRelease(). Use those other routines as the +** entry point for releasing Mem resources. +*/ +static SQLITE_NOINLINE void vdbeMemClearExternAndSetNull(Mem *p){ + assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) ); + assert( VdbeMemDynamic(p) ); + if( p->flags&MEM_Agg ){ + sqlite3VdbeMemFinalize(p, p->u.pDef); + assert( (p->flags & MEM_Agg)==0 ); + testcase( p->flags & MEM_Dyn ); + } + if( p->flags&MEM_Dyn ){ + assert( p->xDel!=SQLITE_DYNAMIC && p->xDel!=0 ); + p->xDel((void *)p->z); + } + p->flags = MEM_Null; +} + +/* +** Release memory held by the Mem p, both external memory cleared +** by p->xDel and memory in p->zMalloc. +** +** This is a helper routine invoked by sqlite3VdbeMemRelease() in +** the unusual case where there really is memory in p that needs +** to be freed. +*/ +static SQLITE_NOINLINE void vdbeMemClear(Mem *p){ + if( VdbeMemDynamic(p) ){ + vdbeMemClearExternAndSetNull(p); + } + if( p->szMalloc ){ + sqlite3DbFreeNN(p->db, p->zMalloc); + p->szMalloc = 0; + } + p->z = 0; +} + +/* +** Release any memory resources held by the Mem. Both the memory that is +** free by Mem.xDel and the Mem.zMalloc allocation are freed. +** +** Use this routine prior to clean up prior to abandoning a Mem, or to +** reset a Mem back to its minimum memory utilization. +** +** Use sqlite3VdbeMemSetNull() to release just the Mem.xDel space +** prior to inserting new content into the Mem. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p){ + assert( sqlite3VdbeCheckMemInvariants(p) ); + if( VdbeMemDynamic(p) || p->szMalloc ){ + vdbeMemClear(p); + } +} + +/* +** Convert a 64-bit IEEE double into a 64-bit signed integer. +** If the double is out of range of a 64-bit signed integer then +** return the closest available 64-bit signed integer. +*/ +static SQLITE_NOINLINE i64 doubleToInt64(double r){ +#ifdef SQLITE_OMIT_FLOATING_POINT + /* When floating-point is omitted, double and int64 are the same thing */ + return r; +#else + /* + ** Many compilers we encounter do not define constants for the + ** minimum and maximum 64-bit integers, or they define them + ** inconsistently. And many do not understand the "LL" notation. + ** So we define our own static constants here using nothing + ** larger than a 32-bit integer constant. + */ + static const i64 maxInt = LARGEST_INT64; + static const i64 minInt = SMALLEST_INT64; + + if( r<=(double)minInt ){ + return minInt; + }else if( r>=(double)maxInt ){ + return maxInt; + }else{ + return (i64)r; + } +#endif +} + +/* +** Return some kind of integer value which is the best we can do +** at representing the value that *pMem describes as an integer. +** If pMem is an integer, then the value is exact. If pMem is +** a floating-point then the value returned is the integer part. +** If pMem is a string or blob, then we make an attempt to convert +** it into an integer and return that. If pMem represents an +** an SQL-NULL value, return 0. +** +** If pMem represents a string value, its encoding might be changed. +*/ +static SQLITE_NOINLINE i64 memIntValue(Mem *pMem){ + i64 value = 0; + sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc); + return value; +} +SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){ + int flags; + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + flags = pMem->flags; + if( flags & (MEM_Int|MEM_IntReal) ){ + testcase( flags & MEM_IntReal ); + return pMem->u.i; + }else if( flags & MEM_Real ){ + return doubleToInt64(pMem->u.r); + }else if( (flags & (MEM_Str|MEM_Blob))!=0 && pMem->z!=0 ){ + return memIntValue(pMem); + }else{ + return 0; + } +} + +/* +** Return the best representation of pMem that we can get into a +** double. If pMem is already a double or an integer, return its +** value. If it is a string or blob, try to convert it to a double. +** If it is a NULL, return 0.0. +*/ +static SQLITE_NOINLINE double memRealValue(Mem *pMem){ + /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ + double val = (double)0; + sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc); + return val; +} +SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){ + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + if( pMem->flags & MEM_Real ){ + return pMem->u.r; + }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){ + testcase( pMem->flags & MEM_IntReal ); + return (double)pMem->u.i; + }else if( pMem->flags & (MEM_Str|MEM_Blob) ){ + return memRealValue(pMem); + }else{ + /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ + return (double)0; + } +} + +/* +** Return 1 if pMem represents true, and return 0 if pMem represents false. +** Return the value ifNull if pMem is NULL. +*/ +SQLITE_PRIVATE int sqlite3VdbeBooleanValue(Mem *pMem, int ifNull){ + testcase( pMem->flags & MEM_IntReal ); + if( pMem->flags & (MEM_Int|MEM_IntReal) ) return pMem->u.i!=0; + if( pMem->flags & MEM_Null ) return ifNull; + return sqlite3VdbeRealValue(pMem)!=0.0; +} + +/* +** The MEM structure is already a MEM_Real. Try to also make it a +** MEM_Int if we can. +*/ +SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){ + i64 ix; + assert( pMem->flags & MEM_Real ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + + ix = doubleToInt64(pMem->u.r); + + /* Only mark the value as an integer if + ** + ** (1) the round-trip conversion real->int->real is a no-op, and + ** (2) The integer is neither the largest nor the smallest + ** possible integer (ticket #3922) + ** + ** The second and third terms in the following conditional enforces + ** the second condition under the assumption that addition overflow causes + ** values to wrap around. + */ + if( pMem->u.r==ix && ix>SMALLEST_INT64 && ixu.i = ix; + MemSetTypeFlag(pMem, MEM_Int); + } +} + +/* +** Convert pMem to type integer. Invalidate any prior representations. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem *pMem){ + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + + pMem->u.i = sqlite3VdbeIntValue(pMem); + MemSetTypeFlag(pMem, MEM_Int); + return SQLITE_OK; +} + +/* +** Convert pMem so that it is of type MEM_Real. +** Invalidate any prior representations. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem *pMem){ + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + + pMem->u.r = sqlite3VdbeRealValue(pMem); + MemSetTypeFlag(pMem, MEM_Real); + return SQLITE_OK; +} + +/* Compare a floating point value to an integer. Return true if the two +** values are the same within the precision of the floating point value. +** +** This function assumes that i was obtained by assignment from r1. +** +** For some versions of GCC on 32-bit machines, if you do the more obvious +** comparison of "r1==(double)i" you sometimes get an answer of false even +** though the r1 and (double)i values are bit-for-bit the same. +*/ +SQLITE_PRIVATE int sqlite3RealSameAsInt(double r1, sqlite3_int64 i){ + double r2 = (double)i; + return r1==0.0 + || (memcmp(&r1, &r2, sizeof(r1))==0 + && i >= -2251799813685248LL && i < 2251799813685248LL); +} + +/* +** Convert pMem so that it has type MEM_Real or MEM_Int. +** Invalidate any prior representations. +** +** Every effort is made to force the conversion, even if the input +** is a string that does not look completely like a number. Convert +** as much of the string as we can and ignore the rest. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){ + testcase( pMem->flags & MEM_Int ); + testcase( pMem->flags & MEM_Real ); + testcase( pMem->flags & MEM_IntReal ); + testcase( pMem->flags & MEM_Null ); + if( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))==0 ){ + int rc; + sqlite3_int64 ix; + assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc); + if( ((rc==0 || rc==1) && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1) + || sqlite3RealSameAsInt(pMem->u.r, (ix = (i64)pMem->u.r)) + ){ + pMem->u.i = ix; + MemSetTypeFlag(pMem, MEM_Int); + }else{ + MemSetTypeFlag(pMem, MEM_Real); + } + } + assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))!=0 ); + pMem->flags &= ~(MEM_Str|MEM_Blob|MEM_Zero); + return SQLITE_OK; +} + +/* +** Cast the datatype of the value in pMem according to the affinity +** "aff". Casting is different from applying affinity in that a cast +** is forced. In other words, the value is converted into the desired +** affinity even if that results in loss of data. This routine is +** used (for example) to implement the SQL "cast()" operator. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemCast(Mem *pMem, u8 aff, u8 encoding){ + if( pMem->flags & MEM_Null ) return SQLITE_OK; + switch( aff ){ + case SQLITE_AFF_BLOB: { /* Really a cast to BLOB */ + if( (pMem->flags & MEM_Blob)==0 ){ + sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding); + assert( pMem->flags & MEM_Str || pMem->db->mallocFailed ); + if( pMem->flags & MEM_Str ) MemSetTypeFlag(pMem, MEM_Blob); + }else{ + pMem->flags &= ~(MEM_TypeMask&~MEM_Blob); + } + break; + } + case SQLITE_AFF_NUMERIC: { + sqlite3VdbeMemNumerify(pMem); + break; + } + case SQLITE_AFF_INTEGER: { + sqlite3VdbeMemIntegerify(pMem); + break; + } + case SQLITE_AFF_REAL: { + sqlite3VdbeMemRealify(pMem); + break; + } + default: { + assert( aff==SQLITE_AFF_TEXT ); + assert( MEM_Str==(MEM_Blob>>3) ); + pMem->flags |= (pMem->flags&MEM_Blob)>>3; + sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding); + assert( pMem->flags & MEM_Str || pMem->db->mallocFailed ); + pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal|MEM_Blob|MEM_Zero); + return sqlite3VdbeChangeEncoding(pMem, encoding); + } + } + return SQLITE_OK; +} + +/* +** Initialize bulk memory to be a consistent Mem object. +** +** The minimum amount of initialization feasible is performed. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemInit(Mem *pMem, sqlite3 *db, u16 flags){ + assert( (flags & ~MEM_TypeMask)==0 ); + pMem->flags = flags; + pMem->db = db; + pMem->szMalloc = 0; +} + + +/* +** Delete any previous value and set the value stored in *pMem to NULL. +** +** This routine calls the Mem.xDel destructor to dispose of values that +** require the destructor. But it preserves the Mem.zMalloc memory allocation. +** To free all resources, use sqlite3VdbeMemRelease(), which both calls this +** routine to invoke the destructor and deallocates Mem.zMalloc. +** +** Use this routine to reset the Mem prior to insert a new value. +** +** Use sqlite3VdbeMemRelease() to complete erase the Mem prior to abandoning it. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem *pMem){ + if( VdbeMemDynamic(pMem) ){ + vdbeMemClearExternAndSetNull(pMem); + }else{ + pMem->flags = MEM_Null; + } +} +SQLITE_PRIVATE void sqlite3ValueSetNull(sqlite3_value *p){ + sqlite3VdbeMemSetNull((Mem*)p); +} + +/* +** Delete any previous value and set the value to be a BLOB of length +** n containing all zeros. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){ + sqlite3VdbeMemRelease(pMem); + pMem->flags = MEM_Blob|MEM_Zero; + pMem->n = 0; + if( n<0 ) n = 0; + pMem->u.nZero = n; + pMem->enc = SQLITE_UTF8; + pMem->z = 0; +} + +/* +** The pMem is known to contain content that needs to be destroyed prior +** to a value change. So invoke the destructor, then set the value to +** a 64-bit integer. +*/ +static SQLITE_NOINLINE void vdbeReleaseAndSetInt64(Mem *pMem, i64 val){ + sqlite3VdbeMemSetNull(pMem); + pMem->u.i = val; + pMem->flags = MEM_Int; +} + +/* +** Delete any previous value and set the value stored in *pMem to val, +** manifest type INTEGER. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){ + if( VdbeMemDynamic(pMem) ){ + vdbeReleaseAndSetInt64(pMem, val); + }else{ + pMem->u.i = val; + pMem->flags = MEM_Int; + } +} + +/* A no-op destructor */ +SQLITE_PRIVATE void sqlite3NoopDestructor(void *p){ UNUSED_PARAMETER(p); } + +/* +** Set the value stored in *pMem should already be a NULL. +** Also store a pointer to go with it. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemSetPointer( + Mem *pMem, + void *pPtr, + const char *zPType, + void (*xDestructor)(void*) +){ + assert( pMem->flags==MEM_Null ); + pMem->u.zPType = zPType ? zPType : ""; + pMem->z = pPtr; + pMem->flags = MEM_Null|MEM_Dyn|MEM_Subtype|MEM_Term; + pMem->eSubtype = 'p'; + pMem->xDel = xDestructor ? xDestructor : sqlite3NoopDestructor; +} + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* +** Delete any previous value and set the value stored in *pMem to val, +** manifest type REAL. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){ + sqlite3VdbeMemSetNull(pMem); + if( !sqlite3IsNaN(val) ){ + pMem->u.r = val; + pMem->flags = MEM_Real; + } +} +#endif + +#ifdef SQLITE_DEBUG +/* +** Return true if the Mem holds a RowSet object. This routine is intended +** for use inside of assert() statements. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemIsRowSet(const Mem *pMem){ + return (pMem->flags&(MEM_Blob|MEM_Dyn))==(MEM_Blob|MEM_Dyn) + && pMem->xDel==sqlite3RowSetDelete; +} +#endif + +/* +** Delete any previous value and set the value of pMem to be an +** empty boolean index. +** +** Return SQLITE_OK on success and SQLITE_NOMEM if a memory allocation +** error occurs. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemSetRowSet(Mem *pMem){ + sqlite3 *db = pMem->db; + RowSet *p; + assert( db!=0 ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + sqlite3VdbeMemRelease(pMem); + p = sqlite3RowSetInit(db); + if( p==0 ) return SQLITE_NOMEM; + pMem->z = (char*)p; + pMem->flags = MEM_Blob|MEM_Dyn; + pMem->xDel = sqlite3RowSetDelete; + return SQLITE_OK; +} + +/* +** Return true if the Mem object contains a TEXT or BLOB that is +** too large - whose size exceeds SQLITE_MAX_LENGTH. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem *p){ + assert( p->db!=0 ); + if( p->flags & (MEM_Str|MEM_Blob) ){ + int n = p->n; + if( p->flags & MEM_Zero ){ + n += p->u.nZero; + } + return n>p->db->aLimit[SQLITE_LIMIT_LENGTH]; + } + return 0; +} + +#ifdef SQLITE_DEBUG +/* +** This routine prepares a memory cell for modification by breaking +** its link to a shallow copy and by marking any current shallow +** copies of this cell as invalid. +** +** This is used for testing and debugging only - to help ensure that shallow +** copies (created by OP_SCopy) are not misused. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){ + int i; + Mem *pX; + for(i=1, pX=pVdbe->aMem+1; inMem; i++, pX++){ + if( pX->pScopyFrom==pMem ){ + u16 mFlags; + if( pVdbe->db->flags & SQLITE_VdbeTrace ){ + sqlite3DebugPrintf("Invalidate R[%d] due to change in R[%d]\n", + (int)(pX - pVdbe->aMem), (int)(pMem - pVdbe->aMem)); + } + /* If pX is marked as a shallow copy of pMem, then try to verify that + ** no significant changes have been made to pX since the OP_SCopy. + ** A significant change would indicated a missed call to this + ** function for pX. Minor changes, such as adding or removing a + ** dual type, are allowed, as long as the underlying value is the + ** same. */ + mFlags = pMem->flags & pX->flags & pX->mScopyFlags; + assert( (mFlags&(MEM_Int|MEM_IntReal))==0 || pMem->u.i==pX->u.i ); + + /* pMem is the register that is changing. But also mark pX as + ** undefined so that we can quickly detect the shallow-copy error */ + pX->flags = MEM_Undefined; + pX->pScopyFrom = 0; + } + } + pMem->pScopyFrom = 0; +} +#endif /* SQLITE_DEBUG */ + +/* +** Make an shallow copy of pFrom into pTo. Prior contents of +** pTo are freed. The pFrom->z field is not duplicated. If +** pFrom->z is used, then pTo->z points to the same thing as pFrom->z +** and flags gets srcType (either MEM_Ephem or MEM_Static). +*/ +static SQLITE_NOINLINE void vdbeClrCopy(Mem *pTo, const Mem *pFrom, int eType){ + vdbeMemClearExternAndSetNull(pTo); + assert( !VdbeMemDynamic(pTo) ); + sqlite3VdbeMemShallowCopy(pTo, pFrom, eType); +} +SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){ + assert( !sqlite3VdbeMemIsRowSet(pFrom) ); + assert( pTo->db==pFrom->db ); + if( VdbeMemDynamic(pTo) ){ vdbeClrCopy(pTo,pFrom,srcType); return; } + memcpy(pTo, pFrom, MEMCELLSIZE); + if( (pFrom->flags&MEM_Static)==0 ){ + pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem); + assert( srcType==MEM_Ephem || srcType==MEM_Static ); + pTo->flags |= srcType; + } +} + +/* +** Make a full copy of pFrom into pTo. Prior contents of pTo are +** freed before the copy is made. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){ + int rc = SQLITE_OK; + + assert( !sqlite3VdbeMemIsRowSet(pFrom) ); + if( VdbeMemDynamic(pTo) ) vdbeMemClearExternAndSetNull(pTo); + memcpy(pTo, pFrom, MEMCELLSIZE); + pTo->flags &= ~MEM_Dyn; + if( pTo->flags&(MEM_Str|MEM_Blob) ){ + if( 0==(pFrom->flags&MEM_Static) ){ + pTo->flags |= MEM_Ephem; + rc = sqlite3VdbeMemMakeWriteable(pTo); + } + } + + return rc; +} + +/* +** Transfer the contents of pFrom to pTo. Any existing value in pTo is +** freed. If pFrom contains ephemeral data, a copy is made. +** +** pFrom contains an SQL NULL when this routine returns. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){ + assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) ); + assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) ); + assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db ); + + sqlite3VdbeMemRelease(pTo); + memcpy(pTo, pFrom, sizeof(Mem)); + pFrom->flags = MEM_Null; + pFrom->szMalloc = 0; +} + +/* +** Change the value of a Mem to be a string or a BLOB. +** +** The memory management strategy depends on the value of the xDel +** parameter. If the value passed is SQLITE_TRANSIENT, then the +** string is copied into a (possibly existing) buffer managed by the +** Mem structure. Otherwise, any existing buffer is freed and the +** pointer copied. +** +** If the string is too large (if it exceeds the SQLITE_LIMIT_LENGTH +** size limit) then no memory allocation occurs. If the string can be +** stored without allocating memory, then it is. If a memory allocation +** is required to store the string, then value of pMem is unchanged. In +** either case, SQLITE_TOOBIG is returned. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemSetStr( + Mem *pMem, /* Memory cell to set to string value */ + const char *z, /* String pointer */ + int n, /* Bytes in string, or negative */ + u8 enc, /* Encoding of z. 0 for BLOBs */ + void (*xDel)(void*) /* Destructor function */ +){ + int nByte = n; /* New value for pMem->n */ + int iLimit; /* Maximum allowed string or blob size */ + u16 flags = 0; /* New value for pMem->flags */ + + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + + /* If z is a NULL pointer, set pMem to contain an SQL NULL. */ + if( !z ){ + sqlite3VdbeMemSetNull(pMem); + return SQLITE_OK; + } + + if( pMem->db ){ + iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH]; + }else{ + iLimit = SQLITE_MAX_LENGTH; + } + flags = (enc==0?MEM_Blob:MEM_Str); + if( nByte<0 ){ + assert( enc!=0 ); + if( enc==SQLITE_UTF8 ){ + nByte = 0x7fffffff & (int)strlen(z); + }else{ + for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){} + } + flags |= MEM_Term; + } + + /* The following block sets the new values of Mem.z and Mem.xDel. It + ** also sets a flag in local variable "flags" to indicate the memory + ** management (one of MEM_Dyn or MEM_Static). + */ + if( xDel==SQLITE_TRANSIENT ){ + u32 nAlloc = nByte; + if( flags&MEM_Term ){ + nAlloc += (enc==SQLITE_UTF8?1:2); + } + if( nByte>iLimit ){ + return sqlite3ErrorToParser(pMem->db, SQLITE_TOOBIG); + } + testcase( nAlloc==0 ); + testcase( nAlloc==31 ); + testcase( nAlloc==32 ); + if( sqlite3VdbeMemClearAndResize(pMem, (int)MAX(nAlloc,32)) ){ + return SQLITE_NOMEM_BKPT; + } + memcpy(pMem->z, z, nAlloc); + }else{ + sqlite3VdbeMemRelease(pMem); + pMem->z = (char *)z; + if( xDel==SQLITE_DYNAMIC ){ + pMem->zMalloc = pMem->z; + pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc); + }else{ + pMem->xDel = xDel; + flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn); + } + } + + pMem->n = nByte; + pMem->flags = flags; + if( enc ){ + pMem->enc = enc; +#ifdef SQLITE_ENABLE_SESSION + }else if( pMem->db==0 ){ + pMem->enc = SQLITE_UTF8; +#endif + }else{ + assert( pMem->db!=0 ); + pMem->enc = ENC(pMem->db); + } + +#ifndef SQLITE_OMIT_UTF16 + if( enc>SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){ + return SQLITE_NOMEM_BKPT; + } +#endif + + if( nByte>iLimit ){ + return SQLITE_TOOBIG; + } + + return SQLITE_OK; +} + +/* +** Move data out of a btree key or data field and into a Mem structure. +** The data is payload from the entry that pCur is currently pointing +** to. offset and amt determine what portion of the data or key to retrieve. +** The result is written into the pMem element. +** +** The pMem object must have been initialized. This routine will use +** pMem->zMalloc to hold the content from the btree, if possible. New +** pMem->zMalloc space will be allocated if necessary. The calling routine +** is responsible for making sure that the pMem object is eventually +** destroyed. +** +** If this routine fails for any reason (malloc returns NULL or unable +** to read from the disk) then the pMem is left in an inconsistent state. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemFromBtree( + BtCursor *pCur, /* Cursor pointing at record to retrieve. */ + u32 offset, /* Offset from the start of data to return bytes from. */ + u32 amt, /* Number of bytes to return. */ + Mem *pMem /* OUT: Return data in this Mem structure. */ +){ + int rc; + pMem->flags = MEM_Null; + if( sqlite3BtreeMaxRecordSize(pCur)z); + if( rc==SQLITE_OK ){ + pMem->z[amt] = 0; /* Overrun area used when reading malformed records */ + pMem->flags = MEM_Blob; + pMem->n = (int)amt; + }else{ + sqlite3VdbeMemRelease(pMem); + } + } + return rc; +} +SQLITE_PRIVATE int sqlite3VdbeMemFromBtreeZeroOffset( + BtCursor *pCur, /* Cursor pointing at record to retrieve. */ + u32 amt, /* Number of bytes to return. */ + Mem *pMem /* OUT: Return data in this Mem structure. */ +){ + u32 available = 0; /* Number of bytes available on the local btree page */ + int rc = SQLITE_OK; /* Return code */ + + assert( sqlite3BtreeCursorIsValid(pCur) ); + assert( !VdbeMemDynamic(pMem) ); + + /* Note: the calls to BtreeKeyFetch() and DataFetch() below assert() + ** that both the BtShared and database handle mutexes are held. */ + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + pMem->z = (char *)sqlite3BtreePayloadFetch(pCur, &available); + assert( pMem->z!=0 ); + + if( amt<=available ){ + pMem->flags = MEM_Blob|MEM_Ephem; + pMem->n = (int)amt; + }else{ + rc = sqlite3VdbeMemFromBtree(pCur, 0, amt, pMem); + } + + return rc; +} + +/* +** The pVal argument is known to be a value other than NULL. +** Convert it into a string with encoding enc and return a pointer +** to a zero-terminated version of that string. +*/ +static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){ + assert( pVal!=0 ); + assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) ); + assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) ); + assert( !sqlite3VdbeMemIsRowSet(pVal) ); + assert( (pVal->flags & (MEM_Null))==0 ); + if( pVal->flags & (MEM_Blob|MEM_Str) ){ + if( ExpandBlob(pVal) ) return 0; + pVal->flags |= MEM_Str; + if( pVal->enc != (enc & ~SQLITE_UTF16_ALIGNED) ){ + sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED); + } + if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){ + assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 ); + if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){ + return 0; + } + } + sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */ + }else{ + sqlite3VdbeMemStringify(pVal, enc, 0); + assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) ); + } + assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0 + || pVal->db->mallocFailed ); + if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){ + assert( sqlite3VdbeMemValidStrRep(pVal) ); + return pVal->z; + }else{ + return 0; + } +} + +/* This function is only available internally, it is not part of the +** external API. It works in a similar way to sqlite3_value_text(), +** except the data returned is in the encoding specified by the second +** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or +** SQLITE_UTF8. +** +** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED. +** If that is the case, then the result must be aligned on an even byte +** boundary. +*/ +SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){ + if( !pVal ) return 0; + assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) ); + assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) ); + assert( !sqlite3VdbeMemIsRowSet(pVal) ); + if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){ + assert( sqlite3VdbeMemValidStrRep(pVal) ); + return pVal->z; + } + if( pVal->flags&MEM_Null ){ + return 0; + } + return valueToText(pVal, enc); +} + +/* +** Create a new sqlite3_value object. +*/ +SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *db){ + Mem *p = sqlite3DbMallocZero(db, sizeof(*p)); + if( p ){ + p->flags = MEM_Null; + p->db = db; + } + return p; +} + +/* +** Context object passed by sqlite3Stat4ProbeSetValue() through to +** valueNew(). See comments above valueNew() for details. +*/ +struct ValueNewStat4Ctx { + Parse *pParse; + Index *pIdx; + UnpackedRecord **ppRec; + int iVal; +}; + +/* +** Allocate and return a pointer to a new sqlite3_value object. If +** the second argument to this function is NULL, the object is allocated +** by calling sqlite3ValueNew(). +** +** Otherwise, if the second argument is non-zero, then this function is +** being called indirectly by sqlite3Stat4ProbeSetValue(). If it has not +** already been allocated, allocate the UnpackedRecord structure that +** that function will return to its caller here. Then return a pointer to +** an sqlite3_value within the UnpackedRecord.a[] array. +*/ +static sqlite3_value *valueNew(sqlite3 *db, struct ValueNewStat4Ctx *p){ +#ifdef SQLITE_ENABLE_STAT4 + if( p ){ + UnpackedRecord *pRec = p->ppRec[0]; + + if( pRec==0 ){ + Index *pIdx = p->pIdx; /* Index being probed */ + int nByte; /* Bytes of space to allocate */ + int i; /* Counter variable */ + int nCol = pIdx->nColumn; /* Number of index columns including rowid */ + + nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord)); + pRec = (UnpackedRecord*)sqlite3DbMallocZero(db, nByte); + if( pRec ){ + pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx); + if( pRec->pKeyInfo ){ + assert( pRec->pKeyInfo->nAllField==nCol ); + assert( pRec->pKeyInfo->enc==ENC(db) ); + pRec->aMem = (Mem *)((u8*)pRec + ROUND8(sizeof(UnpackedRecord))); + for(i=0; iaMem[i].flags = MEM_Null; + pRec->aMem[i].db = db; + } + }else{ + sqlite3DbFreeNN(db, pRec); + pRec = 0; + } + } + if( pRec==0 ) return 0; + p->ppRec[0] = pRec; + } + + pRec->nField = p->iVal+1; + return &pRec->aMem[p->iVal]; + } +#else + UNUSED_PARAMETER(p); +#endif /* defined(SQLITE_ENABLE_STAT4) */ + return sqlite3ValueNew(db); +} + +/* +** The expression object indicated by the second argument is guaranteed +** to be a scalar SQL function. If +** +** * all function arguments are SQL literals, +** * one of the SQLITE_FUNC_CONSTANT or _SLOCHNG function flags is set, and +** * the SQLITE_FUNC_NEEDCOLL function flag is not set, +** +** then this routine attempts to invoke the SQL function. Assuming no +** error occurs, output parameter (*ppVal) is set to point to a value +** object containing the result before returning SQLITE_OK. +** +** Affinity aff is applied to the result of the function before returning. +** If the result is a text value, the sqlite3_value object uses encoding +** enc. +** +** If the conditions above are not met, this function returns SQLITE_OK +** and sets (*ppVal) to NULL. Or, if an error occurs, (*ppVal) is set to +** NULL and an SQLite error code returned. +*/ +#ifdef SQLITE_ENABLE_STAT4 +static int valueFromFunction( + sqlite3 *db, /* The database connection */ + Expr *p, /* The expression to evaluate */ + u8 enc, /* Encoding to use */ + u8 aff, /* Affinity to use */ + sqlite3_value **ppVal, /* Write the new value here */ + struct ValueNewStat4Ctx *pCtx /* Second argument for valueNew() */ +){ + sqlite3_context ctx; /* Context object for function invocation */ + sqlite3_value **apVal = 0; /* Function arguments */ + int nVal = 0; /* Size of apVal[] array */ + FuncDef *pFunc = 0; /* Function definition */ + sqlite3_value *pVal = 0; /* New value */ + int rc = SQLITE_OK; /* Return code */ + ExprList *pList = 0; /* Function arguments */ + int i; /* Iterator variable */ + + assert( pCtx!=0 ); + assert( (p->flags & EP_TokenOnly)==0 ); + pList = p->x.pList; + if( pList ) nVal = pList->nExpr; + pFunc = sqlite3FindFunction(db, p->u.zToken, nVal, enc, 0); + assert( pFunc ); + if( (pFunc->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG))==0 + || (pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL) + ){ + return SQLITE_OK; + } + + if( pList ){ + apVal = (sqlite3_value**)sqlite3DbMallocZero(db, sizeof(apVal[0]) * nVal); + if( apVal==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto value_from_function_out; + } + for(i=0; ia[i].pExpr, enc, aff, &apVal[i]); + if( apVal[i]==0 || rc!=SQLITE_OK ) goto value_from_function_out; + } + } + + pVal = valueNew(db, pCtx); + if( pVal==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto value_from_function_out; + } + + assert( pCtx->pParse->rc==SQLITE_OK ); + memset(&ctx, 0, sizeof(ctx)); + ctx.pOut = pVal; + ctx.pFunc = pFunc; + pFunc->xSFunc(&ctx, nVal, apVal); + if( ctx.isError ){ + rc = ctx.isError; + sqlite3ErrorMsg(pCtx->pParse, "%s", sqlite3_value_text(pVal)); + }else{ + sqlite3ValueApplyAffinity(pVal, aff, SQLITE_UTF8); + assert( rc==SQLITE_OK ); + rc = sqlite3VdbeChangeEncoding(pVal, enc); + if( rc==SQLITE_OK && sqlite3VdbeMemTooBig(pVal) ){ + rc = SQLITE_TOOBIG; + pCtx->pParse->nErr++; + } + } + pCtx->pParse->rc = rc; + + value_from_function_out: + if( rc!=SQLITE_OK ){ + pVal = 0; + } + if( apVal ){ + for(i=0; iop)==TK_UPLUS || op==TK_SPAN ) pExpr = pExpr->pLeft; +#if defined(SQLITE_ENABLE_STAT4) + if( op==TK_REGISTER ) op = pExpr->op2; +#else + if( NEVER(op==TK_REGISTER) ) op = pExpr->op2; +#endif + + /* Compressed expressions only appear when parsing the DEFAULT clause + ** on a table column definition, and hence only when pCtx==0. This + ** check ensures that an EP_TokenOnly expression is never passed down + ** into valueFromFunction(). */ + assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 ); + + if( op==TK_CAST ){ + u8 aff = sqlite3AffinityType(pExpr->u.zToken,0); + rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx); + testcase( rc!=SQLITE_OK ); + if( *ppVal ){ + sqlite3VdbeMemCast(*ppVal, aff, SQLITE_UTF8); + sqlite3ValueApplyAffinity(*ppVal, affinity, SQLITE_UTF8); + } + return rc; + } + + /* Handle negative integers in a single step. This is needed in the + ** case when the value is -9223372036854775808. + */ + if( op==TK_UMINUS + && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){ + pExpr = pExpr->pLeft; + op = pExpr->op; + negInt = -1; + zNeg = "-"; + } + + if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){ + pVal = valueNew(db, pCtx); + if( pVal==0 ) goto no_mem; + if( ExprHasProperty(pExpr, EP_IntValue) ){ + sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt); + }else{ + zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken); + if( zVal==0 ) goto no_mem; + sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC); + } + if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_BLOB ){ + sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8); + }else{ + sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8); + } + assert( (pVal->flags & MEM_IntReal)==0 ); + if( pVal->flags & (MEM_Int|MEM_IntReal|MEM_Real) ){ + testcase( pVal->flags & MEM_Int ); + testcase( pVal->flags & MEM_Real ); + pVal->flags &= ~MEM_Str; + } + if( enc!=SQLITE_UTF8 ){ + rc = sqlite3VdbeChangeEncoding(pVal, enc); + } + }else if( op==TK_UMINUS ) { + /* This branch happens for multiple negative signs. Ex: -(-5) */ + if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx) + && pVal!=0 + ){ + sqlite3VdbeMemNumerify(pVal); + if( pVal->flags & MEM_Real ){ + pVal->u.r = -pVal->u.r; + }else if( pVal->u.i==SMALLEST_INT64 ){ +#ifndef SQLITE_OMIT_FLOATING_POINT + pVal->u.r = -(double)SMALLEST_INT64; +#else + pVal->u.r = LARGEST_INT64; +#endif + MemSetTypeFlag(pVal, MEM_Real); + }else{ + pVal->u.i = -pVal->u.i; + } + sqlite3ValueApplyAffinity(pVal, affinity, enc); + } + }else if( op==TK_NULL ){ + pVal = valueNew(db, pCtx); + if( pVal==0 ) goto no_mem; + sqlite3VdbeMemSetNull(pVal); + } +#ifndef SQLITE_OMIT_BLOB_LITERAL + else if( op==TK_BLOB ){ + int nVal; + assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' ); + assert( pExpr->u.zToken[1]=='\'' ); + pVal = valueNew(db, pCtx); + if( !pVal ) goto no_mem; + zVal = &pExpr->u.zToken[2]; + nVal = sqlite3Strlen30(zVal)-1; + assert( zVal[nVal]=='\'' ); + sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2, + 0, SQLITE_DYNAMIC); + } +#endif +#ifdef SQLITE_ENABLE_STAT4 + else if( op==TK_FUNCTION && pCtx!=0 ){ + rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx); + } +#endif + else if( op==TK_TRUEFALSE ){ + pVal = valueNew(db, pCtx); + if( pVal ){ + pVal->flags = MEM_Int; + pVal->u.i = pExpr->u.zToken[4]==0; + } + } + + *ppVal = pVal; + return rc; + +no_mem: +#ifdef SQLITE_ENABLE_STAT4 + if( pCtx==0 || pCtx->pParse->nErr==0 ) +#endif + sqlite3OomFault(db); + sqlite3DbFree(db, zVal); + assert( *ppVal==0 ); +#ifdef SQLITE_ENABLE_STAT4 + if( pCtx==0 ) sqlite3ValueFree(pVal); +#else + assert( pCtx==0 ); sqlite3ValueFree(pVal); +#endif + return SQLITE_NOMEM_BKPT; +} + +/* +** Create a new sqlite3_value object, containing the value of pExpr. +** +** This only works for very simple expressions that consist of one constant +** token (i.e. "5", "5.1", "'a string'"). If the expression can +** be converted directly into a value, then the value is allocated and +** a pointer written to *ppVal. The caller is responsible for deallocating +** the value by passing it to sqlite3ValueFree() later on. If the expression +** cannot be converted to a value, then *ppVal is set to NULL. +*/ +SQLITE_PRIVATE int sqlite3ValueFromExpr( + sqlite3 *db, /* The database connection */ + Expr *pExpr, /* The expression to evaluate */ + u8 enc, /* Encoding to use */ + u8 affinity, /* Affinity to use */ + sqlite3_value **ppVal /* Write the new value here */ +){ + return pExpr ? valueFromExpr(db, pExpr, enc, affinity, ppVal, 0) : 0; +} + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Attempt to extract a value from pExpr and use it to construct *ppVal. +** +** If pAlloc is not NULL, then an UnpackedRecord object is created for +** pAlloc if one does not exist and the new value is added to the +** UnpackedRecord object. +** +** A value is extracted in the following cases: +** +** * (pExpr==0). In this case the value is assumed to be an SQL NULL, +** +** * The expression is a bound variable, and this is a reprepare, or +** +** * The expression is a literal value. +** +** On success, *ppVal is made to point to the extracted value. The caller +** is responsible for ensuring that the value is eventually freed. +*/ +static int stat4ValueFromExpr( + Parse *pParse, /* Parse context */ + Expr *pExpr, /* The expression to extract a value from */ + u8 affinity, /* Affinity to use */ + struct ValueNewStat4Ctx *pAlloc,/* How to allocate space. Or NULL */ + sqlite3_value **ppVal /* OUT: New value object (or NULL) */ +){ + int rc = SQLITE_OK; + sqlite3_value *pVal = 0; + sqlite3 *db = pParse->db; + + /* Skip over any TK_COLLATE nodes */ + pExpr = sqlite3ExprSkipCollate(pExpr); + + assert( pExpr==0 || pExpr->op!=TK_REGISTER || pExpr->op2!=TK_VARIABLE ); + if( !pExpr ){ + pVal = valueNew(db, pAlloc); + if( pVal ){ + sqlite3VdbeMemSetNull((Mem*)pVal); + } + }else if( pExpr->op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){ + Vdbe *v; + int iBindVar = pExpr->iColumn; + sqlite3VdbeSetVarmask(pParse->pVdbe, iBindVar); + if( (v = pParse->pReprepare)!=0 ){ + pVal = valueNew(db, pAlloc); + if( pVal ){ + rc = sqlite3VdbeMemCopy((Mem*)pVal, &v->aVar[iBindVar-1]); + sqlite3ValueApplyAffinity(pVal, affinity, ENC(db)); + pVal->db = pParse->db; + } + } + }else{ + rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc); + } + + assert( pVal==0 || pVal->db==db ); + *ppVal = pVal; + return rc; +} + +/* +** This function is used to allocate and populate UnpackedRecord +** structures intended to be compared against sample index keys stored +** in the sqlite_stat4 table. +** +** A single call to this function populates zero or more fields of the +** record starting with field iVal (fields are numbered from left to +** right starting with 0). A single field is populated if: +** +** * (pExpr==0). In this case the value is assumed to be an SQL NULL, +** +** * The expression is a bound variable, and this is a reprepare, or +** +** * The sqlite3ValueFromExpr() function is able to extract a value +** from the expression (i.e. the expression is a literal value). +** +** Or, if pExpr is a TK_VECTOR, one field is populated for each of the +** vector components that match either of the two latter criteria listed +** above. +** +** Before any value is appended to the record, the affinity of the +** corresponding column within index pIdx is applied to it. Before +** this function returns, output parameter *pnExtract is set to the +** number of values appended to the record. +** +** When this function is called, *ppRec must either point to an object +** allocated by an earlier call to this function, or must be NULL. If it +** is NULL and a value can be successfully extracted, a new UnpackedRecord +** is allocated (and *ppRec set to point to it) before returning. +** +** Unless an error is encountered, SQLITE_OK is returned. It is not an +** error if a value cannot be extracted from pExpr. If an error does +** occur, an SQLite error code is returned. +*/ +SQLITE_PRIVATE int sqlite3Stat4ProbeSetValue( + Parse *pParse, /* Parse context */ + Index *pIdx, /* Index being probed */ + UnpackedRecord **ppRec, /* IN/OUT: Probe record */ + Expr *pExpr, /* The expression to extract a value from */ + int nElem, /* Maximum number of values to append */ + int iVal, /* Array element to populate */ + int *pnExtract /* OUT: Values appended to the record */ +){ + int rc = SQLITE_OK; + int nExtract = 0; + + if( pExpr==0 || pExpr->op!=TK_SELECT ){ + int i; + struct ValueNewStat4Ctx alloc; + + alloc.pParse = pParse; + alloc.pIdx = pIdx; + alloc.ppRec = ppRec; + + for(i=0; idb, pIdx, iVal+i); + alloc.iVal = iVal+i; + rc = stat4ValueFromExpr(pParse, pElem, aff, &alloc, &pVal); + if( !pVal ) break; + nExtract++; + } + } + + *pnExtract = nExtract; + return rc; +} + +/* +** Attempt to extract a value from expression pExpr using the methods +** as described for sqlite3Stat4ProbeSetValue() above. +** +** If successful, set *ppVal to point to a new value object and return +** SQLITE_OK. If no value can be extracted, but no other error occurs +** (e.g. OOM), return SQLITE_OK and set *ppVal to NULL. Or, if an error +** does occur, return an SQLite error code. The final value of *ppVal +** is undefined in this case. +*/ +SQLITE_PRIVATE int sqlite3Stat4ValueFromExpr( + Parse *pParse, /* Parse context */ + Expr *pExpr, /* The expression to extract a value from */ + u8 affinity, /* Affinity to use */ + sqlite3_value **ppVal /* OUT: New value object (or NULL) */ +){ + return stat4ValueFromExpr(pParse, pExpr, affinity, 0, ppVal); +} + +/* +** Extract the iCol-th column from the nRec-byte record in pRec. Write +** the column value into *ppVal. If *ppVal is initially NULL then a new +** sqlite3_value object is allocated. +** +** If *ppVal is initially NULL then the caller is responsible for +** ensuring that the value written into *ppVal is eventually freed. +*/ +SQLITE_PRIVATE int sqlite3Stat4Column( + sqlite3 *db, /* Database handle */ + const void *pRec, /* Pointer to buffer containing record */ + int nRec, /* Size of buffer pRec in bytes */ + int iCol, /* Column to extract */ + sqlite3_value **ppVal /* OUT: Extracted value */ +){ + u32 t = 0; /* a column type code */ + int nHdr; /* Size of the header in the record */ + int iHdr; /* Next unread header byte */ + int iField; /* Next unread data byte */ + int szField = 0; /* Size of the current data field */ + int i; /* Column index */ + u8 *a = (u8*)pRec; /* Typecast byte array */ + Mem *pMem = *ppVal; /* Write result into this Mem object */ + + assert( iCol>0 ); + iHdr = getVarint32(a, nHdr); + if( nHdr>nRec || iHdr>=nHdr ) return SQLITE_CORRUPT_BKPT; + iField = nHdr; + for(i=0; i<=iCol; i++){ + iHdr += getVarint32(&a[iHdr], t); + testcase( iHdr==nHdr ); + testcase( iHdr==nHdr+1 ); + if( iHdr>nHdr ) return SQLITE_CORRUPT_BKPT; + szField = sqlite3VdbeSerialTypeLen(t); + iField += szField; + } + testcase( iField==nRec ); + testcase( iField==nRec+1 ); + if( iField>nRec ) return SQLITE_CORRUPT_BKPT; + if( pMem==0 ){ + pMem = *ppVal = sqlite3ValueNew(db); + if( pMem==0 ) return SQLITE_NOMEM_BKPT; + } + sqlite3VdbeSerialGet(&a[iField-szField], t, pMem); + pMem->enc = ENC(db); + return SQLITE_OK; +} + +/* +** Unless it is NULL, the argument must be an UnpackedRecord object returned +** by an earlier call to sqlite3Stat4ProbeSetValue(). This call deletes +** the object. +*/ +SQLITE_PRIVATE void sqlite3Stat4ProbeFree(UnpackedRecord *pRec){ + if( pRec ){ + int i; + int nCol = pRec->pKeyInfo->nAllField; + Mem *aMem = pRec->aMem; + sqlite3 *db = aMem[0].db; + for(i=0; ipKeyInfo); + sqlite3DbFreeNN(db, pRec); + } +} +#endif /* ifdef SQLITE_ENABLE_STAT4 */ + +/* +** Change the string value of an sqlite3_value object +*/ +SQLITE_PRIVATE void sqlite3ValueSetStr( + sqlite3_value *v, /* Value to be set */ + int n, /* Length of string z */ + const void *z, /* Text of the new string */ + u8 enc, /* Encoding to use */ + void (*xDel)(void*) /* Destructor for the string */ +){ + if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel); +} + +/* +** Free an sqlite3_value object +*/ +SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value *v){ + if( !v ) return; + sqlite3VdbeMemRelease((Mem *)v); + sqlite3DbFreeNN(((Mem*)v)->db, v); +} + +/* +** The sqlite3ValueBytes() routine returns the number of bytes in the +** sqlite3_value object assuming that it uses the encoding "enc". +** The valueBytes() routine is a helper function. +*/ +static SQLITE_NOINLINE int valueBytes(sqlite3_value *pVal, u8 enc){ + return valueToText(pVal, enc)!=0 ? pVal->n : 0; +} +SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){ + Mem *p = (Mem*)pVal; + assert( (p->flags & MEM_Null)==0 || (p->flags & (MEM_Str|MEM_Blob))==0 ); + if( (p->flags & MEM_Str)!=0 && pVal->enc==enc ){ + return p->n; + } + if( (p->flags & MEM_Blob)!=0 ){ + if( p->flags & MEM_Zero ){ + return p->n + p->u.nZero; + }else{ + return p->n; + } + } + if( p->flags & MEM_Null ) return 0; + return valueBytes(pVal, enc); +} + +/************** End of vdbemem.c *********************************************/ +/************** Begin file vdbeaux.c *****************************************/ +/* +** 2003 September 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used for creating, destroying, and populating +** a VDBE (or an "sqlite3_stmt" as it is known to the outside world.) +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +/* Forward references */ +static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef); +static void vdbeFreeOpArray(sqlite3 *, Op *, int); + +/* +** Create a new virtual database engine. +*/ +SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse *pParse){ + sqlite3 *db = pParse->db; + Vdbe *p; + p = sqlite3DbMallocRawNN(db, sizeof(Vdbe) ); + if( p==0 ) return 0; + memset(&p->aOp, 0, sizeof(Vdbe)-offsetof(Vdbe,aOp)); + p->db = db; + if( db->pVdbe ){ + db->pVdbe->pPrev = p; + } + p->pNext = db->pVdbe; + p->pPrev = 0; + db->pVdbe = p; + p->magic = VDBE_MAGIC_INIT; + p->pParse = pParse; + pParse->pVdbe = p; + assert( pParse->aLabel==0 ); + assert( pParse->nLabel==0 ); + assert( p->nOpAlloc==0 ); + assert( pParse->szOpAlloc==0 ); + sqlite3VdbeAddOp2(p, OP_Init, 0, 1); + return p; +} + +/* +** Return the Parse object that owns a Vdbe object. +*/ +SQLITE_PRIVATE Parse *sqlite3VdbeParser(Vdbe *p){ + return p->pParse; +} + +/* +** Change the error string stored in Vdbe.zErrMsg +*/ +SQLITE_PRIVATE void sqlite3VdbeError(Vdbe *p, const char *zFormat, ...){ + va_list ap; + sqlite3DbFree(p->db, p->zErrMsg); + va_start(ap, zFormat); + p->zErrMsg = sqlite3VMPrintf(p->db, zFormat, ap); + va_end(ap); +} + +/* +** Remember the SQL string for a prepared statement. +*/ +SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, u8 prepFlags){ + if( p==0 ) return; + p->prepFlags = prepFlags; + if( (prepFlags & SQLITE_PREPARE_SAVESQL)==0 ){ + p->expmask = 0; + } + assert( p->zSql==0 ); + p->zSql = sqlite3DbStrNDup(p->db, z, n); +} + +#ifdef SQLITE_ENABLE_NORMALIZE +/* +** Add a new element to the Vdbe->pDblStr list. +*/ +SQLITE_PRIVATE void sqlite3VdbeAddDblquoteStr(sqlite3 *db, Vdbe *p, const char *z){ + if( p ){ + int n = sqlite3Strlen30(z); + DblquoteStr *pStr = sqlite3DbMallocRawNN(db, + sizeof(*pStr)+n+1-sizeof(pStr->z)); + if( pStr ){ + pStr->pNextStr = p->pDblStr; + p->pDblStr = pStr; + memcpy(pStr->z, z, n+1); + } + } +} +#endif + +#ifdef SQLITE_ENABLE_NORMALIZE +/* +** zId of length nId is a double-quoted identifier. Check to see if +** that identifier is really used as a string literal. +*/ +SQLITE_PRIVATE int sqlite3VdbeUsesDoubleQuotedString( + Vdbe *pVdbe, /* The prepared statement */ + const char *zId /* The double-quoted identifier, already dequoted */ +){ + DblquoteStr *pStr; + assert( zId!=0 ); + if( pVdbe->pDblStr==0 ) return 0; + for(pStr=pVdbe->pDblStr; pStr; pStr=pStr->pNextStr){ + if( strcmp(zId, pStr->z)==0 ) return 1; + } + return 0; +} +#endif + +/* +** Swap all content between two VDBE structures. +*/ +SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){ + Vdbe tmp, *pTmp; + char *zTmp; + assert( pA->db==pB->db ); + tmp = *pA; + *pA = *pB; + *pB = tmp; + pTmp = pA->pNext; + pA->pNext = pB->pNext; + pB->pNext = pTmp; + pTmp = pA->pPrev; + pA->pPrev = pB->pPrev; + pB->pPrev = pTmp; + zTmp = pA->zSql; + pA->zSql = pB->zSql; + pB->zSql = zTmp; +#ifdef SQLITE_ENABLE_NORMALIZE + zTmp = pA->zNormSql; + pA->zNormSql = pB->zNormSql; + pB->zNormSql = zTmp; +#endif + pB->expmask = pA->expmask; + pB->prepFlags = pA->prepFlags; + memcpy(pB->aCounter, pA->aCounter, sizeof(pB->aCounter)); + pB->aCounter[SQLITE_STMTSTATUS_REPREPARE]++; +} + +/* +** Resize the Vdbe.aOp array so that it is at least nOp elements larger +** than its current size. nOp is guaranteed to be less than or equal +** to 1024/sizeof(Op). +** +** If an out-of-memory error occurs while resizing the array, return +** SQLITE_NOMEM. In this case Vdbe.aOp and Vdbe.nOpAlloc remain +** unchanged (this is so that any opcodes already allocated can be +** correctly deallocated along with the rest of the Vdbe). +*/ +static int growOpArray(Vdbe *v, int nOp){ + VdbeOp *pNew; + Parse *p = v->pParse; + + /* The SQLITE_TEST_REALLOC_STRESS compile-time option is designed to force + ** more frequent reallocs and hence provide more opportunities for + ** simulated OOM faults. SQLITE_TEST_REALLOC_STRESS is generally used + ** during testing only. With SQLITE_TEST_REALLOC_STRESS grow the op array + ** by the minimum* amount required until the size reaches 512. Normal + ** operation (without SQLITE_TEST_REALLOC_STRESS) is to double the current + ** size of the op array or add 1KB of space, whichever is smaller. */ +#ifdef SQLITE_TEST_REALLOC_STRESS + sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc + : (sqlite3_int64)v->nOpAlloc+nOp); +#else + sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc + : (sqlite3_int64)(1024/sizeof(Op))); + UNUSED_PARAMETER(nOp); +#endif + + /* Ensure that the size of a VDBE does not grow too large */ + if( nNew > p->db->aLimit[SQLITE_LIMIT_VDBE_OP] ){ + sqlite3OomFault(p->db); + return SQLITE_NOMEM; + } + + assert( nOp<=(1024/sizeof(Op)) ); + assert( nNew>=(v->nOpAlloc+nOp) ); + pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op)); + if( pNew ){ + p->szOpAlloc = sqlite3DbMallocSize(p->db, pNew); + v->nOpAlloc = p->szOpAlloc/sizeof(Op); + v->aOp = pNew; + } + return (pNew ? SQLITE_OK : SQLITE_NOMEM_BKPT); +} + +#ifdef SQLITE_DEBUG +/* This routine is just a convenient place to set a breakpoint that will +** fire after each opcode is inserted and displayed using +** "PRAGMA vdbe_addoptrace=on". Parameters "pc" (program counter) and +** pOp are available to make the breakpoint conditional. +** +** Other useful labels for breakpoints include: +** test_trace_breakpoint(pc,pOp) +** sqlite3CorruptError(lineno) +** sqlite3MisuseError(lineno) +** sqlite3CantopenError(lineno) +*/ +static void test_addop_breakpoint(int pc, Op *pOp){ + static int n = 0; + n++; +} +#endif + +/* +** Add a new instruction to the list of instructions current in the +** VDBE. Return the address of the new instruction. +** +** Parameters: +** +** p Pointer to the VDBE +** +** op The opcode for this instruction +** +** p1, p2, p3 Operands +** +** Use the sqlite3VdbeResolveLabel() function to fix an address and +** the sqlite3VdbeChangeP4() function to change the value of the P4 +** operand. +*/ +static SQLITE_NOINLINE int growOp3(Vdbe *p, int op, int p1, int p2, int p3){ + assert( p->nOpAlloc<=p->nOp ); + if( growOpArray(p, 1) ) return 1; + assert( p->nOpAlloc>p->nOp ); + return sqlite3VdbeAddOp3(p, op, p1, p2, p3); +} +SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){ + int i; + VdbeOp *pOp; + + i = p->nOp; + assert( p->magic==VDBE_MAGIC_INIT ); + assert( op>=0 && op<0xff ); + if( p->nOpAlloc<=i ){ + return growOp3(p, op, p1, p2, p3); + } + p->nOp++; + pOp = &p->aOp[i]; + pOp->opcode = (u8)op; + pOp->p5 = 0; + pOp->p1 = p1; + pOp->p2 = p2; + pOp->p3 = p3; + pOp->p4.p = 0; + pOp->p4type = P4_NOTUSED; +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + pOp->zComment = 0; +#endif +#ifdef SQLITE_DEBUG + if( p->db->flags & SQLITE_VdbeAddopTrace ){ + sqlite3VdbePrintOp(0, i, &p->aOp[i]); + 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 + return i; +} +SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe *p, int op){ + return sqlite3VdbeAddOp3(p, op, 0, 0, 0); +} +SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){ + return sqlite3VdbeAddOp3(p, op, p1, 0, 0); +} +SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){ + return sqlite3VdbeAddOp3(p, op, p1, p2, 0); +} + +/* Generate code for an unconditional jump to instruction iDest +*/ +SQLITE_PRIVATE int sqlite3VdbeGoto(Vdbe *p, int iDest){ + return sqlite3VdbeAddOp3(p, OP_Goto, 0, iDest, 0); +} + +/* Generate code to cause the string zStr to be loaded into +** register iDest +*/ +SQLITE_PRIVATE int sqlite3VdbeLoadString(Vdbe *p, int iDest, const char *zStr){ + return sqlite3VdbeAddOp4(p, OP_String8, 0, iDest, 0, zStr, 0); +} + +/* +** Generate code that initializes multiple registers to string or integer +** constants. The registers begin with iDest and increase consecutively. +** One register is initialized for each characgter in zTypes[]. For each +** "s" character in zTypes[], the register is a string if the argument is +** not NULL, or OP_Null if the value is a null pointer. For each "i" character +** in zTypes[], the register is initialized to an integer. +** +** If the input string does not end with "X" then an OP_ResultRow instruction +** is generated for the values inserted. +*/ +SQLITE_PRIVATE void sqlite3VdbeMultiLoad(Vdbe *p, int iDest, const char *zTypes, ...){ + va_list ap; + int i; + char c; + va_start(ap, zTypes); + for(i=0; (c = zTypes[i])!=0; i++){ + if( c=='s' ){ + const char *z = va_arg(ap, const char*); + sqlite3VdbeAddOp4(p, z==0 ? OP_Null : OP_String8, 0, iDest+i, 0, z, 0); + }else if( c=='i' ){ + sqlite3VdbeAddOp2(p, OP_Integer, va_arg(ap, int), iDest+i); + }else{ + goto skip_op_resultrow; + } + } + sqlite3VdbeAddOp2(p, OP_ResultRow, iDest, i); +skip_op_resultrow: + va_end(ap); +} + +/* +** Add an opcode that includes the p4 value as a pointer. +*/ +SQLITE_PRIVATE int sqlite3VdbeAddOp4( + Vdbe *p, /* Add the opcode to this VM */ + int op, /* The new opcode */ + int p1, /* The P1 operand */ + int p2, /* The P2 operand */ + int p3, /* The P3 operand */ + const char *zP4, /* The P4 operand */ + int p4type /* P4 operand type */ +){ + int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3); + sqlite3VdbeChangeP4(p, addr, zP4, p4type); + return addr; +} + +/* +** Add an OP_Function or OP_PureFunc opcode. +** +** The eCallCtx argument is information (typically taken from Expr.op2) +** that describes the calling context of the function. 0 means a general +** function call. NC_IsCheck means called by a check constraint, +** NC_IdxExpr means called as part of an index expression. NC_PartIdx +** means in the WHERE clause of a partial index. NC_GenCol means called +** while computing a generated column value. 0 is the usual case. +*/ +SQLITE_PRIVATE int sqlite3VdbeAddFunctionCall( + Parse *pParse, /* Parsing context */ + int p1, /* Constant argument mask */ + int p2, /* First argument register */ + int p3, /* Register into which results are written */ + int nArg, /* Number of argument */ + const FuncDef *pFunc, /* The function to be invoked */ + int eCallCtx /* Calling context */ +){ + Vdbe *v = pParse->pVdbe; + int nByte; + int addr; + sqlite3_context *pCtx; + assert( v ); + nByte = sizeof(*pCtx) + (nArg-1)*sizeof(sqlite3_value*); + pCtx = sqlite3DbMallocRawNN(pParse->db, nByte); + if( pCtx==0 ){ + assert( pParse->db->mallocFailed ); + freeEphemeralFunction(pParse->db, (FuncDef*)pFunc); + return 0; + } + pCtx->pOut = 0; + pCtx->pFunc = (FuncDef*)pFunc; + pCtx->pVdbe = 0; + pCtx->isError = 0; + pCtx->argc = nArg; + pCtx->iOp = sqlite3VdbeCurrentAddr(v); + addr = sqlite3VdbeAddOp4(v, eCallCtx ? OP_PureFunc : OP_Function, + p1, p2, p3, (char*)pCtx, P4_FUNCCTX); + sqlite3VdbeChangeP5(v, eCallCtx & NC_SelfRef); + return addr; +} + +/* +** Add an opcode that includes the p4 value with a P4_INT64 or +** P4_REAL type. +*/ +SQLITE_PRIVATE int sqlite3VdbeAddOp4Dup8( + Vdbe *p, /* Add the opcode to this VM */ + int op, /* The new opcode */ + int p1, /* The P1 operand */ + int p2, /* The P2 operand */ + int p3, /* The P3 operand */ + const u8 *zP4, /* The P4 operand */ + int p4type /* P4 operand type */ +){ + char *p4copy = sqlite3DbMallocRawNN(sqlite3VdbeDb(p), 8); + if( p4copy ) memcpy(p4copy, zP4, 8); + return sqlite3VdbeAddOp4(p, op, p1, p2, p3, p4copy, p4type); +} + +#ifndef SQLITE_OMIT_EXPLAIN +/* +** Return the address of the current EXPLAIN QUERY PLAN baseline. +** 0 means "none". +*/ +SQLITE_PRIVATE int sqlite3VdbeExplainParent(Parse *pParse){ + VdbeOp *pOp; + if( pParse->addrExplain==0 ) return 0; + pOp = sqlite3VdbeGetOp(pParse->pVdbe, pParse->addrExplain); + return pOp->p2; +} + +/* +** Set a debugger breakpoint on the following routine in order to +** monitor the EXPLAIN QUERY PLAN code generation. +*/ +#if defined(SQLITE_DEBUG) +SQLITE_PRIVATE void sqlite3ExplainBreakpoint(const char *z1, const char *z2){ + (void)z1; + (void)z2; +} +#endif + +/* +** Add a new OP_Explain opcode. +** +** If the bPush flag is true, then make this opcode the parent for +** subsequent Explains until sqlite3VdbeExplainPop() is called. +*/ +SQLITE_PRIVATE void sqlite3VdbeExplain(Parse *pParse, u8 bPush, const char *zFmt, ...){ +#ifndef SQLITE_DEBUG + /* Always include the OP_Explain opcodes if SQLITE_DEBUG is defined. + ** But omit them (for performance) during production builds */ + if( pParse->explain==2 ) +#endif + { + char *zMsg; + Vdbe *v; + va_list ap; + int iThis; + va_start(ap, zFmt); + zMsg = sqlite3VMPrintf(pParse->db, zFmt, ap); + va_end(ap); + v = pParse->pVdbe; + iThis = v->nOp; + sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0, + zMsg, P4_DYNAMIC); + sqlite3ExplainBreakpoint(bPush?"PUSH":"", sqlite3VdbeGetOp(v,-1)->p4.z); + if( bPush){ + pParse->addrExplain = iThis; + } + } +} + +/* +** Pop the EXPLAIN QUERY PLAN stack one level. +*/ +SQLITE_PRIVATE void sqlite3VdbeExplainPop(Parse *pParse){ + sqlite3ExplainBreakpoint("POP", 0); + pParse->addrExplain = sqlite3VdbeExplainParent(pParse); +} +#endif /* SQLITE_OMIT_EXPLAIN */ + +/* +** Add an OP_ParseSchema opcode. This routine is broken out from +** sqlite3VdbeAddOp4() since it needs to also needs to mark all btrees +** as having been used. +** +** The zWhere string must have been obtained from sqlite3_malloc(). +** This routine will take ownership of the allocated memory. +*/ +SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere){ + int j; + sqlite3VdbeAddOp4(p, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC); + for(j=0; jdb->nDb; j++) sqlite3VdbeUsesBtree(p, j); + sqlite3MayAbort(p->pParse); +} + +/* +** Add an opcode that includes the p4 value as an integer. +*/ +SQLITE_PRIVATE int sqlite3VdbeAddOp4Int( + Vdbe *p, /* Add the opcode to this VM */ + int op, /* The new opcode */ + int p1, /* The P1 operand */ + int p2, /* The P2 operand */ + int p3, /* The P3 operand */ + int p4 /* The P4 operand as an integer */ +){ + int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3); + if( p->db->mallocFailed==0 ){ + VdbeOp *pOp = &p->aOp[addr]; + pOp->p4type = P4_INT32; + pOp->p4.i = p4; + } + return addr; +} + +/* Insert the end of a co-routine +*/ +SQLITE_PRIVATE void sqlite3VdbeEndCoroutine(Vdbe *v, int regYield){ + sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield); + + /* Clear the temporary register cache, thereby ensuring that each + ** co-routine has its own independent set of registers, because co-routines + ** might expect their registers to be preserved across an OP_Yield, and + ** that could cause problems if two or more co-routines are using the same + ** temporary register. + */ + v->pParse->nTempReg = 0; + v->pParse->nRangeReg = 0; +} + +/* +** Create a new symbolic label for an instruction that has yet to be +** coded. The symbolic label is really just a negative number. The +** label can be used as the P2 value of an operation. Later, when +** the label is resolved to a specific address, the VDBE will scan +** through its operation list and change all values of P2 which match +** the label into the resolved address. +** +** The VDBE knows that a P2 value is a label because labels are +** always negative and P2 values are suppose to be non-negative. +** Hence, a negative P2 value is a label that has yet to be resolved. +** (Later:) This is only true for opcodes that have the OPFLG_JUMP +** property. +** +** Variable usage notes: +** +** Parse.aLabel[x] Stores the address that the x-th label resolves +** into. For testing (SQLITE_DEBUG), unresolved +** labels stores -1, but that is not required. +** Parse.nLabelAlloc Number of slots allocated to Parse.aLabel[] +** Parse.nLabel The *negative* of the number of labels that have +** been issued. The negative is stored because +** that gives a performance improvement over storing +** the equivalent positive value. +*/ +SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Parse *pParse){ + return --pParse->nLabel; +} + +/* +** Resolve label "x" to be the address of the next instruction to +** be inserted. The parameter "x" must have been obtained from +** a prior call to sqlite3VdbeMakeLabel(). +*/ +static SQLITE_NOINLINE void resizeResolveLabel(Parse *p, Vdbe *v, int j){ + int nNewSize = 10 - p->nLabel; + p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel, + nNewSize*sizeof(p->aLabel[0])); + if( p->aLabel==0 ){ + p->nLabelAlloc = 0; + }else{ +#ifdef SQLITE_DEBUG + int i; + for(i=p->nLabelAlloc; iaLabel[i] = -1; +#endif + p->nLabelAlloc = nNewSize; + p->aLabel[j] = v->nOp; + } +} +SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe *v, int x){ + Parse *p = v->pParse; + int j = ADDR(x); + assert( v->magic==VDBE_MAGIC_INIT ); + assert( j<-p->nLabel ); + assert( j>=0 ); +#ifdef SQLITE_DEBUG + if( p->db->flags & SQLITE_VdbeAddopTrace ){ + printf("RESOLVE LABEL %d to %d\n", x, v->nOp); + } +#endif + if( p->nLabelAlloc + p->nLabel < 0 ){ + resizeResolveLabel(p,v,j); + }else{ + assert( p->aLabel[j]==(-1) ); /* Labels may only be resolved once */ + p->aLabel[j] = v->nOp; + } +} + +/* +** Mark the VDBE as one that can only be run one time. +*/ +SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe *p){ + p->runOnlyOnce = 1; +} + +/* +** Mark the VDBE as one that can only be run multiple times. +*/ +SQLITE_PRIVATE void sqlite3VdbeReusable(Vdbe *p){ + p->runOnlyOnce = 0; +} + +#ifdef SQLITE_DEBUG /* sqlite3AssertMayAbort() logic */ + +/* +** The following type and function are used to iterate through all opcodes +** in a Vdbe main program and each of the sub-programs (triggers) it may +** invoke directly or indirectly. It should be used as follows: +** +** Op *pOp; +** VdbeOpIter sIter; +** +** memset(&sIter, 0, sizeof(sIter)); +** sIter.v = v; // v is of type Vdbe* +** while( (pOp = opIterNext(&sIter)) ){ +** // Do something with pOp +** } +** sqlite3DbFree(v->db, sIter.apSub); +** +*/ +typedef struct VdbeOpIter VdbeOpIter; +struct VdbeOpIter { + Vdbe *v; /* Vdbe to iterate through the opcodes of */ + SubProgram **apSub; /* Array of subprograms */ + int nSub; /* Number of entries in apSub */ + int iAddr; /* Address of next instruction to return */ + int iSub; /* 0 = main program, 1 = first sub-program etc. */ +}; +static Op *opIterNext(VdbeOpIter *p){ + Vdbe *v = p->v; + Op *pRet = 0; + Op *aOp; + int nOp; + + if( p->iSub<=p->nSub ){ + + if( p->iSub==0 ){ + aOp = v->aOp; + nOp = v->nOp; + }else{ + aOp = p->apSub[p->iSub-1]->aOp; + nOp = p->apSub[p->iSub-1]->nOp; + } + assert( p->iAddriAddr]; + p->iAddr++; + if( p->iAddr==nOp ){ + p->iSub++; + p->iAddr = 0; + } + + if( pRet->p4type==P4_SUBPROGRAM ){ + int nByte = (p->nSub+1)*sizeof(SubProgram*); + int j; + for(j=0; jnSub; j++){ + if( p->apSub[j]==pRet->p4.pProgram ) break; + } + if( j==p->nSub ){ + p->apSub = sqlite3DbReallocOrFree(v->db, p->apSub, nByte); + if( !p->apSub ){ + pRet = 0; + }else{ + p->apSub[p->nSub++] = pRet->p4.pProgram; + } + } + } + } + + return pRet; +} + +/* +** Check if the program stored in the VM associated with pParse may +** throw an ABORT exception (causing the statement, but not entire transaction +** to be rolled back). This condition is true if the main program or any +** sub-programs contains any of the following: +** +** * OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort. +** * OP_HaltIfNull with P1=SQLITE_CONSTRAINT and P2=OE_Abort. +** * OP_Destroy +** * OP_VUpdate +** * OP_VCreate +** * OP_VRename +** * OP_FkCounter with P2==0 (immediate foreign key constraint) +** * OP_CreateBtree/BTREE_INTKEY and OP_InitCoroutine +** (for CREATE TABLE AS SELECT ...) +** +** Then check that the value of Parse.mayAbort is true if an +** ABORT may be thrown, or false otherwise. Return true if it does +** match, or false otherwise. This function is intended to be used as +** part of an assert statement in the compiler. Similar to: +** +** assert( sqlite3VdbeAssertMayAbort(pParse->pVdbe, pParse->mayAbort) ); +*/ +SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){ + int hasAbort = 0; + int hasFkCounter = 0; + int hasCreateTable = 0; + int hasCreateIndex = 0; + int hasInitCoroutine = 0; + Op *pOp; + VdbeOpIter sIter; + memset(&sIter, 0, sizeof(sIter)); + sIter.v = v; + + while( (pOp = opIterNext(&sIter))!=0 ){ + int opcode = pOp->opcode; + if( opcode==OP_Destroy || opcode==OP_VUpdate || opcode==OP_VRename + || opcode==OP_VDestroy + || opcode==OP_VCreate + || opcode==OP_ParseSchema + || ((opcode==OP_Halt || opcode==OP_HaltIfNull) + && ((pOp->p1)!=SQLITE_OK && pOp->p2==OE_Abort)) + ){ + hasAbort = 1; + break; + } + if( opcode==OP_CreateBtree && pOp->p3==BTREE_INTKEY ) hasCreateTable = 1; + if( mayAbort ){ + /* hasCreateIndex may also be set for some DELETE statements that use + ** OP_Clear. So this routine may end up returning true in the case + ** where a "DELETE FROM tbl" has a statement-journal but does not + ** require one. This is not so bad - it is an inefficiency, not a bug. */ + if( opcode==OP_CreateBtree && pOp->p3==BTREE_BLOBKEY ) hasCreateIndex = 1; + if( opcode==OP_Clear ) hasCreateIndex = 1; + } + if( opcode==OP_InitCoroutine ) hasInitCoroutine = 1; +#ifndef SQLITE_OMIT_FOREIGN_KEY + if( opcode==OP_FkCounter && pOp->p1==0 && pOp->p2==1 ){ + hasFkCounter = 1; + } +#endif + } + sqlite3DbFree(v->db, sIter.apSub); + + /* Return true if hasAbort==mayAbort. Or if a malloc failure occurred. + ** If malloc failed, then the while() loop above may not have iterated + ** through all opcodes and hasAbort may be set incorrectly. Return + ** true for this case to prevent the assert() in the callers frame + ** from failing. */ + return ( v->db->mallocFailed || hasAbort==mayAbort || hasFkCounter + || (hasCreateTable && hasInitCoroutine) || hasCreateIndex + ); +} +#endif /* SQLITE_DEBUG - the sqlite3AssertMayAbort() function */ + +#ifdef SQLITE_DEBUG +/* +** Increment the nWrite counter in the VDBE if the cursor is not an +** ephemeral cursor, or if the cursor argument is NULL. +*/ +SQLITE_PRIVATE void sqlite3VdbeIncrWriteCounter(Vdbe *p, VdbeCursor *pC){ + if( pC==0 + || (pC->eCurType!=CURTYPE_SORTER + && pC->eCurType!=CURTYPE_PSEUDO + && !pC->isEphemeral) + ){ + p->nWrite++; + } +} +#endif + +#ifdef SQLITE_DEBUG +/* +** Assert if an Abort at this point in time might result in a corrupt +** database. +*/ +SQLITE_PRIVATE void sqlite3VdbeAssertAbortable(Vdbe *p){ + assert( p->nWrite==0 || p->usesStmtJournal ); +} +#endif + +/* +** This routine is called after all opcodes have been inserted. It loops +** through all the opcodes and fixes up some details. +** +** (1) For each jump instruction with a negative P2 value (a label) +** resolve the P2 value to an actual address. +** +** (2) Compute the maximum number of arguments used by any SQL function +** and store that value in *pMaxFuncArgs. +** +** (3) Update the Vdbe.readOnly and Vdbe.bIsReader flags to accurately +** indicate what the prepared statement actually does. +** +** (4) Initialize the p4.xAdvance pointer on opcodes that use it. +** +** (5) Reclaim the memory allocated for storing labels. +** +** This routine will only function correctly if the mkopcodeh.tcl generator +** script numbers the opcodes correctly. Changes to this routine must be +** coordinated with changes to mkopcodeh.tcl. +*/ +static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){ + int nMaxArgs = *pMaxFuncArgs; + Op *pOp; + Parse *pParse = p->pParse; + int *aLabel = pParse->aLabel; + p->readOnly = 1; + p->bIsReader = 0; + pOp = &p->aOp[p->nOp-1]; + while(1){ + + /* Only JUMP opcodes and the short list of special opcodes in the switch + ** below need to be considered. The mkopcodeh.tcl generator script groups + ** all these opcodes together near the front of the opcode list. Skip + ** any opcode that does not need processing by virtual of the fact that + ** it is larger than SQLITE_MX_JUMP_OPCODE, as a performance optimization. + */ + if( pOp->opcode<=SQLITE_MX_JUMP_OPCODE ){ + /* NOTE: Be sure to update mkopcodeh.tcl when adding or removing + ** cases from this switch! */ + switch( pOp->opcode ){ + case OP_Transaction: { + if( pOp->p2!=0 ) p->readOnly = 0; + /* no break */ deliberate_fall_through + } + case OP_AutoCommit: + case OP_Savepoint: { + p->bIsReader = 1; + break; + } +#ifndef SQLITE_OMIT_WAL + case OP_Checkpoint: +#endif + case OP_Vacuum: + case OP_JournalMode: { + p->readOnly = 0; + p->bIsReader = 1; + break; + } + case OP_Next: + case OP_SorterNext: { + pOp->p4.xAdvance = sqlite3BtreeNext; + pOp->p4type = P4_ADVANCE; + /* The code generator never codes any of these opcodes as a jump + ** to a label. They are always coded as a jump backwards to a + ** known address */ + assert( pOp->p2>=0 ); + break; + } + case OP_Prev: { + pOp->p4.xAdvance = sqlite3BtreePrevious; + pOp->p4type = P4_ADVANCE; + /* The code generator never codes any of these opcodes as a jump + ** to a label. They are always coded as a jump backwards to a + ** known address */ + assert( pOp->p2>=0 ); + break; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + case OP_VUpdate: { + if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2; + break; + } + case OP_VFilter: { + int n; + assert( (pOp - p->aOp) >= 3 ); + assert( pOp[-1].opcode==OP_Integer ); + n = pOp[-1].p1; + if( n>nMaxArgs ) nMaxArgs = n; + /* Fall through into the default case */ + /* no break */ deliberate_fall_through + } +#endif + default: { + if( pOp->p2<0 ){ + /* The mkopcodeh.tcl script has so arranged things that the only + ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to + ** have non-negative values for P2. */ + assert( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)!=0 ); + assert( ADDR(pOp->p2)<-pParse->nLabel ); + pOp->p2 = aLabel[ADDR(pOp->p2)]; + } + break; + } + } + /* The mkopcodeh.tcl script has so arranged things that the only + ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to + ** have non-negative values for P2. */ + assert( (sqlite3OpcodeProperty[pOp->opcode]&OPFLG_JUMP)==0 || pOp->p2>=0); + } + if( pOp==p->aOp ) break; + pOp--; + } + sqlite3DbFree(p->db, pParse->aLabel); + pParse->aLabel = 0; + pParse->nLabel = 0; + *pMaxFuncArgs = nMaxArgs; + assert( p->bIsReader!=0 || DbMaskAllZero(p->btreeMask) ); +} + +/* +** Return the address of the next instruction to be inserted. +*/ +SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe *p){ + assert( p->magic==VDBE_MAGIC_INIT ); + return p->nOp; +} + +/* +** Verify that at least N opcode slots are available in p without +** having to malloc for more space (except when compiled using +** SQLITE_TEST_REALLOC_STRESS). This interface is used during testing +** to verify that certain calls to sqlite3VdbeAddOpList() can never +** fail due to a OOM fault and hence that the return value from +** sqlite3VdbeAddOpList() will always be non-NULL. +*/ +#if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS) +SQLITE_PRIVATE void sqlite3VdbeVerifyNoMallocRequired(Vdbe *p, int N){ + assert( p->nOp + N <= p->nOpAlloc ); +} +#endif + +/* +** Verify that the VM passed as the only argument does not contain +** an OP_ResultRow opcode. Fail an assert() if it does. This is used +** by code in pragma.c to ensure that the implementation of certain +** pragmas comports with the flags specified in the mkpragmatab.tcl +** script. +*/ +#if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS) +SQLITE_PRIVATE void sqlite3VdbeVerifyNoResultRow(Vdbe *p){ + int i; + for(i=0; inOp; i++){ + assert( p->aOp[i].opcode!=OP_ResultRow ); + } +} +#endif + +/* +** Generate code (a single OP_Abortable opcode) that will +** verify that the VDBE program can safely call Abort in the current +** context. +*/ +#if defined(SQLITE_DEBUG) +SQLITE_PRIVATE void sqlite3VdbeVerifyAbortable(Vdbe *p, int onError){ + if( onError==OE_Abort ) sqlite3VdbeAddOp0(p, OP_Abortable); +} +#endif + +/* +** This function returns a pointer to the array of opcodes associated with +** the Vdbe passed as the first argument. It is the callers responsibility +** to arrange for the returned array to be eventually freed using the +** vdbeFreeOpArray() function. +** +** Before returning, *pnOp is set to the number of entries in the returned +** array. Also, *pnMaxArg is set to the larger of its current value and +** the number of entries in the Vdbe.apArg[] array required to execute the +** returned program. +*/ +SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe *p, int *pnOp, int *pnMaxArg){ + VdbeOp *aOp = p->aOp; + assert( aOp && !p->db->mallocFailed ); + + /* Check that sqlite3VdbeUsesBtree() was not called on this VM */ + assert( DbMaskAllZero(p->btreeMask) ); + + resolveP2Values(p, pnMaxArg); + *pnOp = p->nOp; + p->aOp = 0; + return aOp; +} + +/* +** Add a whole list of operations to the operation stack. Return a +** pointer to the first operation inserted. +** +** Non-zero P2 arguments to jump instructions are automatically adjusted +** so that the jump target is relative to the first operation inserted. +*/ +SQLITE_PRIVATE VdbeOp *sqlite3VdbeAddOpList( + Vdbe *p, /* Add opcodes to the prepared statement */ + int nOp, /* Number of opcodes to add */ + VdbeOpList const *aOp, /* The opcodes to be added */ + int iLineno /* Source-file line number of first opcode */ +){ + int i; + VdbeOp *pOut, *pFirst; + assert( nOp>0 ); + assert( p->magic==VDBE_MAGIC_INIT ); + if( p->nOp + nOp > p->nOpAlloc && growOpArray(p, nOp) ){ + return 0; + } + pFirst = pOut = &p->aOp[p->nOp]; + for(i=0; iopcode = aOp->opcode; + pOut->p1 = aOp->p1; + pOut->p2 = aOp->p2; + assert( aOp->p2>=0 ); + if( (sqlite3OpcodeProperty[aOp->opcode] & OPFLG_JUMP)!=0 && aOp->p2>0 ){ + pOut->p2 += p->nOp; + } + pOut->p3 = aOp->p3; + pOut->p4type = P4_NOTUSED; + pOut->p4.p = 0; + pOut->p5 = 0; +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + pOut->zComment = 0; +#endif +#ifdef SQLITE_VDBE_COVERAGE + pOut->iSrcLine = iLineno+i; +#else + (void)iLineno; +#endif +#ifdef SQLITE_DEBUG + if( p->db->flags & SQLITE_VdbeAddopTrace ){ + sqlite3VdbePrintOp(0, i+p->nOp, &p->aOp[i+p->nOp]); + } +#endif + } + p->nOp += nOp; + return pFirst; +} + +#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) +/* +** Add an entry to the array of counters managed by sqlite3_stmt_scanstatus(). +*/ +SQLITE_PRIVATE void sqlite3VdbeScanStatus( + Vdbe *p, /* VM to add scanstatus() to */ + int addrExplain, /* Address of OP_Explain (or 0) */ + int addrLoop, /* Address of loop counter */ + int addrVisit, /* Address of rows visited counter */ + LogEst nEst, /* Estimated number of output rows */ + const char *zName /* Name of table or index being scanned */ +){ + sqlite3_int64 nByte = (p->nScan+1) * sizeof(ScanStatus); + ScanStatus *aNew; + aNew = (ScanStatus*)sqlite3DbRealloc(p->db, p->aScan, nByte); + if( aNew ){ + ScanStatus *pNew = &aNew[p->nScan++]; + pNew->addrExplain = addrExplain; + pNew->addrLoop = addrLoop; + pNew->addrVisit = addrVisit; + pNew->nEst = nEst; + pNew->zName = sqlite3DbStrDup(p->db, zName); + p->aScan = aNew; + } +} +#endif + + +/* +** Change the value of the opcode, or P1, P2, P3, or P5 operands +** for a specific instruction. +*/ +SQLITE_PRIVATE void sqlite3VdbeChangeOpcode(Vdbe *p, int addr, u8 iNewOpcode){ + sqlite3VdbeGetOp(p,addr)->opcode = iNewOpcode; +} +SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe *p, int addr, int val){ + sqlite3VdbeGetOp(p,addr)->p1 = val; +} +SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe *p, int addr, int val){ + sqlite3VdbeGetOp(p,addr)->p2 = val; +} +SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe *p, int addr, int val){ + sqlite3VdbeGetOp(p,addr)->p3 = val; +} +SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe *p, u16 p5){ + assert( p->nOp>0 || p->db->mallocFailed ); + if( p->nOp>0 ) p->aOp[p->nOp-1].p5 = p5; +} + +/* +** Change the P2 operand of instruction addr so that it points to +** the address of the next instruction to be coded. +*/ +SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe *p, int addr){ + sqlite3VdbeChangeP2(p, addr, p->nOp); +} + +/* +** Change the P2 operand of the jump instruction at addr so that +** the jump lands on the next opcode. Or if the jump instruction was +** the previous opcode (and is thus a no-op) then simply back up +** the next instruction counter by one slot so that the jump is +** overwritten by the next inserted opcode. +** +** This routine is an optimization of sqlite3VdbeJumpHere() that +** strives to omit useless byte-code like this: +** +** 7 Once 0 8 0 +** 8 ... +*/ +SQLITE_PRIVATE void sqlite3VdbeJumpHereOrPopInst(Vdbe *p, int addr){ + if( addr==p->nOp-1 ){ + assert( p->aOp[addr].opcode==OP_Once + || p->aOp[addr].opcode==OP_If + || p->aOp[addr].opcode==OP_FkIfZero ); + assert( p->aOp[addr].p4type==0 ); +#ifdef SQLITE_VDBE_COVERAGE + sqlite3VdbeGetOp(p,-1)->iSrcLine = 0; /* Erase VdbeCoverage() macros */ +#endif + p->nOp--; + }else{ + sqlite3VdbeChangeP2(p, addr, p->nOp); + } +} + + +/* +** If the input FuncDef structure is ephemeral, then free it. If +** the FuncDef is not ephermal, then do nothing. +*/ +static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef){ + if( (pDef->funcFlags & SQLITE_FUNC_EPHEM)!=0 ){ + sqlite3DbFreeNN(db, pDef); + } +} + +/* +** Delete a P4 value if necessary. +*/ +static SQLITE_NOINLINE void freeP4Mem(sqlite3 *db, Mem *p){ + if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc); + sqlite3DbFreeNN(db, p); +} +static SQLITE_NOINLINE void freeP4FuncCtx(sqlite3 *db, sqlite3_context *p){ + freeEphemeralFunction(db, p->pFunc); + sqlite3DbFreeNN(db, p); +} +static void freeP4(sqlite3 *db, int p4type, void *p4){ + assert( db ); + switch( p4type ){ + case P4_FUNCCTX: { + freeP4FuncCtx(db, (sqlite3_context*)p4); + break; + } + case P4_REAL: + case P4_INT64: + case P4_DYNAMIC: + case P4_DYNBLOB: + case P4_INTARRAY: { + sqlite3DbFree(db, p4); + break; + } + case P4_KEYINFO: { + if( db->pnBytesFreed==0 ) sqlite3KeyInfoUnref((KeyInfo*)p4); + break; + } +#ifdef SQLITE_ENABLE_CURSOR_HINTS + case P4_EXPR: { + sqlite3ExprDelete(db, (Expr*)p4); + break; + } +#endif + case P4_FUNCDEF: { + freeEphemeralFunction(db, (FuncDef*)p4); + break; + } + case P4_MEM: { + if( db->pnBytesFreed==0 ){ + sqlite3ValueFree((sqlite3_value*)p4); + }else{ + freeP4Mem(db, (Mem*)p4); + } + break; + } + case P4_VTAB : { + if( db->pnBytesFreed==0 ) sqlite3VtabUnlock((VTable *)p4); + break; + } + } +} + +/* +** Free the space allocated for aOp and any p4 values allocated for the +** opcodes contained within. If aOp is not NULL it is assumed to contain +** nOp entries. +*/ +static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){ + if( aOp ){ + Op *pOp; + for(pOp=&aOp[nOp-1]; pOp>=aOp; pOp--){ + if( pOp->p4type <= P4_FREE_IF_LE ) freeP4(db, pOp->p4type, pOp->p4.p); +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + sqlite3DbFree(db, pOp->zComment); +#endif + } + sqlite3DbFreeNN(db, aOp); + } +} + +/* +** Link the SubProgram object passed as the second argument into the linked +** list at Vdbe.pSubProgram. This list is used to delete all sub-program +** objects when the VM is no longer required. +*/ +SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *pVdbe, SubProgram *p){ + p->pNext = pVdbe->pProgram; + pVdbe->pProgram = p; +} + +/* +** Return true if the given Vdbe has any SubPrograms. +*/ +SQLITE_PRIVATE int sqlite3VdbeHasSubProgram(Vdbe *pVdbe){ + return pVdbe->pProgram!=0; +} + +/* +** Change the opcode at addr into OP_Noop +*/ +SQLITE_PRIVATE int sqlite3VdbeChangeToNoop(Vdbe *p, int addr){ + VdbeOp *pOp; + if( p->db->mallocFailed ) return 0; + assert( addr>=0 && addrnOp ); + pOp = &p->aOp[addr]; + freeP4(p->db, pOp->p4type, pOp->p4.p); + pOp->p4type = P4_NOTUSED; + pOp->p4.z = 0; + pOp->opcode = OP_Noop; + return 1; +} + +/* +** If the last opcode is "op" and it is not a jump destination, +** then remove it. Return true if and only if an opcode was removed. +*/ +SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode(Vdbe *p, u8 op){ + if( p->nOp>0 && p->aOp[p->nOp-1].opcode==op ){ + return sqlite3VdbeChangeToNoop(p, p->nOp-1); + }else{ + return 0; + } +} + +#ifdef SQLITE_DEBUG +/* +** Generate an OP_ReleaseReg opcode to indicate that a range of +** registers, except any identified by mask, are no longer in use. +*/ +SQLITE_PRIVATE void sqlite3VdbeReleaseRegisters( + Parse *pParse, /* Parsing context */ + int iFirst, /* Index of first register to be released */ + int N, /* Number of registers to release */ + u32 mask, /* Mask of registers to NOT release */ + int bUndefine /* If true, mark registers as undefined */ +){ + if( N==0 ) return; + assert( pParse->pVdbe ); + assert( iFirst>=1 ); + assert( iFirst+N-1<=pParse->nMem ); + if( N<=31 && mask!=0 ){ + while( N>0 && (mask&1)!=0 ){ + mask >>= 1; + iFirst++; + N--; + } + while( N>0 && N<=32 && (mask & MASKBIT32(N-1))!=0 ){ + mask &= ~MASKBIT32(N-1); + N--; + } + } + if( N>0 ){ + sqlite3VdbeAddOp3(pParse->pVdbe, OP_ReleaseReg, iFirst, N, *(int*)&mask); + if( bUndefine ) sqlite3VdbeChangeP5(pParse->pVdbe, 1); + } +} +#endif /* SQLITE_DEBUG */ + + +/* +** Change the value of the P4 operand for a specific instruction. +** This routine is useful when a large program is loaded from a +** static array using sqlite3VdbeAddOpList but we want to make a +** few minor changes to the program. +** +** If n>=0 then the P4 operand is dynamic, meaning that a copy of +** the string is made into memory obtained from sqlite3_malloc(). +** A value of n==0 means copy bytes of zP4 up to and including the +** first null byte. If n>0 then copy n+1 bytes of zP4. +** +** Other values of n (P4_STATIC, P4_COLLSEQ etc.) indicate that zP4 points +** to a string or structure that is guaranteed to exist for the lifetime of +** the Vdbe. In these cases we can just copy the pointer. +** +** If addr<0 then change P4 on the most recently inserted instruction. +*/ +static void SQLITE_NOINLINE vdbeChangeP4Full( + Vdbe *p, + Op *pOp, + const char *zP4, + int n +){ + if( pOp->p4type ){ + freeP4(p->db, pOp->p4type, pOp->p4.p); + pOp->p4type = 0; + pOp->p4.p = 0; + } + if( n<0 ){ + sqlite3VdbeChangeP4(p, (int)(pOp - p->aOp), zP4, n); + }else{ + if( n==0 ) n = sqlite3Strlen30(zP4); + pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n); + pOp->p4type = P4_DYNAMIC; + } +} +SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){ + Op *pOp; + sqlite3 *db; + assert( p!=0 ); + db = p->db; + assert( p->magic==VDBE_MAGIC_INIT ); + assert( p->aOp!=0 || db->mallocFailed ); + if( db->mallocFailed ){ + if( n!=P4_VTAB ) freeP4(db, n, (void*)*(char**)&zP4); + return; + } + assert( p->nOp>0 ); + assert( addrnOp ); + if( addr<0 ){ + addr = p->nOp - 1; + } + pOp = &p->aOp[addr]; + if( n>=0 || pOp->p4type ){ + vdbeChangeP4Full(p, pOp, zP4, n); + return; + } + if( n==P4_INT32 ){ + /* Note: this cast is safe, because the origin data point was an int + ** that was cast to a (const char *). */ + pOp->p4.i = SQLITE_PTR_TO_INT(zP4); + pOp->p4type = P4_INT32; + }else if( zP4!=0 ){ + assert( n<0 ); + pOp->p4.p = (void*)zP4; + pOp->p4type = (signed char)n; + if( n==P4_VTAB ) sqlite3VtabLock((VTable*)zP4); + } +} + +/* +** Change the P4 operand of the most recently coded instruction +** to the value defined by the arguments. This is a high-speed +** version of sqlite3VdbeChangeP4(). +** +** The P4 operand must not have been previously defined. And the new +** P4 must not be P4_INT32. Use sqlite3VdbeChangeP4() in either of +** those cases. +*/ +SQLITE_PRIVATE void sqlite3VdbeAppendP4(Vdbe *p, void *pP4, int n){ + VdbeOp *pOp; + assert( n!=P4_INT32 && n!=P4_VTAB ); + assert( n<=0 ); + if( p->db->mallocFailed ){ + freeP4(p->db, n, pP4); + }else{ + assert( pP4!=0 ); + assert( p->nOp>0 ); + pOp = &p->aOp[p->nOp-1]; + assert( pOp->p4type==P4_NOTUSED ); + pOp->p4type = n; + pOp->p4.p = pP4; + } +} + +/* +** Set the P4 on the most recently added opcode to the KeyInfo for the +** index given. +*/ +SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo(Parse *pParse, Index *pIdx){ + Vdbe *v = pParse->pVdbe; + KeyInfo *pKeyInfo; + assert( v!=0 ); + assert( pIdx!=0 ); + pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pIdx); + if( pKeyInfo ) sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO); +} + +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS +/* +** Change the comment on the most recently coded instruction. Or +** insert a No-op and add the comment to that new instruction. This +** makes the code easier to read during debugging. None of this happens +** in a production build. +*/ +static void vdbeVComment(Vdbe *p, const char *zFormat, va_list ap){ + assert( p->nOp>0 || p->aOp==0 ); + assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed + || p->pParse->nErr>0 ); + if( p->nOp ){ + assert( p->aOp ); + sqlite3DbFree(p->db, p->aOp[p->nOp-1].zComment); + p->aOp[p->nOp-1].zComment = sqlite3VMPrintf(p->db, zFormat, ap); + } +} +SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){ + va_list ap; + if( p ){ + va_start(ap, zFormat); + vdbeVComment(p, zFormat, ap); + va_end(ap); + } +} +SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe *p, const char *zFormat, ...){ + va_list ap; + if( p ){ + sqlite3VdbeAddOp0(p, OP_Noop); + va_start(ap, zFormat); + vdbeVComment(p, zFormat, ap); + va_end(ap); + } +} +#endif /* NDEBUG */ + +#ifdef SQLITE_VDBE_COVERAGE +/* +** Set the value if the iSrcLine field for the previously coded instruction. +*/ +SQLITE_PRIVATE void sqlite3VdbeSetLineNumber(Vdbe *v, int iLine){ + sqlite3VdbeGetOp(v,-1)->iSrcLine = iLine; +} +#endif /* SQLITE_VDBE_COVERAGE */ + +/* +** Return the opcode for a given address. If the address is -1, then +** return the most recently inserted opcode. +** +** If a memory allocation error has occurred prior to the calling of this +** routine, then a pointer to a dummy VdbeOp will be returned. That opcode +** is readable but not writable, though it is cast to a writable value. +** The return of a dummy opcode allows the call to continue functioning +** after an OOM fault without having to check to see if the return from +** this routine is a valid pointer. But because the dummy.opcode is 0, +** dummy will never be written to. This is verified by code inspection and +** by running with Valgrind. +*/ +SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){ + /* C89 specifies that the constant "dummy" will be initialized to all + ** zeros, which is correct. MSVC generates a warning, nevertheless. */ + static VdbeOp dummy; /* Ignore the MSVC warning about no initializer */ + assert( p->magic==VDBE_MAGIC_INIT ); + if( addr<0 ){ + addr = p->nOp - 1; + } + assert( (addr>=0 && addrnOp) || p->db->mallocFailed ); + if( p->db->mallocFailed ){ + return (VdbeOp*)&dummy; + }else{ + return &p->aOp[addr]; + } +} + +#if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) +/* +** Return an integer value for one of the parameters to the opcode pOp +** determined by character c. +*/ +static int translateP(char c, const Op *pOp){ + if( c=='1' ) return pOp->p1; + if( c=='2' ) return pOp->p2; + if( c=='3' ) return pOp->p3; + if( c=='4' ) return pOp->p4.i; + return pOp->p5; +} + +/* +** Compute a string for the "comment" field of a VDBE opcode listing. +** +** The Synopsis: field in comments in the vdbe.c source file gets converted +** to an extra string that is appended to the sqlite3OpcodeName(). In the +** absence of other comments, this synopsis becomes the comment on the opcode. +** Some translation occurs: +** +** "PX" -> "r[X]" +** "PX@PY" -> "r[X..X+Y-1]" or "r[x]" if y is 0 or 1 +** "PX@PY+1" -> "r[X..X+Y]" or "r[x]" if y is 0 +** "PY..PY" -> "r[X..Y]" or "r[x]" if y<=x +*/ +SQLITE_PRIVATE char *sqlite3VdbeDisplayComment( + sqlite3 *db, /* Optional - Oom error reporting only */ + const Op *pOp, /* The opcode to be commented */ + const char *zP4 /* Previously obtained value for P4 */ +){ + const char *zOpName; + const char *zSynopsis; + int nOpName; + int ii; + char zAlt[50]; + StrAccum x; + + sqlite3StrAccumInit(&x, 0, 0, 0, SQLITE_MAX_LENGTH); + zOpName = sqlite3OpcodeName(pOp->opcode); + nOpName = sqlite3Strlen30(zOpName); + if( zOpName[nOpName+1] ){ + int seenCom = 0; + char c; + zSynopsis = zOpName += nOpName + 1; + if( strncmp(zSynopsis,"IF ",3)==0 ){ + if( pOp->p5 & SQLITE_STOREP2 ){ + sqlite3_snprintf(sizeof(zAlt), zAlt, "r[P2] = (%s)", zSynopsis+3); + }else{ + sqlite3_snprintf(sizeof(zAlt), zAlt, "if %s goto P2", zSynopsis+3); + } + zSynopsis = zAlt; + } + for(ii=0; (c = zSynopsis[ii])!=0; ii++){ + if( c=='P' ){ + c = zSynopsis[++ii]; + if( c=='4' ){ + sqlite3_str_appendall(&x, zP4); + }else if( c=='X' ){ + sqlite3_str_appendall(&x, pOp->zComment); + seenCom = 1; + }else{ + int v1 = translateP(c, pOp); + int v2; + if( strncmp(zSynopsis+ii+1, "@P", 2)==0 ){ + ii += 3; + v2 = translateP(zSynopsis[ii], pOp); + if( strncmp(zSynopsis+ii+1,"+1",2)==0 ){ + ii += 2; + v2++; + } + if( v2<2 ){ + sqlite3_str_appendf(&x, "%d", v1); + }else{ + sqlite3_str_appendf(&x, "%d..%d", v1, v1+v2-1); + } + }else if( strncmp(zSynopsis+ii+1, "@NP", 3)==0 ){ + sqlite3_context *pCtx = pOp->p4.pCtx; + if( pOp->p4type!=P4_FUNCCTX || pCtx->argc==1 ){ + sqlite3_str_appendf(&x, "%d", v1); + }else if( pCtx->argc>1 ){ + sqlite3_str_appendf(&x, "%d..%d", v1, v1+pCtx->argc-1); + }else if( x.accError==0 ){ + assert( x.nChar>2 ); + x.nChar -= 2; + ii++; + } + ii += 3; + }else{ + sqlite3_str_appendf(&x, "%d", v1); + if( strncmp(zSynopsis+ii+1, "..P3", 4)==0 && pOp->p3==0 ){ + ii += 4; + } + } + } + }else{ + sqlite3_str_appendchar(&x, 1, c); + } + } + if( !seenCom && pOp->zComment ){ + sqlite3_str_appendf(&x, "; %s", pOp->zComment); + } + }else if( pOp->zComment ){ + sqlite3_str_appendall(&x, pOp->zComment); + } + if( (x.accError & SQLITE_NOMEM)!=0 && db!=0 ){ + sqlite3OomFault(db); + } + return sqlite3StrAccumFinish(&x); +} +#endif /* SQLITE_ENABLE_EXPLAIN_COMMENTS */ + +#if VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS) +/* +** Translate the P4.pExpr value for an OP_CursorHint opcode into text +** that can be displayed in the P4 column of EXPLAIN output. +*/ +static void displayP4Expr(StrAccum *p, Expr *pExpr){ + const char *zOp = 0; + switch( pExpr->op ){ + case TK_STRING: + sqlite3_str_appendf(p, "%Q", pExpr->u.zToken); + break; + case TK_INTEGER: + sqlite3_str_appendf(p, "%d", pExpr->u.iValue); + break; + case TK_NULL: + sqlite3_str_appendf(p, "NULL"); + break; + case TK_REGISTER: { + sqlite3_str_appendf(p, "r[%d]", pExpr->iTable); + break; + } + case TK_COLUMN: { + if( pExpr->iColumn<0 ){ + sqlite3_str_appendf(p, "rowid"); + }else{ + sqlite3_str_appendf(p, "c%d", (int)pExpr->iColumn); + } + break; + } + case TK_LT: zOp = "LT"; break; + case TK_LE: zOp = "LE"; break; + case TK_GT: zOp = "GT"; break; + case TK_GE: zOp = "GE"; break; + case TK_NE: zOp = "NE"; break; + case TK_EQ: zOp = "EQ"; break; + case TK_IS: zOp = "IS"; break; + case TK_ISNOT: zOp = "ISNOT"; break; + case TK_AND: zOp = "AND"; break; + case TK_OR: zOp = "OR"; break; + case TK_PLUS: zOp = "ADD"; break; + case TK_STAR: zOp = "MUL"; break; + case TK_MINUS: zOp = "SUB"; break; + case TK_REM: zOp = "REM"; break; + case TK_BITAND: zOp = "BITAND"; break; + case TK_BITOR: zOp = "BITOR"; break; + case TK_SLASH: zOp = "DIV"; break; + case TK_LSHIFT: zOp = "LSHIFT"; break; + case TK_RSHIFT: zOp = "RSHIFT"; break; + case TK_CONCAT: zOp = "CONCAT"; break; + case TK_UMINUS: zOp = "MINUS"; break; + case TK_UPLUS: zOp = "PLUS"; break; + case TK_BITNOT: zOp = "BITNOT"; break; + case TK_NOT: zOp = "NOT"; break; + case TK_ISNULL: zOp = "ISNULL"; break; + case TK_NOTNULL: zOp = "NOTNULL"; break; + + default: + sqlite3_str_appendf(p, "%s", "expr"); + break; + } + + if( zOp ){ + sqlite3_str_appendf(p, "%s(", zOp); + displayP4Expr(p, pExpr->pLeft); + if( pExpr->pRight ){ + sqlite3_str_append(p, ",", 1); + displayP4Expr(p, pExpr->pRight); + } + sqlite3_str_append(p, ")", 1); + } +} +#endif /* VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS) */ + + +#if VDBE_DISPLAY_P4 +/* +** Compute a string that describes the P4 parameter for an opcode. +** Use zTemp for any required temporary buffer space. +*/ +SQLITE_PRIVATE char *sqlite3VdbeDisplayP4(sqlite3 *db, Op *pOp){ + char *zP4 = 0; + StrAccum x; + + sqlite3StrAccumInit(&x, 0, 0, 0, SQLITE_MAX_LENGTH); + switch( pOp->p4type ){ + case P4_KEYINFO: { + int j; + KeyInfo *pKeyInfo = pOp->p4.pKeyInfo; + assert( pKeyInfo->aSortFlags!=0 ); + sqlite3_str_appendf(&x, "k(%d", pKeyInfo->nKeyField); + for(j=0; jnKeyField; j++){ + CollSeq *pColl = pKeyInfo->aColl[j]; + const char *zColl = pColl ? pColl->zName : ""; + if( strcmp(zColl, "BINARY")==0 ) zColl = "B"; + sqlite3_str_appendf(&x, ",%s%s%s", + (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_DESC) ? "-" : "", + (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_BIGNULL)? "N." : "", + zColl); + } + sqlite3_str_append(&x, ")", 1); + break; + } +#ifdef SQLITE_ENABLE_CURSOR_HINTS + case P4_EXPR: { + displayP4Expr(&x, pOp->p4.pExpr); + break; + } +#endif + case P4_COLLSEQ: { + static const char *const encnames[] = {"?", "8", "16LE", "16BE"}; + CollSeq *pColl = pOp->p4.pColl; + assert( pColl->enc>=0 && pColl->enc<4 ); + sqlite3_str_appendf(&x, "%.18s-%s", pColl->zName, + encnames[pColl->enc]); + break; + } + case P4_FUNCDEF: { + FuncDef *pDef = pOp->p4.pFunc; + sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg); + break; + } + case P4_FUNCCTX: { + FuncDef *pDef = pOp->p4.pCtx->pFunc; + sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg); + break; + } + case P4_INT64: { + sqlite3_str_appendf(&x, "%lld", *pOp->p4.pI64); + break; + } + case P4_INT32: { + sqlite3_str_appendf(&x, "%d", pOp->p4.i); + break; + } + case P4_REAL: { + sqlite3_str_appendf(&x, "%.16g", *pOp->p4.pReal); + break; + } + case P4_MEM: { + Mem *pMem = pOp->p4.pMem; + if( pMem->flags & MEM_Str ){ + zP4 = pMem->z; + }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){ + sqlite3_str_appendf(&x, "%lld", pMem->u.i); + }else if( pMem->flags & MEM_Real ){ + sqlite3_str_appendf(&x, "%.16g", pMem->u.r); + }else if( pMem->flags & MEM_Null ){ + zP4 = "NULL"; + }else{ + assert( pMem->flags & MEM_Blob ); + zP4 = "(blob)"; + } + break; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + case P4_VTAB: { + sqlite3_vtab *pVtab = pOp->p4.pVtab->pVtab; + sqlite3_str_appendf(&x, "vtab:%p", pVtab); + break; + } +#endif + case P4_INTARRAY: { + u32 i; + u32 *ai = pOp->p4.ai; + u32 n = ai[0]; /* The first element of an INTARRAY is always the + ** count of the number of elements to follow */ + for(i=1; i<=n; i++){ + sqlite3_str_appendf(&x, "%c%u", (i==1 ? '[' : ','), ai[i]); + } + sqlite3_str_append(&x, "]", 1); + break; + } + case P4_SUBPROGRAM: { + zP4 = "program"; + break; + } + case P4_DYNBLOB: + case P4_ADVANCE: { + break; + } + case P4_TABLE: { + zP4 = pOp->p4.pTab->zName; + break; + } + default: { + zP4 = pOp->p4.z; + } + } + if( zP4 ) sqlite3_str_appendall(&x, zP4); + if( (x.accError & SQLITE_NOMEM)!=0 ){ + sqlite3OomFault(db); + } + return sqlite3StrAccumFinish(&x); +} +#endif /* VDBE_DISPLAY_P4 */ + +/* +** Declare to the Vdbe that the BTree object at db->aDb[i] is used. +** +** The prepared statements need to know in advance the complete set of +** attached databases that will be use. A mask of these databases +** is maintained in p->btreeMask. The p->lockMask value is the subset of +** p->btreeMask of databases that will require a lock. +*/ +SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe *p, int i){ + assert( i>=0 && idb->nDb && i<(int)sizeof(yDbMask)*8 ); + assert( i<(int)sizeof(p->btreeMask)*8 ); + DbMaskSet(p->btreeMask, i); + if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){ + DbMaskSet(p->lockMask, i); + } +} + +#if !defined(SQLITE_OMIT_SHARED_CACHE) +/* +** If SQLite is compiled to support shared-cache mode and to be threadsafe, +** this routine obtains the mutex associated with each BtShared structure +** that may be accessed by the VM passed as an argument. In doing so it also +** sets the BtShared.db member of each of the BtShared structures, ensuring +** that the correct busy-handler callback is invoked if required. +** +** If SQLite is not threadsafe but does support shared-cache mode, then +** sqlite3BtreeEnter() is invoked to set the BtShared.db variables +** of all of BtShared structures accessible via the database handle +** associated with the VM. +** +** If SQLite is not threadsafe and does not support shared-cache mode, this +** function is a no-op. +** +** The p->btreeMask field is a bitmask of all btrees that the prepared +** statement p will ever use. Let N be the number of bits in p->btreeMask +** corresponding to btrees that use shared cache. Then the runtime of +** this routine is N*N. But as N is rarely more than 1, this should not +** be a problem. +*/ +SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe *p){ + int i; + sqlite3 *db; + Db *aDb; + int nDb; + if( DbMaskAllZero(p->lockMask) ) return; /* The common case */ + db = p->db; + aDb = db->aDb; + nDb = db->nDb; + for(i=0; ilockMask,i) && ALWAYS(aDb[i].pBt!=0) ){ + sqlite3BtreeEnter(aDb[i].pBt); + } + } +} +#endif + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0 +/* +** Unlock all of the btrees previously locked by a call to sqlite3VdbeEnter(). +*/ +static SQLITE_NOINLINE void vdbeLeave(Vdbe *p){ + int i; + sqlite3 *db; + Db *aDb; + int nDb; + db = p->db; + aDb = db->aDb; + nDb = db->nDb; + for(i=0; ilockMask,i) && ALWAYS(aDb[i].pBt!=0) ){ + sqlite3BtreeLeave(aDb[i].pBt); + } + } +} +SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe *p){ + if( DbMaskAllZero(p->lockMask) ) return; /* The common case */ + vdbeLeave(p); +} +#endif + +#if defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) +/* +** Print a single opcode. This routine is used for debugging only. +*/ +SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, VdbeOp *pOp){ + char *zP4; + char *zCom; + sqlite3 dummyDb; + static const char *zFormat1 = "%4d %-13s %4d %4d %4d %-13s %.2X %s\n"; + if( pOut==0 ) pOut = stdout; + sqlite3BeginBenignMalloc(); + dummyDb.mallocFailed = 1; + zP4 = sqlite3VdbeDisplayP4(&dummyDb, pOp); +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + zCom = sqlite3VdbeDisplayComment(0, pOp, zP4); +#else + zCom = 0; +#endif + /* NB: The sqlite3OpcodeName() function is implemented by code created + ** by the mkopcodeh.awk and mkopcodec.awk scripts which extract the + ** information from the vdbe.c source text */ + fprintf(pOut, zFormat1, pc, + sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3, + zP4 ? zP4 : "", pOp->p5, + zCom ? zCom : "" + ); + fflush(pOut); + sqlite3_free(zP4); + sqlite3_free(zCom); + sqlite3EndBenignMalloc(); +} +#endif + +/* +** Initialize an array of N Mem element. +*/ +static void initMemArray(Mem *p, int N, sqlite3 *db, u16 flags){ + while( (N--)>0 ){ + p->db = db; + p->flags = flags; + p->szMalloc = 0; +#ifdef SQLITE_DEBUG + p->pScopyFrom = 0; +#endif + p++; + } +} + +/* +** Release an array of N Mem elements +*/ +static void releaseMemArray(Mem *p, int N){ + if( p && N ){ + Mem *pEnd = &p[N]; + sqlite3 *db = p->db; + if( db->pnBytesFreed ){ + do{ + if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc); + }while( (++p)flags & MEM_Agg ); + testcase( p->flags & MEM_Dyn ); + testcase( p->xDel==sqlite3VdbeFrameMemDel ); + if( p->flags&(MEM_Agg|MEM_Dyn) ){ + sqlite3VdbeMemRelease(p); + }else if( p->szMalloc ){ + sqlite3DbFreeNN(db, p->zMalloc); + p->szMalloc = 0; + } + + p->flags = MEM_Undefined; + }while( (++p)iFrameMagic!=SQLITE_FRAME_MAGIC ) return 0; + return 1; +} +#endif + + +/* +** This is a destructor on a Mem object (which is really an sqlite3_value) +** that deletes the Frame object that is attached to it as a blob. +** +** This routine does not delete the Frame right away. It merely adds the +** frame to a list of frames to be deleted when the Vdbe halts. +*/ +SQLITE_PRIVATE void sqlite3VdbeFrameMemDel(void *pArg){ + VdbeFrame *pFrame = (VdbeFrame*)pArg; + assert( sqlite3VdbeFrameIsValid(pFrame) ); + pFrame->pParent = pFrame->v->pDelFrame; + pFrame->v->pDelFrame = pFrame; +} + +#if defined(SQLITE_ENABLE_BYTECODE_VTAB) || !defined(SQLITE_OMIT_EXPLAIN) +/* +** Locate the next opcode to be displayed in EXPLAIN or EXPLAIN +** QUERY PLAN output. +** +** Return SQLITE_ROW on success. Return SQLITE_DONE if there are no +** more opcodes to be displayed. +*/ +SQLITE_PRIVATE int sqlite3VdbeNextOpcode( + Vdbe *p, /* The statement being explained */ + Mem *pSub, /* Storage for keeping track of subprogram nesting */ + int eMode, /* 0: normal. 1: EQP. 2: TablesUsed */ + int *piPc, /* IN/OUT: Current rowid. Overwritten with next rowid */ + int *piAddr, /* OUT: Write index into (*paOp)[] here */ + Op **paOp /* OUT: Write the opcode array here */ +){ + int nRow; /* Stop when row count reaches this */ + int nSub = 0; /* Number of sub-vdbes seen so far */ + SubProgram **apSub = 0; /* Array of sub-vdbes */ + int i; /* Next instruction address */ + int rc = SQLITE_OK; /* Result code */ + Op *aOp = 0; /* Opcode array */ + int iPc; /* Rowid. Copy of value in *piPc */ + + /* When the number of output rows reaches nRow, that means the + ** listing has finished and sqlite3_step() should return SQLITE_DONE. + ** nRow is the sum of the number of rows in the main program, plus + ** the sum of the number of rows in all trigger subprograms encountered + ** so far. The nRow value will increase as new trigger subprograms are + ** encountered, but p->pc will eventually catch up to nRow. + */ + nRow = p->nOp; + if( pSub!=0 ){ + if( pSub->flags&MEM_Blob ){ + /* pSub is initiallly NULL. It is initialized to a BLOB by + ** the P4_SUBPROGRAM processing logic below */ + nSub = pSub->n/sizeof(Vdbe*); + apSub = (SubProgram **)pSub->z; + } + for(i=0; inOp; + } + } + iPc = *piPc; + while(1){ /* Loop exits via break */ + i = iPc++; + if( i>=nRow ){ + p->rc = SQLITE_OK; + rc = SQLITE_DONE; + break; + } + if( inOp ){ + /* The rowid is small enough that we are still in the + ** main program. */ + aOp = p->aOp; + }else{ + /* We are currently listing subprograms. Figure out which one and + ** pick up the appropriate opcode. */ + int j; + i -= p->nOp; + assert( apSub!=0 ); + assert( nSub>0 ); + for(j=0; i>=apSub[j]->nOp; j++){ + i -= apSub[j]->nOp; + assert( inOp || j+1aOp; + } + + /* When an OP_Program opcode is encounter (the only opcode that has + ** a P4_SUBPROGRAM argument), expand the size of the array of subprograms + ** kept in p->aMem[9].z to hold the new program - assuming this subprogram + ** has not already been seen. + */ + if( pSub!=0 && aOp[i].p4type==P4_SUBPROGRAM ){ + int nByte = (nSub+1)*sizeof(SubProgram*); + int j; + for(j=0; jrc = sqlite3VdbeMemGrow(pSub, nByte, nSub!=0); + if( p->rc!=SQLITE_OK ){ + rc = SQLITE_ERROR; + break; + } + apSub = (SubProgram **)pSub->z; + apSub[nSub++] = aOp[i].p4.pProgram; + MemSetTypeFlag(pSub, MEM_Blob); + pSub->n = nSub*sizeof(SubProgram*); + nRow += aOp[i].p4.pProgram->nOp; + } + } + if( eMode==0 ) break; +#ifdef SQLITE_ENABLE_BYTECODE_VTAB + if( eMode==2 ){ + Op *pOp = aOp + i; + if( pOp->opcode==OP_OpenRead ) break; + if( pOp->opcode==OP_OpenWrite && (pOp->p5 & OPFLAG_P2ISREG)==0 ) break; + if( pOp->opcode==OP_ReopenIdx ) break; + }else +#endif + { + assert( eMode==1 ); + if( aOp[i].opcode==OP_Explain ) break; + if( aOp[i].opcode==OP_Init && iPc>1 ) break; + } + } + *piPc = iPc; + *piAddr = i; + *paOp = aOp; + return rc; +} +#endif /* SQLITE_ENABLE_BYTECODE_VTAB || !SQLITE_OMIT_EXPLAIN */ + + +/* +** Delete a VdbeFrame object and its contents. VdbeFrame objects are +** allocated by the OP_Program opcode in sqlite3VdbeExec(). +*/ +SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame *p){ + int i; + Mem *aMem = VdbeFrameMem(p); + VdbeCursor **apCsr = (VdbeCursor **)&aMem[p->nChildMem]; + assert( sqlite3VdbeFrameIsValid(p) ); + for(i=0; inChildCsr; i++){ + sqlite3VdbeFreeCursor(p->v, apCsr[i]); + } + releaseMemArray(aMem, p->nChildMem); + sqlite3VdbeDeleteAuxData(p->v->db, &p->pAuxData, -1, 0); + sqlite3DbFree(p->v->db, p); +} + +#ifndef SQLITE_OMIT_EXPLAIN +/* +** Give a listing of the program in the virtual machine. +** +** The interface is the same as sqlite3VdbeExec(). But instead of +** running the code, it invokes the callback once for each instruction. +** This feature is used to implement "EXPLAIN". +** +** When p->explain==1, each instruction is listed. When +** p->explain==2, only OP_Explain instructions are listed and these +** are shown in a different format. p->explain==2 is used to implement +** EXPLAIN QUERY PLAN. +** 2018-04-24: In p->explain==2 mode, the OP_Init opcodes of triggers +** are also shown, so that the boundaries between the main program and +** each trigger are clear. +** +** When p->explain==1, first the main program is listed, then each of +** the trigger subprograms are listed one by one. +*/ +SQLITE_PRIVATE int sqlite3VdbeList( + Vdbe *p /* The VDBE */ +){ + Mem *pSub = 0; /* Memory cell hold array of subprogs */ + sqlite3 *db = p->db; /* The database connection */ + int i; /* Loop counter */ + int rc = SQLITE_OK; /* Return code */ + Mem *pMem = &p->aMem[1]; /* First Mem of result set */ + int bListSubprogs = (p->explain==1 || (db->flags & SQLITE_TriggerEQP)!=0); + Op *aOp; /* Array of opcodes */ + Op *pOp; /* Current opcode */ + + assert( p->explain ); + assert( p->magic==VDBE_MAGIC_RUN ); + assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM ); + + /* Even though this opcode does not use dynamic strings for + ** the result, result columns may become dynamic if the user calls + ** sqlite3_column_text16(), causing a translation to UTF-16 encoding. + */ + releaseMemArray(pMem, 8); + p->pResultSet = 0; + + if( p->rc==SQLITE_NOMEM ){ + /* This happens if a malloc() inside a call to sqlite3_column_text() or + ** sqlite3_column_text16() failed. */ + sqlite3OomFault(db); + return SQLITE_ERROR; + } + + if( bListSubprogs ){ + /* The first 8 memory cells are used for the result set. So we will + ** commandeer the 9th cell to use as storage for an array of pointers + ** to trigger subprograms. The VDBE is guaranteed to have at least 9 + ** cells. */ + assert( p->nMem>9 ); + pSub = &p->aMem[9]; + }else{ + pSub = 0; + } + + /* Figure out which opcode is next to display */ + rc = sqlite3VdbeNextOpcode(p, pSub, p->explain==2, &p->pc, &i, &aOp); + + if( rc==SQLITE_OK ){ + pOp = aOp + i; + if( AtomicLoad(&db->u1.isInterrupted) ){ + p->rc = SQLITE_INTERRUPT; + rc = SQLITE_ERROR; + sqlite3VdbeError(p, sqlite3ErrStr(p->rc)); + }else{ + char *zP4 = sqlite3VdbeDisplayP4(db, pOp); + if( p->explain==2 ){ + sqlite3VdbeMemSetInt64(pMem, pOp->p1); + sqlite3VdbeMemSetInt64(pMem+1, pOp->p2); + sqlite3VdbeMemSetInt64(pMem+2, pOp->p3); + sqlite3VdbeMemSetStr(pMem+3, zP4, -1, SQLITE_UTF8, sqlite3_free); + p->nResColumn = 4; + }else{ + sqlite3VdbeMemSetInt64(pMem+0, i); + sqlite3VdbeMemSetStr(pMem+1, (char*)sqlite3OpcodeName(pOp->opcode), + -1, SQLITE_UTF8, SQLITE_STATIC); + sqlite3VdbeMemSetInt64(pMem+2, pOp->p1); + sqlite3VdbeMemSetInt64(pMem+3, pOp->p2); + sqlite3VdbeMemSetInt64(pMem+4, pOp->p3); + /* pMem+5 for p4 is done last */ + sqlite3VdbeMemSetInt64(pMem+6, pOp->p5); +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + { + char *zCom = sqlite3VdbeDisplayComment(db, pOp, zP4); + sqlite3VdbeMemSetStr(pMem+7, zCom, -1, SQLITE_UTF8, sqlite3_free); + } +#else + sqlite3VdbeMemSetNull(pMem+7); +#endif + sqlite3VdbeMemSetStr(pMem+5, zP4, -1, SQLITE_UTF8, sqlite3_free); + p->nResColumn = 8; + } + p->pResultSet = pMem; + if( db->mallocFailed ){ + p->rc = SQLITE_NOMEM; + rc = SQLITE_ERROR; + }else{ + p->rc = SQLITE_OK; + rc = SQLITE_ROW; + } + } + } + return rc; +} +#endif /* SQLITE_OMIT_EXPLAIN */ + +#ifdef SQLITE_DEBUG +/* +** Print the SQL that was used to generate a VDBE program. +*/ +SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe *p){ + const char *z = 0; + if( p->zSql ){ + z = p->zSql; + }else if( p->nOp>=1 ){ + const VdbeOp *pOp = &p->aOp[0]; + if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){ + z = pOp->p4.z; + while( sqlite3Isspace(*z) ) z++; + } + } + if( z ) printf("SQL: [%s]\n", z); +} +#endif + +#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE) +/* +** Print an IOTRACE message showing SQL content. +*/ +SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe *p){ + int nOp = p->nOp; + VdbeOp *pOp; + if( sqlite3IoTrace==0 ) return; + if( nOp<1 ) return; + pOp = &p->aOp[0]; + if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){ + int i, j; + char z[1000]; + sqlite3_snprintf(sizeof(z), z, "%s", pOp->p4.z); + for(i=0; sqlite3Isspace(z[i]); i++){} + for(j=0; z[i]; i++){ + if( sqlite3Isspace(z[i]) ){ + if( z[i-1]!=' ' ){ + z[j++] = ' '; + } + }else{ + z[j++] = z[i]; + } + } + z[j] = 0; + sqlite3IoTrace("SQL %s\n", z); + } +} +#endif /* !SQLITE_OMIT_TRACE && SQLITE_ENABLE_IOTRACE */ + +/* An instance of this object describes bulk memory available for use +** by subcomponents of a prepared statement. Space is allocated out +** of a ReusableSpace object by the allocSpace() routine below. +*/ +struct ReusableSpace { + u8 *pSpace; /* Available memory */ + sqlite3_int64 nFree; /* Bytes of available memory */ + sqlite3_int64 nNeeded; /* Total bytes that could not be allocated */ +}; + +/* Try to allocate nByte bytes of 8-byte aligned bulk memory for pBuf +** from the ReusableSpace object. Return a pointer to the allocated +** memory on success. If insufficient memory is available in the +** ReusableSpace object, increase the ReusableSpace.nNeeded +** value by the amount needed and return NULL. +** +** If pBuf is not initially NULL, that means that the memory has already +** been allocated by a prior call to this routine, so just return a copy +** of pBuf and leave ReusableSpace unchanged. +** +** This allocator is employed to repurpose unused slots at the end of the +** opcode array of prepared state for other memory needs of the prepared +** statement. +*/ +static void *allocSpace( + struct ReusableSpace *p, /* Bulk memory available for allocation */ + void *pBuf, /* Pointer to a prior allocation */ + sqlite3_int64 nByte /* Bytes of memory needed */ +){ + assert( EIGHT_BYTE_ALIGNMENT(p->pSpace) ); + if( pBuf==0 ){ + nByte = ROUND8(nByte); + if( nByte <= p->nFree ){ + p->nFree -= nByte; + pBuf = &p->pSpace[p->nFree]; + }else{ + p->nNeeded += nByte; + } + } + assert( EIGHT_BYTE_ALIGNMENT(pBuf) ); + return pBuf; +} + +/* +** Rewind the VDBE back to the beginning in preparation for +** running it. +*/ +SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe *p){ +#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) + int i; +#endif + assert( p!=0 ); + assert( p->magic==VDBE_MAGIC_INIT || p->magic==VDBE_MAGIC_RESET ); + + /* There should be at least one opcode. + */ + assert( p->nOp>0 ); + + /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. */ + p->magic = VDBE_MAGIC_RUN; + +#ifdef SQLITE_DEBUG + for(i=0; inMem; i++){ + assert( p->aMem[i].db==p->db ); + } +#endif + p->pc = -1; + p->rc = SQLITE_OK; + p->errorAction = OE_Abort; + p->nChange = 0; + p->cacheCtr = 1; + p->minWriteFileFormat = 255; + p->iStatement = 0; + p->nFkConstraint = 0; +#ifdef VDBE_PROFILE + for(i=0; inOp; i++){ + p->aOp[i].cnt = 0; + p->aOp[i].cycles = 0; + } +#endif +} + +/* +** Prepare a virtual machine for execution for the first time after +** creating the virtual machine. This involves things such +** as allocating registers and initializing the program counter. +** After the VDBE has be prepped, it can be executed by one or more +** calls to sqlite3VdbeExec(). +** +** This function may be called exactly once on each virtual machine. +** After this routine is called the VM has been "packaged" and is ready +** to run. After this routine is called, further calls to +** sqlite3VdbeAddOp() functions are prohibited. This routine disconnects +** the Vdbe from the Parse object that helped generate it so that the +** the Vdbe becomes an independent entity and the Parse object can be +** destroyed. +** +** Use the sqlite3VdbeRewind() procedure to restore a virtual machine back +** to its initial state after it has been run. +*/ +SQLITE_PRIVATE void sqlite3VdbeMakeReady( + Vdbe *p, /* The VDBE */ + Parse *pParse /* Parsing context */ +){ + sqlite3 *db; /* The database connection */ + int nVar; /* Number of parameters */ + int nMem; /* Number of VM memory registers */ + int nCursor; /* Number of cursors required */ + int nArg; /* Number of arguments in subprograms */ + int n; /* Loop counter */ + struct ReusableSpace x; /* Reusable bulk memory */ + + assert( p!=0 ); + assert( p->nOp>0 ); + assert( pParse!=0 ); + assert( p->magic==VDBE_MAGIC_INIT ); + assert( pParse==p->pParse ); + db = p->db; + assert( db->mallocFailed==0 ); + nVar = pParse->nVar; + nMem = pParse->nMem; + nCursor = pParse->nTab; + nArg = pParse->nMaxArg; + + /* Each cursor uses a memory cell. The first cursor (cursor 0) can + ** use aMem[0] which is not otherwise used by the VDBE program. Allocate + ** space at the end of aMem[] for cursors 1 and greater. + ** See also: allocateCursor(). + */ + nMem += nCursor; + if( nCursor==0 && nMem>0 ) nMem++; /* Space for aMem[0] even if not used */ + + /* Figure out how much reusable memory is available at the end of the + ** opcode array. This extra memory will be reallocated for other elements + ** of the prepared statement. + */ + n = ROUND8(sizeof(Op)*p->nOp); /* Bytes of opcode memory used */ + x.pSpace = &((u8*)p->aOp)[n]; /* Unused opcode memory */ + assert( EIGHT_BYTE_ALIGNMENT(x.pSpace) ); + x.nFree = ROUNDDOWN8(pParse->szOpAlloc - n); /* Bytes of unused memory */ + assert( x.nFree>=0 ); + assert( EIGHT_BYTE_ALIGNMENT(&x.pSpace[x.nFree]) ); + + resolveP2Values(p, &nArg); + p->usesStmtJournal = (u8)(pParse->isMultiWrite && pParse->mayAbort); + if( pParse->explain ){ + static const char * const azColName[] = { + "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment", + "id", "parent", "notused", "detail" + }; + int iFirst, mx, i; + if( nMem<10 ) nMem = 10; + p->explain = pParse->explain; + if( pParse->explain==2 ){ + sqlite3VdbeSetNumCols(p, 4); + iFirst = 8; + mx = 12; + }else{ + sqlite3VdbeSetNumCols(p, 8); + iFirst = 0; + mx = 8; + } + for(i=iFirst; iexpired = 0; + + /* Memory for registers, parameters, cursor, etc, is allocated in one or two + ** passes. On the first pass, we try to reuse unused memory at the + ** end of the opcode array. If we are unable to satisfy all memory + ** requirements by reusing the opcode array tail, then the second + ** pass will fill in the remainder using a fresh memory allocation. + ** + ** This two-pass approach that reuses as much memory as possible from + ** the leftover memory at the end of the opcode array. This can significantly + ** reduce the amount of memory held by a prepared statement. + */ + x.nNeeded = 0; + p->aMem = allocSpace(&x, 0, nMem*sizeof(Mem)); + 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 + p->anExec = allocSpace(&x, 0, p->nOp*sizeof(i64)); +#endif + if( x.nNeeded ){ + x.pSpace = p->pFree = sqlite3DbMallocRawNN(db, x.nNeeded); + x.nFree = x.nNeeded; + if( !db->mallocFailed ){ + p->aMem = allocSpace(&x, p->aMem, nMem*sizeof(Mem)); + 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 + p->anExec = allocSpace(&x, p->anExec, p->nOp*sizeof(i64)); +#endif + } + } + + p->pVList = pParse->pVList; + pParse->pVList = 0; + if( db->mallocFailed ){ + p->nVar = 0; + p->nCursor = 0; + p->nMem = 0; + }else{ + p->nCursor = nCursor; + p->nVar = (ynVar)nVar; + initMemArray(p->aVar, nVar, db, MEM_Null); + p->nMem = nMem; + initMemArray(p->aMem, nMem, db, MEM_Undefined); + memset(p->apCsr, 0, nCursor*sizeof(VdbeCursor*)); +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + memset(p->anExec, 0, p->nOp*sizeof(i64)); +#endif + } + sqlite3VdbeRewind(p); +} + +/* +** Close a VDBE cursor and release all the resources that cursor +** happens to hold. +*/ +SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){ + if( pCx==0 ){ + return; + } + assert( pCx->pBtx==0 || pCx->eCurType==CURTYPE_BTREE ); + switch( pCx->eCurType ){ + case CURTYPE_SORTER: { + sqlite3VdbeSorterClose(p->db, pCx); + break; + } + case CURTYPE_BTREE: { + if( pCx->isEphemeral ){ + if( pCx->pBtx ) sqlite3BtreeClose(pCx->pBtx); + /* The pCx->pCursor will be close automatically, if it exists, by + ** the call above. */ + }else{ + assert( pCx->uc.pCursor!=0 ); + sqlite3BtreeCloseCursor(pCx->uc.pCursor); + } + break; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + case CURTYPE_VTAB: { + sqlite3_vtab_cursor *pVCur = pCx->uc.pVCur; + const sqlite3_module *pModule = pVCur->pVtab->pModule; + assert( pVCur->pVtab->nRef>0 ); + pVCur->pVtab->nRef--; + pModule->xClose(pVCur); + break; + } +#endif + } +} + +/* +** Close all cursors in the current frame. +*/ +static void closeCursorsInFrame(Vdbe *p){ + if( p->apCsr ){ + int i; + for(i=0; inCursor; i++){ + VdbeCursor *pC = p->apCsr[i]; + if( pC ){ + sqlite3VdbeFreeCursor(p, pC); + p->apCsr[i] = 0; + } + } + } +} + +/* +** Copy the values stored in the VdbeFrame structure to its Vdbe. This +** is used, for example, when a trigger sub-program is halted to restore +** control to the main program. +*/ +SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *pFrame){ + Vdbe *v = pFrame->v; + closeCursorsInFrame(v); +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + v->anExec = pFrame->anExec; +#endif + v->aOp = pFrame->aOp; + v->nOp = pFrame->nOp; + v->aMem = pFrame->aMem; + v->nMem = pFrame->nMem; + v->apCsr = pFrame->apCsr; + v->nCursor = pFrame->nCursor; + v->db->lastRowid = pFrame->lastRowid; + v->nChange = pFrame->nChange; + v->db->nChange = pFrame->nDbChange; + sqlite3VdbeDeleteAuxData(v->db, &v->pAuxData, -1, 0); + v->pAuxData = pFrame->pAuxData; + pFrame->pAuxData = 0; + return pFrame->pc; +} + +/* +** Close all cursors. +** +** Also release any dynamic memory held by the VM in the Vdbe.aMem memory +** cell array. This is necessary as the memory cell array may contain +** pointers to VdbeFrame objects, which may in turn contain pointers to +** open cursors. +*/ +static void closeAllCursors(Vdbe *p){ + if( p->pFrame ){ + VdbeFrame *pFrame; + for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent); + sqlite3VdbeFrameRestore(pFrame); + p->pFrame = 0; + p->nFrame = 0; + } + assert( p->nFrame==0 ); + closeCursorsInFrame(p); + if( p->aMem ){ + releaseMemArray(p->aMem, p->nMem); + } + while( p->pDelFrame ){ + VdbeFrame *pDel = p->pDelFrame; + p->pDelFrame = pDel->pParent; + sqlite3VdbeFrameDelete(pDel); + } + + /* Delete any auxdata allocations made by the VM */ + if( p->pAuxData ) sqlite3VdbeDeleteAuxData(p->db, &p->pAuxData, -1, 0); + assert( p->pAuxData==0 ); +} + +/* +** Set the number of result columns that will be returned by this SQL +** statement. This is now set at compile time, rather than during +** execution of the vdbe program so that sqlite3_column_count() can +** be called on an SQL statement before sqlite3_step(). +*/ +SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){ + int n; + sqlite3 *db = p->db; + + if( p->nResColumn ){ + releaseMemArray(p->aColName, p->nResColumn*COLNAME_N); + sqlite3DbFree(db, p->aColName); + } + n = nResColumn*COLNAME_N; + p->nResColumn = (u16)nResColumn; + p->aColName = (Mem*)sqlite3DbMallocRawNN(db, sizeof(Mem)*n ); + if( p->aColName==0 ) return; + initMemArray(p->aColName, n, db, MEM_Null); +} + +/* +** Set the name of the idx'th column to be returned by the SQL statement. +** zName must be a pointer to a nul terminated string. +** +** This call must be made after a call to sqlite3VdbeSetNumCols(). +** +** The final parameter, xDel, must be one of SQLITE_DYNAMIC, SQLITE_STATIC +** or SQLITE_TRANSIENT. If it is SQLITE_DYNAMIC, then the buffer pointed +** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed. +*/ +SQLITE_PRIVATE int sqlite3VdbeSetColName( + Vdbe *p, /* Vdbe being configured */ + int idx, /* Index of column zName applies to */ + int var, /* One of the COLNAME_* constants */ + const char *zName, /* Pointer to buffer containing name */ + void (*xDel)(void*) /* Memory management strategy for zName */ +){ + int rc; + Mem *pColName; + assert( idxnResColumn ); + assert( vardb->mallocFailed ){ + assert( !zName || xDel!=SQLITE_DYNAMIC ); + return SQLITE_NOMEM_BKPT; + } + assert( p->aColName!=0 ); + pColName = &(p->aColName[idx+var*p->nResColumn]); + rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel); + assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 ); + return rc; +} + +/* +** A read or write transaction may or may not be active on database handle +** db. If a transaction is active, commit it. If there is a +** write-transaction spanning more than one database file, this routine +** takes care of the super-journal trickery. +*/ +static int vdbeCommit(sqlite3 *db, Vdbe *p){ + int i; + int nTrans = 0; /* Number of databases with an active write-transaction + ** that are candidates for a two-phase commit using a + ** super-journal */ + int rc = SQLITE_OK; + int needXcommit = 0; + +#ifdef SQLITE_OMIT_VIRTUALTABLE + /* With this option, sqlite3VtabSync() is defined to be simply + ** SQLITE_OK so p is not used. + */ + UNUSED_PARAMETER(p); +#endif + + /* Before doing anything else, call the xSync() callback for any + ** virtual module tables written in this transaction. This has to + ** be done before determining whether a super-journal file is + ** required, as an xSync() callback may add an attached database + ** to the transaction. + */ + rc = sqlite3VtabSync(db, p); + + /* This loop determines (a) if the commit hook should be invoked and + ** (b) how many database files have open write transactions, not + ** including the temp database. (b) is important because if more than + ** one database file has an open write transaction, a super-journal + ** file is required for an atomic commit. + */ + for(i=0; rc==SQLITE_OK && inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( sqlite3BtreeTxnState(pBt)==SQLITE_TXN_WRITE ){ + /* Whether or not a database might need a super-journal depends upon + ** its journal mode (among other things). This matrix determines which + ** journal modes use a super-journal and which do not */ + static const u8 aMJNeeded[] = { + /* DELETE */ 1, + /* PERSIST */ 1, + /* OFF */ 0, + /* TRUNCATE */ 1, + /* MEMORY */ 0, + /* WAL */ 0 + }; + Pager *pPager; /* Pager associated with pBt */ + needXcommit = 1; + sqlite3BtreeEnter(pBt); + pPager = sqlite3BtreePager(pBt); + if( db->aDb[i].safety_level!=PAGER_SYNCHRONOUS_OFF + && aMJNeeded[sqlite3PagerGetJournalMode(pPager)] + && sqlite3PagerIsMemdb(pPager)==0 + ){ + assert( i!=1 ); + nTrans++; + } + rc = sqlite3PagerExclusiveLock(pPager); + sqlite3BtreeLeave(pBt); + } + } + if( rc!=SQLITE_OK ){ + return rc; + } + + /* If there are any write-transactions at all, invoke the commit hook */ + if( needXcommit && db->xCommitCallback ){ + rc = db->xCommitCallback(db->pCommitArg); + if( rc ){ + return SQLITE_CONSTRAINT_COMMITHOOK; + } + } + + /* The simple case - no more than one database file (not counting the + ** TEMP database) has a transaction active. There is no need for the + ** super-journal. + ** + ** If the return value of sqlite3BtreeGetFilename() is a zero length + ** string, it means the main database is :memory: or a temp file. In + ** that case we do not support atomic multi-file commits, so use the + ** simple case then too. + */ + if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt)) + || nTrans<=1 + ){ + for(i=0; rc==SQLITE_OK && inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + rc = sqlite3BtreeCommitPhaseOne(pBt, 0); + } + } + + /* Do the commit only if all databases successfully complete phase 1. + ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an + ** IO error while deleting or truncating a journal file. It is unlikely, + ** but could happen. In this case abandon processing and return the error. + */ + for(i=0; rc==SQLITE_OK && inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + rc = sqlite3BtreeCommitPhaseTwo(pBt, 0); + } + } + if( rc==SQLITE_OK ){ + sqlite3VtabCommit(db); + } + } + + /* The complex case - There is a multi-file write-transaction active. + ** This requires a super-journal file to ensure the transaction is + ** committed atomically. + */ +#ifndef SQLITE_OMIT_DISKIO + else{ + sqlite3_vfs *pVfs = db->pVfs; + char *zSuper = 0; /* File-name for the super-journal */ + char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt); + sqlite3_file *pSuperJrnl = 0; + i64 offset = 0; + int res; + int retryCount = 0; + int nMainFile; + + /* Select a super-journal file name */ + nMainFile = sqlite3Strlen30(zMainFile); + zSuper = sqlite3MPrintf(db, "%.4c%s%.16c", 0,zMainFile,0); + if( zSuper==0 ) return SQLITE_NOMEM_BKPT; + zSuper += 4; + do { + u32 iRandom; + if( retryCount ){ + if( retryCount>100 ){ + sqlite3_log(SQLITE_FULL, "MJ delete: %s", zSuper); + sqlite3OsDelete(pVfs, zSuper, 0); + break; + }else if( retryCount==1 ){ + sqlite3_log(SQLITE_FULL, "MJ collide: %s", zSuper); + } + } + retryCount++; + sqlite3_randomness(sizeof(iRandom), &iRandom); + sqlite3_snprintf(13, &zSuper[nMainFile], "-mj%06X9%02X", + (iRandom>>8)&0xffffff, iRandom&0xff); + /* The antipenultimate character of the super-journal name must + ** be "9" to avoid name collisions when using 8+3 filenames. */ + assert( zSuper[sqlite3Strlen30(zSuper)-3]=='9' ); + sqlite3FileSuffix3(zMainFile, zSuper); + rc = sqlite3OsAccess(pVfs, zSuper, SQLITE_ACCESS_EXISTS, &res); + }while( rc==SQLITE_OK && res ); + if( rc==SQLITE_OK ){ + /* Open the super-journal. */ + rc = sqlite3OsOpenMalloc(pVfs, zSuper, &pSuperJrnl, + SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE| + SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_SUPER_JOURNAL, 0 + ); + } + if( rc!=SQLITE_OK ){ + sqlite3DbFree(db, zSuper-4); + return rc; + } + + /* Write the name of each database file in the transaction into the new + ** super-journal file. If an error occurs at this point close + ** and delete the super-journal file. All the individual journal files + ** still have 'null' as the super-journal pointer, so they will roll + ** back independently if a failure occurs. + */ + for(i=0; inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( sqlite3BtreeTxnState(pBt)==SQLITE_TXN_WRITE ){ + char const *zFile = sqlite3BtreeGetJournalname(pBt); + if( zFile==0 ){ + continue; /* Ignore TEMP and :memory: databases */ + } + assert( zFile[0]!=0 ); + rc = sqlite3OsWrite(pSuperJrnl, zFile, sqlite3Strlen30(zFile)+1,offset); + offset += sqlite3Strlen30(zFile)+1; + if( rc!=SQLITE_OK ){ + sqlite3OsCloseFree(pSuperJrnl); + sqlite3OsDelete(pVfs, zSuper, 0); + sqlite3DbFree(db, zSuper-4); + return rc; + } + } + } + + /* Sync the super-journal file. If the IOCAP_SEQUENTIAL device + ** flag is set this is not required. + */ + if( 0==(sqlite3OsDeviceCharacteristics(pSuperJrnl)&SQLITE_IOCAP_SEQUENTIAL) + && SQLITE_OK!=(rc = sqlite3OsSync(pSuperJrnl, SQLITE_SYNC_NORMAL)) + ){ + sqlite3OsCloseFree(pSuperJrnl); + sqlite3OsDelete(pVfs, zSuper, 0); + sqlite3DbFree(db, zSuper-4); + return rc; + } + + /* Sync all the db files involved in the transaction. The same call + ** sets the super-journal pointer in each individual journal. If + ** an error occurs here, do not delete the super-journal file. + ** + ** If the error occurs during the first call to + ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the + ** super-journal file will be orphaned. But we cannot delete it, + ** in case the super-journal file name was written into the journal + ** file before the failure occurred. + */ + for(i=0; rc==SQLITE_OK && inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + rc = sqlite3BtreeCommitPhaseOne(pBt, zSuper); + } + } + sqlite3OsCloseFree(pSuperJrnl); + assert( rc!=SQLITE_BUSY ); + if( rc!=SQLITE_OK ){ + sqlite3DbFree(db, zSuper-4); + return rc; + } + + /* Delete the super-journal file. This commits the transaction. After + ** doing this the directory is synced again before any individual + ** transaction files are deleted. + */ + rc = sqlite3OsDelete(pVfs, zSuper, 1); + sqlite3DbFree(db, zSuper-4); + zSuper = 0; + if( rc ){ + return rc; + } + + /* All files and directories have already been synced, so the following + ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and + ** deleting or truncating journals. If something goes wrong while + ** this is happening we don't really care. The integrity of the + ** transaction is already guaranteed, but some stray 'cold' journals + ** may be lying around. Returning an error code won't help matters. + */ + disable_simulated_io_errors(); + sqlite3BeginBenignMalloc(); + for(i=0; inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + sqlite3BtreeCommitPhaseTwo(pBt, 1); + } + } + sqlite3EndBenignMalloc(); + enable_simulated_io_errors(); + + sqlite3VtabCommit(db); + } +#endif + + return rc; +} + +/* +** This routine checks that the sqlite3.nVdbeActive count variable +** matches the number of vdbe's in the list sqlite3.pVdbe that are +** currently active. An assertion fails if the two counts do not match. +** This is an internal self-check only - it is not an essential processing +** step. +** +** This is a no-op if NDEBUG is defined. +*/ +#ifndef NDEBUG +static void checkActiveVdbeCnt(sqlite3 *db){ + Vdbe *p; + int cnt = 0; + int nWrite = 0; + int nRead = 0; + p = db->pVdbe; + while( p ){ + if( sqlite3_stmt_busy((sqlite3_stmt*)p) ){ + cnt++; + if( p->readOnly==0 ) nWrite++; + if( p->bIsReader ) nRead++; + } + p = p->pNext; + } + assert( cnt==db->nVdbeActive ); + assert( nWrite==db->nVdbeWrite ); + assert( nRead==db->nVdbeRead ); +} +#else +#define checkActiveVdbeCnt(x) +#endif + +/* +** If the Vdbe passed as the first argument opened a statement-transaction, +** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or +** SAVEPOINT_RELEASE. If it is SAVEPOINT_ROLLBACK, then the statement +** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the +** statement transaction is committed. +** +** If an IO error occurs, an SQLITE_IOERR_XXX error code is returned. +** Otherwise SQLITE_OK. +*/ +static SQLITE_NOINLINE int vdbeCloseStatement(Vdbe *p, int eOp){ + sqlite3 *const db = p->db; + int rc = SQLITE_OK; + int i; + const int iSavepoint = p->iStatement-1; + + assert( eOp==SAVEPOINT_ROLLBACK || eOp==SAVEPOINT_RELEASE); + assert( db->nStatement>0 ); + assert( p->iStatement==(db->nStatement+db->nSavepoint) ); + + for(i=0; inDb; i++){ + int rc2 = SQLITE_OK; + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + if( eOp==SAVEPOINT_ROLLBACK ){ + rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_ROLLBACK, iSavepoint); + } + if( rc2==SQLITE_OK ){ + rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_RELEASE, iSavepoint); + } + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + } + db->nStatement--; + p->iStatement = 0; + + if( rc==SQLITE_OK ){ + if( eOp==SAVEPOINT_ROLLBACK ){ + rc = sqlite3VtabSavepoint(db, SAVEPOINT_ROLLBACK, iSavepoint); + } + if( rc==SQLITE_OK ){ + rc = sqlite3VtabSavepoint(db, SAVEPOINT_RELEASE, iSavepoint); + } + } + + /* If the statement transaction is being rolled back, also restore the + ** database handles deferred constraint counter to the value it had when + ** the statement transaction was opened. */ + if( eOp==SAVEPOINT_ROLLBACK ){ + db->nDeferredCons = p->nStmtDefCons; + db->nDeferredImmCons = p->nStmtDefImmCons; + } + return rc; +} +SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *p, int eOp){ + if( p->db->nStatement && p->iStatement ){ + return vdbeCloseStatement(p, eOp); + } + return SQLITE_OK; +} + + +/* +** This function is called when a transaction opened by the database +** handle associated with the VM passed as an argument is about to be +** committed. If there are outstanding deferred foreign key constraint +** violations, return SQLITE_ERROR. Otherwise, SQLITE_OK. +** +** If there are outstanding FK violations and this function returns +** SQLITE_ERROR, set the result of the VM to SQLITE_CONSTRAINT_FOREIGNKEY +** and write an error message to it. Then return SQLITE_ERROR. +*/ +#ifndef SQLITE_OMIT_FOREIGN_KEY +SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *p, int deferred){ + sqlite3 *db = p->db; + if( (deferred && (db->nDeferredCons+db->nDeferredImmCons)>0) + || (!deferred && p->nFkConstraint>0) + ){ + p->rc = SQLITE_CONSTRAINT_FOREIGNKEY; + p->errorAction = OE_Abort; + sqlite3VdbeError(p, "FOREIGN KEY constraint failed"); + return SQLITE_ERROR; + } + return SQLITE_OK; +} +#endif + +/* +** This routine is called the when a VDBE tries to halt. If the VDBE +** has made changes and is in autocommit mode, then commit those +** changes. If a rollback is needed, then do the rollback. +** +** This routine is the only way to move the state of a VM from +** SQLITE_MAGIC_RUN to SQLITE_MAGIC_HALT. It is harmless to +** call this on a VM that is in the SQLITE_MAGIC_HALT state. +** +** Return an error code. If the commit could not complete because of +** lock contention, return SQLITE_BUSY. If SQLITE_BUSY is returned, it +** means the close did not happen and needs to be repeated. +*/ +SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){ + int rc; /* Used to store transient return codes */ + sqlite3 *db = p->db; + + /* This function contains the logic that determines if a statement or + ** transaction will be committed or rolled back as a result of the + ** execution of this virtual machine. + ** + ** If any of the following errors occur: + ** + ** SQLITE_NOMEM + ** SQLITE_IOERR + ** SQLITE_FULL + ** SQLITE_INTERRUPT + ** + ** Then the internal cache might have been left in an inconsistent + ** state. We need to rollback the statement transaction, if there is + ** one, or the complete transaction if there is no statement transaction. + */ + + if( p->magic!=VDBE_MAGIC_RUN ){ + return SQLITE_OK; + } + if( db->mallocFailed ){ + p->rc = SQLITE_NOMEM_BKPT; + } + closeAllCursors(p); + checkActiveVdbeCnt(db); + + /* No commit or rollback needed if the program never started or if the + ** SQL statement does not read or write a database file. */ + if( p->pc>=0 && p->bIsReader ){ + int mrc; /* Primary error code from p->rc */ + int eStatementOp = 0; + int isSpecialError; /* Set to true if a 'special' error */ + + /* Lock all btrees used by the statement */ + sqlite3VdbeEnter(p); + + /* Check for one of the special errors */ + mrc = p->rc & 0xff; + isSpecialError = mrc==SQLITE_NOMEM || mrc==SQLITE_IOERR + || mrc==SQLITE_INTERRUPT || mrc==SQLITE_FULL; + if( isSpecialError ){ + /* If the query was read-only and the error code is SQLITE_INTERRUPT, + ** no rollback is necessary. Otherwise, at least a savepoint + ** transaction must be rolled back to restore the database to a + ** consistent state. + ** + ** Even if the statement is read-only, it is important to perform + ** a statement or transaction rollback operation. If the error + ** occurred while writing to the journal, sub-journal or database + ** file as part of an effort to free up cache space (see function + ** pagerStress() in pager.c), the rollback is required to restore + ** the pager to a consistent state. + */ + if( !p->readOnly || mrc!=SQLITE_INTERRUPT ){ + if( (mrc==SQLITE_NOMEM || mrc==SQLITE_FULL) && p->usesStmtJournal ){ + eStatementOp = SAVEPOINT_ROLLBACK; + }else{ + /* We are forced to roll back the active transaction. Before doing + ** so, abort any other statements this handle currently has active. + */ + sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); + sqlite3CloseSavepoints(db); + db->autoCommit = 1; + p->nChange = 0; + } + } + } + + /* Check for immediate foreign key violations. */ + if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){ + sqlite3VdbeCheckFk(p, 0); + } + + /* If the auto-commit flag is set and this is the only active writer + ** VM, then we do either a commit or rollback of the current transaction. + ** + ** Note: This block also runs if one of the special errors handled + ** above has occurred. + */ + if( !sqlite3VtabInSync(db) + && db->autoCommit + && db->nVdbeWrite==(p->readOnly==0) + ){ + if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){ + rc = sqlite3VdbeCheckFk(p, 1); + if( rc!=SQLITE_OK ){ + if( NEVER(p->readOnly) ){ + sqlite3VdbeLeave(p); + return SQLITE_ERROR; + } + rc = SQLITE_CONSTRAINT_FOREIGNKEY; + }else{ + /* The auto-commit flag is true, the vdbe program was successful + ** or hit an 'OR FAIL' constraint and there are no deferred foreign + ** key constraints to hold up the transaction. This means a commit + ** is required. */ + rc = vdbeCommit(db, p); + } + if( rc==SQLITE_BUSY && p->readOnly ){ + sqlite3VdbeLeave(p); + return SQLITE_BUSY; + }else if( rc!=SQLITE_OK ){ + p->rc = rc; + sqlite3RollbackAll(db, SQLITE_OK); + p->nChange = 0; + }else{ + db->nDeferredCons = 0; + db->nDeferredImmCons = 0; + db->flags &= ~(u64)SQLITE_DeferFKs; + sqlite3CommitInternalChanges(db); + } + }else{ + sqlite3RollbackAll(db, SQLITE_OK); + p->nChange = 0; + } + db->nStatement = 0; + }else if( eStatementOp==0 ){ + if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){ + eStatementOp = SAVEPOINT_RELEASE; + }else if( p->errorAction==OE_Abort ){ + eStatementOp = SAVEPOINT_ROLLBACK; + }else{ + sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); + sqlite3CloseSavepoints(db); + db->autoCommit = 1; + p->nChange = 0; + } + } + + /* If eStatementOp is non-zero, then a statement transaction needs to + ** be committed or rolled back. Call sqlite3VdbeCloseStatement() to + ** do so. If this operation returns an error, and the current statement + ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the + ** current statement error code. + */ + if( eStatementOp ){ + rc = sqlite3VdbeCloseStatement(p, eStatementOp); + if( rc ){ + if( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ){ + p->rc = rc; + sqlite3DbFree(db, p->zErrMsg); + p->zErrMsg = 0; + } + sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); + sqlite3CloseSavepoints(db); + db->autoCommit = 1; + p->nChange = 0; + } + } + + /* If this was an INSERT, UPDATE or DELETE and no statement transaction + ** has been rolled back, update the database connection change-counter. + */ + if( p->changeCntOn ){ + if( eStatementOp!=SAVEPOINT_ROLLBACK ){ + sqlite3VdbeSetChanges(db, p->nChange); + }else{ + sqlite3VdbeSetChanges(db, 0); + } + p->nChange = 0; + } + + /* Release the locks */ + sqlite3VdbeLeave(p); + } + + /* We have successfully halted and closed the VM. Record this fact. */ + if( p->pc>=0 ){ + db->nVdbeActive--; + if( !p->readOnly ) db->nVdbeWrite--; + if( p->bIsReader ) db->nVdbeRead--; + assert( db->nVdbeActive>=db->nVdbeRead ); + assert( db->nVdbeRead>=db->nVdbeWrite ); + assert( db->nVdbeWrite>=0 ); + } + p->magic = VDBE_MAGIC_HALT; + checkActiveVdbeCnt(db); + if( db->mallocFailed ){ + p->rc = SQLITE_NOMEM_BKPT; + } + + /* If the auto-commit flag is set to true, then any locks that were held + ** by connection db have now been released. Call sqlite3ConnectionUnlocked() + ** to invoke any required unlock-notify callbacks. + */ + if( db->autoCommit ){ + sqlite3ConnectionUnlocked(db); + } + + assert( db->nVdbeActive>0 || db->autoCommit==0 || db->nStatement==0 ); + return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK); +} + + +/* +** Each VDBE holds the result of the most recent sqlite3_step() call +** in p->rc. This routine sets that result back to SQLITE_OK. +*/ +SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe *p){ + p->rc = SQLITE_OK; +} + +/* +** Copy the error code and error message belonging to the VDBE passed +** as the first argument to its database handle (so that they will be +** returned by calls to sqlite3_errcode() and sqlite3_errmsg()). +** +** This function does not clear the VDBE error code or message, just +** copies them to the database handle. +*/ +SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p){ + sqlite3 *db = p->db; + int rc = p->rc; + if( p->zErrMsg ){ + db->bBenignMalloc++; + sqlite3BeginBenignMalloc(); + if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db); + sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT); + sqlite3EndBenignMalloc(); + db->bBenignMalloc--; + }else if( db->pErr ){ + sqlite3ValueSetNull(db->pErr); + } + db->errCode = rc; + return rc; +} + +#ifdef SQLITE_ENABLE_SQLLOG +/* +** If an SQLITE_CONFIG_SQLLOG hook is registered and the VM has been run, +** invoke it. +*/ +static void vdbeInvokeSqllog(Vdbe *v){ + if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){ + char *zExpanded = sqlite3VdbeExpandSql(v, v->zSql); + assert( v->db->init.busy==0 ); + if( zExpanded ){ + sqlite3GlobalConfig.xSqllog( + sqlite3GlobalConfig.pSqllogArg, v->db, zExpanded, 1 + ); + sqlite3DbFree(v->db, zExpanded); + } + } +} +#else +# define vdbeInvokeSqllog(x) +#endif + +/* +** Clean up a VDBE after execution but do not delete the VDBE just yet. +** Write any error messages into *pzErrMsg. Return the result code. +** +** After this routine is run, the VDBE should be ready to be executed +** again. +** +** To look at it another way, this routine resets the state of the +** virtual machine from VDBE_MAGIC_RUN or VDBE_MAGIC_HALT back to +** VDBE_MAGIC_INIT. +*/ +SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){ +#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) + int i; +#endif + + sqlite3 *db; + db = p->db; + + /* If the VM did not run to completion or if it encountered an + ** error, then it might not have been halted properly. So halt + ** it now. + */ + sqlite3VdbeHalt(p); + + /* If the VDBE has been run even partially, then transfer the error code + ** and error message from the VDBE into the main database structure. But + ** if the VDBE has just been set to run but has not actually executed any + ** instructions yet, leave the main database error information unchanged. + */ + if( p->pc>=0 ){ + vdbeInvokeSqllog(p); + if( db->pErr || p->zErrMsg ){ + sqlite3VdbeTransferError(p); + }else{ + db->errCode = p->rc; + } + if( p->runOnlyOnce ) p->expired = 1; + }else if( p->rc && p->expired ){ + /* The expired flag was set on the VDBE before the first call + ** to sqlite3_step(). For consistency (since sqlite3_step() was + ** called), set the database error in this case as well. + */ + sqlite3ErrorWithMsg(db, p->rc, p->zErrMsg ? "%s" : 0, p->zErrMsg); + } + + /* Reset register contents and reclaim error message memory. + */ +#ifdef SQLITE_DEBUG + /* Execute assert() statements to ensure that the Vdbe.apCsr[] and + ** Vdbe.aMem[] arrays have already been cleaned up. */ + if( p->apCsr ) for(i=0; inCursor; i++) assert( p->apCsr[i]==0 ); + if( p->aMem ){ + for(i=0; inMem; i++) assert( p->aMem[i].flags==MEM_Undefined ); + } +#endif + if( p->zErrMsg ){ + sqlite3DbFree(db, p->zErrMsg); + p->zErrMsg = 0; + } + p->pResultSet = 0; +#ifdef SQLITE_DEBUG + p->nWrite = 0; +#endif + + /* Save profiling information from this VDBE run. + */ +#ifdef VDBE_PROFILE + { + FILE *out = fopen("vdbe_profile.out", "a"); + if( out ){ + fprintf(out, "---- "); + for(i=0; inOp; i++){ + fprintf(out, "%02x", p->aOp[i].opcode); + } + fprintf(out, "\n"); + if( p->zSql ){ + char c, pc = 0; + fprintf(out, "-- "); + for(i=0; (c = p->zSql[i])!=0; i++){ + if( pc=='\n' ) fprintf(out, "-- "); + putc(c, out); + pc = c; + } + if( pc!='\n' ) fprintf(out, "\n"); + } + for(i=0; inOp; i++){ + char zHdr[100]; + 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 + ); + fprintf(out, "%s", zHdr); + sqlite3VdbePrintOp(out, i, &p->aOp[i]); + } + fclose(out); + } + } +#endif + p->magic = VDBE_MAGIC_RESET; + return p->rc & db->errMask; +} + +/* +** Clean up and delete a VDBE after execution. Return an integer which is +** the result code. Write any error message text into *pzErrMsg. +*/ +SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe *p){ + int rc = SQLITE_OK; + if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){ + rc = sqlite3VdbeReset(p); + assert( (rc & p->db->errMask)==rc ); + } + sqlite3VdbeDelete(p); + return rc; +} + +/* +** If parameter iOp is less than zero, then invoke the destructor for +** all auxiliary data pointers currently cached by the VM passed as +** the first argument. +** +** Or, if iOp is greater than or equal to zero, then the destructor is +** only invoked for those auxiliary data pointers created by the user +** function invoked by the OP_Function opcode at instruction iOp of +** VM pVdbe, and only then if: +** +** * the associated function parameter is the 32nd or later (counting +** from left to right), or +** +** * the corresponding bit in argument mask is clear (where the first +** function parameter corresponds to bit 0 etc.). +*/ +SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(sqlite3 *db, AuxData **pp, int iOp, int mask){ + while( *pp ){ + AuxData *pAux = *pp; + if( (iOp<0) + || (pAux->iAuxOp==iOp + && pAux->iAuxArg>=0 + && (pAux->iAuxArg>31 || !(mask & MASKBIT32(pAux->iAuxArg)))) + ){ + testcase( pAux->iAuxArg==31 ); + if( pAux->xDeleteAux ){ + pAux->xDeleteAux(pAux->pAux); + } + *pp = pAux->pNextAux; + sqlite3DbFree(db, pAux); + }else{ + pp= &pAux->pNextAux; + } + } +} + +/* +** Free all memory associated with the Vdbe passed as the second argument, +** except for object itself, which is preserved. +** +** The difference between this function and sqlite3VdbeDelete() is that +** VdbeDelete() also unlinks the Vdbe from the list of VMs associated with +** the database connection and frees the object itself. +*/ +SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){ + SubProgram *pSub, *pNext; + assert( p->db==0 || p->db==db ); + releaseMemArray(p->aColName, p->nResColumn*COLNAME_N); + for(pSub=p->pProgram; pSub; pSub=pNext){ + pNext = pSub->pNext; + vdbeFreeOpArray(db, pSub->aOp, pSub->nOp); + sqlite3DbFree(db, pSub); + } + if( p->magic!=VDBE_MAGIC_INIT ){ + releaseMemArray(p->aVar, p->nVar); + sqlite3DbFree(db, p->pVList); + sqlite3DbFree(db, p->pFree); + } + vdbeFreeOpArray(db, p->aOp, p->nOp); + sqlite3DbFree(db, p->aColName); + sqlite3DbFree(db, p->zSql); +#ifdef SQLITE_ENABLE_NORMALIZE + sqlite3DbFree(db, p->zNormSql); + { + DblquoteStr *pThis, *pNext; + for(pThis=p->pDblStr; pThis; pThis=pNext){ + pNext = pThis->pNextStr; + sqlite3DbFree(db, pThis); + } + } +#endif +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + { + int i; + for(i=0; inScan; i++){ + sqlite3DbFree(db, p->aScan[i].zName); + } + sqlite3DbFree(db, p->aScan); + } +#endif +} + +/* +** Delete an entire VDBE. +*/ +SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe *p){ + sqlite3 *db; + + assert( p!=0 ); + db = p->db; + assert( sqlite3_mutex_held(db->mutex) ); + sqlite3VdbeClearObject(db, p); + if( p->pPrev ){ + p->pPrev->pNext = p->pNext; + }else{ + assert( db->pVdbe==p ); + db->pVdbe = p->pNext; + } + if( p->pNext ){ + p->pNext->pPrev = p->pPrev; + } + p->magic = VDBE_MAGIC_DEAD; + p->db = 0; + sqlite3DbFreeNN(db, p); +} + +/* +** The cursor "p" has a pending seek operation that has not yet been +** carried out. Seek the cursor now. If an error occurs, return +** the appropriate error code. +*/ +SQLITE_PRIVATE int SQLITE_NOINLINE sqlite3VdbeFinishMoveto(VdbeCursor *p){ + int res, rc; +#ifdef SQLITE_TEST + extern int sqlite3_search_count; +#endif + assert( p->deferredMoveto ); + assert( p->isTable ); + assert( p->eCurType==CURTYPE_BTREE ); + rc = sqlite3BtreeMovetoUnpacked(p->uc.pCursor, 0, p->movetoTarget, 0, &res); + if( rc ) return rc; + if( res!=0 ) return SQLITE_CORRUPT_BKPT; +#ifdef SQLITE_TEST + sqlite3_search_count++; +#endif + p->deferredMoveto = 0; + p->cacheStatus = CACHE_STALE; + return SQLITE_OK; +} + +/* +** Something has moved cursor "p" out of place. Maybe the row it was +** pointed to was deleted out from under it. Or maybe the btree was +** rebalanced. Whatever the cause, try to restore "p" to the place it +** is supposed to be pointing. If the row was deleted out from under the +** cursor, set the cursor to point to a NULL row. +*/ +static int SQLITE_NOINLINE handleMovedCursor(VdbeCursor *p){ + int isDifferentRow, rc; + assert( p->eCurType==CURTYPE_BTREE ); + assert( p->uc.pCursor!=0 ); + assert( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ); + rc = sqlite3BtreeCursorRestore(p->uc.pCursor, &isDifferentRow); + p->cacheStatus = CACHE_STALE; + if( isDifferentRow ) p->nullRow = 1; + return rc; +} + +/* +** Check to ensure that the cursor is valid. Restore the cursor +** if need be. Return any I/O error from the restore operation. +*/ +SQLITE_PRIVATE int sqlite3VdbeCursorRestore(VdbeCursor *p){ + assert( p->eCurType==CURTYPE_BTREE ); + if( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ){ + return handleMovedCursor(p); + } + return SQLITE_OK; +} + +/* +** Make sure the cursor p is ready to read or write the row to which it +** was last positioned. Return an error code if an OOM fault or I/O error +** prevents us from positioning the cursor to its correct position. +** +** If a MoveTo operation is pending on the given cursor, then do that +** MoveTo now. If no move is pending, check to see if the row has been +** deleted out from under the cursor and if it has, mark the row as +** a NULL row. +** +** If the cursor is already pointing to the correct row and that row has +** not been deleted out from under the cursor, then this routine is a no-op. +*/ +SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor **pp, u32 *piCol){ + VdbeCursor *p = *pp; + assert( p->eCurType==CURTYPE_BTREE || p->eCurType==CURTYPE_PSEUDO ); + if( p->deferredMoveto ){ + u32 iMap; + if( p->aAltMap && (iMap = p->aAltMap[1+*piCol])>0 && !p->nullRow ){ + *pp = p->pAltCursor; + *piCol = iMap - 1; + return SQLITE_OK; + } + return sqlite3VdbeFinishMoveto(p); + } + if( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ){ + return handleMovedCursor(p); + } + return SQLITE_OK; +} + +/* +** The following functions: +** +** sqlite3VdbeSerialType() +** sqlite3VdbeSerialTypeLen() +** sqlite3VdbeSerialLen() +** sqlite3VdbeSerialPut() +** sqlite3VdbeSerialGet() +** +** encapsulate the code that serializes values for storage in SQLite +** data and index records. Each serialized value consists of a +** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned +** integer, stored as a varint. +** +** In an SQLite index record, the serial type is stored directly before +** the blob of data that it corresponds to. In a table record, all serial +** types are stored at the start of the record, and the blobs of data at +** the end. Hence these functions allow the caller to handle the +** serial-type and data blob separately. +** +** The following table describes the various storage classes for data: +** +** serial type bytes of data type +** -------------- --------------- --------------- +** 0 0 NULL +** 1 1 signed integer +** 2 2 signed integer +** 3 3 signed integer +** 4 4 signed integer +** 5 6 signed integer +** 6 8 signed integer +** 7 8 IEEE float +** 8 0 Integer constant 0 +** 9 0 Integer constant 1 +** 10,11 reserved for expansion +** N>=12 and even (N-12)/2 BLOB +** N>=13 and odd (N-13)/2 text +** +** The 8 and 9 types were added in 3.3.0, file format 4. Prior versions +** of SQLite will not understand those serial types. +*/ + +#if 0 /* Inlined into the OP_MakeRecord opcode */ +/* +** Return the serial-type for the value stored in pMem. +** +** This routine might convert a large MEM_IntReal value into MEM_Real. +** +** 2019-07-11: The primary user of this subroutine was the OP_MakeRecord +** opcode in the byte-code engine. But by moving this routine in-line, we +** can omit some redundant tests and make that opcode a lot faster. So +** this routine is now only used by the STAT3 logic and STAT3 support has +** ended. The code is kept here for historical reference only. +*/ +SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem *pMem, int file_format, u32 *pLen){ + int flags = pMem->flags; + u32 n; + + assert( pLen!=0 ); + if( flags&MEM_Null ){ + *pLen = 0; + return 0; + } + if( flags&(MEM_Int|MEM_IntReal) ){ + /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */ +# define MAX_6BYTE ((((i64)0x00008000)<<32)-1) + i64 i = pMem->u.i; + u64 u; + testcase( flags & MEM_Int ); + testcase( flags & MEM_IntReal ); + if( i<0 ){ + u = ~i; + }else{ + u = i; + } + if( u<=127 ){ + if( (i&1)==i && file_format>=4 ){ + *pLen = 0; + return 8+(u32)u; + }else{ + *pLen = 1; + return 1; + } + } + if( u<=32767 ){ *pLen = 2; return 2; } + if( u<=8388607 ){ *pLen = 3; return 3; } + if( u<=2147483647 ){ *pLen = 4; return 4; } + if( u<=MAX_6BYTE ){ *pLen = 6; return 5; } + *pLen = 8; + if( flags&MEM_IntReal ){ + /* If the value is IntReal and is going to take up 8 bytes to store + ** as an integer, then we might as well make it an 8-byte floating + ** point value */ + pMem->u.r = (double)pMem->u.i; + pMem->flags &= ~MEM_IntReal; + pMem->flags |= MEM_Real; + return 7; + } + return 6; + } + if( flags&MEM_Real ){ + *pLen = 8; + return 7; + } + assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) ); + assert( pMem->n>=0 ); + n = (u32)pMem->n; + if( flags & MEM_Zero ){ + n += pMem->u.nZero; + } + *pLen = n; + return ((n*2) + 12 + ((flags&MEM_Str)!=0)); +} +#endif /* inlined into OP_MakeRecord */ + +/* +** The sizes for serial types less than 128 +*/ +static const u8 sqlite3SmallTypeSizes[] = { + /* 0 1 2 3 4 5 6 7 8 9 */ +/* 0 */ 0, 1, 2, 3, 4, 6, 8, 8, 0, 0, +/* 10 */ 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, +/* 20 */ 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, +/* 30 */ 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, +/* 40 */ 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, +/* 50 */ 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, +/* 60 */ 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, +/* 70 */ 29, 29, 30, 30, 31, 31, 32, 32, 33, 33, +/* 80 */ 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, +/* 90 */ 39, 39, 40, 40, 41, 41, 42, 42, 43, 43, +/* 100 */ 44, 44, 45, 45, 46, 46, 47, 47, 48, 48, +/* 110 */ 49, 49, 50, 50, 51, 51, 52, 52, 53, 53, +/* 120 */ 54, 54, 55, 55, 56, 56, 57, 57 +}; + +/* +** Return the length of the data corresponding to the supplied serial-type. +*/ +SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32 serial_type){ + if( serial_type>=128 ){ + return (serial_type-12)/2; + }else{ + assert( serial_type<12 + || sqlite3SmallTypeSizes[serial_type]==(serial_type - 12)/2 ); + return sqlite3SmallTypeSizes[serial_type]; + } +} +SQLITE_PRIVATE u8 sqlite3VdbeOneByteSerialTypeLen(u8 serial_type){ + assert( serial_type<128 ); + return sqlite3SmallTypeSizes[serial_type]; +} + +/* +** If we are on an architecture with mixed-endian floating +** points (ex: ARM7) then swap the lower 4 bytes with the +** upper 4 bytes. Return the result. +** +** For most architectures, this is a no-op. +** +** (later): It is reported to me that the mixed-endian problem +** on ARM7 is an issue with GCC, not with the ARM7 chip. It seems +** that early versions of GCC stored the two words of a 64-bit +** float in the wrong order. And that error has been propagated +** ever since. The blame is not necessarily with GCC, though. +** GCC might have just copying the problem from a prior compiler. +** I am also told that newer versions of GCC that follow a different +** ABI get the byte order right. +** +** Developers using SQLite on an ARM7 should compile and run their +** application using -DSQLITE_DEBUG=1 at least once. With DEBUG +** enabled, some asserts below will ensure that the byte order of +** floating point values is correct. +** +** (2007-08-30) Frank van Vugt has studied this problem closely +** and has send his findings to the SQLite developers. Frank +** writes that some Linux kernels offer floating point hardware +** emulation that uses only 32-bit mantissas instead of a full +** 48-bits as required by the IEEE standard. (This is the +** CONFIG_FPE_FASTFPE option.) On such systems, floating point +** byte swapping becomes very complicated. To avoid problems, +** the necessary byte swapping is carried out using a 64-bit integer +** rather than a 64-bit float. Frank assures us that the code here +** works for him. We, the developers, have no way to independently +** verify this, but Frank seems to know what he is talking about +** so we trust him. +*/ +#ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT +static u64 floatSwap(u64 in){ + union { + u64 r; + u32 i[2]; + } u; + u32 t; + + u.r = in; + t = u.i[0]; + u.i[0] = u.i[1]; + u.i[1] = t; + return u.r; +} +# define swapMixedEndianFloat(X) X = floatSwap(X) +#else +# define swapMixedEndianFloat(X) +#endif + +/* +** Write the serialized data blob for the value stored in pMem into +** buf. It is assumed that the caller has allocated sufficient space. +** Return the number of bytes written. +** +** nBuf is the amount of space left in buf[]. The caller is responsible +** for allocating enough space to buf[] to hold the entire field, exclusive +** of the pMem->u.nZero bytes for a MEM_Zero value. +** +** Return the number of bytes actually written into buf[]. The number +** of bytes in the zero-filled tail is included in the return value only +** if those bytes were zeroed in buf[]. +*/ +SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, Mem *pMem, u32 serial_type){ + u32 len; + + /* Integer and Real */ + if( serial_type<=7 && serial_type>0 ){ + u64 v; + u32 i; + if( serial_type==7 ){ + assert( sizeof(v)==sizeof(pMem->u.r) ); + memcpy(&v, &pMem->u.r, sizeof(v)); + swapMixedEndianFloat(v); + }else{ + v = pMem->u.i; + } + len = i = sqlite3SmallTypeSizes[serial_type]; + assert( i>0 ); + do{ + buf[--i] = (u8)(v&0xFF); + v >>= 8; + }while( i ); + return len; + } + + /* String or blob */ + if( serial_type>=12 ){ + assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.nZero:0) + == (int)sqlite3VdbeSerialTypeLen(serial_type) ); + len = pMem->n; + if( len>0 ) memcpy(buf, pMem->z, len); + return len; + } + + /* NULL or constants 0 or 1 */ + return 0; +} + +/* Input "x" is a sequence of unsigned characters that represent a +** big-endian integer. Return the equivalent native integer +*/ +#define ONE_BYTE_INT(x) ((i8)(x)[0]) +#define TWO_BYTE_INT(x) (256*(i8)((x)[0])|(x)[1]) +#define THREE_BYTE_INT(x) (65536*(i8)((x)[0])|((x)[1]<<8)|(x)[2]) +#define FOUR_BYTE_UINT(x) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3]) +#define FOUR_BYTE_INT(x) (16777216*(i8)((x)[0])|((x)[1]<<16)|((x)[2]<<8)|(x)[3]) + +/* +** Deserialize the data blob pointed to by buf as serial type serial_type +** and store the result in pMem. Return the number of bytes read. +** +** This function is implemented as two separate routines for performance. +** The few cases that require local variables are broken out into a separate +** routine so that in most cases the overhead of moving the stack pointer +** is avoided. +*/ +static u32 serialGet( + const unsigned char *buf, /* Buffer to deserialize from */ + u32 serial_type, /* Serial type to deserialize */ + Mem *pMem /* Memory cell to write value into */ +){ + u64 x = FOUR_BYTE_UINT(buf); + u32 y = FOUR_BYTE_UINT(buf+4); + x = (x<<32) + y; + if( serial_type==6 ){ + /* EVIDENCE-OF: R-29851-52272 Value is a big-endian 64-bit + ** twos-complement integer. */ + pMem->u.i = *(i64*)&x; + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + }else{ + /* EVIDENCE-OF: R-57343-49114 Value is a big-endian IEEE 754-2008 64-bit + ** floating point number. */ +#if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT) + /* Verify that integers and floating point values use the same + ** byte order. Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is + ** defined that 64-bit floating point values really are mixed + ** endian. + */ + static const u64 t1 = ((u64)0x3ff00000)<<32; + static const double r1 = 1.0; + u64 t2 = t1; + swapMixedEndianFloat(t2); + assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 ); +#endif + assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 ); + swapMixedEndianFloat(x); + memcpy(&pMem->u.r, &x, sizeof(x)); + pMem->flags = IsNaN(x) ? MEM_Null : MEM_Real; + } + return 8; +} +SQLITE_PRIVATE u32 sqlite3VdbeSerialGet( + const unsigned char *buf, /* Buffer to deserialize from */ + u32 serial_type, /* Serial type to deserialize */ + Mem *pMem /* Memory cell to write value into */ +){ + switch( serial_type ){ + case 10: { /* Internal use only: NULL with virtual table + ** UPDATE no-change flag set */ + pMem->flags = MEM_Null|MEM_Zero; + pMem->n = 0; + pMem->u.nZero = 0; + break; + } + case 11: /* Reserved for future use */ + case 0: { /* Null */ + /* EVIDENCE-OF: R-24078-09375 Value is a NULL. */ + pMem->flags = MEM_Null; + break; + } + case 1: { + /* EVIDENCE-OF: R-44885-25196 Value is an 8-bit twos-complement + ** integer. */ + pMem->u.i = ONE_BYTE_INT(buf); + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + return 1; + } + case 2: { /* 2-byte signed integer */ + /* EVIDENCE-OF: R-49794-35026 Value is a big-endian 16-bit + ** twos-complement integer. */ + pMem->u.i = TWO_BYTE_INT(buf); + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + return 2; + } + case 3: { /* 3-byte signed integer */ + /* EVIDENCE-OF: R-37839-54301 Value is a big-endian 24-bit + ** twos-complement integer. */ + pMem->u.i = THREE_BYTE_INT(buf); + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + return 3; + } + case 4: { /* 4-byte signed integer */ + /* EVIDENCE-OF: R-01849-26079 Value is a big-endian 32-bit + ** twos-complement integer. */ + pMem->u.i = FOUR_BYTE_INT(buf); +#ifdef __HP_cc + /* Work around a sign-extension bug in the HP compiler for HP/UX */ + if( buf[0]&0x80 ) pMem->u.i |= 0xffffffff80000000LL; +#endif + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + return 4; + } + case 5: { /* 6-byte signed integer */ + /* EVIDENCE-OF: R-50385-09674 Value is a big-endian 48-bit + ** twos-complement integer. */ + pMem->u.i = FOUR_BYTE_UINT(buf+2) + (((i64)1)<<32)*TWO_BYTE_INT(buf); + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + return 6; + } + case 6: /* 8-byte signed integer */ + case 7: { /* IEEE floating point */ + /* These use local variables, so do them in a separate routine + ** to avoid having to move the frame pointer in the common case */ + return serialGet(buf,serial_type,pMem); + } + case 8: /* Integer 0 */ + case 9: { /* Integer 1 */ + /* EVIDENCE-OF: R-12976-22893 Value is the integer 0. */ + /* EVIDENCE-OF: R-18143-12121 Value is the integer 1. */ + pMem->u.i = serial_type-8; + pMem->flags = MEM_Int; + return 0; + } + default: { + /* EVIDENCE-OF: R-14606-31564 Value is a BLOB that is (N-12)/2 bytes in + ** length. + ** EVIDENCE-OF: R-28401-00140 Value is a string in the text encoding and + ** (N-13)/2 bytes in length. */ + static const u16 aFlag[] = { MEM_Blob|MEM_Ephem, MEM_Str|MEM_Ephem }; + pMem->z = (char *)buf; + pMem->n = (serial_type-12)/2; + pMem->flags = aFlag[serial_type&1]; + return pMem->n; + } + } + return 0; +} +/* +** This routine is used to allocate sufficient space for an UnpackedRecord +** structure large enough to be used with sqlite3VdbeRecordUnpack() if +** the first argument is a pointer to KeyInfo structure pKeyInfo. +** +** The space is either allocated using sqlite3DbMallocRaw() or from within +** the unaligned buffer passed via the second and third arguments (presumably +** stack space). If the former, then *ppFree is set to a pointer that should +** be eventually freed by the caller using sqlite3DbFree(). Or, if the +** allocation comes from the pSpace/szSpace buffer, *ppFree is set to NULL +** before returning. +** +** If an OOM error occurs, NULL is returned. +*/ +SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeAllocUnpackedRecord( + KeyInfo *pKeyInfo /* Description of the record */ +){ + UnpackedRecord *p; /* Unpacked record to return */ + int nByte; /* Number of bytes required for *p */ + nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nKeyField+1); + p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte); + if( !p ) return 0; + p->aMem = (Mem*)&((char*)p)[ROUND8(sizeof(UnpackedRecord))]; + assert( pKeyInfo->aSortFlags!=0 ); + p->pKeyInfo = pKeyInfo; + p->nField = pKeyInfo->nKeyField + 1; + return p; +} + +/* +** Given the nKey-byte encoding of a record in pKey[], populate the +** UnpackedRecord structure indicated by the fourth argument with the +** contents of the decoded record. +*/ +SQLITE_PRIVATE void sqlite3VdbeRecordUnpack( + KeyInfo *pKeyInfo, /* Information about the record format */ + int nKey, /* Size of the binary record */ + const void *pKey, /* The binary record */ + UnpackedRecord *p /* Populate this structure before returning. */ +){ + const unsigned char *aKey = (const unsigned char *)pKey; + u32 d; + u32 idx; /* Offset in aKey[] to read from */ + u16 u; /* Unsigned loop counter */ + u32 szHdr; + Mem *pMem = p->aMem; + + p->default_rc = 0; + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + idx = getVarint32(aKey, szHdr); + d = szHdr; + u = 0; + while( idxenc = pKeyInfo->enc; + pMem->db = pKeyInfo->db; + /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */ + pMem->szMalloc = 0; + pMem->z = 0; + d += sqlite3VdbeSerialGet(&aKey[d], serial_type, pMem); + pMem++; + if( (++u)>=p->nField ) break; + } + if( d>(u32)nKey && u ){ + assert( CORRUPT_DB ); + /* In a corrupt record entry, the last pMem might have been set up using + ** uninitialized memory. Overwrite its value with NULL, to prevent + ** warnings from MSAN. */ + sqlite3VdbeMemSetNull(pMem-1); + } + assert( u<=pKeyInfo->nKeyField + 1 ); + p->nField = u; +} + +#ifdef SQLITE_DEBUG +/* +** This function compares two index or table record keys in the same way +** as the sqlite3VdbeRecordCompare() routine. Unlike VdbeRecordCompare(), +** this function deserializes and compares values using the +** sqlite3VdbeSerialGet() and sqlite3MemCompare() functions. It is used +** in assert() statements to ensure that the optimized code in +** sqlite3VdbeRecordCompare() returns results with these two primitives. +** +** Return true if the result of comparison is equivalent to desiredResult. +** Return false if there is a disagreement. +*/ +static int vdbeRecordCompareDebug( + int nKey1, const void *pKey1, /* Left key */ + const UnpackedRecord *pPKey2, /* Right key */ + int desiredResult /* Correct answer */ +){ + u32 d1; /* Offset into aKey[] of next data element */ + u32 idx1; /* Offset into aKey[] of next header element */ + u32 szHdr1; /* Number of bytes in header */ + int i = 0; + int rc = 0; + const unsigned char *aKey1 = (const unsigned char *)pKey1; + KeyInfo *pKeyInfo; + Mem mem1; + + pKeyInfo = pPKey2->pKeyInfo; + if( pKeyInfo->db==0 ) return 1; + mem1.enc = pKeyInfo->enc; + mem1.db = pKeyInfo->db; + /* mem1.flags = 0; // Will be initialized by sqlite3VdbeSerialGet() */ + VVA_ONLY( mem1.szMalloc = 0; ) /* Only needed by assert() statements */ + + /* Compilers may complain that mem1.u.i is potentially uninitialized. + ** We could initialize it, as shown here, to silence those complaints. + ** But in fact, mem1.u.i will never actually be used uninitialized, and doing + ** the unnecessary initialization has a measurable negative performance + ** impact, since this routine is a very high runner. And so, we choose + ** to ignore the compiler warnings and leave this variable uninitialized. + */ + /* mem1.u.i = 0; // not needed, here to silence compiler warning */ + + idx1 = getVarint32(aKey1, szHdr1); + if( szHdr1>98307 ) return SQLITE_CORRUPT; + d1 = szHdr1; + assert( pKeyInfo->nAllField>=pPKey2->nField || CORRUPT_DB ); + assert( pKeyInfo->aSortFlags!=0 ); + assert( pKeyInfo->nKeyField>0 ); + assert( idx1<=szHdr1 || CORRUPT_DB ); + do{ + u32 serial_type1; + + /* Read the serial types for the next element in each key. */ + idx1 += getVarint32( aKey1+idx1, serial_type1 ); + + /* Verify that there is enough key space remaining to avoid + ** a buffer overread. The "d1+serial_type1+2" subexpression will + ** always be greater than or equal to the amount of required key space. + ** Use that approximation to avoid the more expensive call to + ** sqlite3VdbeSerialTypeLen() in the common case. + */ + if( d1+(u64)serial_type1+2>(u64)nKey1 + && d1+(u64)sqlite3VdbeSerialTypeLen(serial_type1)>(u64)nKey1 + ){ + break; + } + + /* Extract the values to be compared. + */ + d1 += sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1); + + /* Do the comparison + */ + rc = sqlite3MemCompare(&mem1, &pPKey2->aMem[i], + pKeyInfo->nAllField>i ? pKeyInfo->aColl[i] : 0); + if( rc!=0 ){ + assert( mem1.szMalloc==0 ); /* See comment below */ + if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) + && ((mem1.flags & MEM_Null) || (pPKey2->aMem[i].flags & MEM_Null)) + ){ + rc = -rc; + } + if( pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC ){ + rc = -rc; /* Invert the result for DESC sort order. */ + } + goto debugCompareEnd; + } + i++; + }while( idx1nField ); + + /* No memory allocation is ever used on mem1. Prove this using + ** the following assert(). If the assert() fails, it indicates a + ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1). + */ + assert( mem1.szMalloc==0 ); + + /* rc==0 here means that one of the keys ran out of fields and + ** all the fields up to that point were equal. Return the default_rc + ** value. */ + rc = pPKey2->default_rc; + +debugCompareEnd: + if( desiredResult==0 && rc==0 ) return 1; + if( desiredResult<0 && rc<0 ) return 1; + if( desiredResult>0 && rc>0 ) return 1; + if( CORRUPT_DB ) return 1; + if( pKeyInfo->db->mallocFailed ) return 1; + return 0; +} +#endif + +#ifdef SQLITE_DEBUG +/* +** Count the number of fields (a.k.a. columns) in the record given by +** pKey,nKey. The verify that this count is less than or equal to the +** limit given by pKeyInfo->nAllField. +** +** If this constraint is not satisfied, it means that the high-speed +** vdbeRecordCompareInt() and vdbeRecordCompareString() routines will +** not work correctly. If this assert() ever fires, it probably means +** that the KeyInfo.nKeyField or KeyInfo.nAllField values were computed +** incorrectly. +*/ +static void vdbeAssertFieldCountWithinLimits( + int nKey, const void *pKey, /* The record to verify */ + const KeyInfo *pKeyInfo /* Compare size with this KeyInfo */ +){ + int nField = 0; + u32 szHdr; + u32 idx; + u32 notUsed; + const unsigned char *aKey = (const unsigned char*)pKey; + + if( CORRUPT_DB ) return; + idx = getVarint32(aKey, szHdr); + assert( nKey>=0 ); + assert( szHdr<=(u32)nKey ); + while( idxnAllField ); +} +#else +# define vdbeAssertFieldCountWithinLimits(A,B,C) +#endif + +/* +** Both *pMem1 and *pMem2 contain string values. Compare the two values +** using the collation sequence pColl. As usual, return a negative , zero +** or positive value if *pMem1 is less than, equal to or greater than +** *pMem2, respectively. Similar in spirit to "rc = (*pMem1) - (*pMem2);". +*/ +static int vdbeCompareMemString( + const Mem *pMem1, + const Mem *pMem2, + const CollSeq *pColl, + u8 *prcErr /* If an OOM occurs, set to SQLITE_NOMEM */ +){ + if( pMem1->enc==pColl->enc ){ + /* The strings are already in the correct encoding. Call the + ** comparison function directly */ + return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z); + }else{ + int rc; + const void *v1, *v2; + Mem c1; + Mem c2; + sqlite3VdbeMemInit(&c1, pMem1->db, MEM_Null); + sqlite3VdbeMemInit(&c2, pMem1->db, MEM_Null); + sqlite3VdbeMemShallowCopy(&c1, pMem1, MEM_Ephem); + sqlite3VdbeMemShallowCopy(&c2, pMem2, MEM_Ephem); + v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc); + v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc); + if( (v1==0 || v2==0) ){ + if( prcErr ) *prcErr = SQLITE_NOMEM_BKPT; + rc = 0; + }else{ + rc = pColl->xCmp(pColl->pUser, c1.n, v1, c2.n, v2); + } + sqlite3VdbeMemRelease(&c1); + sqlite3VdbeMemRelease(&c2); + return rc; + } +} + +/* +** The input pBlob is guaranteed to be a Blob that is not marked +** with MEM_Zero. Return true if it could be a zero-blob. +*/ +static int isAllZero(const char *z, int n){ + int i; + for(i=0; in; + int n2 = pB2->n; + + /* It is possible to have a Blob value that has some non-zero content + ** followed by zero content. But that only comes up for Blobs formed + ** by the OP_MakeRecord opcode, and such Blobs never get passed into + ** sqlite3MemCompare(). */ + assert( (pB1->flags & MEM_Zero)==0 || n1==0 ); + assert( (pB2->flags & MEM_Zero)==0 || n2==0 ); + + if( (pB1->flags|pB2->flags) & MEM_Zero ){ + if( pB1->flags & pB2->flags & MEM_Zero ){ + return pB1->u.nZero - pB2->u.nZero; + }else if( pB1->flags & MEM_Zero ){ + if( !isAllZero(pB2->z, pB2->n) ) return -1; + return pB1->u.nZero - n2; + }else{ + if( !isAllZero(pB1->z, pB1->n) ) return +1; + return n1 - pB2->u.nZero; + } + } + c = memcmp(pB1->z, pB2->z, n1>n2 ? n2 : n1); + if( c ) return c; + return n1 - n2; +} + +/* +** Do a comparison between a 64-bit signed integer and a 64-bit floating-point +** number. Return negative, zero, or positive if the first (i64) is less than, +** equal to, or greater than the second (double). +*/ +static int sqlite3IntFloatCompare(i64 i, double r){ + if( sizeof(LONGDOUBLE_TYPE)>8 ){ + LONGDOUBLE_TYPE x = (LONGDOUBLE_TYPE)i; + testcase( xr ); + testcase( x==r ); + if( xr ) return +1; /*NO_TEST*/ /* work around bugs in gcov */ + return 0; /*NO_TEST*/ /* work around bugs in gcov */ + }else{ + i64 y; + double s; + if( r<-9223372036854775808.0 ) return +1; + if( r>=9223372036854775808.0 ) return -1; + y = (i64)r; + if( iy ) return +1; + s = (double)i; + if( sr ) return +1; + return 0; + } +} + +/* +** Compare the values contained by the two memory cells, returning +** negative, zero or positive if pMem1 is less than, equal to, or greater +** than pMem2. Sorting order is NULL's first, followed by numbers (integers +** and reals) sorted numerically, followed by text ordered by the collating +** sequence pColl and finally blob's ordered by memcmp(). +** +** Two NULL values are considered equal by this function. +*/ +SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){ + int f1, f2; + int combined_flags; + + f1 = pMem1->flags; + f2 = pMem2->flags; + combined_flags = f1|f2; + assert( !sqlite3VdbeMemIsRowSet(pMem1) && !sqlite3VdbeMemIsRowSet(pMem2) ); + + /* If one value is NULL, it is less than the other. If both values + ** are NULL, return 0. + */ + if( combined_flags&MEM_Null ){ + return (f2&MEM_Null) - (f1&MEM_Null); + } + + /* At least one of the two values is a number + */ + if( combined_flags&(MEM_Int|MEM_Real|MEM_IntReal) ){ + testcase( combined_flags & MEM_Int ); + testcase( combined_flags & MEM_Real ); + testcase( combined_flags & MEM_IntReal ); + if( (f1 & f2 & (MEM_Int|MEM_IntReal))!=0 ){ + testcase( f1 & f2 & MEM_Int ); + testcase( f1 & f2 & MEM_IntReal ); + if( pMem1->u.i < pMem2->u.i ) return -1; + if( pMem1->u.i > pMem2->u.i ) return +1; + return 0; + } + if( (f1 & f2 & MEM_Real)!=0 ){ + if( pMem1->u.r < pMem2->u.r ) return -1; + if( pMem1->u.r > pMem2->u.r ) return +1; + return 0; + } + if( (f1&(MEM_Int|MEM_IntReal))!=0 ){ + testcase( f1 & MEM_Int ); + testcase( f1 & MEM_IntReal ); + if( (f2&MEM_Real)!=0 ){ + return sqlite3IntFloatCompare(pMem1->u.i, pMem2->u.r); + }else if( (f2&(MEM_Int|MEM_IntReal))!=0 ){ + if( pMem1->u.i < pMem2->u.i ) return -1; + if( pMem1->u.i > pMem2->u.i ) return +1; + return 0; + }else{ + return -1; + } + } + if( (f1&MEM_Real)!=0 ){ + if( (f2&(MEM_Int|MEM_IntReal))!=0 ){ + testcase( f2 & MEM_Int ); + testcase( f2 & MEM_IntReal ); + return -sqlite3IntFloatCompare(pMem2->u.i, pMem1->u.r); + }else{ + return -1; + } + } + return +1; + } + + /* If one value is a string and the other is a blob, the string is less. + ** If both are strings, compare using the collating functions. + */ + if( combined_flags&MEM_Str ){ + if( (f1 & MEM_Str)==0 ){ + return 1; + } + if( (f2 & MEM_Str)==0 ){ + return -1; + } + + assert( pMem1->enc==pMem2->enc || pMem1->db->mallocFailed ); + assert( pMem1->enc==SQLITE_UTF8 || + pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE ); + + /* The collation sequence must be defined at this point, even if + ** the user deletes the collation sequence after the vdbe program is + ** compiled (this was not always the case). + */ + assert( !pColl || pColl->xCmp ); + + if( pColl ){ + return vdbeCompareMemString(pMem1, pMem2, pColl, 0); + } + /* If a NULL pointer was passed as the collate function, fall through + ** to the blob case and use memcmp(). */ + } + + /* Both values must be blobs. Compare using memcmp(). */ + return sqlite3BlobCompare(pMem1, pMem2); +} + + +/* +** The first argument passed to this function is a serial-type that +** corresponds to an integer - all values between 1 and 9 inclusive +** except 7. The second points to a buffer containing an integer value +** serialized according to serial_type. This function deserializes +** and returns the value. +*/ +static i64 vdbeRecordDecodeInt(u32 serial_type, const u8 *aKey){ + u32 y; + assert( CORRUPT_DB || (serial_type>=1 && serial_type<=9 && serial_type!=7) ); + switch( serial_type ){ + case 0: + case 1: + testcase( aKey[0]&0x80 ); + return ONE_BYTE_INT(aKey); + case 2: + testcase( aKey[0]&0x80 ); + return TWO_BYTE_INT(aKey); + case 3: + testcase( aKey[0]&0x80 ); + return THREE_BYTE_INT(aKey); + case 4: { + testcase( aKey[0]&0x80 ); + y = FOUR_BYTE_UINT(aKey); + return (i64)*(int*)&y; + } + case 5: { + testcase( aKey[0]&0x80 ); + return FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey); + } + case 6: { + u64 x = FOUR_BYTE_UINT(aKey); + testcase( aKey[0]&0x80 ); + x = (x<<32) | FOUR_BYTE_UINT(aKey+4); + return (i64)*(i64*)&x; + } + } + + return (serial_type - 8); +} + +/* +** This function compares the two table rows or index records +** specified by {nKey1, pKey1} and pPKey2. It returns a negative, zero +** or positive integer if key1 is less than, equal to or +** greater than key2. The {nKey1, pKey1} key must be a blob +** created by the OP_MakeRecord opcode of the VDBE. The pPKey2 +** key must be a parsed key such as obtained from +** sqlite3VdbeParseRecord. +** +** If argument bSkip is non-zero, it is assumed that the caller has already +** determined that the first fields of the keys are equal. +** +** Key1 and Key2 do not have to contain the same number of fields. If all +** fields that appear in both keys are equal, then pPKey2->default_rc is +** returned. +** +** If database corruption is discovered, set pPKey2->errCode to +** SQLITE_CORRUPT and return 0. If an OOM error is encountered, +** pPKey2->errCode is set to SQLITE_NOMEM and, if it is not NULL, the +** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db). +*/ +SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip( + int nKey1, const void *pKey1, /* Left key */ + UnpackedRecord *pPKey2, /* Right key */ + int bSkip /* If true, skip the first field */ +){ + u32 d1; /* Offset into aKey[] of next data element */ + int i; /* Index of next field to compare */ + u32 szHdr1; /* Size of record header in bytes */ + u32 idx1; /* Offset of first type in header */ + int rc = 0; /* Return value */ + Mem *pRhs = pPKey2->aMem; /* Next field of pPKey2 to compare */ + KeyInfo *pKeyInfo; + const unsigned char *aKey1 = (const unsigned char *)pKey1; + Mem mem1; + + /* If bSkip is true, then the caller has already determined that the first + ** two elements in the keys are equal. Fix the various stack variables so + ** that this routine begins comparing at the second field. */ + if( bSkip ){ + u32 s1; + idx1 = 1 + getVarint32(&aKey1[1], s1); + szHdr1 = aKey1[0]; + d1 = szHdr1 + sqlite3VdbeSerialTypeLen(s1); + i = 1; + pRhs++; + }else{ + idx1 = getVarint32(aKey1, szHdr1); + d1 = szHdr1; + i = 0; + } + if( d1>(unsigned)nKey1 ){ + pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; + return 0; /* Corruption */ + } + + VVA_ONLY( mem1.szMalloc = 0; ) /* Only needed by assert() statements */ + assert( pPKey2->pKeyInfo->nAllField>=pPKey2->nField + || CORRUPT_DB ); + assert( pPKey2->pKeyInfo->aSortFlags!=0 ); + assert( pPKey2->pKeyInfo->nKeyField>0 ); + assert( idx1<=szHdr1 || CORRUPT_DB ); + do{ + u32 serial_type; + + /* RHS is an integer */ + if( pRhs->flags & (MEM_Int|MEM_IntReal) ){ + testcase( pRhs->flags & MEM_Int ); + testcase( pRhs->flags & MEM_IntReal ); + serial_type = aKey1[idx1]; + testcase( serial_type==12 ); + if( serial_type>=10 ){ + rc = +1; + }else if( serial_type==0 ){ + rc = -1; + }else if( serial_type==7 ){ + sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1); + rc = -sqlite3IntFloatCompare(pRhs->u.i, mem1.u.r); + }else{ + i64 lhs = vdbeRecordDecodeInt(serial_type, &aKey1[d1]); + i64 rhs = pRhs->u.i; + if( lhsrhs ){ + rc = +1; + } + } + } + + /* RHS is real */ + else if( pRhs->flags & MEM_Real ){ + serial_type = aKey1[idx1]; + if( serial_type>=10 ){ + /* Serial types 12 or greater are strings and blobs (greater than + ** numbers). Types 10 and 11 are currently "reserved for future + ** use", so it doesn't really matter what the results of comparing + ** them to numberic values are. */ + rc = +1; + }else if( serial_type==0 ){ + rc = -1; + }else{ + sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1); + if( serial_type==7 ){ + if( mem1.u.ru.r ){ + rc = -1; + }else if( mem1.u.r>pRhs->u.r ){ + rc = +1; + } + }else{ + rc = sqlite3IntFloatCompare(mem1.u.i, pRhs->u.r); + } + } + } + + /* RHS is a string */ + else if( pRhs->flags & MEM_Str ){ + getVarint32NR(&aKey1[idx1], serial_type); + testcase( serial_type==12 ); + if( serial_type<12 ){ + rc = -1; + }else if( !(serial_type & 0x01) ){ + rc = +1; + }else{ + mem1.n = (serial_type - 12) / 2; + testcase( (d1+mem1.n)==(unsigned)nKey1 ); + testcase( (d1+mem1.n+1)==(unsigned)nKey1 ); + if( (d1+mem1.n) > (unsigned)nKey1 + || (pKeyInfo = pPKey2->pKeyInfo)->nAllField<=i + ){ + pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; + return 0; /* Corruption */ + }else if( pKeyInfo->aColl[i] ){ + mem1.enc = pKeyInfo->enc; + mem1.db = pKeyInfo->db; + mem1.flags = MEM_Str; + mem1.z = (char*)&aKey1[d1]; + rc = vdbeCompareMemString( + &mem1, pRhs, pKeyInfo->aColl[i], &pPKey2->errCode + ); + }else{ + int nCmp = MIN(mem1.n, pRhs->n); + rc = memcmp(&aKey1[d1], pRhs->z, nCmp); + if( rc==0 ) rc = mem1.n - pRhs->n; + } + } + } + + /* RHS is a blob */ + else if( pRhs->flags & MEM_Blob ){ + assert( (pRhs->flags & MEM_Zero)==0 || pRhs->n==0 ); + getVarint32NR(&aKey1[idx1], serial_type); + testcase( serial_type==12 ); + if( serial_type<12 || (serial_type & 0x01) ){ + rc = -1; + }else{ + int nStr = (serial_type - 12) / 2; + testcase( (d1+nStr)==(unsigned)nKey1 ); + testcase( (d1+nStr+1)==(unsigned)nKey1 ); + if( (d1+nStr) > (unsigned)nKey1 ){ + pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; + return 0; /* Corruption */ + }else if( pRhs->flags & MEM_Zero ){ + if( !isAllZero((const char*)&aKey1[d1],nStr) ){ + rc = 1; + }else{ + rc = nStr - pRhs->u.nZero; + } + }else{ + int nCmp = MIN(nStr, pRhs->n); + rc = memcmp(&aKey1[d1], pRhs->z, nCmp); + if( rc==0 ) rc = nStr - pRhs->n; + } + } + } + + /* RHS is null */ + else{ + serial_type = aKey1[idx1]; + rc = (serial_type!=0); + } + + if( rc!=0 ){ + int sortFlags = pPKey2->pKeyInfo->aSortFlags[i]; + if( sortFlags ){ + if( (sortFlags & KEYINFO_ORDER_BIGNULL)==0 + || ((sortFlags & KEYINFO_ORDER_DESC) + !=(serial_type==0 || (pRhs->flags&MEM_Null))) + ){ + rc = -rc; + } + } + assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, rc) ); + assert( mem1.szMalloc==0 ); /* See comment below */ + return rc; + } + + i++; + if( i==pPKey2->nField ) break; + pRhs++; + d1 += sqlite3VdbeSerialTypeLen(serial_type); + idx1 += sqlite3VarintLen(serial_type); + }while( idx1<(unsigned)szHdr1 && d1<=(unsigned)nKey1 ); + + /* No memory allocation is ever used on mem1. Prove this using + ** the following assert(). If the assert() fails, it indicates a + ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1). */ + assert( mem1.szMalloc==0 ); + + /* rc==0 here means that one or both of the keys ran out of fields and + ** all the fields up to that point were equal. Return the default_rc + ** value. */ + assert( CORRUPT_DB + || vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, pPKey2->default_rc) + || pPKey2->pKeyInfo->db->mallocFailed + ); + pPKey2->eqSeen = 1; + return pPKey2->default_rc; +} +SQLITE_PRIVATE int sqlite3VdbeRecordCompare( + int nKey1, const void *pKey1, /* Left key */ + UnpackedRecord *pPKey2 /* Right key */ +){ + return sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 0); +} + + +/* +** This function is an optimized version of sqlite3VdbeRecordCompare() +** that (a) the first field of pPKey2 is an integer, and (b) the +** size-of-header varint at the start of (pKey1/nKey1) fits in a single +** byte (i.e. is less than 128). +** +** To avoid concerns about buffer overreads, this routine is only used +** on schemas where the maximum valid header size is 63 bytes or less. +*/ +static int vdbeRecordCompareInt( + int nKey1, const void *pKey1, /* Left key */ + UnpackedRecord *pPKey2 /* Right key */ +){ + const u8 *aKey = &((const u8*)pKey1)[*(const u8*)pKey1 & 0x3F]; + int serial_type = ((const u8*)pKey1)[1]; + int res; + u32 y; + u64 x; + i64 v; + i64 lhs; + + vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo); + assert( (*(u8*)pKey1)<=0x3F || CORRUPT_DB ); + switch( serial_type ){ + case 1: { /* 1-byte signed integer */ + lhs = ONE_BYTE_INT(aKey); + testcase( lhs<0 ); + break; + } + case 2: { /* 2-byte signed integer */ + lhs = TWO_BYTE_INT(aKey); + testcase( lhs<0 ); + break; + } + case 3: { /* 3-byte signed integer */ + lhs = THREE_BYTE_INT(aKey); + testcase( lhs<0 ); + break; + } + case 4: { /* 4-byte signed integer */ + y = FOUR_BYTE_UINT(aKey); + lhs = (i64)*(int*)&y; + testcase( lhs<0 ); + break; + } + case 5: { /* 6-byte signed integer */ + lhs = FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey); + testcase( lhs<0 ); + break; + } + case 6: { /* 8-byte signed integer */ + x = FOUR_BYTE_UINT(aKey); + x = (x<<32) | FOUR_BYTE_UINT(aKey+4); + lhs = *(i64*)&x; + testcase( lhs<0 ); + break; + } + case 8: + lhs = 0; + break; + case 9: + lhs = 1; + break; + + /* This case could be removed without changing the results of running + ** this code. Including it causes gcc to generate a faster switch + ** statement (since the range of switch targets now starts at zero and + ** is contiguous) but does not cause any duplicate code to be generated + ** (as gcc is clever enough to combine the two like cases). Other + ** compilers might be similar. */ + case 0: case 7: + return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2); + + default: + return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2); + } + + v = pPKey2->aMem[0].u.i; + if( v>lhs ){ + res = pPKey2->r1; + }else if( vr2; + }else if( pPKey2->nField>1 ){ + /* The first fields of the two keys are equal. Compare the trailing + ** fields. */ + res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1); + }else{ + /* The first fields of the two keys are equal and there are no trailing + ** fields. Return pPKey2->default_rc in this case. */ + res = pPKey2->default_rc; + pPKey2->eqSeen = 1; + } + + assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res) ); + return res; +} + +/* +** This function is an optimized version of sqlite3VdbeRecordCompare() +** that (a) the first field of pPKey2 is a string, that (b) the first field +** uses the collation sequence BINARY and (c) that the size-of-header varint +** at the start of (pKey1/nKey1) fits in a single byte. +*/ +static int vdbeRecordCompareString( + int nKey1, const void *pKey1, /* Left key */ + UnpackedRecord *pPKey2 /* Right key */ +){ + const u8 *aKey1 = (const u8*)pKey1; + int serial_type; + int res; + + assert( pPKey2->aMem[0].flags & MEM_Str ); + vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo); + serial_type = (u8)(aKey1[1]); + if( serial_type >= 0x80 ){ + sqlite3GetVarint32(&aKey1[1], (u32*)&serial_type); + } + if( serial_type<12 ){ + res = pPKey2->r1; /* (pKey1/nKey1) is a number or a null */ + }else if( !(serial_type & 0x01) ){ + res = pPKey2->r2; /* (pKey1/nKey1) is a blob */ + }else{ + int nCmp; + int nStr; + int szHdr = aKey1[0]; + + nStr = (serial_type-12) / 2; + if( (szHdr + nStr) > nKey1 ){ + pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; + return 0; /* Corruption */ + } + nCmp = MIN( pPKey2->aMem[0].n, nStr ); + res = memcmp(&aKey1[szHdr], pPKey2->aMem[0].z, nCmp); + + if( res>0 ){ + res = pPKey2->r2; + }else if( res<0 ){ + res = pPKey2->r1; + }else{ + res = nStr - pPKey2->aMem[0].n; + if( res==0 ){ + if( pPKey2->nField>1 ){ + res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1); + }else{ + res = pPKey2->default_rc; + pPKey2->eqSeen = 1; + } + }else if( res>0 ){ + res = pPKey2->r2; + }else{ + res = pPKey2->r1; + } + } + } + + assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res) + || CORRUPT_DB + || pPKey2->pKeyInfo->db->mallocFailed + ); + return res; +} + +/* +** Return a pointer to an sqlite3VdbeRecordCompare() compatible function +** suitable for comparing serialized records to the unpacked record passed +** as the only argument. +*/ +SQLITE_PRIVATE RecordCompare sqlite3VdbeFindCompare(UnpackedRecord *p){ + /* varintRecordCompareInt() and varintRecordCompareString() both assume + ** that the size-of-header varint that occurs at the start of each record + ** fits in a single byte (i.e. is 127 or less). varintRecordCompareInt() + ** also assumes that it is safe to overread a buffer by at least the + ** maximum possible legal header size plus 8 bytes. Because there is + ** guaranteed to be at least 74 (but not 136) bytes of padding following each + ** buffer passed to varintRecordCompareInt() this makes it convenient to + ** limit the size of the header to 64 bytes in cases where the first field + ** is an integer. + ** + ** The easiest way to enforce this limit is to consider only records with + ** 13 fields or less. If the first field is an integer, the maximum legal + ** header size is (12*5 + 1 + 1) bytes. */ + if( p->pKeyInfo->nAllField<=13 ){ + int flags = p->aMem[0].flags; + if( p->pKeyInfo->aSortFlags[0] ){ + if( p->pKeyInfo->aSortFlags[0] & KEYINFO_ORDER_BIGNULL ){ + return sqlite3VdbeRecordCompare; + } + p->r1 = 1; + p->r2 = -1; + }else{ + p->r1 = -1; + p->r2 = 1; + } + if( (flags & MEM_Int) ){ + return vdbeRecordCompareInt; + } + testcase( flags & MEM_Real ); + testcase( flags & MEM_Null ); + testcase( flags & MEM_Blob ); + if( (flags & (MEM_Real|MEM_IntReal|MEM_Null|MEM_Blob))==0 + && p->pKeyInfo->aColl[0]==0 + ){ + assert( flags & MEM_Str ); + return vdbeRecordCompareString; + } + } + + return sqlite3VdbeRecordCompare; +} + +/* +** pCur points at an index entry created using the OP_MakeRecord opcode. +** Read the rowid (the last field in the record) and store it in *rowid. +** Return SQLITE_OK if everything works, or an error code otherwise. +** +** pCur might be pointing to text obtained from a corrupt database file. +** So the content cannot be trusted. Do appropriate checks on the content. +*/ +SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){ + i64 nCellKey = 0; + int rc; + u32 szHdr; /* Size of the header */ + u32 typeRowid; /* Serial type of the rowid */ + u32 lenRowid; /* Size of the rowid */ + Mem m, v; + + /* Get the size of the index entry. Only indices entries of less + ** than 2GiB are support - anything large must be database corruption. + ** Any corruption is detected in sqlite3BtreeParseCellPtr(), though, so + ** this code can safely assume that nCellKey is 32-bits + */ + assert( sqlite3BtreeCursorIsValid(pCur) ); + nCellKey = sqlite3BtreePayloadSize(pCur); + assert( (nCellKey & SQLITE_MAX_U32)==(u64)nCellKey ); + + /* Read in the complete content of the index entry */ + sqlite3VdbeMemInit(&m, db, 0); + rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m); + if( rc ){ + return rc; + } + + /* The index entry must begin with a header size */ + getVarint32NR((u8*)m.z, szHdr); + testcase( szHdr==3 ); + testcase( szHdr==m.n ); + testcase( szHdr>0x7fffffff ); + assert( m.n>=0 ); + if( unlikely(szHdr<3 || szHdr>(unsigned)m.n) ){ + goto idx_rowid_corruption; + } + + /* The last field of the index should be an integer - the ROWID. + ** Verify that the last entry really is an integer. */ + getVarint32NR((u8*)&m.z[szHdr-1], typeRowid); + testcase( typeRowid==1 ); + testcase( typeRowid==2 ); + testcase( typeRowid==3 ); + testcase( typeRowid==4 ); + testcase( typeRowid==5 ); + testcase( typeRowid==6 ); + testcase( typeRowid==8 ); + testcase( typeRowid==9 ); + if( unlikely(typeRowid<1 || typeRowid>9 || typeRowid==7) ){ + goto idx_rowid_corruption; + } + lenRowid = sqlite3SmallTypeSizes[typeRowid]; + testcase( (u32)m.n==szHdr+lenRowid ); + if( unlikely((u32)m.neCurType==CURTYPE_BTREE ); + pCur = pC->uc.pCursor; + assert( sqlite3BtreeCursorIsValid(pCur) ); + nCellKey = sqlite3BtreePayloadSize(pCur); + /* nCellKey will always be between 0 and 0xffffffff because of the way + ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */ + if( nCellKey<=0 || nCellKey>0x7fffffff ){ + *res = 0; + return SQLITE_CORRUPT_BKPT; + } + sqlite3VdbeMemInit(&m, db, 0); + rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m); + if( rc ){ + return rc; + } + *res = sqlite3VdbeRecordCompareWithSkip(m.n, m.z, pUnpacked, 0); + sqlite3VdbeMemRelease(&m); + return SQLITE_OK; +} + +/* +** This routine sets the value to be returned by subsequent calls to +** sqlite3_changes() on the database handle 'db'. +*/ +SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *db, int nChange){ + assert( sqlite3_mutex_held(db->mutex) ); + db->nChange = nChange; + db->nTotalChange += nChange; +} + +/* +** Set a flag in the vdbe to update the change counter when it is finalised +** or reset. +*/ +SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe *v){ + v->changeCntOn = 1; +} + +/* +** Mark every prepared statement associated with a database connection +** as expired. +** +** An expired statement means that recompilation of the statement is +** recommend. Statements expire when things happen that make their +** programs obsolete. Removing user-defined functions or collating +** sequences, or changing an authorization function are the types of +** things that make prepared statements obsolete. +** +** If iCode is 1, then expiration is advisory. The statement should +** be reprepared before being restarted, but if it is already running +** it is allowed to run to completion. +** +** Internally, this function just sets the Vdbe.expired flag on all +** prepared statements. The flag is set to 1 for an immediate expiration +** and set to 2 for an advisory expiration. +*/ +SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3 *db, int iCode){ + Vdbe *p; + for(p = db->pVdbe; p; p=p->pNext){ + p->expired = iCode+1; + } +} + +/* +** Return the database associated with the Vdbe. +*/ +SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe *v){ + return v->db; +} + +/* +** Return the SQLITE_PREPARE flags for a Vdbe. +*/ +SQLITE_PRIVATE u8 sqlite3VdbePrepareFlags(Vdbe *v){ + return v->prepFlags; +} + +/* +** Return a pointer to an sqlite3_value structure containing the value bound +** parameter iVar of VM v. Except, if the value is an SQL NULL, return +** 0 instead. Unless it is NULL, apply affinity aff (one of the SQLITE_AFF_* +** constants) to the value before returning it. +** +** The returned value must be freed by the caller using sqlite3ValueFree(). +*/ +SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe *v, int iVar, u8 aff){ + assert( iVar>0 ); + if( v ){ + Mem *pMem = &v->aVar[iVar-1]; + assert( (v->db->flags & SQLITE_EnableQPSG)==0 ); + if( 0==(pMem->flags & MEM_Null) ){ + sqlite3_value *pRet = sqlite3ValueNew(v->db); + if( pRet ){ + sqlite3VdbeMemCopy((Mem *)pRet, pMem); + sqlite3ValueApplyAffinity(pRet, aff, SQLITE_UTF8); + } + return pRet; + } + } + return 0; +} + +/* +** Configure SQL variable iVar so that binding a new value to it signals +** to sqlite3_reoptimize() that re-preparing the statement may result +** in a better query plan. +*/ +SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){ + assert( iVar>0 ); + assert( (v->db->flags & SQLITE_EnableQPSG)==0 ); + if( iVar>=32 ){ + v->expmask |= 0x80000000; + }else{ + v->expmask |= ((u32)1 << (iVar-1)); + } +} + +/* +** Cause a function to throw an error if it was call from OP_PureFunc +** rather than OP_Function. +** +** OP_PureFunc means that the function must be deterministic, and should +** throw an error if it is given inputs that would make it non-deterministic. +** This routine is invoked by date/time functions that use non-deterministic +** features such as 'now'. +*/ +SQLITE_PRIVATE int sqlite3NotPureFunc(sqlite3_context *pCtx){ + const VdbeOp *pOp; +#ifdef SQLITE_ENABLE_STAT4 + if( pCtx->pVdbe==0 ) return 1; +#endif + pOp = pCtx->pVdbe->aOp + pCtx->iOp; + if( pOp->opcode==OP_PureFunc ){ + const char *zContext; + char *zMsg; + if( pOp->p5 & NC_IsCheck ){ + zContext = "a CHECK constraint"; + }else if( pOp->p5 & NC_GenCol ){ + zContext = "a generated column"; + }else{ + zContext = "an index"; + } + zMsg = sqlite3_mprintf("non-deterministic use of %s() in %s", + pCtx->pFunc->zName, zContext); + sqlite3_result_error(pCtx, zMsg, -1); + sqlite3_free(zMsg); + return 0; + } + return 1; +} + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Transfer error message text from an sqlite3_vtab.zErrMsg (text stored +** in memory obtained from sqlite3_malloc) into a Vdbe.zErrMsg (text stored +** in memory obtained from sqlite3DbMalloc). +*/ +SQLITE_PRIVATE void sqlite3VtabImportErrmsg(Vdbe *p, sqlite3_vtab *pVtab){ + if( pVtab->zErrMsg ){ + sqlite3 *db = p->db; + sqlite3DbFree(db, p->zErrMsg); + p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg); + sqlite3_free(pVtab->zErrMsg); + pVtab->zErrMsg = 0; + } +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + +/* +** If the second argument is not NULL, release any allocations associated +** with the memory cells in the p->aMem[] array. Also free the UnpackedRecord +** structure itself, using sqlite3DbFree(). +** +** This function is used to free UnpackedRecord structures allocated by +** the vdbeUnpackRecord() function found in vdbeapi.c. +*/ +static void vdbeFreeUnpacked(sqlite3 *db, int nField, UnpackedRecord *p){ + if( p ){ + int i; + for(i=0; iaMem[i]; + if( pMem->zMalloc ) sqlite3VdbeMemRelease(pMem); + } + sqlite3DbFreeNN(db, p); + } +} +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +/* +** Invoke the pre-update hook. If this is an UPDATE or DELETE pre-update call, +** then cursor passed as the second argument should point to the row about +** to be update or deleted. If the application calls sqlite3_preupdate_old(), +** the required value will be read from the row the cursor points to. +*/ +SQLITE_PRIVATE void sqlite3VdbePreUpdateHook( + Vdbe *v, /* Vdbe pre-update hook is invoked by */ + VdbeCursor *pCsr, /* Cursor to grab old.* values from */ + int op, /* SQLITE_INSERT, UPDATE or DELETE */ + const char *zDb, /* Database name */ + Table *pTab, /* Modified table */ + i64 iKey1, /* Initial key value */ + int iReg /* Register for new.* record */ +){ + sqlite3 *db = v->db; + i64 iKey2; + PreUpdate preupdate; + const char *zTbl = pTab->zName; + static const u8 fakeSortOrder = 0; + + assert( db->pPreUpdate==0 ); + memset(&preupdate, 0, sizeof(PreUpdate)); + if( HasRowid(pTab)==0 ){ + iKey1 = iKey2 = 0; + preupdate.pPk = sqlite3PrimaryKeyIndex(pTab); + }else{ + if( op==SQLITE_UPDATE ){ + iKey2 = v->aMem[iReg].u.i; + }else{ + iKey2 = iKey1; + } + } + + assert( pCsr->nField==pTab->nCol + || (pCsr->nField==pTab->nCol+1 && op==SQLITE_DELETE && iReg==-1) + ); + + preupdate.v = v; + preupdate.pCsr = pCsr; + preupdate.op = op; + preupdate.iNewReg = iReg; + preupdate.keyinfo.db = db; + preupdate.keyinfo.enc = ENC(db); + preupdate.keyinfo.nKeyField = pTab->nCol; + preupdate.keyinfo.aSortFlags = (u8*)&fakeSortOrder; + preupdate.iKey1 = iKey1; + preupdate.iKey2 = iKey2; + preupdate.pTab = pTab; + + db->pPreUpdate = &preupdate; + db->xPreUpdateCallback(db->pPreUpdateArg, db, op, zDb, zTbl, iKey1, iKey2); + db->pPreUpdate = 0; + sqlite3DbFree(db, preupdate.aRecord); + vdbeFreeUnpacked(db, preupdate.keyinfo.nKeyField+1, preupdate.pUnpacked); + vdbeFreeUnpacked(db, preupdate.keyinfo.nKeyField+1, preupdate.pNewUnpacked); + if( preupdate.aNew ){ + int i; + for(i=0; inField; i++){ + sqlite3VdbeMemRelease(&preupdate.aNew[i]); + } + sqlite3DbFreeNN(db, preupdate.aNew); + } +} +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + +/************** End of vdbeaux.c *********************************************/ +/************** Begin file vdbeapi.c *****************************************/ +/* +** 2004 May 26 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code use to implement APIs that are part of the +** VDBE. +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Return TRUE (non-zero) of the statement supplied as an argument needs +** to be recompiled. A statement needs to be recompiled whenever the +** execution environment changes in a way that would alter the program +** that sqlite3_prepare() generates. For example, if new functions or +** collating sequences are registered or if an authorizer function is +** added or changed. +*/ +SQLITE_API int sqlite3_expired(sqlite3_stmt *pStmt){ + Vdbe *p = (Vdbe*)pStmt; + return p==0 || p->expired; +} +#endif + +/* +** Check on a Vdbe to make sure it has not been finalized. Log +** an error and return true if it has been finalized (or is otherwise +** invalid). Return false if it is ok. +*/ +static int vdbeSafety(Vdbe *p){ + if( p->db==0 ){ + sqlite3_log(SQLITE_MISUSE, "API called with finalized prepared statement"); + return 1; + }else{ + return 0; + } +} +static int vdbeSafetyNotNull(Vdbe *p){ + if( p==0 ){ + sqlite3_log(SQLITE_MISUSE, "API called with NULL prepared statement"); + return 1; + }else{ + return vdbeSafety(p); + } +} + +#ifndef SQLITE_OMIT_TRACE +/* +** Invoke the profile callback. This routine is only called if we already +** know that the profile callback is defined and needs to be invoked. +*/ +static SQLITE_NOINLINE void invokeProfileCallback(sqlite3 *db, Vdbe *p){ + sqlite3_int64 iNow; + sqlite3_int64 iElapse; + assert( p->startTime>0 ); + assert( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 ); + assert( db->init.busy==0 ); + assert( p->zSql!=0 ); + sqlite3OsCurrentTimeInt64(db->pVfs, &iNow); + iElapse = (iNow - p->startTime)*1000000; +#ifndef SQLITE_OMIT_DEPRECATED + if( db->xProfile ){ + db->xProfile(db->pProfileArg, p->zSql, iElapse); + } +#endif + if( db->mTrace & SQLITE_TRACE_PROFILE ){ + db->trace.xV2(SQLITE_TRACE_PROFILE, db->pTraceArg, p, (void*)&iElapse); + } + p->startTime = 0; +} +/* +** The checkProfileCallback(DB,P) macro checks to see if a profile callback +** is needed, and it invokes the callback if it is needed. +*/ +# define checkProfileCallback(DB,P) \ + if( ((P)->startTime)>0 ){ invokeProfileCallback(DB,P); } +#else +# define checkProfileCallback(DB,P) /*no-op*/ +#endif + +/* +** The following routine destroys a virtual machine that is created by +** the sqlite3_compile() routine. The integer returned is an SQLITE_ +** success/failure code that describes the result of executing the virtual +** machine. +** +** This routine sets the error code and string returned by +** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16(). +*/ +SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt){ + int rc; + if( pStmt==0 ){ + /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL + ** pointer is a harmless no-op. */ + rc = SQLITE_OK; + }else{ + Vdbe *v = (Vdbe*)pStmt; + sqlite3 *db = v->db; + if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT; + sqlite3_mutex_enter(db->mutex); + checkProfileCallback(db, v); + rc = sqlite3VdbeFinalize(v); + rc = sqlite3ApiExit(db, rc); + sqlite3LeaveMutexAndCloseZombie(db); + } + return rc; +} + +/* +** Terminate the current execution of an SQL statement and reset it +** back to its starting state so that it can be reused. A success code from +** the prior execution is returned. +** +** This routine sets the error code and string returned by +** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16(). +*/ +SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt){ + int rc; + if( pStmt==0 ){ + rc = SQLITE_OK; + }else{ + Vdbe *v = (Vdbe*)pStmt; + sqlite3 *db = v->db; + sqlite3_mutex_enter(db->mutex); + checkProfileCallback(db, v); + rc = sqlite3VdbeReset(v); + sqlite3VdbeRewind(v); + assert( (rc & (db->errMask))==rc ); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + } + return rc; +} + +/* +** Set all the parameters in the compiled SQL statement to NULL. +*/ +SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt *pStmt){ + int i; + int rc = SQLITE_OK; + Vdbe *p = (Vdbe*)pStmt; +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex; +#endif + sqlite3_mutex_enter(mutex); + for(i=0; inVar; i++){ + sqlite3VdbeMemRelease(&p->aVar[i]); + p->aVar[i].flags = MEM_Null; + } + assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 ); + if( p->expmask ){ + p->expired = 1; + } + sqlite3_mutex_leave(mutex); + return rc; +} + + +/**************************** sqlite3_value_ ******************************* +** The following routines extract information from a Mem or sqlite3_value +** structure. +*/ +SQLITE_API const void *sqlite3_value_blob(sqlite3_value *pVal){ + Mem *p = (Mem*)pVal; + if( p->flags & (MEM_Blob|MEM_Str) ){ + if( ExpandBlob(p)!=SQLITE_OK ){ + assert( p->flags==MEM_Null && p->z==0 ); + return 0; + } + p->flags |= MEM_Blob; + return p->n ? p->z : 0; + }else{ + return sqlite3_value_text(pVal); + } +} +SQLITE_API int sqlite3_value_bytes(sqlite3_value *pVal){ + return sqlite3ValueBytes(pVal, SQLITE_UTF8); +} +SQLITE_API int sqlite3_value_bytes16(sqlite3_value *pVal){ + return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE); +} +SQLITE_API double sqlite3_value_double(sqlite3_value *pVal){ + return sqlite3VdbeRealValue((Mem*)pVal); +} +SQLITE_API int sqlite3_value_int(sqlite3_value *pVal){ + return (int)sqlite3VdbeIntValue((Mem*)pVal); +} +SQLITE_API sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){ + return sqlite3VdbeIntValue((Mem*)pVal); +} +SQLITE_API unsigned int sqlite3_value_subtype(sqlite3_value *pVal){ + Mem *pMem = (Mem*)pVal; + return ((pMem->flags & MEM_Subtype) ? pMem->eSubtype : 0); +} +SQLITE_API void *sqlite3_value_pointer(sqlite3_value *pVal, const char *zPType){ + Mem *p = (Mem*)pVal; + if( (p->flags&(MEM_TypeMask|MEM_Term|MEM_Subtype)) == + (MEM_Null|MEM_Term|MEM_Subtype) + && zPType!=0 + && p->eSubtype=='p' + && strcmp(p->u.zPType, zPType)==0 + ){ + return (void*)p->z; + }else{ + return 0; + } +} +SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value *pVal){ + return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *sqlite3_value_text16(sqlite3_value* pVal){ + return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE); +} +SQLITE_API const void *sqlite3_value_text16be(sqlite3_value *pVal){ + return sqlite3ValueText(pVal, SQLITE_UTF16BE); +} +SQLITE_API const void *sqlite3_value_text16le(sqlite3_value *pVal){ + return sqlite3ValueText(pVal, SQLITE_UTF16LE); +} +#endif /* SQLITE_OMIT_UTF16 */ +/* EVIDENCE-OF: R-12793-43283 Every value in SQLite has one of five +** fundamental datatypes: 64-bit signed integer 64-bit IEEE floating +** point number string BLOB NULL +*/ +SQLITE_API int sqlite3_value_type(sqlite3_value* pVal){ + static const u8 aType[] = { + SQLITE_BLOB, /* 0x00 (not possible) */ + SQLITE_NULL, /* 0x01 NULL */ + SQLITE_TEXT, /* 0x02 TEXT */ + SQLITE_NULL, /* 0x03 (not possible) */ + SQLITE_INTEGER, /* 0x04 INTEGER */ + SQLITE_NULL, /* 0x05 (not possible) */ + SQLITE_INTEGER, /* 0x06 INTEGER + TEXT */ + SQLITE_NULL, /* 0x07 (not possible) */ + SQLITE_FLOAT, /* 0x08 FLOAT */ + SQLITE_NULL, /* 0x09 (not possible) */ + SQLITE_FLOAT, /* 0x0a FLOAT + TEXT */ + SQLITE_NULL, /* 0x0b (not possible) */ + SQLITE_INTEGER, /* 0x0c (not possible) */ + SQLITE_NULL, /* 0x0d (not possible) */ + SQLITE_INTEGER, /* 0x0e (not possible) */ + SQLITE_NULL, /* 0x0f (not possible) */ + SQLITE_BLOB, /* 0x10 BLOB */ + SQLITE_NULL, /* 0x11 (not possible) */ + SQLITE_TEXT, /* 0x12 (not possible) */ + SQLITE_NULL, /* 0x13 (not possible) */ + SQLITE_INTEGER, /* 0x14 INTEGER + BLOB */ + SQLITE_NULL, /* 0x15 (not possible) */ + SQLITE_INTEGER, /* 0x16 (not possible) */ + SQLITE_NULL, /* 0x17 (not possible) */ + SQLITE_FLOAT, /* 0x18 FLOAT + BLOB */ + SQLITE_NULL, /* 0x19 (not possible) */ + SQLITE_FLOAT, /* 0x1a (not possible) */ + SQLITE_NULL, /* 0x1b (not possible) */ + SQLITE_INTEGER, /* 0x1c (not possible) */ + SQLITE_NULL, /* 0x1d (not possible) */ + SQLITE_INTEGER, /* 0x1e (not possible) */ + SQLITE_NULL, /* 0x1f (not possible) */ + SQLITE_FLOAT, /* 0x20 INTREAL */ + SQLITE_NULL, /* 0x21 (not possible) */ + SQLITE_TEXT, /* 0x22 INTREAL + TEXT */ + SQLITE_NULL, /* 0x23 (not possible) */ + SQLITE_FLOAT, /* 0x24 (not possible) */ + SQLITE_NULL, /* 0x25 (not possible) */ + SQLITE_FLOAT, /* 0x26 (not possible) */ + SQLITE_NULL, /* 0x27 (not possible) */ + SQLITE_FLOAT, /* 0x28 (not possible) */ + SQLITE_NULL, /* 0x29 (not possible) */ + SQLITE_FLOAT, /* 0x2a (not possible) */ + SQLITE_NULL, /* 0x2b (not possible) */ + SQLITE_FLOAT, /* 0x2c (not possible) */ + SQLITE_NULL, /* 0x2d (not possible) */ + SQLITE_FLOAT, /* 0x2e (not possible) */ + SQLITE_NULL, /* 0x2f (not possible) */ + SQLITE_BLOB, /* 0x30 (not possible) */ + SQLITE_NULL, /* 0x31 (not possible) */ + SQLITE_TEXT, /* 0x32 (not possible) */ + SQLITE_NULL, /* 0x33 (not possible) */ + SQLITE_FLOAT, /* 0x34 (not possible) */ + SQLITE_NULL, /* 0x35 (not possible) */ + SQLITE_FLOAT, /* 0x36 (not possible) */ + SQLITE_NULL, /* 0x37 (not possible) */ + SQLITE_FLOAT, /* 0x38 (not possible) */ + SQLITE_NULL, /* 0x39 (not possible) */ + SQLITE_FLOAT, /* 0x3a (not possible) */ + SQLITE_NULL, /* 0x3b (not possible) */ + SQLITE_FLOAT, /* 0x3c (not possible) */ + SQLITE_NULL, /* 0x3d (not possible) */ + SQLITE_FLOAT, /* 0x3e (not possible) */ + SQLITE_NULL, /* 0x3f (not possible) */ + }; +#ifdef SQLITE_DEBUG + { + int eType = SQLITE_BLOB; + if( pVal->flags & MEM_Null ){ + eType = SQLITE_NULL; + }else if( pVal->flags & (MEM_Real|MEM_IntReal) ){ + eType = SQLITE_FLOAT; + }else if( pVal->flags & MEM_Int ){ + eType = SQLITE_INTEGER; + }else if( pVal->flags & MEM_Str ){ + eType = SQLITE_TEXT; + } + assert( eType == aType[pVal->flags&MEM_AffMask] ); + } +#endif + return aType[pVal->flags&MEM_AffMask]; +} + +/* Return true if a parameter to xUpdate represents an unchanged column */ +SQLITE_API int sqlite3_value_nochange(sqlite3_value *pVal){ + return (pVal->flags&(MEM_Null|MEM_Zero))==(MEM_Null|MEM_Zero); +} + +/* Return true if a parameter value originated from an sqlite3_bind() */ +SQLITE_API int sqlite3_value_frombind(sqlite3_value *pVal){ + return (pVal->flags&MEM_FromBind)!=0; +} + +/* Make a copy of an sqlite3_value object +*/ +SQLITE_API sqlite3_value *sqlite3_value_dup(const sqlite3_value *pOrig){ + sqlite3_value *pNew; + if( pOrig==0 ) return 0; + pNew = sqlite3_malloc( sizeof(*pNew) ); + if( pNew==0 ) return 0; + memset(pNew, 0, sizeof(*pNew)); + memcpy(pNew, pOrig, MEMCELLSIZE); + pNew->flags &= ~MEM_Dyn; + pNew->db = 0; + if( pNew->flags&(MEM_Str|MEM_Blob) ){ + pNew->flags &= ~(MEM_Static|MEM_Dyn); + pNew->flags |= MEM_Ephem; + if( sqlite3VdbeMemMakeWriteable(pNew)!=SQLITE_OK ){ + sqlite3ValueFree(pNew); + pNew = 0; + } + } + return pNew; +} + +/* Destroy an sqlite3_value object previously obtained from +** sqlite3_value_dup(). +*/ +SQLITE_API void sqlite3_value_free(sqlite3_value *pOld){ + sqlite3ValueFree(pOld); +} + + +/**************************** sqlite3_result_ ******************************* +** The following routines are used by user-defined functions to specify +** the function result. +** +** The setStrOrError() function calls sqlite3VdbeMemSetStr() to store the +** result as a string or blob but if the string or blob is too large, it +** then sets the error code to SQLITE_TOOBIG +** +** The invokeValueDestructor(P,X) routine invokes destructor function X() +** on value P is not going to be used and need to be destroyed. +*/ +static void setResultStrOrError( + sqlite3_context *pCtx, /* Function context */ + const char *z, /* String pointer */ + int n, /* Bytes in string, or negative */ + u8 enc, /* Encoding of z. 0 for BLOBs */ + void (*xDel)(void*) /* Destructor function */ +){ + if( sqlite3VdbeMemSetStr(pCtx->pOut, z, n, enc, xDel)==SQLITE_TOOBIG ){ + sqlite3_result_error_toobig(pCtx); + } +} +static int invokeValueDestructor( + const void *p, /* Value to destroy */ + void (*xDel)(void*), /* The destructor */ + sqlite3_context *pCtx /* Set a SQLITE_TOOBIG error if no NULL */ +){ + assert( xDel!=SQLITE_DYNAMIC ); + if( xDel==0 ){ + /* noop */ + }else if( xDel==SQLITE_TRANSIENT ){ + /* noop */ + }else{ + xDel((void*)p); + } + if( pCtx ) sqlite3_result_error_toobig(pCtx); + return SQLITE_TOOBIG; +} +SQLITE_API void sqlite3_result_blob( + sqlite3_context *pCtx, + const void *z, + int n, + void (*xDel)(void *) +){ + assert( n>=0 ); + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + setResultStrOrError(pCtx, z, n, 0, xDel); +} +SQLITE_API void sqlite3_result_blob64( + sqlite3_context *pCtx, + const void *z, + sqlite3_uint64 n, + void (*xDel)(void *) +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + assert( xDel!=SQLITE_DYNAMIC ); + if( n>0x7fffffff ){ + (void)invokeValueDestructor(z, xDel, pCtx); + }else{ + setResultStrOrError(pCtx, z, (int)n, 0, xDel); + } +} +SQLITE_API void sqlite3_result_double(sqlite3_context *pCtx, double rVal){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetDouble(pCtx->pOut, rVal); +} +SQLITE_API void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + pCtx->isError = SQLITE_ERROR; + sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + pCtx->isError = SQLITE_ERROR; + sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT); +} +#endif +SQLITE_API void sqlite3_result_int(sqlite3_context *pCtx, int iVal){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal); +} +SQLITE_API void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetInt64(pCtx->pOut, iVal); +} +SQLITE_API void sqlite3_result_null(sqlite3_context *pCtx){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetNull(pCtx->pOut); +} +SQLITE_API void sqlite3_result_pointer( + sqlite3_context *pCtx, + void *pPtr, + const char *zPType, + void (*xDestructor)(void*) +){ + Mem *pOut = pCtx->pOut; + assert( sqlite3_mutex_held(pOut->db->mutex) ); + sqlite3VdbeMemRelease(pOut); + pOut->flags = MEM_Null; + sqlite3VdbeMemSetPointer(pOut, pPtr, zPType, xDestructor); +} +SQLITE_API void sqlite3_result_subtype(sqlite3_context *pCtx, unsigned int eSubtype){ + Mem *pOut = pCtx->pOut; + assert( sqlite3_mutex_held(pOut->db->mutex) ); + pOut->eSubtype = eSubtype & 0xff; + pOut->flags |= MEM_Subtype; +} +SQLITE_API void sqlite3_result_text( + sqlite3_context *pCtx, + const char *z, + int n, + void (*xDel)(void *) +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel); +} +SQLITE_API void sqlite3_result_text64( + sqlite3_context *pCtx, + const char *z, + sqlite3_uint64 n, + void (*xDel)(void *), + unsigned char enc +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + assert( xDel!=SQLITE_DYNAMIC ); + if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE; + if( n>0x7fffffff ){ + (void)invokeValueDestructor(z, xDel, pCtx); + }else{ + setResultStrOrError(pCtx, z, (int)n, enc, xDel); + } +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API void sqlite3_result_text16( + sqlite3_context *pCtx, + const void *z, + int n, + void (*xDel)(void *) +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel); +} +SQLITE_API void sqlite3_result_text16be( + sqlite3_context *pCtx, + const void *z, + int n, + void (*xDel)(void *) +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel); +} +SQLITE_API void sqlite3_result_text16le( + sqlite3_context *pCtx, + const void *z, + int n, + void (*xDel)(void *) +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel); +} +#endif /* SQLITE_OMIT_UTF16 */ +SQLITE_API void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemCopy(pCtx->pOut, pValue); +} +SQLITE_API void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetZeroBlob(pCtx->pOut, n); +} +SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){ + Mem *pOut = pCtx->pOut; + assert( sqlite3_mutex_held(pOut->db->mutex) ); + if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){ + return SQLITE_TOOBIG; + } + sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n); + return SQLITE_OK; +} +SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){ + pCtx->isError = errCode ? errCode : -1; +#ifdef SQLITE_DEBUG + if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode; +#endif + if( pCtx->pOut->flags & MEM_Null ){ + sqlite3VdbeMemSetStr(pCtx->pOut, sqlite3ErrStr(errCode), -1, + SQLITE_UTF8, SQLITE_STATIC); + } +} + +/* Force an SQLITE_TOOBIG error. */ +SQLITE_API void sqlite3_result_error_toobig(sqlite3_context *pCtx){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + pCtx->isError = SQLITE_TOOBIG; + sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1, + SQLITE_UTF8, SQLITE_STATIC); +} + +/* An SQLITE_NOMEM error. */ +SQLITE_API void sqlite3_result_error_nomem(sqlite3_context *pCtx){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetNull(pCtx->pOut); + pCtx->isError = SQLITE_NOMEM_BKPT; + sqlite3OomFault(pCtx->pOut->db); +} + +#ifndef SQLITE_UNTESTABLE +/* Force the INT64 value currently stored as the result to be +** a MEM_IntReal value. See the SQLITE_TESTCTRL_RESULT_INTREAL +** test-control. +*/ +SQLITE_PRIVATE void sqlite3ResultIntReal(sqlite3_context *pCtx){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + if( pCtx->pOut->flags & MEM_Int ){ + pCtx->pOut->flags &= ~MEM_Int; + pCtx->pOut->flags |= MEM_IntReal; + } +} +#endif + + +/* +** This function is called after a transaction has been committed. It +** invokes callbacks registered with sqlite3_wal_hook() as required. +*/ +static int doWalCallbacks(sqlite3 *db){ + int rc = SQLITE_OK; +#ifndef SQLITE_OMIT_WAL + int i; + for(i=0; inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + int nEntry; + sqlite3BtreeEnter(pBt); + nEntry = sqlite3PagerWalCallback(sqlite3BtreePager(pBt)); + sqlite3BtreeLeave(pBt); + if( nEntry>0 && db->xWalCallback && rc==SQLITE_OK ){ + rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zDbSName, nEntry); + } + } + } +#endif + return rc; +} + + +/* +** Execute the statement pStmt, either until a row of data is ready, the +** statement is completely executed or an error occurs. +** +** This routine implements the bulk of the logic behind the sqlite_step() +** API. The only thing omitted is the automatic recompile if a +** schema change has occurred. That detail is handled by the +** outer sqlite3_step() wrapper procedure. +*/ +static int sqlite3Step(Vdbe *p){ + sqlite3 *db; + int rc; + + assert(p); + if( p->magic!=VDBE_MAGIC_RUN ){ + /* We used to require that sqlite3_reset() be called before retrying + ** sqlite3_step() after any error or after SQLITE_DONE. But beginning + ** with version 3.7.0, we changed this so that sqlite3_reset() would + ** be called automatically instead of throwing the SQLITE_MISUSE error. + ** This "automatic-reset" change is not technically an incompatibility, + ** since any application that receives an SQLITE_MISUSE is broken by + ** definition. + ** + ** Nevertheless, some published applications that were originally written + ** for version 3.6.23 or earlier do in fact depend on SQLITE_MISUSE + ** returns, and those were broken by the automatic-reset change. As a + ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the + ** legacy behavior of returning SQLITE_MISUSE for cases where the + ** previous sqlite3_step() returned something other than a SQLITE_LOCKED + ** or SQLITE_BUSY error. + */ +#ifdef SQLITE_OMIT_AUTORESET + if( (rc = p->rc&0xff)==SQLITE_BUSY || rc==SQLITE_LOCKED ){ + sqlite3_reset((sqlite3_stmt*)p); + }else{ + return SQLITE_MISUSE_BKPT; + } +#else + sqlite3_reset((sqlite3_stmt*)p); +#endif + } + + /* Check that malloc() has not failed. If it has, return early. */ + db = p->db; + if( db->mallocFailed ){ + p->rc = SQLITE_NOMEM; + return SQLITE_NOMEM_BKPT; + } + + if( p->pc<0 && p->expired ){ + p->rc = SQLITE_SCHEMA; + rc = SQLITE_ERROR; + if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){ + /* If this statement was prepared using saved SQL and an + ** error has occurred, then return the error code in p->rc to the + ** caller. Set the error code in the database handle to the same value. + */ + rc = sqlite3VdbeTransferError(p); + } + goto end_of_step; + } + if( p->pc<0 ){ + /* If there are no other statements currently running, then + ** reset the interrupt flag. This prevents a call to sqlite3_interrupt + ** from interrupting a statement that has not yet started. + */ + if( db->nVdbeActive==0 ){ + AtomicStore(&db->u1.isInterrupted, 0); + } + + assert( db->nVdbeWrite>0 || db->autoCommit==0 + || (db->nDeferredCons==0 && db->nDeferredImmCons==0) + ); + +#ifndef SQLITE_OMIT_TRACE + if( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 + && !db->init.busy && p->zSql ){ + sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime); + }else{ + assert( p->startTime==0 ); + } +#endif + + db->nVdbeActive++; + if( p->readOnly==0 ) db->nVdbeWrite++; + if( p->bIsReader ) db->nVdbeRead++; + p->pc = 0; + } +#ifdef SQLITE_DEBUG + p->rcApp = SQLITE_OK; +#endif +#ifndef SQLITE_OMIT_EXPLAIN + if( p->explain ){ + rc = sqlite3VdbeList(p); + }else +#endif /* SQLITE_OMIT_EXPLAIN */ + { + db->nVdbeExec++; + rc = sqlite3VdbeExec(p); + db->nVdbeExec--; + } + + if( rc!=SQLITE_ROW ){ +#ifndef SQLITE_OMIT_TRACE + /* If the statement completed successfully, invoke the profile callback */ + checkProfileCallback(db, p); +#endif + + if( rc==SQLITE_DONE && db->autoCommit ){ + assert( p->rc==SQLITE_OK ); + p->rc = doWalCallbacks(db); + if( p->rc!=SQLITE_OK ){ + rc = SQLITE_ERROR; + } + }else if( rc!=SQLITE_DONE && (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){ + /* If this statement was prepared using saved SQL and an + ** error has occurred, then return the error code in p->rc to the + ** caller. Set the error code in the database handle to the same value. + */ + rc = sqlite3VdbeTransferError(p); + } + } + + db->errCode = rc; + if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){ + p->rc = SQLITE_NOMEM_BKPT; + if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ) rc = p->rc; + } +end_of_step: + /* There are only a limited number of result codes allowed from the + ** statements prepared using the legacy sqlite3_prepare() interface */ + assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 + || rc==SQLITE_ROW || rc==SQLITE_DONE || rc==SQLITE_ERROR + || (rc&0xff)==SQLITE_BUSY || rc==SQLITE_MISUSE + ); + return (rc&db->errMask); +} + +/* +** This is the top-level implementation of sqlite3_step(). Call +** sqlite3Step() to do most of the work. If a schema error occurs, +** call sqlite3Reprepare() and try again. +*/ +SQLITE_API int sqlite3_step(sqlite3_stmt *pStmt){ + int rc = SQLITE_OK; /* Result from sqlite3Step() */ + Vdbe *v = (Vdbe*)pStmt; /* the prepared statement */ + int cnt = 0; /* Counter to prevent infinite loop of reprepares */ + sqlite3 *db; /* The database connection */ + + if( vdbeSafetyNotNull(v) ){ + return SQLITE_MISUSE_BKPT; + } + db = v->db; + sqlite3_mutex_enter(db->mutex); + v->doingRerun = 0; + while( (rc = sqlite3Step(v))==SQLITE_SCHEMA + && cnt++ < SQLITE_MAX_SCHEMA_RETRY ){ + int savedPc = v->pc; + rc = sqlite3Reprepare(v); + if( rc!=SQLITE_OK ){ + /* This case occurs after failing to recompile an sql statement. + ** The error message from the SQL compiler has already been loaded + ** into the database handle. This block copies the error message + ** from the database handle into the statement and sets the statement + ** program counter to 0 to ensure that when the statement is + ** finalized or reset the parser error message is available via + ** sqlite3_errmsg() and sqlite3_errcode(). + */ + const char *zErr = (const char *)sqlite3_value_text(db->pErr); + sqlite3DbFree(db, v->zErrMsg); + if( !db->mallocFailed ){ + v->zErrMsg = sqlite3DbStrDup(db, zErr); + v->rc = rc = sqlite3ApiExit(db, rc); + } else { + v->zErrMsg = 0; + v->rc = rc = SQLITE_NOMEM_BKPT; + } + break; + } + sqlite3_reset(pStmt); + if( savedPc>=0 ) v->doingRerun = 1; + assert( v->expired==0 ); + } + sqlite3_mutex_leave(db->mutex); + return rc; +} + + +/* +** Extract the user data from a sqlite3_context structure and return a +** pointer to it. +*/ +SQLITE_API void *sqlite3_user_data(sqlite3_context *p){ + assert( p && p->pFunc ); + return p->pFunc->pUserData; +} + +/* +** Extract the user data from a sqlite3_context structure and return a +** pointer to it. +** +** IMPLEMENTATION-OF: R-46798-50301 The sqlite3_context_db_handle() interface +** returns a copy of the pointer to the database connection (the 1st +** parameter) of the sqlite3_create_function() and +** sqlite3_create_function16() routines that originally registered the +** application defined function. +*/ +SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){ + assert( p && p->pOut ); + return p->pOut->db; +} + +/* +** If this routine is invoked from within an xColumn method of a virtual +** table, then it returns true if and only if the the call is during an +** UPDATE operation and the value of the column will not be modified +** by the UPDATE. +** +** If this routine is called from any context other than within the +** xColumn method of a virtual table, then the return value is meaningless +** and arbitrary. +** +** Virtual table implements might use this routine to optimize their +** performance by substituting a NULL result, or some other light-weight +** value, as a signal to the xUpdate routine that the column is unchanged. +*/ +SQLITE_API int sqlite3_vtab_nochange(sqlite3_context *p){ + assert( p ); + return sqlite3_value_nochange(p->pOut); +} + +/* +** Return the current time for a statement. If the current time +** is requested more than once within the same run of a single prepared +** statement, the exact same time is returned for each invocation regardless +** of the amount of time that elapses between invocations. In other words, +** the time returned is always the time of the first call. +*/ +SQLITE_PRIVATE sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context *p){ + int rc; +#ifndef SQLITE_ENABLE_STAT4 + sqlite3_int64 *piTime = &p->pVdbe->iCurrentTime; + assert( p->pVdbe!=0 ); +#else + sqlite3_int64 iTime = 0; + sqlite3_int64 *piTime = p->pVdbe!=0 ? &p->pVdbe->iCurrentTime : &iTime; +#endif + if( *piTime==0 ){ + rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime); + if( rc ) *piTime = 0; + } + return *piTime; +} + +/* +** Create a new aggregate context for p and return a pointer to +** its pMem->z element. +*/ +static SQLITE_NOINLINE void *createAggContext(sqlite3_context *p, int nByte){ + Mem *pMem = p->pMem; + assert( (pMem->flags & MEM_Agg)==0 ); + if( nByte<=0 ){ + sqlite3VdbeMemSetNull(pMem); + pMem->z = 0; + }else{ + sqlite3VdbeMemClearAndResize(pMem, nByte); + pMem->flags = MEM_Agg; + pMem->u.pDef = p->pFunc; + if( pMem->z ){ + memset(pMem->z, 0, nByte); + } + } + return (void*)pMem->z; +} + +/* +** Allocate or return the aggregate context for a user function. A new +** context is allocated on the first call. Subsequent calls return the +** same context that was returned on prior calls. +*/ +SQLITE_API void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){ + assert( p && p->pFunc && p->pFunc->xFinalize ); + assert( sqlite3_mutex_held(p->pOut->db->mutex) ); + testcase( nByte<0 ); + if( (p->pMem->flags & MEM_Agg)==0 ){ + return createAggContext(p, nByte); + }else{ + return (void*)p->pMem->z; + } +} + +/* +** Return the auxiliary data pointer, if any, for the iArg'th argument to +** the user-function defined by pCtx. +** +** The left-most argument is 0. +** +** Undocumented behavior: If iArg is negative then access a cache of +** auxiliary data pointers that is available to all functions within a +** single prepared statement. The iArg values must match. +*/ +SQLITE_API void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){ + AuxData *pAuxData; + + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); +#if SQLITE_ENABLE_STAT4 + if( pCtx->pVdbe==0 ) return 0; +#else + assert( pCtx->pVdbe!=0 ); +#endif + for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){ + if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){ + return pAuxData->pAux; + } + } + return 0; +} + +/* +** Set the auxiliary data pointer and delete function, for the iArg'th +** argument to the user-function defined by pCtx. Any previous value is +** deleted by calling the delete function specified when it was set. +** +** The left-most argument is 0. +** +** Undocumented behavior: If iArg is negative then make the data available +** to all functions within the current prepared statement using iArg as an +** access code. +*/ +SQLITE_API void sqlite3_set_auxdata( + sqlite3_context *pCtx, + int iArg, + void *pAux, + void (*xDelete)(void*) +){ + AuxData *pAuxData; + Vdbe *pVdbe = pCtx->pVdbe; + + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); +#ifdef SQLITE_ENABLE_STAT4 + if( pVdbe==0 ) goto failed; +#else + assert( pVdbe!=0 ); +#endif + + for(pAuxData=pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){ + if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){ + break; + } + } + if( pAuxData==0 ){ + pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData)); + if( !pAuxData ) goto failed; + pAuxData->iAuxOp = pCtx->iOp; + pAuxData->iAuxArg = iArg; + pAuxData->pNextAux = pVdbe->pAuxData; + pVdbe->pAuxData = pAuxData; + if( pCtx->isError==0 ) pCtx->isError = -1; + }else if( pAuxData->xDeleteAux ){ + pAuxData->xDeleteAux(pAuxData->pAux); + } + + pAuxData->pAux = pAux; + pAuxData->xDeleteAux = xDelete; + return; + +failed: + if( xDelete ){ + xDelete(pAux); + } +} + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Return the number of times the Step function of an aggregate has been +** called. +** +** This function is deprecated. Do not use it for new code. It is +** provide only to avoid breaking legacy code. New aggregate function +** implementations should keep their own counts within their aggregate +** context. +*/ +SQLITE_API int sqlite3_aggregate_count(sqlite3_context *p){ + assert( p && p->pMem && p->pFunc && p->pFunc->xFinalize ); + return p->pMem->n; +} +#endif + +/* +** Return the number of columns in the result set for the statement pStmt. +*/ +SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt){ + Vdbe *pVm = (Vdbe *)pStmt; + return pVm ? pVm->nResColumn : 0; +} + +/* +** Return the number of values available from the current row of the +** currently executing statement pStmt. +*/ +SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt){ + Vdbe *pVm = (Vdbe *)pStmt; + if( pVm==0 || pVm->pResultSet==0 ) return 0; + return pVm->nResColumn; +} + +/* +** Return a pointer to static memory containing an SQL NULL value. +*/ +static const Mem *columnNullValue(void){ + /* Even though the Mem structure contains an element + ** of type i64, on certain architectures (x86) with certain compiler + ** switches (-Os), gcc may align this Mem object on a 4-byte boundary + ** instead of an 8-byte one. This all works fine, except that when + ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s + ** that a Mem structure is located on an 8-byte boundary. To prevent + ** these assert()s from failing, when building with SQLITE_DEBUG defined + ** using gcc, we force nullMem to be 8-byte aligned using the magical + ** __attribute__((aligned(8))) macro. */ + static const Mem nullMem +#if defined(SQLITE_DEBUG) && defined(__GNUC__) + __attribute__((aligned(8))) +#endif + = { + /* .u = */ {0}, + /* .flags = */ (u16)MEM_Null, + /* .enc = */ (u8)0, + /* .eSubtype = */ (u8)0, + /* .n = */ (int)0, + /* .z = */ (char*)0, + /* .zMalloc = */ (char*)0, + /* .szMalloc = */ (int)0, + /* .uTemp = */ (u32)0, + /* .db = */ (sqlite3*)0, + /* .xDel = */ (void(*)(void*))0, +#ifdef SQLITE_DEBUG + /* .pScopyFrom = */ (Mem*)0, + /* .mScopyFlags= */ 0, +#endif + }; + return &nullMem; +} + +/* +** Check to see if column iCol of the given statement is valid. If +** it is, return a pointer to the Mem for the value of that column. +** If iCol is not valid, return a pointer to a Mem which has a value +** of NULL. +*/ +static Mem *columnMem(sqlite3_stmt *pStmt, int i){ + Vdbe *pVm; + Mem *pOut; + + pVm = (Vdbe *)pStmt; + if( pVm==0 ) return (Mem*)columnNullValue(); + assert( pVm->db ); + sqlite3_mutex_enter(pVm->db->mutex); + if( pVm->pResultSet!=0 && inResColumn && i>=0 ){ + pOut = &pVm->pResultSet[i]; + }else{ + sqlite3Error(pVm->db, SQLITE_RANGE); + pOut = (Mem*)columnNullValue(); + } + return pOut; +} + +/* +** This function is called after invoking an sqlite3_value_XXX function on a +** column value (i.e. a value returned by evaluating an SQL expression in the +** select list of a SELECT statement) that may cause a malloc() failure. If +** malloc() has failed, the threads mallocFailed flag is cleared and the result +** code of statement pStmt set to SQLITE_NOMEM. +** +** Specifically, this is called from within: +** +** sqlite3_column_int() +** sqlite3_column_int64() +** sqlite3_column_text() +** sqlite3_column_text16() +** sqlite3_column_real() +** sqlite3_column_bytes() +** sqlite3_column_bytes16() +** sqiite3_column_blob() +*/ +static void columnMallocFailure(sqlite3_stmt *pStmt) +{ + /* If malloc() failed during an encoding conversion within an + ** sqlite3_column_XXX API, then set the return code of the statement to + ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR + ** and _finalize() will return NOMEM. + */ + Vdbe *p = (Vdbe *)pStmt; + if( p ){ + assert( p->db!=0 ); + assert( sqlite3_mutex_held(p->db->mutex) ); + p->rc = sqlite3ApiExit(p->db, p->rc); + sqlite3_mutex_leave(p->db->mutex); + } +} + +/**************************** sqlite3_column_ ******************************* +** The following routines are used to access elements of the current row +** in the result set. +*/ +SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){ + const void *val; + val = sqlite3_value_blob( columnMem(pStmt,i) ); + /* Even though there is no encoding conversion, value_blob() might + ** need to call malloc() to expand the result of a zeroblob() + ** expression. + */ + columnMallocFailure(pStmt); + return val; +} +SQLITE_API int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){ + int val = sqlite3_value_bytes( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){ + int val = sqlite3_value_bytes16( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API double sqlite3_column_double(sqlite3_stmt *pStmt, int i){ + double val = sqlite3_value_double( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API int sqlite3_column_int(sqlite3_stmt *pStmt, int i){ + int val = sqlite3_value_int( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){ + sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){ + const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){ + Mem *pOut = columnMem(pStmt, i); + if( pOut->flags&MEM_Static ){ + pOut->flags &= ~MEM_Static; + pOut->flags |= MEM_Ephem; + } + columnMallocFailure(pStmt); + return (sqlite3_value *)pOut; +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){ + const void *val = sqlite3_value_text16( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +#endif /* SQLITE_OMIT_UTF16 */ +SQLITE_API int sqlite3_column_type(sqlite3_stmt *pStmt, int i){ + int iType = sqlite3_value_type( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return iType; +} + +/* +** Convert the N-th element of pStmt->pColName[] into a string using +** xFunc() then return that string. If N is out of range, return 0. +** +** There are up to 5 names for each column. useType determines which +** name is returned. Here are the names: +** +** 0 The column name as it should be displayed for output +** 1 The datatype name for the column +** 2 The name of the database that the column derives from +** 3 The name of the table that the column derives from +** 4 The name of the table column that the result column derives from +** +** If the result is not a simple column reference (if it is an expression +** or a constant) then useTypes 2, 3, and 4 return NULL. +*/ +static const void *columnName( + sqlite3_stmt *pStmt, /* The statement */ + int N, /* Which column to get the name for */ + int useUtf16, /* True to return the name as UTF16 */ + int useType /* What type of name */ +){ + const void *ret; + Vdbe *p; + int n; + sqlite3 *db; +#ifdef SQLITE_ENABLE_API_ARMOR + if( pStmt==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + ret = 0; + p = (Vdbe *)pStmt; + db = p->db; + assert( db!=0 ); + n = sqlite3_column_count(pStmt); + if( N=0 ){ + N += useType*n; + sqlite3_mutex_enter(db->mutex); + assert( db->mallocFailed==0 ); +#ifndef SQLITE_OMIT_UTF16 + if( useUtf16 ){ + ret = sqlite3_value_text16((sqlite3_value*)&p->aColName[N]); + }else +#endif + { + ret = sqlite3_value_text((sqlite3_value*)&p->aColName[N]); + } + /* A malloc may have failed inside of the _text() call. If this + ** is the case, clear the mallocFailed flag and return NULL. + */ + if( db->mallocFailed ){ + sqlite3OomClear(db); + ret = 0; + } + sqlite3_mutex_leave(db->mutex); + } + return ret; +} + +/* +** Return the name of the Nth column of the result set returned by SQL +** statement pStmt. +*/ +SQLITE_API const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 0, COLNAME_NAME); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 1, COLNAME_NAME); +} +#endif + +/* +** Constraint: If you have ENABLE_COLUMN_METADATA then you must +** not define OMIT_DECLTYPE. +*/ +#if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA) +# error "Must not define both SQLITE_OMIT_DECLTYPE \ + and SQLITE_ENABLE_COLUMN_METADATA" +#endif + +#ifndef SQLITE_OMIT_DECLTYPE +/* +** Return the column declaration type (if applicable) of the 'i'th column +** of the result set of SQL statement pStmt. +*/ +SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 0, COLNAME_DECLTYPE); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 1, COLNAME_DECLTYPE); +} +#endif /* SQLITE_OMIT_UTF16 */ +#endif /* SQLITE_OMIT_DECLTYPE */ + +#ifdef SQLITE_ENABLE_COLUMN_METADATA +/* +** Return the name of the database from which a result column derives. +** NULL is returned if the result column is an expression or constant or +** anything else which is not an unambiguous reference to a database column. +*/ +SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 0, COLNAME_DATABASE); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 1, COLNAME_DATABASE); +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Return the name of the table from which a result column derives. +** NULL is returned if the result column is an expression or constant or +** anything else which is not an unambiguous reference to a database column. +*/ +SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 0, COLNAME_TABLE); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 1, COLNAME_TABLE); +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Return the name of the table column from which a result column derives. +** NULL is returned if the result column is an expression or constant or +** anything else which is not an unambiguous reference to a database column. +*/ +SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 0, COLNAME_COLUMN); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 1, COLNAME_COLUMN); +} +#endif /* SQLITE_OMIT_UTF16 */ +#endif /* SQLITE_ENABLE_COLUMN_METADATA */ + + +/******************************* sqlite3_bind_ *************************** +** +** Routines used to attach values to wildcards in a compiled SQL statement. +*/ +/* +** Unbind the value bound to variable i in virtual machine p. This is the +** the same as binding a NULL value to the column. If the "i" parameter is +** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK. +** +** A successful evaluation of this routine acquires the mutex on p. +** the mutex is released if any kind of error occurs. +** +** The error code stored in database p->db is overwritten with the return +** value in any case. +*/ +static int vdbeUnbind(Vdbe *p, int i){ + Mem *pVar; + if( vdbeSafetyNotNull(p) ){ + return SQLITE_MISUSE_BKPT; + } + sqlite3_mutex_enter(p->db->mutex); + if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){ + sqlite3Error(p->db, SQLITE_MISUSE); + sqlite3_mutex_leave(p->db->mutex); + sqlite3_log(SQLITE_MISUSE, + "bind on a busy prepared statement: [%s]", p->zSql); + return SQLITE_MISUSE_BKPT; + } + if( i<1 || i>p->nVar ){ + sqlite3Error(p->db, SQLITE_RANGE); + sqlite3_mutex_leave(p->db->mutex); + return SQLITE_RANGE; + } + i--; + pVar = &p->aVar[i]; + sqlite3VdbeMemRelease(pVar); + pVar->flags = MEM_Null; + p->db->errCode = SQLITE_OK; + + /* If the bit corresponding to this variable in Vdbe.expmask is set, then + ** binding a new value to this variable invalidates the current query plan. + ** + ** IMPLEMENTATION-OF: R-57496-20354 If the specific value bound to a host + ** parameter in the WHERE clause might influence the choice of query plan + ** for a statement, then the statement will be automatically recompiled, + ** as if there had been a schema change, on the first sqlite3_step() call + ** following any change to the bindings of that parameter. + */ + assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 ); + if( p->expmask!=0 && (p->expmask & (i>=31 ? 0x80000000 : (u32)1<expired = 1; + } + return SQLITE_OK; +} + +/* +** Bind a text or BLOB value. +*/ +static int bindText( + sqlite3_stmt *pStmt, /* The statement to bind against */ + int i, /* Index of the parameter to bind */ + const void *zData, /* Pointer to the data to be bound */ + int nData, /* Number of bytes of data to be bound */ + void (*xDel)(void*), /* Destructor for the data */ + u8 encoding /* Encoding for the data */ +){ + Vdbe *p = (Vdbe *)pStmt; + Mem *pVar; + int rc; + + rc = vdbeUnbind(p, i); + if( rc==SQLITE_OK ){ + if( zData!=0 ){ + pVar = &p->aVar[i-1]; + rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel); + if( rc==SQLITE_OK && encoding!=0 ){ + rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db)); + } + if( rc ){ + sqlite3Error(p->db, rc); + rc = sqlite3ApiExit(p->db, rc); + } + } + sqlite3_mutex_leave(p->db->mutex); + }else if( xDel!=SQLITE_STATIC && xDel!=SQLITE_TRANSIENT ){ + xDel((void*)zData); + } + return rc; +} + + +/* +** Bind a blob value to an SQL statement variable. +*/ +SQLITE_API int sqlite3_bind_blob( + sqlite3_stmt *pStmt, + int i, + const void *zData, + int nData, + void (*xDel)(void*) +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( nData<0 ) return SQLITE_MISUSE_BKPT; +#endif + return bindText(pStmt, i, zData, nData, xDel, 0); +} +SQLITE_API int sqlite3_bind_blob64( + sqlite3_stmt *pStmt, + int i, + const void *zData, + sqlite3_uint64 nData, + void (*xDel)(void*) +){ + assert( xDel!=SQLITE_DYNAMIC ); + if( nData>0x7fffffff ){ + return invokeValueDestructor(zData, xDel, 0); + }else{ + return bindText(pStmt, i, zData, (int)nData, xDel, 0); + } +} +SQLITE_API int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){ + int rc; + Vdbe *p = (Vdbe *)pStmt; + rc = vdbeUnbind(p, i); + if( rc==SQLITE_OK ){ + sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue); + sqlite3_mutex_leave(p->db->mutex); + } + return rc; +} +SQLITE_API int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){ + return sqlite3_bind_int64(p, i, (i64)iValue); +} +SQLITE_API int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){ + int rc; + Vdbe *p = (Vdbe *)pStmt; + rc = vdbeUnbind(p, i); + if( rc==SQLITE_OK ){ + sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue); + sqlite3_mutex_leave(p->db->mutex); + } + return rc; +} +SQLITE_API int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){ + int rc; + Vdbe *p = (Vdbe*)pStmt; + rc = vdbeUnbind(p, i); + if( rc==SQLITE_OK ){ + sqlite3_mutex_leave(p->db->mutex); + } + return rc; +} +SQLITE_API int sqlite3_bind_pointer( + sqlite3_stmt *pStmt, + int i, + void *pPtr, + const char *zPTtype, + void (*xDestructor)(void*) +){ + int rc; + Vdbe *p = (Vdbe*)pStmt; + rc = vdbeUnbind(p, i); + if( rc==SQLITE_OK ){ + sqlite3VdbeMemSetPointer(&p->aVar[i-1], pPtr, zPTtype, xDestructor); + sqlite3_mutex_leave(p->db->mutex); + }else if( xDestructor ){ + xDestructor(pPtr); + } + return rc; +} +SQLITE_API int sqlite3_bind_text( + sqlite3_stmt *pStmt, + int i, + const char *zData, + int nData, + void (*xDel)(void*) +){ + return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8); +} +SQLITE_API int sqlite3_bind_text64( + sqlite3_stmt *pStmt, + int i, + const char *zData, + sqlite3_uint64 nData, + void (*xDel)(void*), + unsigned char enc +){ + assert( xDel!=SQLITE_DYNAMIC ); + if( nData>0x7fffffff ){ + return invokeValueDestructor(zData, xDel, 0); + }else{ + if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE; + return bindText(pStmt, i, zData, (int)nData, xDel, enc); + } +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API int sqlite3_bind_text16( + sqlite3_stmt *pStmt, + int i, + const void *zData, + int nData, + void (*xDel)(void*) +){ + return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE); +} +#endif /* SQLITE_OMIT_UTF16 */ +SQLITE_API int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){ + int rc; + switch( sqlite3_value_type((sqlite3_value*)pValue) ){ + case SQLITE_INTEGER: { + rc = sqlite3_bind_int64(pStmt, i, pValue->u.i); + break; + } + case SQLITE_FLOAT: { + rc = sqlite3_bind_double(pStmt, i, pValue->u.r); + break; + } + case SQLITE_BLOB: { + if( pValue->flags & MEM_Zero ){ + rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero); + }else{ + rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT); + } + break; + } + case SQLITE_TEXT: { + rc = bindText(pStmt,i, pValue->z, pValue->n, SQLITE_TRANSIENT, + pValue->enc); + break; + } + default: { + rc = sqlite3_bind_null(pStmt, i); + break; + } + } + return rc; +} +SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){ + int rc; + Vdbe *p = (Vdbe *)pStmt; + rc = vdbeUnbind(p, i); + if( rc==SQLITE_OK ){ + sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n); + sqlite3_mutex_leave(p->db->mutex); + } + return rc; +} +SQLITE_API int sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){ + int rc; + Vdbe *p = (Vdbe *)pStmt; + sqlite3_mutex_enter(p->db->mutex); + if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){ + rc = SQLITE_TOOBIG; + }else{ + assert( (n & 0x7FFFFFFF)==n ); + rc = sqlite3_bind_zeroblob(pStmt, i, n); + } + rc = sqlite3ApiExit(p->db, rc); + sqlite3_mutex_leave(p->db->mutex); + return rc; +} + +/* +** Return the number of wildcards that can be potentially bound to. +** This routine is added to support DBD::SQLite. +*/ +SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){ + Vdbe *p = (Vdbe*)pStmt; + return p ? p->nVar : 0; +} + +/* +** Return the name of a wildcard parameter. Return NULL if the index +** is out of range or if the wildcard is unnamed. +** +** The result is always UTF-8. +*/ +SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){ + Vdbe *p = (Vdbe*)pStmt; + if( p==0 ) return 0; + return sqlite3VListNumToName(p->pVList, i); +} + +/* +** Given a wildcard parameter name, return the index of the variable +** with that name. If there is no variable with the given name, +** return 0. +*/ +SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){ + if( p==0 || zName==0 ) return 0; + return sqlite3VListNameToNum(p->pVList, zName, nName); +} +SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){ + return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName)); +} + +/* +** Transfer all bindings from the first statement over to the second. +*/ +SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){ + Vdbe *pFrom = (Vdbe*)pFromStmt; + Vdbe *pTo = (Vdbe*)pToStmt; + int i; + assert( pTo->db==pFrom->db ); + assert( pTo->nVar==pFrom->nVar ); + sqlite3_mutex_enter(pTo->db->mutex); + for(i=0; inVar; i++){ + sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]); + } + sqlite3_mutex_leave(pTo->db->mutex); + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Deprecated external interface. Internal/core SQLite code +** should call sqlite3TransferBindings. +** +** It is misuse to call this routine with statements from different +** database connections. But as this is a deprecated interface, we +** will not bother to check for that condition. +** +** If the two statements contain a different number of bindings, then +** an SQLITE_ERROR is returned. Nothing else can go wrong, so otherwise +** SQLITE_OK is returned. +*/ +SQLITE_API int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){ + Vdbe *pFrom = (Vdbe*)pFromStmt; + Vdbe *pTo = (Vdbe*)pToStmt; + if( pFrom->nVar!=pTo->nVar ){ + return SQLITE_ERROR; + } + assert( (pTo->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pTo->expmask==0 ); + if( pTo->expmask ){ + pTo->expired = 1; + } + assert( (pFrom->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pFrom->expmask==0 ); + if( pFrom->expmask ){ + pFrom->expired = 1; + } + return sqlite3TransferBindings(pFromStmt, pToStmt); +} +#endif + +/* +** Return the sqlite3* database handle to which the prepared statement given +** in the argument belongs. This is the same database handle that was +** the first argument to the sqlite3_prepare() that was used to create +** the statement in the first place. +*/ +SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){ + return pStmt ? ((Vdbe*)pStmt)->db : 0; +} + +/* +** Return true if the prepared statement is guaranteed to not modify the +** database. +*/ +SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt){ + return pStmt ? ((Vdbe*)pStmt)->readOnly : 1; +} + +/* +** Return 1 if the statement is an EXPLAIN and return 2 if the +** statement is an EXPLAIN QUERY PLAN +*/ +SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt){ + return pStmt ? ((Vdbe*)pStmt)->explain : 0; +} + +/* +** Return true if the prepared statement is in need of being reset. +*/ +SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt *pStmt){ + Vdbe *v = (Vdbe*)pStmt; + return v!=0 && v->magic==VDBE_MAGIC_RUN && v->pc>=0; +} + +/* +** Return a pointer to the next prepared statement after pStmt associated +** with database connection pDb. If pStmt is NULL, return the first +** prepared statement for the database connection. Return NULL if there +** are no more. +*/ +SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){ + sqlite3_stmt *pNext; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(pDb) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(pDb->mutex); + if( pStmt==0 ){ + pNext = (sqlite3_stmt*)pDb->pVdbe; + }else{ + pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext; + } + sqlite3_mutex_leave(pDb->mutex); + return pNext; +} + +/* +** Return the value of a status counter for a prepared statement +*/ +SQLITE_API int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){ + Vdbe *pVdbe = (Vdbe*)pStmt; + u32 v; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !pStmt + || (op!=SQLITE_STMTSTATUS_MEMUSED && (op<0||op>=ArraySize(pVdbe->aCounter))) + ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + if( op==SQLITE_STMTSTATUS_MEMUSED ){ + sqlite3 *db = pVdbe->db; + sqlite3_mutex_enter(db->mutex); + v = 0; + db->pnBytesFreed = (int*)&v; + sqlite3VdbeClearObject(db, pVdbe); + sqlite3DbFree(db, pVdbe); + db->pnBytesFreed = 0; + sqlite3_mutex_leave(db->mutex); + }else{ + v = pVdbe->aCounter[op]; + if( resetFlag ) pVdbe->aCounter[op] = 0; + } + return (int)v; +} + +/* +** Return the SQL associated with a prepared statement +*/ +SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt){ + Vdbe *p = (Vdbe *)pStmt; + return p ? p->zSql : 0; +} + +/* +** Return the SQL associated with a prepared statement with +** bound parameters expanded. Space to hold the returned string is +** obtained from sqlite3_malloc(). The caller is responsible for +** freeing the returned string by passing it to sqlite3_free(). +** +** The SQLITE_TRACE_SIZE_LIMIT puts an upper bound on the size of +** expanded bound parameters. +*/ +SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt){ +#ifdef SQLITE_OMIT_TRACE + return 0; +#else + char *z = 0; + const char *zSql = sqlite3_sql(pStmt); + if( zSql ){ + Vdbe *p = (Vdbe *)pStmt; + sqlite3_mutex_enter(p->db->mutex); + z = sqlite3VdbeExpandSql(p, zSql); + sqlite3_mutex_leave(p->db->mutex); + } + return z; +#endif +} + +#ifdef SQLITE_ENABLE_NORMALIZE +/* +** Return the normalized SQL associated with a prepared statement. +*/ +SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt){ + Vdbe *p = (Vdbe *)pStmt; + if( p==0 ) return 0; + if( p->zNormSql==0 && ALWAYS(p->zSql!=0) ){ + sqlite3_mutex_enter(p->db->mutex); + p->zNormSql = sqlite3Normalize(p, p->zSql); + sqlite3_mutex_leave(p->db->mutex); + } + return p->zNormSql; +} +#endif /* SQLITE_ENABLE_NORMALIZE */ + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +/* +** Allocate and populate an UnpackedRecord structure based on the serialized +** record in nKey/pKey. Return a pointer to the new UnpackedRecord structure +** if successful, or a NULL pointer if an OOM error is encountered. +*/ +static UnpackedRecord *vdbeUnpackRecord( + KeyInfo *pKeyInfo, + int nKey, + const void *pKey +){ + UnpackedRecord *pRet; /* Return value */ + + pRet = sqlite3VdbeAllocUnpackedRecord(pKeyInfo); + if( pRet ){ + memset(pRet->aMem, 0, sizeof(Mem)*(pKeyInfo->nKeyField+1)); + sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, pRet); + } + return pRet; +} + +/* +** This function is called from within a pre-update callback to retrieve +** a field of the row currently being updated or deleted. +*/ +SQLITE_API int sqlite3_preupdate_old(sqlite3 *db, int iIdx, sqlite3_value **ppValue){ + PreUpdate *p = db->pPreUpdate; + Mem *pMem; + int rc = SQLITE_OK; + + /* Test that this call is being made from within an SQLITE_DELETE or + ** SQLITE_UPDATE pre-update callback, and that iIdx is within range. */ + if( !p || p->op==SQLITE_INSERT ){ + rc = SQLITE_MISUSE_BKPT; + goto preupdate_old_out; + } + if( p->pPk ){ + iIdx = sqlite3TableColumnToIndex(p->pPk, iIdx); + } + if( iIdx>=p->pCsr->nField || iIdx<0 ){ + rc = SQLITE_RANGE; + goto preupdate_old_out; + } + + /* If the old.* record has not yet been loaded into memory, do so now. */ + if( p->pUnpacked==0 ){ + u32 nRec; + u8 *aRec; + + nRec = sqlite3BtreePayloadSize(p->pCsr->uc.pCursor); + aRec = sqlite3DbMallocRaw(db, nRec); + if( !aRec ) goto preupdate_old_out; + rc = sqlite3BtreePayload(p->pCsr->uc.pCursor, 0, nRec, aRec); + if( rc==SQLITE_OK ){ + p->pUnpacked = vdbeUnpackRecord(&p->keyinfo, nRec, aRec); + if( !p->pUnpacked ) rc = SQLITE_NOMEM; + } + if( rc!=SQLITE_OK ){ + sqlite3DbFree(db, aRec); + goto preupdate_old_out; + } + p->aRecord = aRec; + } + + pMem = *ppValue = &p->pUnpacked->aMem[iIdx]; + if( iIdx==p->pTab->iPKey ){ + sqlite3VdbeMemSetInt64(pMem, p->iKey1); + }else if( iIdx>=p->pUnpacked->nField ){ + *ppValue = (sqlite3_value *)columnNullValue(); + }else if( p->pTab->aCol[iIdx].affinity==SQLITE_AFF_REAL ){ + if( pMem->flags & (MEM_Int|MEM_IntReal) ){ + testcase( pMem->flags & MEM_Int ); + testcase( pMem->flags & MEM_IntReal ); + sqlite3VdbeMemRealify(pMem); + } + } + + preupdate_old_out: + sqlite3Error(db, rc); + return sqlite3ApiExit(db, rc); +} +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +/* +** This function is called from within a pre-update callback to retrieve +** the number of columns in the row being updated, deleted or inserted. +*/ +SQLITE_API int sqlite3_preupdate_count(sqlite3 *db){ + PreUpdate *p = db->pPreUpdate; + return (p ? p->keyinfo.nKeyField : 0); +} +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +/* +** This function is designed to be called from within a pre-update callback +** only. It returns zero if the change that caused the callback was made +** immediately by a user SQL statement. Or, if the change was made by a +** trigger program, it returns the number of trigger programs currently +** on the stack (1 for a top-level trigger, 2 for a trigger fired by a +** top-level trigger etc.). +** +** For the purposes of the previous paragraph, a foreign key CASCADE, SET NULL +** or SET DEFAULT action is considered a trigger. +*/ +SQLITE_API int sqlite3_preupdate_depth(sqlite3 *db){ + PreUpdate *p = db->pPreUpdate; + return (p ? p->v->nFrame : 0); +} +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +/* +** This function is called from within a pre-update callback to retrieve +** a field of the row currently being updated or inserted. +*/ +SQLITE_API int sqlite3_preupdate_new(sqlite3 *db, int iIdx, sqlite3_value **ppValue){ + PreUpdate *p = db->pPreUpdate; + int rc = SQLITE_OK; + Mem *pMem; + + if( !p || p->op==SQLITE_DELETE ){ + rc = SQLITE_MISUSE_BKPT; + goto preupdate_new_out; + } + if( p->pPk && p->op!=SQLITE_UPDATE ){ + iIdx = sqlite3TableColumnToIndex(p->pPk, iIdx); + } + if( iIdx>=p->pCsr->nField || iIdx<0 ){ + rc = SQLITE_RANGE; + goto preupdate_new_out; + } + + if( p->op==SQLITE_INSERT ){ + /* For an INSERT, memory cell p->iNewReg contains the serialized record + ** that is being inserted. Deserialize it. */ + UnpackedRecord *pUnpack = p->pNewUnpacked; + if( !pUnpack ){ + Mem *pData = &p->v->aMem[p->iNewReg]; + rc = ExpandBlob(pData); + if( rc!=SQLITE_OK ) goto preupdate_new_out; + pUnpack = vdbeUnpackRecord(&p->keyinfo, pData->n, pData->z); + if( !pUnpack ){ + rc = SQLITE_NOMEM; + goto preupdate_new_out; + } + p->pNewUnpacked = pUnpack; + } + pMem = &pUnpack->aMem[iIdx]; + if( iIdx==p->pTab->iPKey ){ + sqlite3VdbeMemSetInt64(pMem, p->iKey2); + }else if( iIdx>=pUnpack->nField ){ + pMem = (sqlite3_value *)columnNullValue(); + } + }else{ + /* For an UPDATE, memory cell (p->iNewReg+1+iIdx) contains the required + ** value. Make a copy of the cell contents and return a pointer to it. + ** It is not safe to return a pointer to the memory cell itself as the + ** caller may modify the value text encoding. + */ + assert( p->op==SQLITE_UPDATE ); + if( !p->aNew ){ + p->aNew = (Mem *)sqlite3DbMallocZero(db, sizeof(Mem) * p->pCsr->nField); + if( !p->aNew ){ + rc = SQLITE_NOMEM; + goto preupdate_new_out; + } + } + assert( iIdx>=0 && iIdxpCsr->nField ); + pMem = &p->aNew[iIdx]; + if( pMem->flags==0 ){ + if( iIdx==p->pTab->iPKey ){ + sqlite3VdbeMemSetInt64(pMem, p->iKey2); + }else{ + rc = sqlite3VdbeMemCopy(pMem, &p->v->aMem[p->iNewReg+1+iIdx]); + if( rc!=SQLITE_OK ) goto preupdate_new_out; + } + } + } + *ppValue = pMem; + + preupdate_new_out: + sqlite3Error(db, rc); + return sqlite3ApiExit(db, rc); +} +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS +/* +** Return status data for a single loop within query pStmt. +*/ +SQLITE_API int sqlite3_stmt_scanstatus( + sqlite3_stmt *pStmt, /* Prepared statement being queried */ + int idx, /* Index of loop to report on */ + int iScanStatusOp, /* Which metric to return */ + 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]; + switch( iScanStatusOp ){ + case SQLITE_SCANSTAT_NLOOP: { + *(sqlite3_int64*)pOut = p->anExec[pScan->addrLoop]; + break; + } + case SQLITE_SCANSTAT_NVISIT: { + *(sqlite3_int64*)pOut = p->anExec[pScan->addrVisit]; + break; + } + case SQLITE_SCANSTAT_EST: { + double r = 1.0; + LogEst x = pScan->nEst; + while( x<100 ){ + x += 10; + r *= 0.5; + } + *(double*)pOut = r*sqlite3LogEstToInt(x); + break; + } + case SQLITE_SCANSTAT_NAME: { + *(const char**)pOut = pScan->zName; + break; + } + case SQLITE_SCANSTAT_EXPLAIN: { + if( pScan->addrExplain ){ + *(const char**)pOut = p->aOp[ pScan->addrExplain ].p4.z; + }else{ + *(const char**)pOut = 0; + } + break; + } + case SQLITE_SCANSTAT_SELECTID: { + if( pScan->addrExplain ){ + *(int*)pOut = p->aOp[ pScan->addrExplain ].p1; + }else{ + *(int*)pOut = -1; + } + break; + } + default: { + return 1; + } + } + return 0; +} + +/* +** Zero all counters associated with the sqlite3_stmt_scanstatus() data. +*/ +SQLITE_API void sqlite3_stmt_scanstatus_reset(sqlite3_stmt *pStmt){ + Vdbe *p = (Vdbe*)pStmt; + memset(p->anExec, 0, p->nOp * sizeof(i64)); +} +#endif /* SQLITE_ENABLE_STMT_SCANSTATUS */ + +/************** End of vdbeapi.c *********************************************/ +/************** Begin file vdbetrace.c ***************************************/ +/* +** 2009 November 25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code used to insert the values of host parameters +** (aka "wildcards") into the SQL text output by sqlite3_trace(). +** +** The Vdbe parse-tree explainer is also found here. +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +#ifndef SQLITE_OMIT_TRACE + +/* +** zSql is a zero-terminated string of UTF-8 SQL text. Return the number of +** bytes in this text up to but excluding the first character in +** a host parameter. If the text contains no host parameters, return +** the total number of bytes in the text. +*/ +static int findNextHostParameter(const char *zSql, int *pnToken){ + int tokenType; + int nTotal = 0; + int n; + + *pnToken = 0; + while( zSql[0] ){ + n = sqlite3GetToken((u8*)zSql, &tokenType); + assert( n>0 && tokenType!=TK_ILLEGAL ); + if( tokenType==TK_VARIABLE ){ + *pnToken = n; + break; + } + nTotal += n; + zSql += n; + } + return nTotal; +} + +/* +** This function returns a pointer to a nul-terminated string in memory +** obtained from sqlite3DbMalloc(). If sqlite3.nVdbeExec is 1, then the +** string contains a copy of zRawSql but with host parameters expanded to +** their current bindings. Or, if sqlite3.nVdbeExec is greater than 1, +** then the returned string holds a copy of zRawSql with "-- " prepended +** to each line of text. +** +** If the SQLITE_TRACE_SIZE_LIMIT macro is defined to an integer, then +** then long strings and blobs are truncated to that many bytes. This +** can be used to prevent unreasonably large trace strings when dealing +** with large (multi-megabyte) strings and blobs. +** +** The calling function is responsible for making sure the memory returned +** is eventually freed. +** +** ALGORITHM: Scan the input string looking for host parameters in any of +** these forms: ?, ?N, $A, @A, :A. Take care to avoid text within +** string literals, quoted identifier names, and comments. For text forms, +** the host parameter index is found by scanning the prepared +** statement for the corresponding OP_Variable opcode. Once the host +** parameter index is known, locate the value in p->aVar[]. Then render +** the value as a literal in place of the host parameter name. +*/ +SQLITE_PRIVATE char *sqlite3VdbeExpandSql( + Vdbe *p, /* The prepared statement being evaluated */ + const char *zRawSql /* Raw text of the SQL statement */ +){ + sqlite3 *db; /* The database connection */ + int idx = 0; /* Index of a host parameter */ + int nextIndex = 1; /* Index of next ? host parameter */ + int n; /* Length of a token prefix */ + int nToken; /* Length of the parameter token */ + int i; /* Loop counter */ + Mem *pVar; /* Value of a host parameter */ + StrAccum out; /* Accumulate the output here */ +#ifndef SQLITE_OMIT_UTF16 + Mem utf8; /* Used to convert UTF16 into UTF8 for display */ +#endif + char zBase[100]; /* Initial working space */ + + db = p->db; + sqlite3StrAccumInit(&out, 0, zBase, sizeof(zBase), + db->aLimit[SQLITE_LIMIT_LENGTH]); + if( db->nVdbeExec>1 ){ + while( *zRawSql ){ + const char *zStart = zRawSql; + while( *(zRawSql++)!='\n' && *zRawSql ); + sqlite3_str_append(&out, "-- ", 3); + assert( (zRawSql - zStart) > 0 ); + sqlite3_str_append(&out, zStart, (int)(zRawSql-zStart)); + } + }else if( p->nVar==0 ){ + sqlite3_str_append(&out, zRawSql, sqlite3Strlen30(zRawSql)); + }else{ + while( zRawSql[0] ){ + n = findNextHostParameter(zRawSql, &nToken); + assert( n>0 ); + sqlite3_str_append(&out, zRawSql, n); + zRawSql += n; + assert( zRawSql[0] || nToken==0 ); + if( nToken==0 ) break; + if( zRawSql[0]=='?' ){ + if( nToken>1 ){ + assert( sqlite3Isdigit(zRawSql[1]) ); + sqlite3GetInt32(&zRawSql[1], &idx); + }else{ + idx = nextIndex; + } + }else{ + assert( zRawSql[0]==':' || zRawSql[0]=='$' || + zRawSql[0]=='@' || zRawSql[0]=='#' ); + testcase( zRawSql[0]==':' ); + testcase( zRawSql[0]=='$' ); + testcase( zRawSql[0]=='@' ); + testcase( zRawSql[0]=='#' ); + idx = sqlite3VdbeParameterIndex(p, zRawSql, nToken); + assert( idx>0 ); + } + zRawSql += nToken; + nextIndex = idx + 1; + assert( idx>0 && idx<=p->nVar ); + pVar = &p->aVar[idx-1]; + if( pVar->flags & MEM_Null ){ + sqlite3_str_append(&out, "NULL", 4); + }else if( pVar->flags & (MEM_Int|MEM_IntReal) ){ + sqlite3_str_appendf(&out, "%lld", pVar->u.i); + }else if( pVar->flags & MEM_Real ){ + sqlite3_str_appendf(&out, "%!.15g", pVar->u.r); + }else if( pVar->flags & MEM_Str ){ + int nOut; /* Number of bytes of the string text to include in output */ +#ifndef SQLITE_OMIT_UTF16 + u8 enc = ENC(db); + if( enc!=SQLITE_UTF8 ){ + memset(&utf8, 0, sizeof(utf8)); + utf8.db = db; + sqlite3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLITE_STATIC); + if( SQLITE_NOMEM==sqlite3VdbeChangeEncoding(&utf8, SQLITE_UTF8) ){ + out.accError = SQLITE_NOMEM; + out.nAlloc = 0; + } + pVar = &utf8; + } +#endif + nOut = pVar->n; +#ifdef SQLITE_TRACE_SIZE_LIMIT + if( nOut>SQLITE_TRACE_SIZE_LIMIT ){ + nOut = SQLITE_TRACE_SIZE_LIMIT; + while( nOutn && (pVar->z[nOut]&0xc0)==0x80 ){ nOut++; } + } +#endif + sqlite3_str_appendf(&out, "'%.*q'", nOut, pVar->z); +#ifdef SQLITE_TRACE_SIZE_LIMIT + if( nOutn ){ + sqlite3_str_appendf(&out, "/*+%d bytes*/", pVar->n-nOut); + } +#endif +#ifndef SQLITE_OMIT_UTF16 + if( enc!=SQLITE_UTF8 ) sqlite3VdbeMemRelease(&utf8); +#endif + }else if( pVar->flags & MEM_Zero ){ + sqlite3_str_appendf(&out, "zeroblob(%d)", pVar->u.nZero); + }else{ + int nOut; /* Number of bytes of the blob to include in output */ + assert( pVar->flags & MEM_Blob ); + sqlite3_str_append(&out, "x'", 2); + nOut = pVar->n; +#ifdef SQLITE_TRACE_SIZE_LIMIT + if( nOut>SQLITE_TRACE_SIZE_LIMIT ) nOut = SQLITE_TRACE_SIZE_LIMIT; +#endif + for(i=0; iz[i]&0xff); + } + sqlite3_str_append(&out, "'", 1); +#ifdef SQLITE_TRACE_SIZE_LIMIT + if( nOutn ){ + sqlite3_str_appendf(&out, "/*+%d bytes*/", pVar->n-nOut); + } +#endif + } + } + } + if( out.accError ) sqlite3_str_reset(&out); + return sqlite3StrAccumFinish(&out); +} + +#endif /* #ifndef SQLITE_OMIT_TRACE */ + +/************** End of vdbetrace.c *******************************************/ +/************** Begin file vdbe.c ********************************************/ +/* +** 2001 September 15 +** +** 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. +** +************************************************************************* +** The code in this file implements the function that runs the +** bytecode of a prepared statement. +** +** Various scripts scan this source file in order to generate HTML +** documentation, headers files, or other derived files. The formatting +** of the code in this file is, therefore, important. See other comments +** in this file for details. If in doubt, do not deviate from existing +** commenting and indentation practices when changing or adding code. +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +/* +** Invoke this macro on memory cells just prior to changing the +** value of the cell. This macro verifies that shallow copies are +** not misused. A shallow copy of a string or blob just copies a +** pointer to the string or blob, not the content. If the original +** is changed while the copy is still in use, the string or blob might +** be changed out from under the copy. This macro verifies that nothing +** like that ever happens. +*/ +#ifdef SQLITE_DEBUG +# define memAboutToChange(P,M) sqlite3VdbeMemAboutToChange(P,M) +#else +# define memAboutToChange(P,M) +#endif + +/* +** The following global variable is incremented every time a cursor +** moves, either by the OP_SeekXX, OP_Next, or OP_Prev opcodes. The test +** procedures use this information to make sure that indices are +** working correctly. This variable has no function other than to +** help verify the correct operation of the library. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_search_count = 0; +#endif + +/* +** When this global variable is positive, it gets decremented once before +** each instruction in the VDBE. When it reaches zero, the u1.isInterrupted +** field of the sqlite3 structure is set in order to simulate an interrupt. +** +** This facility is used for testing purposes only. It does not function +** in an ordinary build. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_interrupt_count = 0; +#endif + +/* +** The next global variable is incremented each type the OP_Sort opcode +** is executed. The test procedures use this information to make sure that +** sorting is occurring or not occurring at appropriate times. This variable +** has no function other than to help verify the correct operation of the +** library. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_sort_count = 0; +#endif + +/* +** The next global variable records the size of the largest MEM_Blob +** or MEM_Str that has been used by a VDBE opcode. The test procedures +** use this information to make sure that the zero-blob functionality +** is working correctly. This variable has no function other than to +** help verify the correct operation of the library. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_max_blobsize = 0; +static void updateMaxBlobsize(Mem *p){ + if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){ + sqlite3_max_blobsize = p->n; + } +} +#endif + +/* +** This macro evaluates to true if either the update hook or the preupdate +** hook are enabled for database connect DB. +*/ +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +# define HAS_UPDATE_HOOK(DB) ((DB)->xPreUpdateCallback||(DB)->xUpdateCallback) +#else +# define HAS_UPDATE_HOOK(DB) ((DB)->xUpdateCallback) +#endif + +/* +** The next global variable is incremented each time the OP_Found opcode +** is executed. This is used to test whether or not the foreign key +** operation implemented using OP_FkIsZero is working. This variable +** has no function other than to help verify the correct operation of the +** library. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_found_count = 0; +#endif + +/* +** Test a register to see if it exceeds the current maximum blob size. +** If it does, record the new maximum blob size. +*/ +#if defined(SQLITE_TEST) && !defined(SQLITE_UNTESTABLE) +# define UPDATE_MAX_BLOBSIZE(P) updateMaxBlobsize(P) +#else +# define UPDATE_MAX_BLOBSIZE(P) +#endif + +#ifdef SQLITE_DEBUG +/* This routine provides a convenient place to set a breakpoint during +** tracing with PRAGMA vdbe_trace=on. The breakpoint fires right after +** each opcode is printed. Variables "pc" (program counter) and pOp are +** available to add conditionals to the breakpoint. GDB example: +** +** break test_trace_breakpoint if pc=22 +** +** Other useful labels for breakpoints include: +** test_addop_breakpoint(pc,pOp) +** sqlite3CorruptError(lineno) +** sqlite3MisuseError(lineno) +** sqlite3CantopenError(lineno) +*/ +static void test_trace_breakpoint(int pc, Op *pOp, Vdbe *v){ + static int n = 0; + n++; +} +#endif + +/* +** Invoke the VDBE coverage callback, if that callback is defined. This +** feature is used for test suite validation only and does not appear an +** production builds. +** +** M is the type of branch. I is the direction taken for this instance of +** the branch. +** +** M: 2 - two-way branch (I=0: fall-thru 1: jump ) +** 3 - two-way + NULL (I=0: fall-thru 1: jump 2: NULL ) +** 4 - OP_Jump (I=0: jump p1 1: jump p2 2: jump p3) +** +** In other words, if M is 2, then I is either 0 (for fall-through) or +** 1 (for when the branch is taken). If M is 3, the I is 0 for an +** ordinary fall-through, I is 1 if the branch was taken, and I is 2 +** if the result of comparison is NULL. For M=3, I=2 the jump may or +** may not be taken, depending on the SQLITE_JUMPIFNULL flags in p5. +** When M is 4, that means that an OP_Jump is being run. I is 0, 1, or 2 +** depending on if the operands are less than, equal, or greater than. +** +** iSrcLine is the source code line (from the __LINE__ macro) that +** generated the VDBE instruction combined with flag bits. The source +** code line number is in the lower 24 bits of iSrcLine and the upper +** 8 bytes are flags. The lower three bits of the flags indicate +** values for I that should never occur. For example, if the branch is +** always taken, the flags should be 0x05 since the fall-through and +** alternate branch are never taken. If a branch is never taken then +** flags should be 0x06 since only the fall-through approach is allowed. +** +** Bit 0x08 of the flags indicates an OP_Jump opcode that is only +** interested in equal or not-equal. In other words, I==0 and I==2 +** should be treated as equivalent +** +** Since only a line number is retained, not the filename, this macro +** only works for amalgamation builds. But that is ok, since these macros +** should be no-ops except for special builds used to measure test coverage. +*/ +#if !defined(SQLITE_VDBE_COVERAGE) +# define VdbeBranchTaken(I,M) +#else +# define VdbeBranchTaken(I,M) vdbeTakeBranch(pOp->iSrcLine,I,M) + static void vdbeTakeBranch(u32 iSrcLine, u8 I, u8 M){ + u8 mNever; + assert( I<=2 ); /* 0: fall through, 1: taken, 2: alternate taken */ + assert( M<=4 ); /* 2: two-way branch, 3: three-way branch, 4: OP_Jump */ + assert( I> 24; + assert( (I & mNever)==0 ); + if( sqlite3GlobalConfig.xVdbeBranch==0 ) return; /*NO_TEST*/ + /* Invoke the branch coverage callback with three arguments: + ** iSrcLine - the line number of the VdbeCoverage() macro, with + ** flags removed. + ** I - Mask of bits 0x07 indicating which cases are are + ** fulfilled by this instance of the jump. 0x01 means + ** fall-thru, 0x02 means taken, 0x04 means NULL. Any + ** impossible cases (ex: if the comparison is never NULL) + ** are filled in automatically so that the coverage + ** measurement logic does not flag those impossible cases + ** as missed coverage. + ** M - Type of jump. Same as M argument above + */ + I |= mNever; + if( M==2 ) I |= 0x04; + if( M==4 ){ + I |= 0x08; + if( (mNever&0x08)!=0 && (I&0x05)!=0) I |= 0x05; /*NO_TEST*/ + } + sqlite3GlobalConfig.xVdbeBranch(sqlite3GlobalConfig.pVdbeBranchArg, + iSrcLine&0xffffff, I, M); + } +#endif + +/* +** An ephemeral string value (signified by the MEM_Ephem flag) contains +** a pointer to a dynamically allocated string where some other entity +** is responsible for deallocating that string. Because the register +** does not control the string, it might be deleted without the register +** knowing it. +** +** This routine converts an ephemeral string into a dynamically allocated +** string that the register itself controls. In other words, it +** converts an MEM_Ephem string into a string with P.z==P.zMalloc. +*/ +#define Deephemeralize(P) \ + if( ((P)->flags&MEM_Ephem)!=0 \ + && sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;} + +/* Return true if the cursor was opened using the OP_OpenSorter opcode. */ +#define isSorter(x) ((x)->eCurType==CURTYPE_SORTER) + +/* +** Allocate VdbeCursor number iCur. Return a pointer to it. Return NULL +** if we run out of memory. +*/ +static VdbeCursor *allocateCursor( + Vdbe *p, /* The virtual machine */ + int iCur, /* Index of the new VdbeCursor */ + int nField, /* Number of fields in the table or index */ + int iDb, /* Database the cursor belongs to, or -1 */ + u8 eCurType /* Type of the new cursor */ +){ + /* Find the memory cell that will be used to store the blob of memory + ** required for this VdbeCursor structure. It is convenient to use a + ** vdbe memory cell to manage the memory allocation required for a + ** VdbeCursor structure for the following reasons: + ** + ** * Sometimes cursor numbers are used for a couple of different + ** purposes in a vdbe program. The different uses might require + ** different sized allocations. Memory cells provide growable + ** allocations. + ** + ** * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can + ** be freed lazily via the sqlite3_release_memory() API. This + ** minimizes the number of malloc calls made by the system. + ** + ** The memory cell for cursor 0 is aMem[0]. The rest are allocated from + ** the top of the register space. Cursor 1 is at Mem[p->nMem-1]. + ** Cursor 2 is at Mem[p->nMem-2]. And so forth. + */ + Mem *pMem = iCur>0 ? &p->aMem[p->nMem-iCur] : p->aMem; + + int nByte; + VdbeCursor *pCx = 0; + nByte = + ROUND8(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField + + (eCurType==CURTYPE_BTREE?sqlite3BtreeCursorSize():0); + + assert( iCur>=0 && iCurnCursor ); + if( p->apCsr[iCur] ){ /*OPTIMIZATION-IF-FALSE*/ + /* Before calling sqlite3VdbeFreeCursor(), ensure the isEphemeral flag + ** is clear. Otherwise, if this is an ephemeral cursor created by + ** OP_OpenDup, the cursor will not be closed and will still be part + ** of a BtShared.pCursor list. */ + if( p->apCsr[iCur]->pBtx==0 ) p->apCsr[iCur]->isEphemeral = 0; + sqlite3VdbeFreeCursor(p, p->apCsr[iCur]); + p->apCsr[iCur] = 0; + } + if( SQLITE_OK==sqlite3VdbeMemClearAndResize(pMem, nByte) ){ + p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->z; + memset(pCx, 0, offsetof(VdbeCursor,pAltCursor)); + pCx->eCurType = eCurType; + pCx->iDb = iDb; + pCx->nField = nField; + pCx->aOffset = &pCx->aType[nField]; + if( eCurType==CURTYPE_BTREE ){ + pCx->uc.pCursor = (BtCursor*) + &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField]; + sqlite3BtreeCursorZero(pCx->uc.pCursor); + } + } + return pCx; +} + +/* +** The string in pRec is known to look like an integer and to have a +** floating point value of rValue. Return true and set *piValue to the +** integer value if the string is in range to be an integer. Otherwise, +** return false. +*/ +static int alsoAnInt(Mem *pRec, double rValue, i64 *piValue){ + i64 iValue = (double)rValue; + if( sqlite3RealSameAsInt(rValue,iValue) ){ + *piValue = iValue; + return 1; + } + return 0==sqlite3Atoi64(pRec->z, piValue, pRec->n, pRec->enc); +} + +/* +** Try to convert a value into a numeric representation if we can +** do so without loss of information. In other words, if the string +** looks like a number, convert it into a number. If it does not +** look like a number, leave it alone. +** +** If the bTryForInt flag is true, then extra effort is made to give +** an integer representation. Strings that look like floating point +** values but which have no fractional component (example: '48.00') +** will have a MEM_Int representation when bTryForInt is true. +** +** If bTryForInt is false, then if the input string contains a decimal +** point or exponential notation, the result is only MEM_Real, even +** if there is an exact integer representation of the quantity. +*/ +static void applyNumericAffinity(Mem *pRec, int bTryForInt){ + double rValue; + u8 enc = pRec->enc; + int rc; + assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real|MEM_IntReal))==MEM_Str ); + rc = sqlite3AtoF(pRec->z, &rValue, pRec->n, enc); + if( rc<=0 ) return; + if( rc==1 && alsoAnInt(pRec, rValue, &pRec->u.i) ){ + pRec->flags |= MEM_Int; + }else{ + pRec->u.r = rValue; + pRec->flags |= MEM_Real; + if( bTryForInt ) sqlite3VdbeIntegerAffinity(pRec); + } + /* TEXT->NUMERIC is many->one. Hence, it is important to invalidate the + ** string representation after computing a numeric equivalent, because the + ** string representation might not be the canonical representation for the + ** numeric value. Ticket [343634942dd54ab57b7024] 2018-01-31. */ + pRec->flags &= ~MEM_Str; +} + +/* +** Processing is determine by the affinity parameter: +** +** SQLITE_AFF_INTEGER: +** SQLITE_AFF_REAL: +** SQLITE_AFF_NUMERIC: +** Try to convert pRec to an integer representation or a +** floating-point representation if an integer representation +** is not possible. Note that the integer representation is +** always preferred, even if the affinity is REAL, because +** an integer representation is more space efficient on disk. +** +** SQLITE_AFF_TEXT: +** Convert pRec to a text representation. +** +** SQLITE_AFF_BLOB: +** SQLITE_AFF_NONE: +** No-op. pRec is unchanged. +*/ +static void applyAffinity( + Mem *pRec, /* The value to apply affinity to */ + char affinity, /* The affinity to be applied */ + u8 enc /* Use this text encoding */ +){ + if( affinity>=SQLITE_AFF_NUMERIC ){ + assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL + || affinity==SQLITE_AFF_NUMERIC ); + if( (pRec->flags & MEM_Int)==0 ){ /*OPTIMIZATION-IF-FALSE*/ + if( (pRec->flags & MEM_Real)==0 ){ + if( pRec->flags & MEM_Str ) applyNumericAffinity(pRec,1); + }else{ + sqlite3VdbeIntegerAffinity(pRec); + } + } + }else if( affinity==SQLITE_AFF_TEXT ){ + /* Only attempt the conversion to TEXT if there is an integer or real + ** representation (blob and NULL do not get converted) but no string + ** representation. It would be harmless to repeat the conversion if + ** there is already a string rep, but it is pointless to waste those + ** CPU cycles. */ + if( 0==(pRec->flags&MEM_Str) ){ /*OPTIMIZATION-IF-FALSE*/ + if( (pRec->flags&(MEM_Real|MEM_Int|MEM_IntReal)) ){ + testcase( pRec->flags & MEM_Int ); + testcase( pRec->flags & MEM_Real ); + testcase( pRec->flags & MEM_IntReal ); + sqlite3VdbeMemStringify(pRec, enc, 1); + } + } + pRec->flags &= ~(MEM_Real|MEM_Int|MEM_IntReal); + } +} + +/* +** Try to convert the type of a function argument or a result column +** into a numeric representation. Use either INTEGER or REAL whichever +** is appropriate. But only do the conversion if it is possible without +** loss of information and return the revised type of the argument. +*/ +SQLITE_API int sqlite3_value_numeric_type(sqlite3_value *pVal){ + int eType = sqlite3_value_type(pVal); + if( eType==SQLITE_TEXT ){ + Mem *pMem = (Mem*)pVal; + applyNumericAffinity(pMem, 0); + eType = sqlite3_value_type(pVal); + } + return eType; +} + +/* +** Exported version of applyAffinity(). This one works on sqlite3_value*, +** not the internal Mem* type. +*/ +SQLITE_PRIVATE void sqlite3ValueApplyAffinity( + sqlite3_value *pVal, + u8 affinity, + u8 enc +){ + applyAffinity((Mem *)pVal, affinity, enc); +} + +/* +** pMem currently only holds a string type (or maybe a BLOB that we can +** interpret as a string if we want to). Compute its corresponding +** numeric type, if has one. Set the pMem->u.r and pMem->u.i fields +** accordingly. +*/ +static u16 SQLITE_NOINLINE computeNumericType(Mem *pMem){ + int rc; + sqlite3_int64 ix; + assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 ); + assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ); + ExpandBlob(pMem); + rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc); + if( rc<=0 ){ + if( rc==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){ + pMem->u.i = ix; + return MEM_Int; + }else{ + return MEM_Real; + } + }else if( rc==1 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)==0 ){ + pMem->u.i = ix; + return MEM_Int; + } + return MEM_Real; +} + +/* +** Return the numeric type for pMem, either MEM_Int or MEM_Real or both or +** none. +** +** Unlike applyNumericAffinity(), this routine does not modify pMem->flags. +** But it does set pMem->u.r and pMem->u.i appropriately. +*/ +static u16 numericType(Mem *pMem){ + if( pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal) ){ + testcase( pMem->flags & MEM_Int ); + testcase( pMem->flags & MEM_Real ); + testcase( pMem->flags & MEM_IntReal ); + return pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal); + } + if( pMem->flags & (MEM_Str|MEM_Blob) ){ + testcase( pMem->flags & MEM_Str ); + testcase( pMem->flags & MEM_Blob ); + return computeNumericType(pMem); + } + return 0; +} + +#ifdef SQLITE_DEBUG +/* +** Write a nice string representation of the contents of cell pMem +** into buffer zBuf, length nBuf. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, StrAccum *pStr){ + int f = pMem->flags; + static const char *const encnames[] = {"(X)", "(8)", "(16LE)", "(16BE)"}; + if( f&MEM_Blob ){ + int i; + char c; + if( f & MEM_Dyn ){ + c = 'z'; + assert( (f & (MEM_Static|MEM_Ephem))==0 ); + }else if( f & MEM_Static ){ + c = 't'; + assert( (f & (MEM_Dyn|MEM_Ephem))==0 ); + }else if( f & MEM_Ephem ){ + c = 'e'; + assert( (f & (MEM_Static|MEM_Dyn))==0 ); + }else{ + c = 's'; + } + sqlite3_str_appendf(pStr, "%cx[", c); + for(i=0; i<25 && in; i++){ + sqlite3_str_appendf(pStr, "%02X", ((int)pMem->z[i] & 0xFF)); + } + sqlite3_str_appendf(pStr, "|"); + for(i=0; i<25 && in; i++){ + char z = pMem->z[i]; + sqlite3_str_appendchar(pStr, 1, (z<32||z>126)?'.':z); + } + sqlite3_str_appendf(pStr,"]"); + if( f & MEM_Zero ){ + sqlite3_str_appendf(pStr, "+%dz",pMem->u.nZero); + } + }else if( f & MEM_Str ){ + int j; + u8 c; + if( f & MEM_Dyn ){ + c = 'z'; + assert( (f & (MEM_Static|MEM_Ephem))==0 ); + }else if( f & MEM_Static ){ + c = 't'; + assert( (f & (MEM_Dyn|MEM_Ephem))==0 ); + }else if( f & MEM_Ephem ){ + c = 'e'; + assert( (f & (MEM_Static|MEM_Dyn))==0 ); + }else{ + c = 's'; + } + sqlite3_str_appendf(pStr, " %c%d[", c, pMem->n); + for(j=0; j<25 && jn; j++){ + c = pMem->z[j]; + sqlite3_str_appendchar(pStr, 1, (c>=0x20&&c<=0x7f) ? c : '.'); + } + sqlite3_str_appendf(pStr, "]%s", encnames[pMem->enc]); + } +} +#endif + +#ifdef SQLITE_DEBUG +/* +** Print the value of a register for tracing purposes: +*/ +static void memTracePrint(Mem *p){ + if( p->flags & MEM_Undefined ){ + printf(" undefined"); + }else if( p->flags & MEM_Null ){ + printf(p->flags & MEM_Zero ? " NULL-nochng" : " NULL"); + }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){ + printf(" si:%lld", p->u.i); + }else if( (p->flags & (MEM_IntReal))!=0 ){ + printf(" ir:%lld", p->u.i); + }else if( p->flags & MEM_Int ){ + printf(" i:%lld", p->u.i); +#ifndef SQLITE_OMIT_FLOATING_POINT + }else if( p->flags & MEM_Real ){ + printf(" r:%.17g", p->u.r); +#endif + }else if( sqlite3VdbeMemIsRowSet(p) ){ + printf(" (rowset)"); + }else{ + StrAccum acc; + char zBuf[1000]; + sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); + sqlite3VdbeMemPrettyPrint(p, &acc); + printf(" %s", sqlite3StrAccumFinish(&acc)); + } + if( p->flags & MEM_Subtype ) printf(" subtype=0x%02x", p->eSubtype); +} +static void registerTrace(int iReg, Mem *p){ + printf("R[%d] = ", iReg); + memTracePrint(p); + if( p->pScopyFrom ){ + printf(" <== R[%d]", (int)(p->pScopyFrom - &p[-iReg])); + } + printf("\n"); + sqlite3VdbeCheckMemInvariants(p); +} +#endif + +#ifdef SQLITE_DEBUG +/* +** Show the values of all registers in the virtual machine. Used for +** interactive debugging. +*/ +SQLITE_PRIVATE void sqlite3VdbeRegisterDump(Vdbe *v){ + int i; + for(i=1; inMem; i++) registerTrace(i, v->aMem+i); +} +#endif /* SQLITE_DEBUG */ + + +#ifdef SQLITE_DEBUG +# define REGISTER_TRACE(R,M) if(db->flags&SQLITE_VdbeTrace)registerTrace(R,M) +#else +# define REGISTER_TRACE(R,M) +#endif + + +#ifdef VDBE_PROFILE + +/* +** hwtime.h contains inline assembler code for implementing +** high-performance timing routines. +*/ +/************** Include hwtime.h in the middle of vdbe.c *********************/ +/************** Begin file hwtime.h ******************************************/ +/* +** 2008 May 27 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains inline asm code for retrieving "high-performance" +** counters for x86 and x86_64 class CPUs. +*/ +#ifndef SQLITE_HWTIME_H +#define SQLITE_HWTIME_H + +/* +** The following routine only works on pentium-class (or newer) processors. +** It uses the RDTSC opcode to read the cycle count value out of the +** processor and returns that value. This can be used for high-res +** profiling. +*/ +#if !defined(__STRICT_ANSI__) && \ + (defined(__GNUC__) || defined(_MSC_VER)) && \ + (defined(i386) || defined(__i386__) || defined(_M_IX86)) + + #if defined(__GNUC__) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned int lo, hi; + __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); + return (sqlite_uint64)hi << 32 | lo; + } + + #elif defined(_MSC_VER) + + __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){ + __asm { + rdtsc + ret ; return value at EDX:EAX + } + } + + #endif + +#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long val; + __asm__ __volatile__ ("rdtsc" : "=A" (val)); + return val; + } + +#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long long retval; + unsigned long junk; + __asm__ __volatile__ ("\n\ + 1: mftbu %1\n\ + mftb %L0\n\ + mftbu %0\n\ + cmpw %0,%1\n\ + bne 1b" + : "=r" (retval), "=r" (junk)); + return retval; + } + +#else + + /* + ** asm() is needed for hardware timing support. Without asm(), + ** disable the sqlite3Hwtime() routine. + ** + ** sqlite3Hwtime() is only used for some obscure debugging + ** and analysis configurations, not in any deliverable, so this + ** should not be a great loss. + */ +SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); } + +#endif + +#endif /* !defined(SQLITE_HWTIME_H) */ + +/************** End of hwtime.h **********************************************/ +/************** Continuing where we left off in vdbe.c ***********************/ + +#endif + +#ifndef NDEBUG +/* +** This function is only called from within an assert() expression. It +** checks that the sqlite3.nTransaction variable is correctly set to +** the number of non-transaction savepoints currently in the +** linked list starting at sqlite3.pSavepoint. +** +** Usage: +** +** assert( checkSavepointCount(db) ); +*/ +static int checkSavepointCount(sqlite3 *db){ + int n = 0; + Savepoint *p; + for(p=db->pSavepoint; p; p=p->pNext) n++; + assert( n==(db->nSavepoint + db->isTransactionSavepoint) ); + return 1; +} +#endif + +/* +** Return the register of pOp->p2 after first preparing it to be +** overwritten with an integer value. +*/ +static SQLITE_NOINLINE Mem *out2PrereleaseWithClear(Mem *pOut){ + sqlite3VdbeMemSetNull(pOut); + pOut->flags = MEM_Int; + return pOut; +} +static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){ + Mem *pOut; + assert( pOp->p2>0 ); + assert( pOp->p2<=(p->nMem+1 - p->nCursor) ); + pOut = &p->aMem[pOp->p2]; + memAboutToChange(p, pOut); + if( VdbeMemDynamic(pOut) ){ /*OPTIMIZATION-IF-FALSE*/ + return out2PrereleaseWithClear(pOut); + }else{ + pOut->flags = MEM_Int; + return pOut; + } +} + + +/* +** Execute as much of a VDBE program as we can. +** This is the core of sqlite3_step(). +*/ +SQLITE_PRIVATE int sqlite3VdbeExec( + Vdbe *p /* The VDBE */ +){ + 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 + int nExtraDelete = 0; /* Verifies FORDELETE and AUXDELETE flags */ +#endif + int rc = SQLITE_OK; /* Value to return */ + sqlite3 *db = p->db; /* The database */ + u8 resetSchemaOnFault = 0; /* Reset schema after an error if positive */ + u8 encoding = ENC(db); /* The database encoding */ + int iCompare = 0; /* Result of last comparison */ + u64 nVmStep = 0; /* Number of virtual machine steps */ +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + u64 nProgressLimit; /* Invoke xProgress() when nVmStep reaches this */ +#endif + Mem *aMem = p->aMem; /* Copy of p->aMem */ + Mem *pIn1 = 0; /* 1st input operand */ + 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 */ +#endif + /*** INSERT STACK UNION HERE ***/ + + assert( p->magic==VDBE_MAGIC_RUN ); /* sqlite3_step() verifies this */ + sqlite3VdbeEnter(p); +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + if( db->xProgress ){ + u32 iPrior = p->aCounter[SQLITE_STMTSTATUS_VM_STEP]; + assert( 0 < db->nProgressOps ); + nProgressLimit = db->nProgressOps - (iPrior % db->nProgressOps); + }else{ + nProgressLimit = LARGEST_UINT64; + } +#endif + if( p->rc==SQLITE_NOMEM ){ + /* This happens if a malloc() inside a call to sqlite3_column_text() or + ** sqlite3_column_text16() failed. */ + goto no_mem; + } + assert( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_BUSY ); + testcase( p->rc!=SQLITE_OK ); + p->rc = SQLITE_OK; + assert( p->bIsReader || p->readOnly!=0 ); + p->iCurrentTime = 0; + assert( p->explain==0 ); + p->pResultSet = 0; + db->busyHandler.nBusy = 0; + if( AtomicLoad(&db->u1.isInterrupted) ) goto abort_due_to_interrupt; + sqlite3VdbeIOTraceSql(p); +#ifdef SQLITE_DEBUG + sqlite3BeginBenignMalloc(); + if( p->pc==0 + && (p->db->flags & (SQLITE_VdbeListing|SQLITE_VdbeEQP|SQLITE_VdbeTrace))!=0 + ){ + int i; + int once = 1; + sqlite3VdbePrintSql(p); + if( p->db->flags & SQLITE_VdbeListing ){ + printf("VDBE Program Listing:\n"); + for(i=0; inOp; i++){ + sqlite3VdbePrintOp(stdout, i, &aOp[i]); + } + } + if( p->db->flags & SQLITE_VdbeEQP ){ + for(i=0; inOp; i++){ + if( aOp[i].opcode==OP_Explain ){ + if( once ) printf("VDBE Query Plan:\n"); + printf("%s\n", aOp[i].p4.z); + once = 0; + } + } + } + if( p->db->flags & SQLITE_VdbeTrace ) printf("VDBE Trace:\n"); + } + sqlite3EndBenignMalloc(); +#endif + for(pOp=&aOp[p->pc]; 1; pOp++){ + /* Errors are detected by individual opcodes, with an immediate + ** jumps to abort_due_to_error. */ + 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)]++; +#endif + + /* Only allow tracing if SQLITE_DEBUG is defined. + */ +#ifdef SQLITE_DEBUG + if( db->flags & SQLITE_VdbeTrace ){ + sqlite3VdbePrintOp(stdout, (int)(pOp - aOp), pOp); + test_trace_breakpoint((int)(pOp - aOp),pOp,p); + } +#endif + + + /* Check to see if we need to simulate an interrupt. This only happens + ** if we have a special test build. + */ +#ifdef SQLITE_TEST + if( sqlite3_interrupt_count>0 ){ + sqlite3_interrupt_count--; + if( sqlite3_interrupt_count==0 ){ + sqlite3_interrupt(db); + } + } +#endif + + /* Sanity checking on other operands */ +#ifdef SQLITE_DEBUG + { + u8 opProperty = sqlite3OpcodeProperty[pOp->opcode]; + if( (opProperty & OPFLG_IN1)!=0 ){ + assert( pOp->p1>0 ); + assert( pOp->p1<=(p->nMem+1 - p->nCursor) ); + assert( memIsValid(&aMem[pOp->p1]) ); + assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) ); + REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]); + } + if( (opProperty & OPFLG_IN2)!=0 ){ + assert( pOp->p2>0 ); + assert( pOp->p2<=(p->nMem+1 - p->nCursor) ); + assert( memIsValid(&aMem[pOp->p2]) ); + assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) ); + REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]); + } + if( (opProperty & OPFLG_IN3)!=0 ){ + assert( pOp->p3>0 ); + assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); + assert( memIsValid(&aMem[pOp->p3]) ); + assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) ); + REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]); + } + if( (opProperty & OPFLG_OUT2)!=0 ){ + assert( pOp->p2>0 ); + assert( pOp->p2<=(p->nMem+1 - p->nCursor) ); + memAboutToChange(p, &aMem[pOp->p2]); + } + if( (opProperty & OPFLG_OUT3)!=0 ){ + assert( pOp->p3>0 ); + assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); + memAboutToChange(p, &aMem[pOp->p3]); + } + } +#endif +#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) + pOrigOp = pOp; +#endif + + switch( pOp->opcode ){ + +/***************************************************************************** +** What follows is a massive switch statement where each case implements a +** separate instruction in the virtual machine. If we follow the usual +** indentation conventions, each case should be indented by 6 spaces. But +** that is a lot of wasted space on the left margin. So the code within +** the switch statement will break with convention and be flush-left. Another +** big comment (similar to this one) will mark the point in the code where +** we transition back to normal indentation. +** +** The formatting of each case is important. The makefile for SQLite +** generates two C files "opcodes.h" and "opcodes.c" by scanning this +** file looking for lines that begin with "case OP_". The opcodes.h files +** will be filled with #defines that give unique integer values to each +** opcode and the opcodes.c file is filled with an array of strings where +** each string is the symbolic name for the corresponding opcode. If the +** case statement is followed by a comment of the form "/# same as ... #/" +** that comment is used to determine the particular value of the opcode. +** +** Other keywords in the comment that follows each case are used to +** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[]. +** Keywords include: in1, in2, in3, out2, out3. See +** the mkopcodeh.awk script for additional information. +** +** Documentation about VDBE opcodes is generated by scanning this file +** for lines of that contain "Opcode:". That line and all subsequent +** comment lines are used in the generation of the opcode.html documentation +** file. +** +** SUMMARY: +** +** Formatting is important to scripts that scan this file. +** Do not deviate from the formatting style currently in use. +** +*****************************************************************************/ + +/* Opcode: Goto * P2 * * * +** +** An unconditional jump to address P2. +** The next instruction executed will be +** the one at index P2 from the beginning of +** the program. +** +** The P1 parameter is not actually used by this opcode. However, it +** is sometimes set to 1 instead of 0 as a hint to the command-line shell +** that this Goto is the bottom of a loop and that the lines from P2 down +** to the current line should be indented for EXPLAIN output. +*/ +case OP_Goto: { /* jump */ + +#ifdef SQLITE_DEBUG + /* In debuggging mode, when the p5 flags is set on an OP_Goto, that + ** means we should really jump back to the preceeding OP_ReleaseReg + ** instruction. */ + if( pOp->p5 ){ + assert( pOp->p2 < (int)(pOp - aOp) ); + assert( pOp->p2 > 1 ); + pOp = &aOp[pOp->p2 - 2]; + assert( pOp[1].opcode==OP_ReleaseReg ); + goto check_for_interrupt; + } +#endif + +jump_to_p2_and_check_for_interrupt: + pOp = &aOp[pOp->p2 - 1]; + + /* Opcodes that are used as the bottom of a loop (OP_Next, OP_Prev, + ** OP_VNext, or OP_SorterNext) all jump here upon + ** completion. Check to see if sqlite3_interrupt() has been called + ** or if the progress callback needs to be invoked. + ** + ** This code uses unstructured "goto" statements and does not look clean. + ** But that is not due to sloppy coding habits. The code is written this + ** way for performance, to avoid having to run the interrupt and progress + ** checks on every opcode. This helps sqlite3_step() to run about 1.5% + ** faster according to "valgrind --tool=cachegrind" */ +check_for_interrupt: + if( AtomicLoad(&db->u1.isInterrupted) ) goto abort_due_to_interrupt; +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + /* Call the progress callback if it is configured and the required number + ** of VDBE ops have been executed (either since this invocation of + ** sqlite3VdbeExec() or since last time the progress callback was called). + ** If the progress callback returns non-zero, exit the virtual machine with + ** a return code SQLITE_ABORT. + */ + while( nVmStep>=nProgressLimit && db->xProgress!=0 ){ + assert( db->nProgressOps!=0 ); + nProgressLimit += db->nProgressOps; + if( db->xProgress(db->pProgressArg) ){ + nProgressLimit = LARGEST_UINT64; + rc = SQLITE_INTERRUPT; + goto abort_due_to_error; + } + } +#endif + + break; +} + +/* Opcode: Gosub P1 P2 * * * +** +** Write the current address onto register P1 +** and then jump to address P2. +*/ +case OP_Gosub: { /* jump */ + assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); + pIn1 = &aMem[pOp->p1]; + assert( VdbeMemDynamic(pIn1)==0 ); + memAboutToChange(p, pIn1); + pIn1->flags = MEM_Int; + pIn1->u.i = (int)(pOp-aOp); + REGISTER_TRACE(pOp->p1, pIn1); + + /* Most jump operations do a goto to this spot in order to update + ** the pOp pointer. */ +jump_to_p2: + pOp = &aOp[pOp->p2 - 1]; + break; +} + +/* Opcode: Return P1 * * * * +** +** Jump to the next instruction after the address in register P1. After +** the jump, register P1 becomes undefined. +*/ +case OP_Return: { /* in1 */ + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags==MEM_Int ); + pOp = &aOp[pIn1->u.i]; + pIn1->flags = MEM_Undefined; + break; +} + +/* Opcode: InitCoroutine P1 P2 P3 * * +** +** Set up register P1 so that it will Yield to the coroutine +** located at address P3. +** +** If P2!=0 then the coroutine implementation immediately follows +** this opcode. So jump over the coroutine implementation to +** address P2. +** +** See also: EndCoroutine +*/ +case OP_InitCoroutine: { /* jump */ + assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); + assert( pOp->p2>=0 && pOp->p2nOp ); + assert( pOp->p3>=0 && pOp->p3nOp ); + pOut = &aMem[pOp->p1]; + assert( !VdbeMemDynamic(pOut) ); + pOut->u.i = pOp->p3 - 1; + pOut->flags = MEM_Int; + if( pOp->p2 ) goto jump_to_p2; + break; +} + +/* Opcode: EndCoroutine P1 * * * * +** +** The instruction at the address in register P1 is a Yield. +** Jump to the P2 parameter of that Yield. +** After the jump, register P1 becomes undefined. +** +** See also: InitCoroutine +*/ +case OP_EndCoroutine: { /* in1 */ + VdbeOp *pCaller; + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags==MEM_Int ); + assert( pIn1->u.i>=0 && pIn1->u.inOp ); + pCaller = &aOp[pIn1->u.i]; + assert( pCaller->opcode==OP_Yield ); + assert( pCaller->p2>=0 && pCaller->p2nOp ); + pOp = &aOp[pCaller->p2 - 1]; + pIn1->flags = MEM_Undefined; + break; +} + +/* Opcode: Yield P1 P2 * * * +** +** Swap the program counter with the value in register P1. This +** has the effect of yielding to a coroutine. +** +** If the coroutine that is launched by this instruction ends with +** Yield or Return then continue to the next instruction. But if +** the coroutine launched by this instruction ends with +** EndCoroutine, then jump to P2 rather than continuing with the +** next instruction. +** +** See also: InitCoroutine +*/ +case OP_Yield: { /* in1, jump */ + int pcDest; + pIn1 = &aMem[pOp->p1]; + assert( VdbeMemDynamic(pIn1)==0 ); + pIn1->flags = MEM_Int; + pcDest = (int)pIn1->u.i; + pIn1->u.i = (int)(pOp - aOp); + REGISTER_TRACE(pOp->p1, pIn1); + pOp = &aOp[pcDest]; + break; +} + +/* Opcode: HaltIfNull P1 P2 P3 P4 P5 +** Synopsis: if r[P3]=null halt +** +** Check the value in register P3. If it is NULL then Halt using +** parameter P1, P2, and P4 as if this were a Halt instruction. If the +** value in register P3 is not NULL, then this routine is a no-op. +** The P5 parameter should be 1. +*/ +case OP_HaltIfNull: { /* in3 */ + pIn3 = &aMem[pOp->p3]; +#ifdef SQLITE_DEBUG + if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); } +#endif + if( (pIn3->flags & MEM_Null)==0 ) break; + /* Fall through into OP_Halt */ + /* no break */ deliberate_fall_through +} + +/* Opcode: Halt P1 P2 * P4 P5 +** +** Exit immediately. All open cursors, etc are closed +** automatically. +** +** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(), +** or sqlite3_finalize(). For a normal halt, this should be SQLITE_OK (0). +** For errors, it can be some other value. If P1!=0 then P2 will determine +** whether or not to rollback the current transaction. Do not rollback +** if P2==OE_Fail. Do the rollback if P2==OE_Rollback. If P2==OE_Abort, +** then back out all changes that have occurred during this execution of the +** VDBE, but do not rollback the transaction. +** +** If P4 is not null then it is an error message string. +** +** P5 is a value between 0 and 4, inclusive, that modifies the P4 string. +** +** 0: (no change) +** 1: NOT NULL contraint failed: P4 +** 2: UNIQUE constraint failed: P4 +** 3: CHECK constraint failed: P4 +** 4: FOREIGN KEY constraint failed: P4 +** +** If P5 is not zero and P4 is NULL, then everything after the ":" is +** omitted. +** +** There is an implied "Halt 0 0 0" instruction inserted at the very end of +** every program. So a jump past the last instruction of the program +** is the same as executing Halt. +*/ +case OP_Halt: { + VdbeFrame *pFrame; + int pcx; + + pcx = (int)(pOp - aOp); +#ifdef SQLITE_DEBUG + if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); } +#endif + if( pOp->p1==SQLITE_OK && p->pFrame ){ + /* Halt the sub-program. Return control to the parent frame. */ + pFrame = p->pFrame; + p->pFrame = pFrame->pParent; + p->nFrame--; + sqlite3VdbeSetChanges(db, p->nChange); + pcx = sqlite3VdbeFrameRestore(pFrame); + if( pOp->p2==OE_Ignore ){ + /* Instruction pcx is the OP_Program that invoked the sub-program + ** currently being halted. If the p2 instruction of this OP_Halt + ** instruction is set to OE_Ignore, then the sub-program is throwing + ** an IGNORE exception. In this case jump to the address specified + ** as the p2 of the calling OP_Program. */ + pcx = p->aOp[pcx].p2-1; + } + aOp = p->aOp; + aMem = p->aMem; + pOp = &aOp[pcx]; + break; + } + p->rc = pOp->p1; + p->errorAction = (u8)pOp->p2; + p->pc = pcx; + assert( pOp->p5<=4 ); + if( p->rc ){ + if( pOp->p5 ){ + static const char * const azType[] = { "NOT NULL", "UNIQUE", "CHECK", + "FOREIGN KEY" }; + testcase( pOp->p5==1 ); + testcase( pOp->p5==2 ); + testcase( pOp->p5==3 ); + testcase( pOp->p5==4 ); + sqlite3VdbeError(p, "%s constraint failed", azType[pOp->p5-1]); + if( pOp->p4.z ){ + p->zErrMsg = sqlite3MPrintf(db, "%z: %s", p->zErrMsg, pOp->p4.z); + } + }else{ + sqlite3VdbeError(p, "%s", pOp->p4.z); + } + sqlite3_log(pOp->p1, "abort at %d in [%s]: %s", pcx, p->zSql, p->zErrMsg); + } + rc = sqlite3VdbeHalt(p); + assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR ); + if( rc==SQLITE_BUSY ){ + p->rc = SQLITE_BUSY; + }else{ + assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ); + assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 ); + rc = p->rc ? SQLITE_ERROR : SQLITE_DONE; + } + goto vdbe_return; +} + +/* Opcode: Integer P1 P2 * * * +** Synopsis: r[P2]=P1 +** +** The 32-bit integer value P1 is written into register P2. +*/ +case OP_Integer: { /* out2 */ + pOut = out2Prerelease(p, pOp); + pOut->u.i = pOp->p1; + break; +} + +/* Opcode: Int64 * P2 * P4 * +** Synopsis: r[P2]=P4 +** +** P4 is a pointer to a 64-bit integer value. +** Write that value into register P2. +*/ +case OP_Int64: { /* out2 */ + pOut = out2Prerelease(p, pOp); + assert( pOp->p4.pI64!=0 ); + pOut->u.i = *pOp->p4.pI64; + break; +} + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* Opcode: Real * P2 * P4 * +** Synopsis: r[P2]=P4 +** +** P4 is a pointer to a 64-bit floating point value. +** Write that value into register P2. +*/ +case OP_Real: { /* same as TK_FLOAT, out2 */ + pOut = out2Prerelease(p, pOp); + pOut->flags = MEM_Real; + assert( !sqlite3IsNaN(*pOp->p4.pReal) ); + pOut->u.r = *pOp->p4.pReal; + break; +} +#endif + +/* Opcode: String8 * P2 * P4 * +** Synopsis: r[P2]='P4' +** +** P4 points to a nul terminated UTF-8 string. This opcode is transformed +** into a String opcode before it is executed for the first time. During +** this transformation, the length of string P4 is computed and stored +** as the P1 parameter. +*/ +case OP_String8: { /* same as TK_STRING, out2 */ + assert( pOp->p4.z!=0 ); + pOut = out2Prerelease(p, pOp); + pOp->p1 = sqlite3Strlen30(pOp->p4.z); + +#ifndef SQLITE_OMIT_UTF16 + if( encoding!=SQLITE_UTF8 ){ + rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC); + assert( rc==SQLITE_OK || rc==SQLITE_TOOBIG ); + if( rc ) goto too_big; + if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem; + assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z ); + assert( VdbeMemDynamic(pOut)==0 ); + pOut->szMalloc = 0; + pOut->flags |= MEM_Static; + if( pOp->p4type==P4_DYNAMIC ){ + sqlite3DbFree(db, pOp->p4.z); + } + pOp->p4type = P4_DYNAMIC; + pOp->p4.z = pOut->z; + pOp->p1 = pOut->n; + } +#endif + if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){ + goto too_big; + } + pOp->opcode = OP_String; + assert( rc==SQLITE_OK ); + /* Fall through to the next case, OP_String */ + /* no break */ deliberate_fall_through +} + +/* Opcode: String P1 P2 P3 P4 P5 +** Synopsis: r[P2]='P4' (len=P1) +** +** The string value P4 of length P1 (bytes) is stored in register P2. +** +** If P3 is not zero and the content of register P3 is equal to P5, then +** the datatype of the register P2 is converted to BLOB. The content is +** the same sequence of bytes, it is merely interpreted as a BLOB instead +** of a string, as if it had been CAST. In other words: +** +** if( P3!=0 and reg[P3]==P5 ) reg[P2] := CAST(reg[P2] as BLOB) +*/ +case OP_String: { /* out2 */ + assert( pOp->p4.z!=0 ); + pOut = out2Prerelease(p, pOp); + pOut->flags = MEM_Str|MEM_Static|MEM_Term; + pOut->z = pOp->p4.z; + pOut->n = pOp->p1; + pOut->enc = encoding; + UPDATE_MAX_BLOBSIZE(pOut); +#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS + if( pOp->p3>0 ){ + assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); + pIn3 = &aMem[pOp->p3]; + assert( pIn3->flags & MEM_Int ); + if( pIn3->u.i==pOp->p5 ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term; + } +#endif + break; +} + +/* Opcode: Null P1 P2 P3 * * +** Synopsis: r[P2..P3]=NULL +** +** Write a NULL into registers P2. If P3 greater than P2, then also write +** NULL into register P3 and every register in between P2 and P3. If P3 +** is less than P2 (typically P3 is zero) then only register P2 is +** set to NULL. +** +** If the P1 value is non-zero, then also set the MEM_Cleared flag so that +** NULL values will not compare equal even if SQLITE_NULLEQ is set on +** OP_Ne or OP_Eq. +*/ +case OP_Null: { /* out2 */ + int cnt; + u16 nullFlag; + pOut = out2Prerelease(p, pOp); + cnt = pOp->p3-pOp->p2; + assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); + pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null; + pOut->n = 0; +#ifdef SQLITE_DEBUG + pOut->uTemp = 0; +#endif + while( cnt>0 ){ + pOut++; + memAboutToChange(p, pOut); + sqlite3VdbeMemSetNull(pOut); + pOut->flags = nullFlag; + pOut->n = 0; + cnt--; + } + break; +} + +/* Opcode: SoftNull P1 * * * * +** Synopsis: r[P1]=NULL +** +** Set register P1 to have the value NULL as seen by the OP_MakeRecord +** instruction, but do not free any string or blob memory associated with +** the register, so that if the value was a string or blob that was +** previously copied using OP_SCopy, the copies will continue to be valid. +*/ +case OP_SoftNull: { + assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); + pOut = &aMem[pOp->p1]; + pOut->flags = (pOut->flags&~(MEM_Undefined|MEM_AffMask))|MEM_Null; + break; +} + +/* Opcode: Blob P1 P2 * P4 * +** Synopsis: r[P2]=P4 (len=P1) +** +** P4 points to a blob of data P1 bytes long. Store this +** blob in register P2. +*/ +case OP_Blob: { /* out2 */ + assert( pOp->p1 <= SQLITE_MAX_LENGTH ); + pOut = out2Prerelease(p, pOp); + sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0); + pOut->enc = encoding; + UPDATE_MAX_BLOBSIZE(pOut); + break; +} + +/* Opcode: Variable P1 P2 * P4 * +** Synopsis: r[P2]=parameter(P1,P4) +** +** Transfer the values of bound parameter P1 into register P2 +** +** If the parameter is named, then its name appears in P4. +** The P4 value is used by sqlite3_bind_parameter_name(). +*/ +case OP_Variable: { /* out2 */ + Mem *pVar; /* Value being transferred */ + + assert( pOp->p1>0 && pOp->p1<=p->nVar ); + assert( pOp->p4.z==0 || pOp->p4.z==sqlite3VListNumToName(p->pVList,pOp->p1) ); + pVar = &p->aVar[pOp->p1 - 1]; + if( sqlite3VdbeMemTooBig(pVar) ){ + goto too_big; + } + pOut = &aMem[pOp->p2]; + if( VdbeMemDynamic(pOut) ) sqlite3VdbeMemSetNull(pOut); + memcpy(pOut, pVar, MEMCELLSIZE); + pOut->flags &= ~(MEM_Dyn|MEM_Ephem); + pOut->flags |= MEM_Static|MEM_FromBind; + UPDATE_MAX_BLOBSIZE(pOut); + break; +} + +/* Opcode: Move P1 P2 P3 * * +** Synopsis: r[P2@P3]=r[P1@P3] +** +** Move the P3 values in register P1..P1+P3-1 over into +** registers P2..P2+P3-1. Registers P1..P1+P3-1 are +** left holding a NULL. It is an error for register ranges +** P1..P1+P3-1 and P2..P2+P3-1 to overlap. It is an error +** for P3 to be less than 1. +*/ +case OP_Move: { + int n; /* Number of registers left to copy */ + int p1; /* Register to copy from */ + int p2; /* Register to copy to */ + + n = pOp->p3; + p1 = pOp->p1; + p2 = pOp->p2; + assert( n>0 && p1>0 && p2>0 ); + assert( p1+n<=p2 || p2+n<=p1 ); + + pIn1 = &aMem[p1]; + pOut = &aMem[p2]; + do{ + assert( pOut<=&aMem[(p->nMem+1 - p->nCursor)] ); + assert( pIn1<=&aMem[(p->nMem+1 - p->nCursor)] ); + assert( memIsValid(pIn1) ); + memAboutToChange(p, pOut); + sqlite3VdbeMemMove(pOut, pIn1); +#ifdef SQLITE_DEBUG + pIn1->pScopyFrom = 0; + { int i; + for(i=1; inMem; i++){ + if( aMem[i].pScopyFrom==pIn1 ){ + aMem[i].pScopyFrom = pOut; + } + } + } +#endif + Deephemeralize(pOut); + REGISTER_TRACE(p2++, pOut); + pIn1++; + pOut++; + }while( --n ); + break; +} + +/* Opcode: Copy P1 P2 P3 * * +** Synopsis: r[P2@P3+1]=r[P1@P3+1] +** +** Make a copy of registers P1..P1+P3 into registers P2..P2+P3. +** +** This instruction makes a deep copy of the value. A duplicate +** is made of any string or blob constant. See also OP_SCopy. +*/ +case OP_Copy: { + int n; + + n = pOp->p3; + pIn1 = &aMem[pOp->p1]; + pOut = &aMem[pOp->p2]; + assert( pOut!=pIn1 ); + while( 1 ){ + memAboutToChange(p, pOut); + sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem); + Deephemeralize(pOut); +#ifdef SQLITE_DEBUG + pOut->pScopyFrom = 0; +#endif + REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut); + if( (n--)==0 ) break; + pOut++; + pIn1++; + } + break; +} + +/* Opcode: SCopy P1 P2 * * * +** Synopsis: r[P2]=r[P1] +** +** Make a shallow copy of register P1 into register P2. +** +** This instruction makes a shallow copy of the value. If the value +** is a string or blob, then the copy is only a pointer to the +** original and hence if the original changes so will the copy. +** Worse, if the original is deallocated, the copy becomes invalid. +** Thus the program must guarantee that the original will not change +** during the lifetime of the copy. Use OP_Copy to make a complete +** copy. +*/ +case OP_SCopy: { /* out2 */ + pIn1 = &aMem[pOp->p1]; + pOut = &aMem[pOp->p2]; + assert( pOut!=pIn1 ); + sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem); +#ifdef SQLITE_DEBUG + pOut->pScopyFrom = pIn1; + pOut->mScopyFlags = pIn1->flags; +#endif + break; +} + +/* Opcode: IntCopy P1 P2 * * * +** Synopsis: r[P2]=r[P1] +** +** Transfer the integer value held in register P1 into register P2. +** +** This is an optimized version of SCopy that works only for integer +** values. +*/ +case OP_IntCopy: { /* out2 */ + pIn1 = &aMem[pOp->p1]; + assert( (pIn1->flags & MEM_Int)!=0 ); + pOut = &aMem[pOp->p2]; + sqlite3VdbeMemSetInt64(pOut, pIn1->u.i); + break; +} + +/* Opcode: ResultRow P1 P2 * * * +** Synopsis: output=r[P1@P2] +** +** The registers P1 through P1+P2-1 contain a single row of +** results. This opcode causes the sqlite3_step() call to terminate +** with an SQLITE_ROW return code and it sets up the sqlite3_stmt +** structure to provide access to the r(P1)..r(P1+P2-1) values as +** the result row. +*/ +case OP_ResultRow: { + Mem *pMem; + int i; + assert( p->nResColumn==pOp->p2 ); + assert( pOp->p1>0 ); + assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 ); + + /* If this statement has violated immediate foreign key constraints, do + ** not return the number of rows modified. And do not RELEASE the statement + ** transaction. It needs to be rolled back. */ + if( SQLITE_OK!=(rc = sqlite3VdbeCheckFk(p, 0)) ){ + assert( db->flags&SQLITE_CountRows ); + assert( p->usesStmtJournal ); + goto abort_due_to_error; + } + + /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then + ** DML statements invoke this opcode to return the number of rows + ** modified to the user. This is the only way that a VM that + ** opens a statement transaction may invoke this opcode. + ** + ** In case this is such a statement, close any statement transaction + ** opened by this VM before returning control to the user. This is to + ** ensure that statement-transactions are always nested, not overlapping. + ** If the open statement-transaction is not closed here, then the user + ** may step another VM that opens its own statement transaction. This + ** may lead to overlapping statement transactions. + ** + ** The statement transaction is never a top-level transaction. Hence + ** the RELEASE call below can never fail. + */ + assert( p->iStatement==0 || db->flags&SQLITE_CountRows ); + rc = sqlite3VdbeCloseStatement(p, SAVEPOINT_RELEASE); + assert( rc==SQLITE_OK ); + + /* Invalidate all ephemeral cursor row caches */ + p->cacheCtr = (p->cacheCtr + 2)|1; + + /* Make sure the results of the current row are \000 terminated + ** and have an assigned type. The results are de-ephemeralized as + ** a side effect. + */ + pMem = p->pResultSet = &aMem[pOp->p1]; + for(i=0; ip2; i++){ + assert( memIsValid(&pMem[i]) ); + Deephemeralize(&pMem[i]); + assert( (pMem[i].flags & MEM_Ephem)==0 + || (pMem[i].flags & (MEM_Str|MEM_Blob))==0 ); + sqlite3VdbeMemNulTerminate(&pMem[i]); + REGISTER_TRACE(pOp->p1+i, &pMem[i]); +#ifdef SQLITE_DEBUG + /* The registers in the result will not be used again when the + ** prepared statement restarts. This is because sqlite3_column() + ** APIs might have caused type conversions of made other changes to + ** the register values. Therefore, we can go ahead and break any + ** OP_SCopy dependencies. */ + pMem[i].pScopyFrom = 0; +#endif + } + if( db->mallocFailed ) goto no_mem; + + if( db->mTrace & SQLITE_TRACE_ROW ){ + db->trace.xV2(SQLITE_TRACE_ROW, db->pTraceArg, p, 0); + } + + + /* Return SQLITE_ROW + */ + p->pc = (int)(pOp - aOp) + 1; + rc = SQLITE_ROW; + goto vdbe_return; +} + +/* Opcode: Concat P1 P2 P3 * * +** Synopsis: r[P3]=r[P2]+r[P1] +** +** Add the text in register P1 onto the end of the text in +** register P2 and store the result in register P3. +** If either the P1 or P2 text are NULL then store NULL in P3. +** +** P3 = P2 || P1 +** +** It is illegal for P1 and P3 to be the same register. Sometimes, +** if P3 is the same register as P2, the implementation is able +** to avoid a memcpy(). +*/ +case OP_Concat: { /* same as TK_CONCAT, in1, in2, out3 */ + i64 nByte; /* Total size of the output string or blob */ + u16 flags1; /* Initial flags for P1 */ + u16 flags2; /* Initial flags for P2 */ + + pIn1 = &aMem[pOp->p1]; + pIn2 = &aMem[pOp->p2]; + pOut = &aMem[pOp->p3]; + testcase( pOut==pIn2 ); + assert( pIn1!=pOut ); + flags1 = pIn1->flags; + testcase( flags1 & MEM_Null ); + testcase( pIn2->flags & MEM_Null ); + if( (flags1 | pIn2->flags) & MEM_Null ){ + sqlite3VdbeMemSetNull(pOut); + break; + } + if( (flags1 & (MEM_Str|MEM_Blob))==0 ){ + if( sqlite3VdbeMemStringify(pIn1,encoding,0) ) goto no_mem; + flags1 = pIn1->flags & ~MEM_Str; + }else if( (flags1 & MEM_Zero)!=0 ){ + if( sqlite3VdbeMemExpandBlob(pIn1) ) goto no_mem; + flags1 = pIn1->flags & ~MEM_Str; + } + flags2 = pIn2->flags; + if( (flags2 & (MEM_Str|MEM_Blob))==0 ){ + if( sqlite3VdbeMemStringify(pIn2,encoding,0) ) goto no_mem; + flags2 = pIn2->flags & ~MEM_Str; + }else if( (flags2 & MEM_Zero)!=0 ){ + if( sqlite3VdbeMemExpandBlob(pIn2) ) goto no_mem; + flags2 = pIn2->flags & ~MEM_Str; + } + nByte = pIn1->n + pIn2->n; + if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){ + goto too_big; + } + if( sqlite3VdbeMemGrow(pOut, (int)nByte+3, pOut==pIn2) ){ + goto no_mem; + } + MemSetTypeFlag(pOut, MEM_Str); + if( pOut!=pIn2 ){ + memcpy(pOut->z, pIn2->z, pIn2->n); + assert( (pIn2->flags & MEM_Dyn) == (flags2 & MEM_Dyn) ); + pIn2->flags = flags2; + } + memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n); + assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) ); + pIn1->flags = flags1; + pOut->z[nByte]=0; + pOut->z[nByte+1] = 0; + pOut->z[nByte+2] = 0; + pOut->flags |= MEM_Term; + pOut->n = (int)nByte; + pOut->enc = encoding; + UPDATE_MAX_BLOBSIZE(pOut); + break; +} + +/* Opcode: Add P1 P2 P3 * * +** Synopsis: r[P3]=r[P1]+r[P2] +** +** Add the value in register P1 to the value in register P2 +** and store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +/* Opcode: Multiply P1 P2 P3 * * +** Synopsis: r[P3]=r[P1]*r[P2] +** +** +** Multiply the value in register P1 by the value in register P2 +** and store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +/* Opcode: Subtract P1 P2 P3 * * +** Synopsis: r[P3]=r[P2]-r[P1] +** +** Subtract the value in register P1 from the value in register P2 +** and store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +/* Opcode: Divide P1 P2 P3 * * +** Synopsis: r[P3]=r[P2]/r[P1] +** +** Divide the value in register P1 by the value in register P2 +** and store the result in register P3 (P3=P2/P1). If the value in +** register P1 is zero, then the result is NULL. If either input is +** NULL, the result is NULL. +*/ +/* Opcode: Remainder P1 P2 P3 * * +** Synopsis: r[P3]=r[P2]%r[P1] +** +** Compute the remainder after integer register P2 is divided by +** register P1 and store the result in register P3. +** If the value in register P1 is zero the result is NULL. +** If either operand is NULL, the result is NULL. +*/ +case OP_Add: /* same as TK_PLUS, in1, in2, out3 */ +case OP_Subtract: /* same as TK_MINUS, in1, in2, out3 */ +case OP_Multiply: /* same as TK_STAR, in1, in2, out3 */ +case OP_Divide: /* same as TK_SLASH, in1, in2, out3 */ +case OP_Remainder: { /* same as TK_REM, in1, in2, out3 */ + u16 flags; /* Combined MEM_* flags from both inputs */ + u16 type1; /* Numeric type of left operand */ + u16 type2; /* Numeric type of right operand */ + i64 iA; /* Integer value of left operand */ + i64 iB; /* Integer value of right operand */ + double rA; /* Real value of left operand */ + double rB; /* Real value of right operand */ + + pIn1 = &aMem[pOp->p1]; + type1 = numericType(pIn1); + pIn2 = &aMem[pOp->p2]; + type2 = numericType(pIn2); + pOut = &aMem[pOp->p3]; + flags = pIn1->flags | pIn2->flags; + if( (type1 & type2 & MEM_Int)!=0 ){ + iA = pIn1->u.i; + iB = pIn2->u.i; + switch( pOp->opcode ){ + case OP_Add: if( sqlite3AddInt64(&iB,iA) ) goto fp_math; break; + case OP_Subtract: if( sqlite3SubInt64(&iB,iA) ) goto fp_math; break; + case OP_Multiply: if( sqlite3MulInt64(&iB,iA) ) goto fp_math; break; + case OP_Divide: { + if( iA==0 ) goto arithmetic_result_is_null; + if( iA==-1 && iB==SMALLEST_INT64 ) goto fp_math; + iB /= iA; + break; + } + default: { + if( iA==0 ) goto arithmetic_result_is_null; + if( iA==-1 ) iA = 1; + iB %= iA; + break; + } + } + pOut->u.i = iB; + MemSetTypeFlag(pOut, MEM_Int); + }else if( (flags & MEM_Null)!=0 ){ + goto arithmetic_result_is_null; + }else{ +fp_math: + rA = sqlite3VdbeRealValue(pIn1); + rB = sqlite3VdbeRealValue(pIn2); + switch( pOp->opcode ){ + case OP_Add: rB += rA; break; + case OP_Subtract: rB -= rA; break; + case OP_Multiply: rB *= rA; break; + case OP_Divide: { + /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ + if( rA==(double)0 ) goto arithmetic_result_is_null; + rB /= rA; + break; + } + default: { + iA = sqlite3VdbeIntValue(pIn1); + iB = sqlite3VdbeIntValue(pIn2); + if( iA==0 ) goto arithmetic_result_is_null; + if( iA==-1 ) iA = 1; + rB = (double)(iB % iA); + break; + } + } +#ifdef SQLITE_OMIT_FLOATING_POINT + pOut->u.i = rB; + MemSetTypeFlag(pOut, MEM_Int); +#else + if( sqlite3IsNaN(rB) ){ + goto arithmetic_result_is_null; + } + pOut->u.r = rB; + MemSetTypeFlag(pOut, MEM_Real); +#endif + } + break; + +arithmetic_result_is_null: + sqlite3VdbeMemSetNull(pOut); + break; +} + +/* Opcode: CollSeq P1 * * P4 +** +** P4 is a pointer to a CollSeq object. If the next call to a user function +** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will +** be returned. This is used by the built-in min(), max() and nullif() +** functions. +** +** If P1 is not zero, then it is a register that a subsequent min() or +** max() aggregate will set to 1 if the current row is not the minimum or +** maximum. The P1 register is initialized to 0 by this instruction. +** +** The interface used by the implementation of the aforementioned functions +** to retrieve the collation sequence set by this opcode is not available +** publicly. Only built-in functions have access to this feature. +*/ +case OP_CollSeq: { + assert( pOp->p4type==P4_COLLSEQ ); + if( pOp->p1 ){ + sqlite3VdbeMemSetInt64(&aMem[pOp->p1], 0); + } + break; +} + +/* Opcode: BitAnd P1 P2 P3 * * +** Synopsis: r[P3]=r[P1]&r[P2] +** +** Take the bit-wise AND of the values in register P1 and P2 and +** store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +/* Opcode: BitOr P1 P2 P3 * * +** Synopsis: r[P3]=r[P1]|r[P2] +** +** Take the bit-wise OR of the values in register P1 and P2 and +** store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +/* Opcode: ShiftLeft P1 P2 P3 * * +** Synopsis: r[P3]=r[P2]<>r[P1] +** +** Shift the integer value in register P2 to the right by the +** number of bits specified by the integer in register P1. +** Store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +case OP_BitAnd: /* same as TK_BITAND, in1, in2, out3 */ +case OP_BitOr: /* same as TK_BITOR, in1, in2, out3 */ +case OP_ShiftLeft: /* same as TK_LSHIFT, in1, in2, out3 */ +case OP_ShiftRight: { /* same as TK_RSHIFT, in1, in2, out3 */ + i64 iA; + u64 uA; + i64 iB; + u8 op; + + pIn1 = &aMem[pOp->p1]; + pIn2 = &aMem[pOp->p2]; + pOut = &aMem[pOp->p3]; + if( (pIn1->flags | pIn2->flags) & MEM_Null ){ + sqlite3VdbeMemSetNull(pOut); + break; + } + iA = sqlite3VdbeIntValue(pIn2); + iB = sqlite3VdbeIntValue(pIn1); + op = pOp->opcode; + if( op==OP_BitAnd ){ + iA &= iB; + }else if( op==OP_BitOr ){ + iA |= iB; + }else if( iB!=0 ){ + assert( op==OP_ShiftRight || op==OP_ShiftLeft ); + + /* If shifting by a negative amount, shift in the other direction */ + if( iB<0 ){ + assert( OP_ShiftRight==OP_ShiftLeft+1 ); + op = 2*OP_ShiftLeft + 1 - op; + iB = iB>(-64) ? -iB : 64; + } + + if( iB>=64 ){ + iA = (iA>=0 || op==OP_ShiftLeft) ? 0 : -1; + }else{ + memcpy(&uA, &iA, sizeof(uA)); + if( op==OP_ShiftLeft ){ + uA <<= iB; + }else{ + uA >>= iB; + /* Sign-extend on a right shift of a negative number */ + if( iA<0 ) uA |= ((((u64)0xffffffff)<<32)|0xffffffff) << (64-iB); + } + memcpy(&iA, &uA, sizeof(iA)); + } + } + pOut->u.i = iA; + MemSetTypeFlag(pOut, MEM_Int); + break; +} + +/* Opcode: AddImm P1 P2 * * * +** Synopsis: r[P1]=r[P1]+P2 +** +** Add the constant P2 to the value in register P1. +** The result is always an integer. +** +** To force any register to be an integer, just add 0. +*/ +case OP_AddImm: { /* in1 */ + pIn1 = &aMem[pOp->p1]; + memAboutToChange(p, pIn1); + sqlite3VdbeMemIntegerify(pIn1); + pIn1->u.i += pOp->p2; + break; +} + +/* Opcode: MustBeInt P1 P2 * * * +** +** Force the value in register P1 to be an integer. If the value +** in P1 is not an integer and cannot be converted into an integer +** without data loss, then jump immediately to P2, or if P2==0 +** raise an SQLITE_MISMATCH exception. +*/ +case OP_MustBeInt: { /* jump, in1 */ + pIn1 = &aMem[pOp->p1]; + if( (pIn1->flags & MEM_Int)==0 ){ + applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding); + if( (pIn1->flags & MEM_Int)==0 ){ + VdbeBranchTaken(1, 2); + if( pOp->p2==0 ){ + rc = SQLITE_MISMATCH; + goto abort_due_to_error; + }else{ + goto jump_to_p2; + } + } + } + VdbeBranchTaken(0, 2); + MemSetTypeFlag(pIn1, MEM_Int); + break; +} + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* Opcode: RealAffinity P1 * * * * +** +** If register P1 holds an integer convert it to a real value. +** +** This opcode is used when extracting information from a column that +** has REAL affinity. Such column values may still be stored as +** integers, for space efficiency, but after extraction we want them +** to have only a real value. +*/ +case OP_RealAffinity: { /* in1 */ + pIn1 = &aMem[pOp->p1]; + if( pIn1->flags & (MEM_Int|MEM_IntReal) ){ + testcase( pIn1->flags & MEM_Int ); + testcase( pIn1->flags & MEM_IntReal ); + sqlite3VdbeMemRealify(pIn1); + REGISTER_TRACE(pOp->p1, pIn1); + } + break; +} +#endif + +#ifndef SQLITE_OMIT_CAST +/* Opcode: Cast P1 P2 * * * +** Synopsis: affinity(r[P1]) +** +** Force the value in register P1 to be the type defined by P2. +** +**
      +**
    • P2=='A' → BLOB +**
    • P2=='B' → TEXT +**
    • P2=='C' → NUMERIC +**
    • P2=='D' → INTEGER +**
    • P2=='E' → REAL +**
    +** +** A NULL value is not changed by this routine. It remains NULL. +*/ +case OP_Cast: { /* in1 */ + assert( pOp->p2>=SQLITE_AFF_BLOB && pOp->p2<=SQLITE_AFF_REAL ); + testcase( pOp->p2==SQLITE_AFF_TEXT ); + testcase( pOp->p2==SQLITE_AFF_BLOB ); + testcase( pOp->p2==SQLITE_AFF_NUMERIC ); + testcase( pOp->p2==SQLITE_AFF_INTEGER ); + testcase( pOp->p2==SQLITE_AFF_REAL ); + pIn1 = &aMem[pOp->p1]; + memAboutToChange(p, pIn1); + rc = ExpandBlob(pIn1); + if( rc ) goto abort_due_to_error; + rc = sqlite3VdbeMemCast(pIn1, pOp->p2, encoding); + if( rc ) goto abort_due_to_error; + UPDATE_MAX_BLOBSIZE(pIn1); + REGISTER_TRACE(pOp->p1, pIn1); + break; +} +#endif /* SQLITE_OMIT_CAST */ + +/* Opcode: Eq P1 P2 P3 P4 P5 +** Synopsis: IF r[P3]==r[P1] +** +** Compare the values in register P1 and P3. If reg(P3)==reg(P1) then +** jump to address P2. Or if the SQLITE_STOREP2 flag is set in P5, then +** store the result of comparison in register P2. +** +** The SQLITE_AFF_MASK portion of P5 must be an affinity character - +** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made +** to coerce both inputs according to this affinity before the +** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric +** affinity is used. Note that the affinity conversions are stored +** back into the input registers P1 and P3. So this opcode can cause +** persistent changes to registers P1 and P3. +** +** Once any conversions have taken place, and neither value is NULL, +** the values are compared. If both values are blobs then memcmp() is +** used to determine the results of the comparison. If both values +** are text, then the appropriate collating function specified in +** P4 is used to do the comparison. If P4 is not specified then +** memcmp() is used to compare text string. If both values are +** numeric, then a numeric comparison is used. If the two values +** are of different types, then numbers are considered less than +** strings and strings are considered less than blobs. +** +** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either +** true or false and is never NULL. If both operands are NULL then the result +** of comparison is true. If either operand is NULL then the result is false. +** If neither operand is NULL the result is the same as it would be if +** the SQLITE_NULLEQ flag were omitted from P5. +** +** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the +** content of r[P2] is only changed if the new value is NULL or 0 (false). +** In other words, a prior r[P2] value will not be overwritten by 1 (true). +*/ +/* Opcode: Ne P1 P2 P3 P4 P5 +** Synopsis: IF r[P3]!=r[P1] +** +** This works just like the Eq opcode except that the jump is taken if +** the operands in registers P1 and P3 are not equal. See the Eq opcode for +** additional information. +** +** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the +** content of r[P2] is only changed if the new value is NULL or 1 (true). +** In other words, a prior r[P2] value will not be overwritten by 0 (false). +*/ +/* Opcode: Lt P1 P2 P3 P4 P5 +** Synopsis: IF r[P3]r[P1] +** +** This works just like the Lt opcode except that the jump is taken if +** the content of register P3 is greater than the content of +** register P1. See the Lt opcode for additional information. +*/ +/* Opcode: Ge P1 P2 P3 P4 P5 +** Synopsis: IF r[P3]>=r[P1] +** +** This works just like the Lt opcode except that the jump is taken if +** the content of register P3 is greater than or equal to the content of +** register P1. See the Lt opcode for additional information. +*/ +case OP_Eq: /* same as TK_EQ, jump, in1, in3 */ +case OP_Ne: /* same as TK_NE, jump, in1, in3 */ +case OP_Lt: /* same as TK_LT, jump, in1, in3 */ +case OP_Le: /* same as TK_LE, jump, in1, in3 */ +case OP_Gt: /* same as TK_GT, jump, in1, in3 */ +case OP_Ge: { /* same as TK_GE, jump, in1, in3 */ + int res, res2; /* Result of the comparison of pIn1 against pIn3 */ + char affinity; /* Affinity to use for comparison */ + u16 flags1; /* Copy of initial value of pIn1->flags */ + u16 flags3; /* Copy of initial value of pIn3->flags */ + + pIn1 = &aMem[pOp->p1]; + pIn3 = &aMem[pOp->p3]; + flags1 = pIn1->flags; + flags3 = pIn3->flags; + if( (flags1 | flags3)&MEM_Null ){ + /* One or both operands are NULL */ + if( pOp->p5 & SQLITE_NULLEQ ){ + /* If SQLITE_NULLEQ is set (which will only happen if the operator is + ** OP_Eq or OP_Ne) then take the jump or not depending on whether + ** or not both operands are null. + */ + assert( (flags1 & MEM_Cleared)==0 ); + assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 || CORRUPT_DB ); + testcase( (pOp->p5 & SQLITE_JUMPIFNULL)!=0 ); + if( (flags1&flags3&MEM_Null)!=0 + && (flags3&MEM_Cleared)==0 + ){ + res = 0; /* Operands are equal */ + }else{ + res = ((flags3 & MEM_Null) ? -1 : +1); /* Operands are not equal */ + } + }else{ + /* SQLITE_NULLEQ is clear and at least one operand is NULL, + ** then the result is always NULL. + ** The jump is taken if the SQLITE_JUMPIFNULL bit is set. + */ + if( pOp->p5 & SQLITE_STOREP2 ){ + pOut = &aMem[pOp->p2]; + iCompare = 1; /* Operands are not equal */ + memAboutToChange(p, pOut); + MemSetTypeFlag(pOut, MEM_Null); + REGISTER_TRACE(pOp->p2, pOut); + }else{ + VdbeBranchTaken(2,3); + if( pOp->p5 & SQLITE_JUMPIFNULL ){ + goto jump_to_p2; + } + } + break; + } + }else{ + /* Neither operand is NULL. Do a comparison. */ + affinity = pOp->p5 & SQLITE_AFF_MASK; + if( affinity>=SQLITE_AFF_NUMERIC ){ + if( (flags1 | flags3)&MEM_Str ){ + if( (flags1 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){ + applyNumericAffinity(pIn1,0); + testcase( flags3==pIn3->flags ); + flags3 = pIn3->flags; + } + if( (flags3 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){ + applyNumericAffinity(pIn3,0); + } + } + /* Handle the common case of integer comparison here, as an + ** optimization, to avoid a call to sqlite3MemCompare() */ + if( (pIn1->flags & pIn3->flags & MEM_Int)!=0 ){ + if( pIn3->u.i > pIn1->u.i ){ res = +1; goto compare_op; } + if( pIn3->u.i < pIn1->u.i ){ res = -1; goto compare_op; } + res = 0; + goto compare_op; + } + }else if( affinity==SQLITE_AFF_TEXT ){ + if( (flags1 & MEM_Str)==0 && (flags1&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){ + testcase( pIn1->flags & MEM_Int ); + testcase( pIn1->flags & MEM_Real ); + testcase( pIn1->flags & MEM_IntReal ); + sqlite3VdbeMemStringify(pIn1, encoding, 1); + testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) ); + flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask); + if( NEVER(pIn1==pIn3) ) flags3 = flags1 | MEM_Str; + } + if( (flags3 & MEM_Str)==0 && (flags3&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){ + testcase( pIn3->flags & MEM_Int ); + testcase( pIn3->flags & MEM_Real ); + testcase( pIn3->flags & MEM_IntReal ); + sqlite3VdbeMemStringify(pIn3, encoding, 1); + testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) ); + flags3 = (pIn3->flags & ~MEM_TypeMask) | (flags3 & MEM_TypeMask); + } + } + assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 ); + res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl); + } +compare_op: + /* At this point, res is negative, zero, or positive if reg[P1] is + ** less than, equal to, or greater than reg[P3], respectively. Compute + ** the answer to this operator in res2, depending on what the comparison + ** operator actually is. The next block of code depends on the fact + ** that the 6 comparison operators are consecutive integers in this + ** order: NE, EQ, GT, LE, LT, GE */ + assert( OP_Eq==OP_Ne+1 ); assert( OP_Gt==OP_Ne+2 ); assert( OP_Le==OP_Ne+3 ); + assert( OP_Lt==OP_Ne+4 ); assert( OP_Ge==OP_Ne+5 ); + if( res<0 ){ /* ne, eq, gt, le, lt, ge */ + static const unsigned char aLTb[] = { 1, 0, 0, 1, 1, 0 }; + res2 = aLTb[pOp->opcode - OP_Ne]; + }else if( res==0 ){ + static const unsigned char aEQb[] = { 0, 1, 0, 1, 0, 1 }; + res2 = aEQb[pOp->opcode - OP_Ne]; + }else{ + static const unsigned char aGTb[] = { 1, 0, 1, 0, 0, 1 }; + res2 = aGTb[pOp->opcode - OP_Ne]; + } + + /* Undo any changes made by applyAffinity() to the input registers. */ + assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) ); + pIn3->flags = flags3; + assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) ); + pIn1->flags = flags1; + + if( pOp->p5 & SQLITE_STOREP2 ){ + pOut = &aMem[pOp->p2]; + iCompare = res; + if( (pOp->p5 & SQLITE_KEEPNULL)!=0 ){ + /* The KEEPNULL flag prevents OP_Eq from overwriting a NULL with 1 + ** and prevents OP_Ne from overwriting NULL with 0. This flag + ** is only used in contexts where either: + ** (1) op==OP_Eq && (r[P2]==NULL || r[P2]==0) + ** (2) op==OP_Ne && (r[P2]==NULL || r[P2]==1) + ** Therefore it is not necessary to check the content of r[P2] for + ** NULL. */ + assert( pOp->opcode==OP_Ne || pOp->opcode==OP_Eq ); + assert( res2==0 || res2==1 ); + testcase( res2==0 && pOp->opcode==OP_Eq ); + testcase( res2==1 && pOp->opcode==OP_Eq ); + testcase( res2==0 && pOp->opcode==OP_Ne ); + testcase( res2==1 && pOp->opcode==OP_Ne ); + if( (pOp->opcode==OP_Eq)==res2 ) break; + } + memAboutToChange(p, pOut); + MemSetTypeFlag(pOut, MEM_Int); + pOut->u.i = res2; + REGISTER_TRACE(pOp->p2, pOut); + }else{ + VdbeBranchTaken(res2!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3); + if( res2 ){ + goto jump_to_p2; + } + } + break; +} + +/* Opcode: ElseNotEq * P2 * * * +** +** This opcode must follow an OP_Lt or OP_Gt comparison operator. There +** can be zero or more OP_ReleaseReg opcodes intervening, but no other +** opcodes are allowed to occur between this instruction and the previous +** OP_Lt or OP_Gt. Furthermore, the prior OP_Lt or OP_Gt must have the +** SQLITE_STOREP2 bit set in the P5 field. +** +** If result of an OP_Eq comparison on the same two operands as the +** prior OP_Lt or OP_Gt would have been NULL or false (0), then then +** jump to P2. If the result of an OP_Eq comparison on the two previous +** operands would have been true (1), then fall through. +*/ +case OP_ElseNotEq: { /* same as TK_ESCAPE, jump */ + +#ifdef SQLITE_DEBUG + /* Verify the preconditions of this opcode - that it follows an OP_Lt or + ** OP_Gt with the SQLITE_STOREP2 flag set, with zero or more intervening + ** OP_ReleaseReg opcodes */ + int iAddr; + for(iAddr = (int)(pOp - aOp) - 1; ALWAYS(iAddr>=0); iAddr--){ + if( aOp[iAddr].opcode==OP_ReleaseReg ) continue; + assert( aOp[iAddr].opcode==OP_Lt || aOp[iAddr].opcode==OP_Gt ); + assert( aOp[iAddr].p5 & SQLITE_STOREP2 ); + break; + } +#endif /* SQLITE_DEBUG */ + VdbeBranchTaken(iCompare!=0, 2); + if( iCompare!=0 ) goto jump_to_p2; + break; +} + + +/* Opcode: Permutation * * * P4 * +** +** Set the permutation used by the OP_Compare operator in the next +** instruction. The permutation is stored in the P4 operand. +** +** The permutation is only valid until the next OP_Compare that has +** the OPFLAG_PERMUTE bit set in P5. Typically the OP_Permutation should +** occur immediately prior to the OP_Compare. +** +** The first integer in the P4 integer array is the length of the array +** and does not become part of the permutation. +*/ +case OP_Permutation: { + assert( pOp->p4type==P4_INTARRAY ); + assert( pOp->p4.ai ); + assert( pOp[1].opcode==OP_Compare ); + assert( pOp[1].p5 & OPFLAG_PERMUTE ); + break; +} + +/* Opcode: Compare P1 P2 P3 P4 P5 +** Synopsis: r[P1@P3] <-> r[P2@P3] +** +** Compare two vectors of registers in reg(P1)..reg(P1+P3-1) (call this +** vector "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of +** the comparison for use by the next OP_Jump instruct. +** +** If P5 has the OPFLAG_PERMUTE bit set, then the order of comparison is +** determined by the most recent OP_Permutation operator. If the +** OPFLAG_PERMUTE bit is clear, then register are compared in sequential +** order. +** +** P4 is a KeyInfo structure that defines collating sequences and sort +** orders for the comparison. The permutation applies to registers +** only. The KeyInfo elements are used sequentially. +** +** The comparison is a sort comparison, so NULLs compare equal, +** NULLs are less than numbers, numbers are less than strings, +** and strings are less than blobs. +*/ +case OP_Compare: { + int n; + int i; + int p1; + int p2; + const KeyInfo *pKeyInfo; + u32 idx; + CollSeq *pColl; /* Collating sequence to use on this term */ + int bRev; /* True for DESCENDING sort order */ + u32 *aPermute; /* The permutation */ + + if( (pOp->p5 & OPFLAG_PERMUTE)==0 ){ + aPermute = 0; + }else{ + assert( pOp>aOp ); + assert( pOp[-1].opcode==OP_Permutation ); + assert( pOp[-1].p4type==P4_INTARRAY ); + aPermute = pOp[-1].p4.ai + 1; + assert( aPermute!=0 ); + } + n = pOp->p3; + pKeyInfo = pOp->p4.pKeyInfo; + assert( n>0 ); + assert( pKeyInfo!=0 ); + p1 = pOp->p1; + p2 = pOp->p2; +#ifdef SQLITE_DEBUG + if( aPermute ){ + int k, mx = 0; + for(k=0; k(u32)mx ) mx = aPermute[k]; + assert( p1>0 && p1+mx<=(p->nMem+1 - p->nCursor)+1 ); + assert( p2>0 && p2+mx<=(p->nMem+1 - p->nCursor)+1 ); + }else{ + assert( p1>0 && p1+n<=(p->nMem+1 - p->nCursor)+1 ); + assert( p2>0 && p2+n<=(p->nMem+1 - p->nCursor)+1 ); + } +#endif /* SQLITE_DEBUG */ + for(i=0; inKeyField ); + pColl = pKeyInfo->aColl[i]; + bRev = (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC); + iCompare = sqlite3MemCompare(&aMem[p1+idx], &aMem[p2+idx], pColl); + if( iCompare ){ + if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) + && ((aMem[p1+idx].flags & MEM_Null) || (aMem[p2+idx].flags & MEM_Null)) + ){ + iCompare = -iCompare; + } + if( bRev ) iCompare = -iCompare; + break; + } + } + break; +} + +/* Opcode: Jump P1 P2 P3 * * +** +** Jump to the instruction at address P1, P2, or P3 depending on whether +** in the most recent OP_Compare instruction the P1 vector was less than +** equal to, or greater than the P2 vector, respectively. +*/ +case OP_Jump: { /* jump */ + if( iCompare<0 ){ + VdbeBranchTaken(0,4); pOp = &aOp[pOp->p1 - 1]; + }else if( iCompare==0 ){ + VdbeBranchTaken(1,4); pOp = &aOp[pOp->p2 - 1]; + }else{ + VdbeBranchTaken(2,4); pOp = &aOp[pOp->p3 - 1]; + } + break; +} + +/* Opcode: And P1 P2 P3 * * +** Synopsis: r[P3]=(r[P1] && r[P2]) +** +** Take the logical AND of the values in registers P1 and P2 and +** write the result into register P3. +** +** If either P1 or P2 is 0 (false) then the result is 0 even if +** the other input is NULL. A NULL and true or two NULLs give +** a NULL output. +*/ +/* Opcode: Or P1 P2 P3 * * +** Synopsis: r[P3]=(r[P1] || r[P2]) +** +** Take the logical OR of the values in register P1 and P2 and +** store the answer in register P3. +** +** If either P1 or P2 is nonzero (true) then the result is 1 (true) +** even if the other input is NULL. A NULL and false or two NULLs +** give a NULL output. +*/ +case OP_And: /* same as TK_AND, in1, in2, out3 */ +case OP_Or: { /* same as TK_OR, in1, in2, out3 */ + int v1; /* Left operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */ + int v2; /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */ + + v1 = sqlite3VdbeBooleanValue(&aMem[pOp->p1], 2); + v2 = sqlite3VdbeBooleanValue(&aMem[pOp->p2], 2); + if( pOp->opcode==OP_And ){ + static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 }; + v1 = and_logic[v1*3+v2]; + }else{ + static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 }; + v1 = or_logic[v1*3+v2]; + } + pOut = &aMem[pOp->p3]; + if( v1==2 ){ + MemSetTypeFlag(pOut, MEM_Null); + }else{ + pOut->u.i = v1; + MemSetTypeFlag(pOut, MEM_Int); + } + break; +} + +/* Opcode: IsTrue P1 P2 P3 P4 * +** Synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4 +** +** This opcode implements the IS TRUE, IS FALSE, IS NOT TRUE, and +** IS NOT FALSE operators. +** +** Interpret the value in register P1 as a boolean value. Store that +** boolean (a 0 or 1) in register P2. Or if the value in register P1 is +** NULL, then the P3 is stored in register P2. Invert the answer if P4 +** is 1. +** +** The logic is summarized like this: +** +**
      +**
    • If P3==0 and P4==0 then r[P2] := r[P1] IS TRUE +**
    • If P3==1 and P4==1 then r[P2] := r[P1] IS FALSE +**
    • If P3==0 and P4==1 then r[P2] := r[P1] IS NOT TRUE +**
    • If P3==1 and P4==0 then r[P2] := r[P1] IS NOT FALSE +**
    +*/ +case OP_IsTrue: { /* in1, out2 */ + assert( pOp->p4type==P4_INT32 ); + assert( pOp->p4.i==0 || pOp->p4.i==1 ); + assert( pOp->p3==0 || pOp->p3==1 ); + sqlite3VdbeMemSetInt64(&aMem[pOp->p2], + sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3) ^ pOp->p4.i); + break; +} + +/* Opcode: Not P1 P2 * * * +** Synopsis: r[P2]= !r[P1] +** +** Interpret the value in register P1 as a boolean value. Store the +** boolean complement in register P2. If the value in register P1 is +** NULL, then a NULL is stored in P2. +*/ +case OP_Not: { /* same as TK_NOT, in1, out2 */ + pIn1 = &aMem[pOp->p1]; + pOut = &aMem[pOp->p2]; + if( (pIn1->flags & MEM_Null)==0 ){ + sqlite3VdbeMemSetInt64(pOut, !sqlite3VdbeBooleanValue(pIn1,0)); + }else{ + sqlite3VdbeMemSetNull(pOut); + } + break; +} + +/* Opcode: BitNot P1 P2 * * * +** Synopsis: r[P2]= ~r[P1] +** +** Interpret the content of register P1 as an integer. Store the +** ones-complement of the P1 value into register P2. If P1 holds +** a NULL then store a NULL in P2. +*/ +case OP_BitNot: { /* same as TK_BITNOT, in1, out2 */ + pIn1 = &aMem[pOp->p1]; + pOut = &aMem[pOp->p2]; + sqlite3VdbeMemSetNull(pOut); + if( (pIn1->flags & MEM_Null)==0 ){ + pOut->flags = MEM_Int; + pOut->u.i = ~sqlite3VdbeIntValue(pIn1); + } + break; +} + +/* Opcode: Once P1 P2 * * * +** +** Fall through to the next instruction the first time this opcode is +** encountered on each invocation of the byte-code program. Jump to P2 +** on the second and all subsequent encounters during the same invocation. +** +** Top-level programs determine first invocation by comparing the P1 +** operand against the P1 operand on the OP_Init opcode at the beginning +** of the program. If the P1 values differ, then fall through and make +** the P1 of this opcode equal to the P1 of OP_Init. If P1 values are +** the same then take the jump. +** +** For subprograms, there is a bitmask in the VdbeFrame that determines +** whether or not the jump should be taken. The bitmask is necessary +** because the self-altering code trick does not work for recursive +** triggers. +*/ +case OP_Once: { /* jump */ + u32 iAddr; /* Address of this instruction */ + assert( p->aOp[0].opcode==OP_Init ); + if( p->pFrame ){ + iAddr = (int)(pOp - p->aOp); + if( (p->pFrame->aOnce[iAddr/8] & (1<<(iAddr & 7)))!=0 ){ + VdbeBranchTaken(1, 2); + goto jump_to_p2; + } + p->pFrame->aOnce[iAddr/8] |= 1<<(iAddr & 7); + }else{ + if( p->aOp[0].p1==pOp->p1 ){ + VdbeBranchTaken(1, 2); + goto jump_to_p2; + } + } + VdbeBranchTaken(0, 2); + pOp->p1 = p->aOp[0].p1; + break; +} + +/* Opcode: If P1 P2 P3 * * +** +** Jump to P2 if the value in register P1 is true. The value +** is considered true if it is numeric and non-zero. If the value +** in P1 is NULL then take the jump if and only if P3 is non-zero. +*/ +case OP_If: { /* jump, in1 */ + int c; + c = sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3); + VdbeBranchTaken(c!=0, 2); + if( c ) goto jump_to_p2; + break; +} + +/* Opcode: IfNot P1 P2 P3 * * +** +** Jump to P2 if the value in register P1 is False. The value +** is considered false if it has a numeric value of zero. If the value +** in P1 is NULL then take the jump if and only if P3 is non-zero. +*/ +case OP_IfNot: { /* jump, in1 */ + int c; + c = !sqlite3VdbeBooleanValue(&aMem[pOp->p1], !pOp->p3); + VdbeBranchTaken(c!=0, 2); + if( c ) goto jump_to_p2; + break; +} + +/* Opcode: IsNull P1 P2 * * * +** Synopsis: if r[P1]==NULL goto P2 +** +** Jump to P2 if the value in register P1 is NULL. +*/ +case OP_IsNull: { /* same as TK_ISNULL, jump, in1 */ + pIn1 = &aMem[pOp->p1]; + VdbeBranchTaken( (pIn1->flags & MEM_Null)!=0, 2); + if( (pIn1->flags & MEM_Null)!=0 ){ + goto jump_to_p2; + } + break; +} + +/* Opcode: NotNull P1 P2 * * * +** Synopsis: if r[P1]!=NULL goto P2 +** +** Jump to P2 if the value in register P1 is not NULL. +*/ +case OP_NotNull: { /* same as TK_NOTNULL, jump, in1 */ + pIn1 = &aMem[pOp->p1]; + VdbeBranchTaken( (pIn1->flags & MEM_Null)==0, 2); + if( (pIn1->flags & MEM_Null)==0 ){ + goto jump_to_p2; + } + break; +} + +/* Opcode: IfNullRow P1 P2 P3 * * +** Synopsis: if P1.nullRow then r[P3]=NULL, goto P2 +** +** Check the cursor P1 to see if it is currently pointing at a NULL row. +** If it is, then set register P3 to NULL and jump immediately to P2. +** If P1 is not on a NULL row, then fall through without making any +** changes. +*/ +case OP_IfNullRow: { /* jump */ + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( p->apCsr[pOp->p1]!=0 ); + if( p->apCsr[pOp->p1]->nullRow ){ + sqlite3VdbeMemSetNull(aMem + pOp->p3); + goto jump_to_p2; + } + break; +} + +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC +/* Opcode: Offset P1 P2 P3 * * +** Synopsis: r[P3] = sqlite_offset(P1) +** +** Store in register r[P3] the byte offset into the database file that is the +** start of the payload for the record at which that cursor P1 is currently +** pointing. +** +** P2 is the column number for the argument to the sqlite_offset() function. +** This opcode does not use P2 itself, but the P2 value is used by the +** code generator. The P1, P2, and P3 operands to this opcode are the +** same as for OP_Column. +** +** This opcode is only available if SQLite is compiled with the +** -DSQLITE_ENABLE_OFFSET_SQL_FUNC option. +*/ +case OP_Offset: { /* out3 */ + VdbeCursor *pC; /* The VDBE cursor */ + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + pOut = &p->aMem[pOp->p3]; + if( NEVER(pC==0) || pC->eCurType!=CURTYPE_BTREE ){ + sqlite3VdbeMemSetNull(pOut); + }else{ + sqlite3VdbeMemSetInt64(pOut, sqlite3BtreeOffset(pC->uc.pCursor)); + } + break; +} +#endif /* SQLITE_ENABLE_OFFSET_SQL_FUNC */ + +/* Opcode: Column P1 P2 P3 P4 P5 +** Synopsis: r[P3]=PX +** +** Interpret the data that cursor P1 points to as a structure built using +** the MakeRecord instruction. (See the MakeRecord opcode for additional +** information about the format of the data.) Extract the P2-th column +** from this record. If there are less that (P2+1) +** values in the record, extract a NULL. +** +** The value extracted is stored in register P3. +** +** If the record contains fewer than P2 fields, then extract a NULL. Or, +** if the P4 argument is a P4_MEM use the value of the P4 argument as +** the result. +** +** If the OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG bits are set on P5 then +** the result is guaranteed to only be used as the argument of a length() +** or typeof() function, respectively. The loading of large blobs can be +** skipped for length() and all content loading can be skipped for typeof(). +*/ +case OP_Column: { + u32 p2; /* column number to retrieve */ + VdbeCursor *pC; /* The VDBE cursor */ + BtCursor *pCrsr; /* The BTree cursor */ + u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */ + int len; /* The length of the serialized data for the column */ + int i; /* Loop counter */ + Mem *pDest; /* Where to write the extracted value */ + Mem sMem; /* For storing the record being decoded */ + const u8 *zData; /* Part of the record being decoded */ + const u8 *zHdr; /* Next unparsed byte of the header */ + const u8 *zEndHdr; /* Pointer to first byte after the header */ + u64 offset64; /* 64-bit offset */ + u32 t; /* A type code from the record header */ + Mem *pReg; /* PseudoTable input register */ + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + p2 = (u32)pOp->p2; + + /* If the cursor cache is stale (meaning it is not currently point at + ** the correct row) then bring it up-to-date by doing the necessary + ** B-Tree seek. */ + rc = sqlite3VdbeCursorMoveto(&pC, &p2); + if( rc ) goto abort_due_to_error; + + assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); + pDest = &aMem[pOp->p3]; + memAboutToChange(p, pDest); + assert( pC!=0 ); + assert( p2<(u32)pC->nField ); + aOffset = pC->aOffset; + assert( pC->eCurType!=CURTYPE_VTAB ); + assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow ); + assert( pC->eCurType!=CURTYPE_SORTER ); + + if( pC->cacheStatus!=p->cacheCtr ){ /*OPTIMIZATION-IF-FALSE*/ + if( pC->nullRow ){ + if( pC->eCurType==CURTYPE_PSEUDO ){ + /* For the special case of as pseudo-cursor, the seekResult field + ** identifies the register that holds the record */ + assert( pC->seekResult>0 ); + pReg = &aMem[pC->seekResult]; + assert( pReg->flags & MEM_Blob ); + assert( memIsValid(pReg) ); + pC->payloadSize = pC->szRow = pReg->n; + pC->aRow = (u8*)pReg->z; + }else{ + sqlite3VdbeMemSetNull(pDest); + goto op_column_out; + } + }else{ + pCrsr = pC->uc.pCursor; + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pCrsr ); + assert( sqlite3BtreeCursorIsValid(pCrsr) ); + pC->payloadSize = sqlite3BtreePayloadSize(pCrsr); + pC->aRow = sqlite3BtreePayloadFetch(pCrsr, &pC->szRow); + assert( pC->szRow<=pC->payloadSize ); + assert( pC->szRow<=65536 ); /* Maximum page size is 64KiB */ + if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){ + goto too_big; + } + } + pC->cacheStatus = p->cacheCtr; + pC->iHdrOffset = getVarint32(pC->aRow, aOffset[0]); + pC->nHdrParsed = 0; + + + if( pC->szRowaRow does not have to hold the entire row, but it does at least + ** need to cover the header of the record. If pC->aRow does not contain + ** the complete header, then set it to zero, forcing the header to be + ** dynamically allocated. */ + pC->aRow = 0; + pC->szRow = 0; + + /* Make sure a corrupt database has not given us an oversize header. + ** Do this now to avoid an oversize memory allocation. + ** + ** Type entries can be between 1 and 5 bytes each. But 4 and 5 byte + ** types use so much data space that there can only be 4096 and 32 of + ** them, respectively. So the maximum header length results from a + ** 3-byte type for each of the maximum of 32768 columns plus three + ** extra bytes for the header length itself. 32768*3 + 3 = 98307. + */ + if( aOffset[0] > 98307 || aOffset[0] > pC->payloadSize ){ + goto op_column_corrupt; + } + }else{ + /* This is an optimization. By skipping over the first few tests + ** (ex: pC->nHdrParsed<=p2) in the next section, we achieve a + ** measurable performance gain. + ** + ** This branch is taken even if aOffset[0]==0. Such a record is never + ** generated by SQLite, and could be considered corruption, but we + ** accept it for historical reasons. When aOffset[0]==0, the code this + ** branch jumps to reads past the end of the record, but never more + ** than a few bytes. Even if the record occurs at the end of the page + ** content area, the "page header" comes after the page content and so + ** this overread is harmless. Similar overreads can occur for a corrupt + ** database file. + */ + zData = pC->aRow; + assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */ + testcase( aOffset[0]==0 ); + goto op_column_read_header; + } + } + + /* Make sure at least the first p2+1 entries of the header have been + ** parsed and valid information is in aOffset[] and pC->aType[]. + */ + if( pC->nHdrParsed<=p2 ){ + /* If there is more header available for parsing in the record, try + ** to extract additional fields up through the p2+1-th field + */ + if( pC->iHdrOffsetaRow==0 ){ + memset(&sMem, 0, sizeof(sMem)); + rc = sqlite3VdbeMemFromBtreeZeroOffset(pC->uc.pCursor,aOffset[0],&sMem); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + zData = (u8*)sMem.z; + }else{ + zData = pC->aRow; + } + + /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */ + op_column_read_header: + i = pC->nHdrParsed; + offset64 = aOffset[i]; + zHdr = zData + pC->iHdrOffset; + zEndHdr = zData + aOffset[0]; + testcase( zHdr>=zEndHdr ); + do{ + if( (pC->aType[i] = t = zHdr[0])<0x80 ){ + zHdr++; + offset64 += sqlite3VdbeOneByteSerialTypeLen(t); + }else{ + zHdr += sqlite3GetVarint32(zHdr, &t); + pC->aType[i] = t; + offset64 += sqlite3VdbeSerialTypeLen(t); + } + aOffset[++i] = (u32)(offset64 & 0xffffffff); + }while( (u32)i<=p2 && zHdr=zEndHdr && (zHdr>zEndHdr || offset64!=pC->payloadSize)) + || (offset64 > pC->payloadSize) + ){ + if( aOffset[0]==0 ){ + i = 0; + zHdr = zEndHdr; + }else{ + if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem); + goto op_column_corrupt; + } + } + + pC->nHdrParsed = i; + pC->iHdrOffset = (u32)(zHdr - zData); + if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem); + }else{ + t = 0; + } + + /* If after trying to extract new entries from the header, nHdrParsed is + ** still not up to p2, that means that the record has fewer than p2 + ** columns. So the result will be either the default value or a NULL. + */ + if( pC->nHdrParsed<=p2 ){ + if( pOp->p4type==P4_MEM ){ + sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static); + }else{ + sqlite3VdbeMemSetNull(pDest); + } + goto op_column_out; + } + }else{ + t = pC->aType[p2]; + } + + /* Extract the content for the p2+1-th column. Control can only + ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are + ** all valid. + */ + assert( p2nHdrParsed ); + assert( rc==SQLITE_OK ); + assert( sqlite3VdbeCheckMemInvariants(pDest) ); + if( VdbeMemDynamic(pDest) ){ + sqlite3VdbeMemSetNull(pDest); + } + assert( t==pC->aType[p2] ); + if( pC->szRow>=aOffset[p2+1] ){ + /* This is the common case where the desired content fits on the original + ** page - where the content is not on an overflow page */ + zData = pC->aRow + aOffset[p2]; + if( t<12 ){ + sqlite3VdbeSerialGet(zData, t, pDest); + }else{ + /* If the column value is a string, we need a persistent value, not + ** a MEM_Ephem value. This branch is a fast short-cut that is equivalent + ** to calling sqlite3VdbeSerialGet() and sqlite3VdbeDeephemeralize(). + */ + static const u16 aFlag[] = { MEM_Blob, MEM_Str|MEM_Term }; + pDest->n = len = (t-12)/2; + pDest->enc = encoding; + if( pDest->szMalloc < len+2 ){ + pDest->flags = MEM_Null; + if( sqlite3VdbeMemGrow(pDest, len+2, 0) ) goto no_mem; + }else{ + pDest->z = pDest->zMalloc; + } + memcpy(pDest->z, zData, len); + pDest->z[len] = 0; + pDest->z[len+1] = 0; + pDest->flags = aFlag[t&1]; + } + }else{ + pDest->enc = encoding; + /* This branch happens only when content is on overflow pages */ + if( ((pOp->p5 & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG))!=0 + && ((t>=12 && (t&1)==0) || (pOp->p5 & OPFLAG_TYPEOFARG)!=0)) + || (len = sqlite3VdbeSerialTypeLen(t))==0 + ){ + /* Content is irrelevant for + ** 1. the typeof() function, + ** 2. the length(X) function if X is a blob, and + ** 3. if the content length is zero. + ** So we might as well use bogus content rather than reading + ** content from disk. + ** + ** Although sqlite3VdbeSerialGet() may read at most 8 bytes from the + ** buffer passed to it, debugging function VdbeMemPrettyPrint() may + ** read more. Use the global constant sqlite3CtypeMap[] as the array, + ** as that array is 256 bytes long (plenty for VdbeMemPrettyPrint()) + ** and it begins with a bunch of zeros. + */ + sqlite3VdbeSerialGet((u8*)sqlite3CtypeMap, t, pDest); + }else{ + rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, aOffset[p2], len, pDest); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + sqlite3VdbeSerialGet((const u8*)pDest->z, t, pDest); + pDest->flags &= ~MEM_Ephem; + } + } + +op_column_out: + UPDATE_MAX_BLOBSIZE(pDest); + REGISTER_TRACE(pOp->p3, pDest); + break; + +op_column_corrupt: + if( aOp[0].p3>0 ){ + pOp = &aOp[aOp[0].p3-1]; + break; + }else{ + rc = SQLITE_CORRUPT_BKPT; + goto abort_due_to_error; + } +} + +/* Opcode: Affinity P1 P2 * P4 * +** Synopsis: affinity(r[P1@P2]) +** +** Apply affinities to a range of P2 registers starting with P1. +** +** P4 is a string that is P2 characters long. The N-th character of the +** string indicates the column affinity that should be used for the N-th +** memory cell in the range. +*/ +case OP_Affinity: { + const char *zAffinity; /* The affinity to be applied */ + + zAffinity = pOp->p4.z; + assert( zAffinity!=0 ); + assert( pOp->p2>0 ); + assert( zAffinity[pOp->p2]==0 ); + pIn1 = &aMem[pOp->p1]; + while( 1 /*exit-by-break*/ ){ + assert( pIn1 <= &p->aMem[(p->nMem+1 - p->nCursor)] ); + assert( zAffinity[0]==SQLITE_AFF_NONE || memIsValid(pIn1) ); + applyAffinity(pIn1, zAffinity[0], encoding); + if( zAffinity[0]==SQLITE_AFF_REAL && (pIn1->flags & MEM_Int)!=0 ){ + /* When applying REAL affinity, if the result is still an MEM_Int + ** that will fit in 6 bytes, then change the type to MEM_IntReal + ** so that we keep the high-resolution integer value but know that + ** the type really wants to be REAL. */ + testcase( pIn1->u.i==140737488355328LL ); + testcase( pIn1->u.i==140737488355327LL ); + testcase( pIn1->u.i==-140737488355328LL ); + testcase( pIn1->u.i==-140737488355329LL ); + if( pIn1->u.i<=140737488355327LL && pIn1->u.i>=-140737488355328LL ){ + pIn1->flags |= MEM_IntReal; + pIn1->flags &= ~MEM_Int; + }else{ + pIn1->u.r = (double)pIn1->u.i; + pIn1->flags |= MEM_Real; + pIn1->flags &= ~MEM_Int; + } + } + REGISTER_TRACE((int)(pIn1-aMem), pIn1); + zAffinity++; + if( zAffinity[0]==0 ) break; + pIn1++; + } + break; +} + +/* Opcode: MakeRecord P1 P2 P3 P4 * +** Synopsis: r[P3]=mkrec(r[P1@P2]) +** +** Convert P2 registers beginning with P1 into the [record format] +** use as a data record in a database table or as a key +** in an index. The OP_Column opcode can decode the record later. +** +** P4 may be a string that is P2 characters long. The N-th character of the +** string indicates the column affinity that should be used for the N-th +** field of the index key. +** +** The mapping from character to affinity is given by the SQLITE_AFF_ +** macros defined in sqliteInt.h. +** +** If P4 is NULL then all index fields have the affinity BLOB. +** +** The meaning of P5 depends on whether or not the SQLITE_ENABLE_NULL_TRIM +** compile-time option is enabled: +** +** * If SQLITE_ENABLE_NULL_TRIM is enabled, then the P5 is the index +** of the right-most table that can be null-trimmed. +** +** * If SQLITE_ENABLE_NULL_TRIM is omitted, then P5 has the value +** OPFLAG_NOCHNG_MAGIC if the OP_MakeRecord opcode is allowed to +** accept no-change records with serial_type 10. This value is +** only used inside an assert() and does not affect the end result. +*/ +case OP_MakeRecord: { + Mem *pRec; /* The new record */ + u64 nData; /* Number of bytes of data space */ + int nHdr; /* Number of bytes of header space */ + i64 nByte; /* Data space required for this record */ + i64 nZero; /* Number of zero bytes at the end of the record */ + int nVarint; /* Number of bytes in a varint */ + u32 serial_type; /* Type field */ + Mem *pData0; /* First field to be combined into the record */ + Mem *pLast; /* Last field of the record */ + int nField; /* Number of fields in the record */ + char *zAffinity; /* The affinity string for the record */ + int file_format; /* File format to use for encoding */ + u32 len; /* Length of a field */ + u8 *zHdr; /* Where to write next byte of the header */ + u8 *zPayload; /* Where to write next byte of the payload */ + + /* Assuming the record contains N fields, the record format looks + ** like this: + ** + ** ------------------------------------------------------------------------ + ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 | + ** ------------------------------------------------------------------------ + ** + ** Data(0) is taken from register P1. Data(1) comes from register P1+1 + ** and so forth. + ** + ** Each type field is a varint representing the serial type of the + ** corresponding data element (see sqlite3VdbeSerialType()). The + ** hdr-size field is also a varint which is the offset from the beginning + ** of the record to data0. + */ + nData = 0; /* Number of bytes of data space */ + nHdr = 0; /* Number of bytes of header space */ + nZero = 0; /* Number of zero bytes at the end of the record */ + nField = pOp->p1; + zAffinity = pOp->p4.z; + assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem+1 - p->nCursor)+1 ); + pData0 = &aMem[nField]; + nField = pOp->p2; + pLast = &pData0[nField-1]; + file_format = p->minWriteFileFormat; + + /* Identify the output register */ + assert( pOp->p3p1 || pOp->p3>=pOp->p1+pOp->p2 ); + pOut = &aMem[pOp->p3]; + memAboutToChange(p, pOut); + + /* Apply the requested affinity to all inputs + */ + assert( pData0<=pLast ); + if( zAffinity ){ + pRec = pData0; + do{ + applyAffinity(pRec, zAffinity[0], encoding); + if( zAffinity[0]==SQLITE_AFF_REAL && (pRec->flags & MEM_Int) ){ + pRec->flags |= MEM_IntReal; + pRec->flags &= ~(MEM_Int); + } + REGISTER_TRACE((int)(pRec-aMem), pRec); + zAffinity++; + pRec++; + assert( zAffinity[0]==0 || pRec<=pLast ); + }while( zAffinity[0] ); + } + +#ifdef SQLITE_ENABLE_NULL_TRIM + /* NULLs can be safely trimmed from the end of the record, as long as + ** as the schema format is 2 or more and none of the omitted columns + ** have a non-NULL default value. Also, the record must be left with + ** at least one field. If P5>0 then it will be one more than the + ** index of the right-most column with a non-NULL default value */ + if( pOp->p5 ){ + while( (pLast->flags & MEM_Null)!=0 && nField>pOp->p5 ){ + pLast--; + nField--; + } + } +#endif + + /* Loop through the elements that will make up the record to figure + ** out how much space is required for the new record. After this loop, + ** the Mem.uTemp field of each term should hold the serial-type that will + ** be used for that term in the generated record: + ** + ** Mem.uTemp value type + ** --------------- --------------- + ** 0 NULL + ** 1 1-byte signed integer + ** 2 2-byte signed integer + ** 3 3-byte signed integer + ** 4 4-byte signed integer + ** 5 6-byte signed integer + ** 6 8-byte signed integer + ** 7 IEEE float + ** 8 Integer constant 0 + ** 9 Integer constant 1 + ** 10,11 reserved for expansion + ** N>=12 and even BLOB + ** N>=13 and odd text + ** + ** The following additional values are computed: + ** nHdr Number of bytes needed for the record header + ** nData Number of bytes of data space needed for the record + ** nZero Zero bytes at the end of the record + */ + pRec = pLast; + do{ + assert( memIsValid(pRec) ); + if( pRec->flags & MEM_Null ){ + if( pRec->flags & MEM_Zero ){ + /* Values with MEM_Null and MEM_Zero are created by xColumn virtual + ** table methods that never invoke sqlite3_result_xxxxx() while + ** computing an unchanging column value in an UPDATE statement. + ** Give such values a special internal-use-only serial-type of 10 + ** so that they can be passed through to xUpdate and have + ** a true sqlite3_value_nochange(). */ +#ifndef SQLITE_ENABLE_NULL_TRIM + assert( pOp->p5==OPFLAG_NOCHNG_MAGIC || CORRUPT_DB ); +#endif + pRec->uTemp = 10; + }else{ + pRec->uTemp = 0; + } + nHdr++; + }else if( pRec->flags & (MEM_Int|MEM_IntReal) ){ + /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */ + i64 i = pRec->u.i; + u64 uu; + testcase( pRec->flags & MEM_Int ); + testcase( pRec->flags & MEM_IntReal ); + if( i<0 ){ + uu = ~i; + }else{ + uu = i; + } + nHdr++; + testcase( uu==127 ); testcase( uu==128 ); + testcase( uu==32767 ); testcase( uu==32768 ); + testcase( uu==8388607 ); testcase( uu==8388608 ); + testcase( uu==2147483647 ); testcase( uu==2147483648 ); + testcase( uu==140737488355327LL ); testcase( uu==140737488355328LL ); + if( uu<=127 ){ + if( (i&1)==i && file_format>=4 ){ + pRec->uTemp = 8+(u32)uu; + }else{ + nData++; + pRec->uTemp = 1; + } + }else if( uu<=32767 ){ + nData += 2; + pRec->uTemp = 2; + }else if( uu<=8388607 ){ + nData += 3; + pRec->uTemp = 3; + }else if( uu<=2147483647 ){ + nData += 4; + pRec->uTemp = 4; + }else if( uu<=140737488355327LL ){ + nData += 6; + pRec->uTemp = 5; + }else{ + nData += 8; + if( pRec->flags & MEM_IntReal ){ + /* If the value is IntReal and is going to take up 8 bytes to store + ** as an integer, then we might as well make it an 8-byte floating + ** point value */ + pRec->u.r = (double)pRec->u.i; + pRec->flags &= ~MEM_IntReal; + pRec->flags |= MEM_Real; + pRec->uTemp = 7; + }else{ + pRec->uTemp = 6; + } + } + }else if( pRec->flags & MEM_Real ){ + nHdr++; + nData += 8; + pRec->uTemp = 7; + }else{ + assert( db->mallocFailed || pRec->flags&(MEM_Str|MEM_Blob) ); + assert( pRec->n>=0 ); + len = (u32)pRec->n; + serial_type = (len*2) + 12 + ((pRec->flags & MEM_Str)!=0); + if( pRec->flags & MEM_Zero ){ + serial_type += pRec->u.nZero*2; + if( nData ){ + if( sqlite3VdbeMemExpandBlob(pRec) ) goto no_mem; + len += pRec->u.nZero; + }else{ + nZero += pRec->u.nZero; + } + } + nData += len; + nHdr += sqlite3VarintLen(serial_type); + pRec->uTemp = serial_type; + } + if( pRec==pData0 ) break; + pRec--; + }while(1); + + /* EVIDENCE-OF: R-22564-11647 The header begins with a single varint + ** which determines the total number of bytes in the header. The varint + ** value is the size of the header in bytes including the size varint + ** itself. */ + testcase( nHdr==126 ); + testcase( nHdr==127 ); + if( nHdr<=126 ){ + /* The common case */ + nHdr += 1; + }else{ + /* Rare case of a really large header */ + nVarint = sqlite3VarintLen(nHdr); + nHdr += nVarint; + if( nVarintp3) is not allowed to + ** be one of the input registers (because the following call to + ** sqlite3VdbeMemClearAndResize() could clobber the value before it is used). + */ + if( nByte+nZero<=pOut->szMalloc ){ + /* The output register is already large enough to hold the record. + ** No error checks or buffer enlargement is required */ + pOut->z = pOut->zMalloc; + }else{ + /* Need to make sure that the output is not too big and then enlarge + ** the output register to hold the full result */ + if( nByte+nZero>db->aLimit[SQLITE_LIMIT_LENGTH] ){ + goto too_big; + } + if( sqlite3VdbeMemClearAndResize(pOut, (int)nByte) ){ + goto no_mem; + } + } + pOut->n = (int)nByte; + pOut->flags = MEM_Blob; + if( nZero ){ + pOut->u.nZero = nZero; + pOut->flags |= MEM_Zero; + } + UPDATE_MAX_BLOBSIZE(pOut); + zHdr = (u8 *)pOut->z; + zPayload = zHdr + nHdr; + + /* Write the record */ + zHdr += putVarint32(zHdr, nHdr); + assert( pData0<=pLast ); + pRec = pData0; + do{ + serial_type = pRec->uTemp; + /* EVIDENCE-OF: R-06529-47362 Following the size varint are one or more + ** additional varints, one per column. */ + zHdr += putVarint32(zHdr, serial_type); /* serial type */ + /* EVIDENCE-OF: R-64536-51728 The values for each column in the record + ** immediately follow the header. */ + zPayload += sqlite3VdbeSerialPut(zPayload, pRec, serial_type); /* content */ + }while( (++pRec)<=pLast ); + assert( nHdr==(int)(zHdr - (u8*)pOut->z) ); + assert( nByte==(int)(zPayload - (u8*)pOut->z) ); + + assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); + REGISTER_TRACE(pOp->p3, pOut); + break; +} + +/* Opcode: Count P1 P2 p3 * * +** Synopsis: r[P2]=count() +** +** Store the number of entries (an integer value) in the table or index +** opened by cursor P1 in register P2. +** +** If P3==0, then an exact count is obtained, which involves visiting +** every btree page of the table. But if P3 is non-zero, an estimate +** is returned based on the current cursor position. +*/ +case OP_Count: { /* out2 */ + i64 nEntry; + BtCursor *pCrsr; + + assert( p->apCsr[pOp->p1]->eCurType==CURTYPE_BTREE ); + pCrsr = p->apCsr[pOp->p1]->uc.pCursor; + assert( pCrsr ); + if( pOp->p3 ){ + nEntry = sqlite3BtreeRowCountEst(pCrsr); + }else{ + nEntry = 0; /* Not needed. Only used to silence a warning. */ + rc = sqlite3BtreeCount(db, pCrsr, &nEntry); + if( rc ) goto abort_due_to_error; + } + pOut = out2Prerelease(p, pOp); + pOut->u.i = nEntry; + goto check_for_interrupt; +} + +/* Opcode: Savepoint P1 * * P4 * +** +** Open, release or rollback the savepoint named by parameter P4, depending +** on the value of P1. To open a new savepoint set P1==0 (SAVEPOINT_BEGIN). +** To release (commit) an existing savepoint set P1==1 (SAVEPOINT_RELEASE). +** To rollback an existing savepoint set P1==2 (SAVEPOINT_ROLLBACK). +*/ +case OP_Savepoint: { + int p1; /* Value of P1 operand */ + char *zName; /* Name of savepoint */ + int nName; + Savepoint *pNew; + Savepoint *pSavepoint; + Savepoint *pTmp; + int iSavepoint; + int ii; + + p1 = pOp->p1; + zName = pOp->p4.z; + + /* Assert that the p1 parameter is valid. Also that if there is no open + ** transaction, then there cannot be any savepoints. + */ + assert( db->pSavepoint==0 || db->autoCommit==0 ); + assert( p1==SAVEPOINT_BEGIN||p1==SAVEPOINT_RELEASE||p1==SAVEPOINT_ROLLBACK ); + assert( db->pSavepoint || db->isTransactionSavepoint==0 ); + assert( checkSavepointCount(db) ); + assert( p->bIsReader ); + + if( p1==SAVEPOINT_BEGIN ){ + if( db->nVdbeWrite>0 ){ + /* A new savepoint cannot be created if there are active write + ** statements (i.e. open read/write incremental blob handles). + */ + sqlite3VdbeError(p, "cannot open savepoint - SQL statements in progress"); + rc = SQLITE_BUSY; + }else{ + nName = sqlite3Strlen30(zName); + +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* This call is Ok even if this savepoint is actually a transaction + ** savepoint (and therefore should not prompt xSavepoint()) callbacks. + ** If this is a transaction savepoint being opened, it is guaranteed + ** that the db->aVTrans[] array is empty. */ + assert( db->autoCommit==0 || db->nVTrans==0 ); + rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, + db->nStatement+db->nSavepoint); + if( rc!=SQLITE_OK ) goto abort_due_to_error; +#endif + + /* Create a new savepoint structure. */ + pNew = sqlite3DbMallocRawNN(db, sizeof(Savepoint)+nName+1); + if( pNew ){ + pNew->zName = (char *)&pNew[1]; + memcpy(pNew->zName, zName, nName+1); + + /* If there is no open transaction, then mark this as a special + ** "transaction savepoint". */ + if( db->autoCommit ){ + db->autoCommit = 0; + db->isTransactionSavepoint = 1; + }else{ + db->nSavepoint++; + } + + /* Link the new savepoint into the database handle's list. */ + pNew->pNext = db->pSavepoint; + db->pSavepoint = pNew; + pNew->nDeferredCons = db->nDeferredCons; + pNew->nDeferredImmCons = db->nDeferredImmCons; + } + } + }else{ + assert( p1==SAVEPOINT_RELEASE || p1==SAVEPOINT_ROLLBACK ); + iSavepoint = 0; + + /* Find the named savepoint. If there is no such savepoint, then an + ** an error is returned to the user. */ + for( + pSavepoint = db->pSavepoint; + pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName); + pSavepoint = pSavepoint->pNext + ){ + iSavepoint++; + } + if( !pSavepoint ){ + sqlite3VdbeError(p, "no such savepoint: %s", zName); + rc = SQLITE_ERROR; + }else if( db->nVdbeWrite>0 && p1==SAVEPOINT_RELEASE ){ + /* It is not possible to release (commit) a savepoint if there are + ** active write statements. + */ + sqlite3VdbeError(p, "cannot release savepoint - " + "SQL statements in progress"); + rc = SQLITE_BUSY; + }else{ + + /* Determine whether or not this is a transaction savepoint. If so, + ** and this is a RELEASE command, then the current transaction + ** is committed. + */ + int isTransaction = pSavepoint->pNext==0 && db->isTransactionSavepoint; + if( isTransaction && p1==SAVEPOINT_RELEASE ){ + if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){ + goto vdbe_return; + } + db->autoCommit = 1; + if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){ + p->pc = (int)(pOp - aOp); + db->autoCommit = 0; + p->rc = rc = SQLITE_BUSY; + goto vdbe_return; + } + rc = p->rc; + if( rc ){ + db->autoCommit = 0; + }else{ + db->isTransactionSavepoint = 0; + } + }else{ + int isSchemaChange; + iSavepoint = db->nSavepoint - iSavepoint - 1; + if( p1==SAVEPOINT_ROLLBACK ){ + isSchemaChange = (db->mDbFlags & DBFLAG_SchemaChange)!=0; + for(ii=0; iinDb; ii++){ + rc = sqlite3BtreeTripAllCursors(db->aDb[ii].pBt, + SQLITE_ABORT_ROLLBACK, + isSchemaChange==0); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + } + }else{ + assert( p1==SAVEPOINT_RELEASE ); + isSchemaChange = 0; + } + for(ii=0; iinDb; ii++){ + rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint); + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + } + if( isSchemaChange ){ + sqlite3ExpirePreparedStatements(db, 0); + sqlite3ResetAllSchemasOfConnection(db); + db->mDbFlags |= DBFLAG_SchemaChange; + } + } + if( rc ) goto abort_due_to_error; + + /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all + ** savepoints nested inside of the savepoint being operated on. */ + while( db->pSavepoint!=pSavepoint ){ + pTmp = db->pSavepoint; + db->pSavepoint = pTmp->pNext; + sqlite3DbFree(db, pTmp); + db->nSavepoint--; + } + + /* If it is a RELEASE, then destroy the savepoint being operated on + ** too. If it is a ROLLBACK TO, then set the number of deferred + ** constraint violations present in the database to the value stored + ** when the savepoint was created. */ + if( p1==SAVEPOINT_RELEASE ){ + assert( pSavepoint==db->pSavepoint ); + db->pSavepoint = pSavepoint->pNext; + sqlite3DbFree(db, pSavepoint); + if( !isTransaction ){ + db->nSavepoint--; + } + }else{ + assert( p1==SAVEPOINT_ROLLBACK ); + db->nDeferredCons = pSavepoint->nDeferredCons; + db->nDeferredImmCons = pSavepoint->nDeferredImmCons; + } + + if( !isTransaction || p1==SAVEPOINT_ROLLBACK ){ + rc = sqlite3VtabSavepoint(db, p1, iSavepoint); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + } + } + } + if( rc ) goto abort_due_to_error; + + break; +} + +/* Opcode: AutoCommit P1 P2 * * * +** +** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll +** back any currently active btree transactions. If there are any active +** VMs (apart from this one), then a ROLLBACK fails. A COMMIT fails if +** there are active writing VMs or active VMs that use shared cache. +** +** This instruction causes the VM to halt. +*/ +case OP_AutoCommit: { + int desiredAutoCommit; + int iRollback; + + desiredAutoCommit = pOp->p1; + iRollback = pOp->p2; + assert( desiredAutoCommit==1 || desiredAutoCommit==0 ); + assert( desiredAutoCommit==1 || iRollback==0 ); + assert( db->nVdbeActive>0 ); /* At least this one VM is active */ + assert( p->bIsReader ); + + if( desiredAutoCommit!=db->autoCommit ){ + if( iRollback ){ + assert( desiredAutoCommit==1 ); + sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); + db->autoCommit = 1; + }else if( desiredAutoCommit && db->nVdbeWrite>0 ){ + /* If this instruction implements a COMMIT and other VMs are writing + ** return an error indicating that the other VMs must complete first. + */ + sqlite3VdbeError(p, "cannot commit transaction - " + "SQL statements in progress"); + rc = SQLITE_BUSY; + goto abort_due_to_error; + }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){ + goto vdbe_return; + }else{ + db->autoCommit = (u8)desiredAutoCommit; + } + if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){ + p->pc = (int)(pOp - aOp); + db->autoCommit = (u8)(1-desiredAutoCommit); + p->rc = rc = SQLITE_BUSY; + goto vdbe_return; + } + sqlite3CloseSavepoints(db); + if( p->rc==SQLITE_OK ){ + rc = SQLITE_DONE; + }else{ + rc = SQLITE_ERROR; + } + goto vdbe_return; + }else{ + sqlite3VdbeError(p, + (!desiredAutoCommit)?"cannot start a transaction within a transaction":( + (iRollback)?"cannot rollback - no transaction is active": + "cannot commit - no transaction is active")); + + rc = SQLITE_ERROR; + goto abort_due_to_error; + } + /*NOTREACHED*/ assert(0); +} + +/* Opcode: Transaction P1 P2 P3 P4 P5 +** +** Begin a transaction on database P1 if a transaction is not already +** active. +** If P2 is non-zero, then a write-transaction is started, or if a +** read-transaction is already active, it is upgraded to a write-transaction. +** If P2 is zero, then a read-transaction is started. If P2 is 2 or more +** then an exclusive transaction is started. +** +** P1 is the index of the database file on which the transaction is +** started. Index 0 is the main database file and index 1 is the +** file used for temporary tables. Indices of 2 or more are used for +** attached databases. +** +** If a write-transaction is started and the Vdbe.usesStmtJournal flag is +** true (this flag is set if the Vdbe may modify more than one row and may +** throw an ABORT exception), a statement transaction may also be opened. +** More specifically, a statement transaction is opened iff the database +** connection is currently not in autocommit mode, or if there are other +** active statements. A statement transaction allows the changes made by this +** VDBE to be rolled back after an error without having to roll back the +** entire transaction. If no error is encountered, the statement transaction +** will automatically commit when the VDBE halts. +** +** If P5!=0 then this opcode also checks the schema cookie against P3 +** and the schema generation counter against P4. +** The cookie changes its value whenever the database schema changes. +** This operation is used to detect when that the cookie has changed +** and that the current process needs to reread the schema. If the schema +** cookie in P3 differs from the schema cookie in the database header or +** if the schema generation counter in P4 differs from the current +** generation counter, then an SQLITE_SCHEMA error is raised and execution +** halts. The sqlite3_step() wrapper function might then reprepare the +** statement and rerun it from the beginning. +*/ +case OP_Transaction: { + Btree *pBt; + int iMeta = 0; + + assert( p->bIsReader ); + assert( p->readOnly==0 || pOp->p2==0 ); + assert( pOp->p2>=0 && pOp->p2<=2 ); + assert( pOp->p1>=0 && pOp->p1nDb ); + assert( DbMaskTest(p->btreeMask, pOp->p1) ); + if( pOp->p2 && (db->flags & SQLITE_QueryOnly)!=0 ){ + rc = SQLITE_READONLY; + goto abort_due_to_error; + } + pBt = db->aDb[pOp->p1].pBt; + + if( pBt ){ + rc = sqlite3BtreeBeginTrans(pBt, pOp->p2, &iMeta); + testcase( rc==SQLITE_BUSY_SNAPSHOT ); + testcase( rc==SQLITE_BUSY_RECOVERY ); + if( rc!=SQLITE_OK ){ + if( (rc&0xff)==SQLITE_BUSY ){ + p->pc = (int)(pOp - aOp); + p->rc = rc; + goto vdbe_return; + } + goto abort_due_to_error; + } + + if( p->usesStmtJournal + && pOp->p2 + && (db->autoCommit==0 || db->nVdbeRead>1) + ){ + assert( sqlite3BtreeTxnState(pBt)==SQLITE_TXN_WRITE ); + if( p->iStatement==0 ){ + assert( db->nStatement>=0 && db->nSavepoint>=0 ); + db->nStatement++; + p->iStatement = db->nSavepoint + db->nStatement; + } + + rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1); + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeBeginStmt(pBt, p->iStatement); + } + + /* Store the current value of the database handles deferred constraint + ** counter. If the statement transaction needs to be rolled back, + ** the value of this counter needs to be restored too. */ + p->nStmtDefCons = db->nDeferredCons; + p->nStmtDefImmCons = db->nDeferredImmCons; + } + } + assert( pOp->p5==0 || pOp->p4type==P4_INT32 ); + if( pOp->p5 + && (iMeta!=pOp->p3 + || db->aDb[pOp->p1].pSchema->iGeneration!=pOp->p4.i) + ){ + /* + ** IMPLEMENTATION-OF: R-03189-51135 As each SQL statement runs, the schema + ** version is checked to ensure that the schema has not changed since the + ** SQL statement was prepared. + */ + sqlite3DbFree(db, p->zErrMsg); + p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed"); + /* If the schema-cookie from the database file matches the cookie + ** stored with the in-memory representation of the schema, do + ** not reload the schema from the database file. + ** + ** If virtual-tables are in use, this is not just an optimization. + ** Often, v-tables store their data in other SQLite tables, which + ** are queried from within xNext() and other v-table methods using + ** prepared queries. If such a query is out-of-date, we do not want to + ** discard the database schema, as the user code implementing the + ** v-table would have to be ready for the sqlite3_vtab structure itself + ** to be invalidated whenever sqlite3_step() is called from within + ** a v-table method. + */ + if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){ + sqlite3ResetOneSchema(db, pOp->p1); + } + p->expired = 1; + rc = SQLITE_SCHEMA; + } + if( rc ) goto abort_due_to_error; + break; +} + +/* Opcode: ReadCookie P1 P2 P3 * * +** +** Read cookie number P3 from database P1 and write it into register P2. +** P3==1 is the schema version. P3==2 is the database format. +** P3==3 is the recommended pager cache size, and so forth. P1==0 is +** the main database file and P1==1 is the database file used to store +** temporary tables. +** +** There must be a read-lock on the database (either a transaction +** must be started or there must be an open cursor) before +** executing this instruction. +*/ +case OP_ReadCookie: { /* out2 */ + int iMeta; + int iDb; + int iCookie; + + assert( p->bIsReader ); + iDb = pOp->p1; + iCookie = pOp->p3; + assert( pOp->p3=0 && iDbnDb ); + assert( db->aDb[iDb].pBt!=0 ); + assert( DbMaskTest(p->btreeMask, iDb) ); + + sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta); + pOut = out2Prerelease(p, pOp); + pOut->u.i = iMeta; + break; +} + +/* Opcode: SetCookie P1 P2 P3 * P5 +** +** Write the integer value P3 into cookie number P2 of database P1. +** P2==1 is the schema version. P2==2 is the database format. +** P2==3 is the recommended pager cache +** size, and so forth. P1==0 is the main database file and P1==1 is the +** database file used to store temporary tables. +** +** A transaction must be started before executing this opcode. +** +** If P2 is the SCHEMA_VERSION cookie (cookie number 1) then the internal +** schema version is set to P3-P5. The "PRAGMA schema_version=N" statement +** has P5 set to 1, so that the internal schema version will be different +** from the database schema version, resulting in a schema reset. +*/ +case OP_SetCookie: { + Db *pDb; + + sqlite3VdbeIncrWriteCounter(p, 0); + assert( pOp->p2p1>=0 && pOp->p1nDb ); + assert( DbMaskTest(p->btreeMask, pOp->p1) ); + assert( p->readOnly==0 ); + pDb = &db->aDb[pOp->p1]; + assert( pDb->pBt!=0 ); + assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) ); + /* See note about index shifting on OP_ReadCookie */ + rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, pOp->p3); + if( pOp->p2==BTREE_SCHEMA_VERSION ){ + /* When the schema cookie changes, record the new cookie internally */ + pDb->pSchema->schema_cookie = pOp->p3 - pOp->p5; + db->mDbFlags |= DBFLAG_SchemaChange; + }else if( pOp->p2==BTREE_FILE_FORMAT ){ + /* Record changes in the file format */ + pDb->pSchema->file_format = pOp->p3; + } + if( pOp->p1==1 ){ + /* Invalidate all prepared statements whenever the TEMP database + ** schema is changed. Ticket #1644 */ + sqlite3ExpirePreparedStatements(db, 0); + p->expired = 0; + } + if( rc ) goto abort_due_to_error; + break; +} + +/* Opcode: OpenRead P1 P2 P3 P4 P5 +** Synopsis: root=P2 iDb=P3 +** +** Open a read-only cursor for the database table whose root page is +** P2 in a database file. The database file is determined by P3. +** P3==0 means the main database, P3==1 means the database used for +** temporary tables, and P3>1 means used the corresponding attached +** database. Give the new cursor an identifier of P1. The P1 +** values need not be contiguous but all P1 values should be small integers. +** It is an error for P1 to be negative. +** +** Allowed P5 bits: +**
      +**
    • 0x02 OPFLAG_SEEKEQ: This cursor will only be used for +** equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT +** of OP_SeekLE/OP_IdxLT) +**
    +** +** The P4 value may be either an integer (P4_INT32) or a pointer to +** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo +** object, then table being opened must be an [index b-tree] where the +** KeyInfo object defines the content and collating +** sequence of that index b-tree. Otherwise, if P4 is an integer +** value, then the table being opened must be a [table b-tree] with a +** number of columns no less than the value of P4. +** +** See also: OpenWrite, ReopenIdx +*/ +/* Opcode: ReopenIdx P1 P2 P3 P4 P5 +** Synopsis: root=P2 iDb=P3 +** +** The ReopenIdx opcode works like OP_OpenRead except that it first +** checks to see if the cursor on P1 is already open on the same +** b-tree and if it is this opcode becomes a no-op. In other words, +** if the cursor is already open, do not reopen it. +** +** The ReopenIdx opcode may only be used with P5==0 or P5==OPFLAG_SEEKEQ +** and with P4 being a P4_KEYINFO object. Furthermore, the P3 value must +** be the same as every other ReopenIdx or OpenRead for the same cursor +** number. +** +** Allowed P5 bits: +**
      +**
    • 0x02 OPFLAG_SEEKEQ: This cursor will only be used for +** equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT +** of OP_SeekLE/OP_IdxLT) +**
    +** +** See also: OP_OpenRead, OP_OpenWrite +*/ +/* Opcode: OpenWrite P1 P2 P3 P4 P5 +** Synopsis: root=P2 iDb=P3 +** +** Open a read/write cursor named P1 on the table or index whose root +** page is P2 (or whose root page is held in register P2 if the +** OPFLAG_P2ISREG bit is set in P5 - see below). +** +** The P4 value may be either an integer (P4_INT32) or a pointer to +** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo +** object, then table being opened must be an [index b-tree] where the +** KeyInfo object defines the content and collating +** sequence of that index b-tree. Otherwise, if P4 is an integer +** value, then the table being opened must be a [table b-tree] with a +** number of columns no less than the value of P4. +** +** Allowed P5 bits: +**
      +**
    • 0x02 OPFLAG_SEEKEQ: This cursor will only be used for +** equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT +** of OP_SeekLE/OP_IdxLT) +**
    • 0x08 OPFLAG_FORDELETE: This cursor is used only to seek +** and subsequently delete entries in an index btree. This is a +** hint to the storage engine that the storage engine is allowed to +** ignore. The hint is not used by the official SQLite b*tree storage +** engine, but is used by COMDB2. +**
    • 0x10 OPFLAG_P2ISREG: Use the content of register P2 +** as the root page, not the value of P2 itself. +**
    +** +** This instruction works like OpenRead except that it opens the cursor +** in read/write mode. +** +** See also: OP_OpenRead, OP_ReopenIdx +*/ +case OP_ReopenIdx: { + int nField; + KeyInfo *pKeyInfo; + u32 p2; + int iDb; + int wrFlag; + Btree *pX; + VdbeCursor *pCur; + Db *pDb; + + assert( pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ ); + assert( pOp->p4type==P4_KEYINFO ); + pCur = p->apCsr[pOp->p1]; + if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){ + assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */ + goto open_cursor_set_hints; + } + /* 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_OpenWrite: + + assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ ); + assert( p->bIsReader ); + assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx + || p->readOnly==0 ); + + if( p->expired==1 ){ + rc = SQLITE_ABORT_ROLLBACK; + goto abort_due_to_error; + } + + nField = 0; + pKeyInfo = 0; + p2 = (u32)pOp->p2; + iDb = pOp->p3; + assert( iDb>=0 && iDbnDb ); + assert( DbMaskTest(p->btreeMask, iDb) ); + pDb = &db->aDb[iDb]; + pX = pDb->pBt; + assert( pX!=0 ); + if( pOp->opcode==OP_OpenWrite ){ + assert( OPFLAG_FORDELETE==BTREE_FORDELETE ); + wrFlag = BTREE_WRCSR | (pOp->p5 & OPFLAG_FORDELETE); + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( pDb->pSchema->file_format < p->minWriteFileFormat ){ + p->minWriteFileFormat = pDb->pSchema->file_format; + } + }else{ + wrFlag = 0; + } + if( pOp->p5 & OPFLAG_P2ISREG ){ + assert( p2>0 ); + assert( p2<=(u32)(p->nMem+1 - p->nCursor) ); + assert( pOp->opcode==OP_OpenWrite ); + pIn2 = &aMem[p2]; + assert( memIsValid(pIn2) ); + assert( (pIn2->flags & MEM_Int)!=0 ); + sqlite3VdbeMemIntegerify(pIn2); + p2 = (int)pIn2->u.i; + /* The p2 value always comes from a prior OP_CreateBtree opcode and + ** that opcode will always set the p2 value to 2 or more or else fail. + ** If there were a failure, the prepared statement would have halted + ** before reaching this instruction. */ + assert( p2>=2 ); + } + if( pOp->p4type==P4_KEYINFO ){ + pKeyInfo = pOp->p4.pKeyInfo; + assert( pKeyInfo->enc==ENC(db) ); + assert( pKeyInfo->db==db ); + nField = pKeyInfo->nAllField; + }else if( pOp->p4type==P4_INT32 ){ + nField = pOp->p4.i; + } + assert( pOp->p1>=0 ); + assert( nField>=0 ); + testcase( nField==0 ); /* Table with INTEGER PRIMARY KEY and nothing else */ + pCur = allocateCursor(p, pOp->p1, nField, iDb, CURTYPE_BTREE); + if( pCur==0 ) goto no_mem; + pCur->nullRow = 1; + pCur->isOrdered = 1; + pCur->pgnoRoot = p2; +#ifdef SQLITE_DEBUG + pCur->wrFlag = wrFlag; +#endif + rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor); + pCur->pKeyInfo = pKeyInfo; + /* Set the VdbeCursor.isTable variable. Previous versions of + ** SQLite used to check if the root-page flags were sane at this point + ** and report database corruption if they were not, but this check has + ** since moved into the btree layer. */ + pCur->isTable = pOp->p4type!=P4_KEYINFO; + +open_cursor_set_hints: + assert( OPFLAG_BULKCSR==BTREE_BULKLOAD ); + assert( OPFLAG_SEEKEQ==BTREE_SEEK_EQ ); + testcase( pOp->p5 & OPFLAG_BULKCSR ); + testcase( pOp->p2 & OPFLAG_SEEKEQ ); + sqlite3BtreeCursorHintFlags(pCur->uc.pCursor, + (pOp->p5 & (OPFLAG_BULKCSR|OPFLAG_SEEKEQ))); + if( rc ) goto abort_due_to_error; + break; +} + +/* Opcode: OpenDup P1 P2 * * * +** +** Open a new cursor P1 that points to the same ephemeral table as +** cursor P2. The P2 cursor must have been opened by a prior OP_OpenEphemeral +** opcode. Only ephemeral cursors may be duplicated. +** +** Duplicate ephemeral cursors are used for self-joins of materialized views. +*/ +case OP_OpenDup: { + VdbeCursor *pOrig; /* The original cursor to be duplicated */ + VdbeCursor *pCx; /* The new cursor */ + + pOrig = p->apCsr[pOp->p2]; + assert( pOrig ); + assert( pOrig->pBtx!=0 ); /* Only ephemeral cursors can be duplicated */ + + pCx = allocateCursor(p, pOp->p1, pOrig->nField, -1, CURTYPE_BTREE); + if( pCx==0 ) goto no_mem; + pCx->nullRow = 1; + pCx->isEphemeral = 1; + pCx->pKeyInfo = pOrig->pKeyInfo; + pCx->isTable = pOrig->isTable; + pCx->pgnoRoot = pOrig->pgnoRoot; + pCx->isOrdered = pOrig->isOrdered; + rc = sqlite3BtreeCursor(pOrig->pBtx, pCx->pgnoRoot, BTREE_WRCSR, + pCx->pKeyInfo, pCx->uc.pCursor); + /* The sqlite3BtreeCursor() routine can only fail for the first cursor + ** opened for a database. Since there is already an open cursor when this + ** opcode is run, the sqlite3BtreeCursor() cannot fail */ + assert( rc==SQLITE_OK ); + break; +} + + +/* Opcode: OpenEphemeral P1 P2 P3 P4 P5 +** Synopsis: nColumn=P2 +** +** Open a new cursor P1 to a transient table. +** The cursor is always opened read/write even if +** the main database is read-only. The ephemeral +** table is deleted automatically when the cursor is closed. +** +** If the cursor P1 is already opened on an ephemeral table, the table +** is cleared (all content is erased). +** +** P2 is the number of columns in the ephemeral table. +** The cursor points to a BTree table if P4==0 and to a BTree index +** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure +** that defines the format of keys in the index. +** +** The P5 parameter can be a mask of the BTREE_* flags defined +** in btree.h. These flags control aspects of the operation of +** the btree. The BTREE_OMIT_JOURNAL and BTREE_SINGLE flags are +** added automatically. +** +** If P3 is positive, then reg[P3] is modified slightly so that it +** can be used as zero-length data for OP_Insert. This is an optimization +** that avoids an extra OP_Blob opcode to initialize that register. +*/ +/* Opcode: OpenAutoindex P1 P2 * P4 * +** Synopsis: nColumn=P2 +** +** This opcode works the same as OP_OpenEphemeral. It has a +** different name to distinguish its use. Tables created using +** by this opcode will be used for automatically created transient +** indices in joins. +*/ +case OP_OpenAutoindex: +case OP_OpenEphemeral: { + VdbeCursor *pCx; + KeyInfo *pKeyInfo; + + static const int vfsFlags = + SQLITE_OPEN_READWRITE | + SQLITE_OPEN_CREATE | + SQLITE_OPEN_EXCLUSIVE | + SQLITE_OPEN_DELETEONCLOSE | + SQLITE_OPEN_TRANSIENT_DB; + assert( pOp->p1>=0 ); + assert( pOp->p2>=0 ); + if( pOp->p3>0 ){ + /* Make register reg[P3] into a value that can be used as the data + ** form sqlite3BtreeInsert() where the length of the data is zero. */ + assert( pOp->p2==0 ); /* Only used when number of columns is zero */ + assert( pOp->opcode==OP_OpenEphemeral ); + assert( aMem[pOp->p3].flags & MEM_Null ); + aMem[pOp->p3].n = 0; + aMem[pOp->p3].z = ""; + } + pCx = p->apCsr[pOp->p1]; + if( pCx && pCx->pBtx ){ + /* If the ephermeral table is already open, erase all existing content + ** so that the table is empty again, rather than creating a new table. */ + assert( pCx->isEphemeral ); + pCx->seqCount = 0; + pCx->cacheStatus = CACHE_STALE; + rc = sqlite3BtreeClearTable(pCx->pBtx, pCx->pgnoRoot, 0); + }else{ + pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_BTREE); + if( pCx==0 ) goto no_mem; + pCx->isEphemeral = 1; + rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->pBtx, + BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5, + vfsFlags); + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeBeginTrans(pCx->pBtx, 1, 0); + } + if( rc==SQLITE_OK ){ + /* If a transient index is required, create it by calling + ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before + ** opening it. If a transient table is required, just use the + ** automatically created table with root-page 1 (an BLOB_INTKEY table). + */ + if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){ + assert( pOp->p4type==P4_KEYINFO ); + rc = sqlite3BtreeCreateTable(pCx->pBtx, &pCx->pgnoRoot, + BTREE_BLOBKEY | pOp->p5); + if( rc==SQLITE_OK ){ + assert( pCx->pgnoRoot==SCHEMA_ROOT+1 ); + assert( pKeyInfo->db==db ); + assert( pKeyInfo->enc==ENC(db) ); + rc = sqlite3BtreeCursor(pCx->pBtx, pCx->pgnoRoot, BTREE_WRCSR, + pKeyInfo, pCx->uc.pCursor); + } + pCx->isTable = 0; + }else{ + pCx->pgnoRoot = SCHEMA_ROOT; + rc = sqlite3BtreeCursor(pCx->pBtx, SCHEMA_ROOT, BTREE_WRCSR, + 0, pCx->uc.pCursor); + pCx->isTable = 1; + } + } + pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED); + } + if( rc ) goto abort_due_to_error; + pCx->nullRow = 1; + break; +} + +/* Opcode: SorterOpen P1 P2 P3 P4 * +** +** This opcode works like OP_OpenEphemeral except that it opens +** a transient index that is specifically designed to sort large +** tables using an external merge-sort algorithm. +** +** If argument P3 is non-zero, then it indicates that the sorter may +** assume that a stable sort considering the first P3 fields of each +** key is sufficient to produce the required results. +*/ +case OP_SorterOpen: { + VdbeCursor *pCx; + + assert( pOp->p1>=0 ); + assert( pOp->p2>=0 ); + pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_SORTER); + if( pCx==0 ) goto no_mem; + pCx->pKeyInfo = pOp->p4.pKeyInfo; + assert( pCx->pKeyInfo->db==db ); + assert( pCx->pKeyInfo->enc==ENC(db) ); + rc = sqlite3VdbeSorterInit(db, pOp->p3, pCx); + if( rc ) goto abort_due_to_error; + break; +} + +/* Opcode: SequenceTest P1 P2 * * * +** Synopsis: if( cursor[P1].ctr++ ) pc = P2 +** +** P1 is a sorter cursor. If the sequence counter is currently zero, jump +** to P2. Regardless of whether or not the jump is taken, increment the +** the sequence value. +*/ +case OP_SequenceTest: { + VdbeCursor *pC; + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( isSorter(pC) ); + if( (pC->seqCount++)==0 ){ + goto jump_to_p2; + } + break; +} + +/* Opcode: OpenPseudo P1 P2 P3 * * +** Synopsis: P3 columns in r[P2] +** +** Open a new cursor that points to a fake table that contains a single +** row of data. The content of that one row is the content of memory +** register P2. In other words, cursor P1 becomes an alias for the +** MEM_Blob content contained in register P2. +** +** A pseudo-table created by this opcode is used to hold a single +** row output from the sorter so that the row can be decomposed into +** individual columns using the OP_Column opcode. The OP_Column opcode +** is the only cursor opcode that works with a pseudo-table. +** +** P3 is the number of fields in the records that will be stored by +** the pseudo-table. +*/ +case OP_OpenPseudo: { + VdbeCursor *pCx; + + assert( pOp->p1>=0 ); + assert( pOp->p3>=0 ); + pCx = allocateCursor(p, pOp->p1, pOp->p3, -1, CURTYPE_PSEUDO); + if( pCx==0 ) goto no_mem; + pCx->nullRow = 1; + pCx->seekResult = pOp->p2; + pCx->isTable = 1; + /* Give this pseudo-cursor a fake BtCursor pointer so that pCx + ** can be safely passed to sqlite3VdbeCursorMoveto(). This avoids a test + ** for pCx->eCurType==CURTYPE_BTREE inside of sqlite3VdbeCursorMoveto() + ** which is a performance optimization */ + pCx->uc.pCursor = sqlite3BtreeFakeValidCursor(); + assert( pOp->p5==0 ); + break; +} + +/* Opcode: Close P1 * * * * +** +** Close a cursor previously opened as P1. If P1 is not +** currently open, this instruction is a no-op. +*/ +case OP_Close: { + assert( pOp->p1>=0 && pOp->p1nCursor ); + sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]); + p->apCsr[pOp->p1] = 0; + break; +} + +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK +/* Opcode: ColumnsUsed P1 * * P4 * +** +** This opcode (which only exists if SQLite was compiled with +** SQLITE_ENABLE_COLUMN_USED_MASK) identifies which columns of the +** table or index for cursor P1 are used. P4 is a 64-bit integer +** (P4_INT64) in which the first 63 bits are one for each of the +** first 63 columns of the table or index that are actually used +** by the cursor. The high-order bit is set if any column after +** the 64th is used. +*/ +case OP_ColumnsUsed: { + VdbeCursor *pC; + pC = p->apCsr[pOp->p1]; + assert( pC->eCurType==CURTYPE_BTREE ); + pC->maskUsed = *(u64*)pOp->p4.pI64; + break; +} +#endif + +/* Opcode: SeekGE P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), +** use the value in register P3 as the key. If cursor P1 refers +** to an SQL index, then P3 is the first in an array of P4 registers +** that are used as an unpacked index key. +** +** Reposition cursor P1 so that it points to the smallest entry that +** is greater than or equal to the key value. If there are no records +** greater than or equal to the key and P2 is not zero, then jump to P2. +** +** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this +** opcode will either land on a record that exactly matches the key, or +** else it will cause a jump to P2. When the cursor is OPFLAG_SEEKEQ, +** this opcode must be followed by an IdxLE opcode with the same arguments. +** The IdxGT opcode will be skipped if this opcode succeeds, but the +** IdxGT opcode will be used on subsequent loop iterations. The +** OPFLAG_SEEKEQ flags is a hint to the btree layer to say that this +** is an equality search. +** +** This opcode leaves the cursor configured to move in forward order, +** from the beginning toward the end. In other words, the cursor is +** configured to use Next, not Prev. +** +** See also: Found, NotFound, SeekLt, SeekGt, SeekLe +*/ +/* Opcode: SeekGT P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), +** use the value in register P3 as a key. If cursor P1 refers +** to an SQL index, then P3 is the first in an array of P4 registers +** that are used as an unpacked index key. +** +** Reposition cursor P1 so that it points to the smallest entry that +** is greater than the key value. If there are no records greater than +** the key and P2 is not zero, then jump to P2. +** +** This opcode leaves the cursor configured to move in forward order, +** from the beginning toward the end. In other words, the cursor is +** configured to use Next, not Prev. +** +** See also: Found, NotFound, SeekLt, SeekGe, SeekLe +*/ +/* Opcode: SeekLT P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), +** use the value in register P3 as a key. If cursor P1 refers +** to an SQL index, then P3 is the first in an array of P4 registers +** that are used as an unpacked index key. +** +** Reposition cursor P1 so that it points to the largest entry that +** is less than the key value. If there are no records less than +** the key and P2 is not zero, then jump to P2. +** +** This opcode leaves the cursor configured to move in reverse order, +** from the end toward the beginning. In other words, the cursor is +** configured to use Prev, not Next. +** +** See also: Found, NotFound, SeekGt, SeekGe, SeekLe +*/ +/* Opcode: SeekLE P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), +** use the value in register P3 as a key. If cursor P1 refers +** to an SQL index, then P3 is the first in an array of P4 registers +** that are used as an unpacked index key. +** +** Reposition cursor P1 so that it points to the largest entry that +** is less than or equal to the key value. If there are no records +** less than or equal to the key and P2 is not zero, then jump to P2. +** +** This opcode leaves the cursor configured to move in reverse order, +** from the end toward the beginning. In other words, the cursor is +** configured to use Prev, not Next. +** +** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this +** opcode will either land on a record that exactly matches the key, or +** else it will cause a jump to P2. When the cursor is OPFLAG_SEEKEQ, +** this opcode must be followed by an IdxLE opcode with the same arguments. +** The IdxGE opcode will be skipped if this opcode succeeds, but the +** IdxGE opcode will be used on subsequent loop iterations. The +** OPFLAG_SEEKEQ flags is a hint to the btree layer to say that this +** is an equality search. +** +** 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 */ + int res; /* Comparison result */ + int oc; /* Opcode */ + VdbeCursor *pC; /* The cursor to seek */ + UnpackedRecord r; /* The key to seek for */ + int nField; /* Number of columns or fields in the key */ + i64 iKey; /* The rowid we are to seek to */ + int eqOnly; /* Only interested in == results */ + + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( pOp->p2!=0 ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( OP_SeekLE == OP_SeekLT+1 ); + assert( OP_SeekGE == OP_SeekLT+2 ); + assert( OP_SeekGT == OP_SeekLT+3 ); + assert( pC->isOrdered ); + assert( pC->uc.pCursor!=0 ); + oc = pOp->opcode; + eqOnly = 0; + pC->nullRow = 0; +#ifdef SQLITE_DEBUG + pC->seekOp = pOp->opcode; +#endif + + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + if( pC->isTable ){ + u16 flags3, newType; + /* The OPFLAG_SEEKEQ/BTREE_SEEK_EQ flag is only set on index cursors */ + assert( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ)==0 + || CORRUPT_DB ); + + /* The input value in P3 might be of any type: integer, real, string, + ** blob, or NULL. But it needs to be an integer before we can do + ** the seek, so convert it. */ + pIn3 = &aMem[pOp->p3]; + flags3 = pIn3->flags; + if( (flags3 & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Str))==MEM_Str ){ + applyNumericAffinity(pIn3, 0); + } + iKey = sqlite3VdbeIntValue(pIn3); /* Get the integer key value */ + newType = pIn3->flags; /* Record the type after applying numeric affinity */ + pIn3->flags = flags3; /* But convert the type back to its original */ + + /* If the P3 value could not be converted into an integer without + ** loss of information, then special processing is required... */ + if( (newType & (MEM_Int|MEM_IntReal))==0 ){ + if( (newType & MEM_Real)==0 ){ + if( (newType & MEM_Null) || oc>=OP_SeekGE ){ + VdbeBranchTaken(1,2); + goto jump_to_p2; + }else{ + rc = sqlite3BtreeLast(pC->uc.pCursor, &res); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + goto seek_not_found; + } + }else + + /* If the approximation iKey is larger than the actual real search + ** term, substitute >= for > and < for <=. e.g. if the search term + ** is 4.9 and the integer approximation 5: + ** + ** (x > 4.9) -> (x >= 5) + ** (x <= 4.9) -> (x < 5) + */ + if( pIn3->u.r<(double)iKey ){ + assert( OP_SeekGE==(OP_SeekGT-1) ); + assert( OP_SeekLT==(OP_SeekLE-1) ); + assert( (OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001) ); + if( (oc & 0x0001)==(OP_SeekGT & 0x0001) ) oc--; + } + + /* If the approximation iKey is smaller than the actual real search + ** term, substitute <= for < and > for >=. */ + else if( pIn3->u.r>(double)iKey ){ + assert( OP_SeekLE==(OP_SeekLT+1) ); + assert( OP_SeekGT==(OP_SeekGE+1) ); + assert( (OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001) ); + if( (oc & 0x0001)==(OP_SeekLT & 0x0001) ) oc++; + } + } + rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)iKey, 0, &res); + pC->movetoTarget = iKey; /* Used by OP_Delete */ + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + }else{ + /* For a cursor with the OPFLAG_SEEKEQ/BTREE_SEEK_EQ hint, only the + ** OP_SeekGE and OP_SeekLE opcodes are allowed, and these must be + ** immediately followed by an OP_IdxGT or OP_IdxLT opcode, respectively, + ** with the same key. + */ + if( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ) ){ + eqOnly = 1; + assert( pOp->opcode==OP_SeekGE || pOp->opcode==OP_SeekLE ); + assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT ); + assert( pOp->opcode==OP_SeekGE || pOp[1].opcode==OP_IdxLT ); + assert( pOp->opcode==OP_SeekLE || pOp[1].opcode==OP_IdxGT ); + assert( pOp[1].p1==pOp[0].p1 ); + assert( pOp[1].p2==pOp[0].p2 ); + assert( pOp[1].p3==pOp[0].p3 ); + assert( pOp[1].p4.i==pOp[0].p4.i ); + } + + nField = pOp->p4.i; + assert( pOp->p4type==P4_INT32 ); + assert( nField>0 ); + r.pKeyInfo = pC->pKeyInfo; + r.nField = (u16)nField; + + /* The next line of code computes as follows, only faster: + ** if( oc==OP_SeekGT || oc==OP_SeekLE ){ + ** r.default_rc = -1; + ** }else{ + ** r.default_rc = +1; + ** } + */ + r.default_rc = ((1 & (oc - OP_SeekLT)) ? -1 : +1); + assert( oc!=OP_SeekGT || r.default_rc==-1 ); + assert( oc!=OP_SeekLE || r.default_rc==-1 ); + assert( oc!=OP_SeekGE || r.default_rc==+1 ); + assert( oc!=OP_SeekLT || r.default_rc==+1 ); + + r.aMem = &aMem[pOp->p3]; +#ifdef SQLITE_DEBUG + { int i; for(i=0; iuc.pCursor, &r, 0, 0, &res); + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + if( eqOnly && r.eqSeen==0 ){ + assert( res!=0 ); + goto seek_not_found; + } + } +#ifdef SQLITE_TEST + sqlite3_search_count++; +#endif + if( oc>=OP_SeekGE ){ assert( oc==OP_SeekGE || oc==OP_SeekGT ); + if( res<0 || (res==0 && oc==OP_SeekGT) ){ + res = 0; + rc = sqlite3BtreeNext(pC->uc.pCursor, 0); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + res = 1; + }else{ + goto abort_due_to_error; + } + } + }else{ + res = 0; + } + }else{ + assert( oc==OP_SeekLT || oc==OP_SeekLE ); + if( res>0 || (res==0 && oc==OP_SeekLT) ){ + res = 0; + rc = sqlite3BtreePrevious(pC->uc.pCursor, 0); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + res = 1; + }else{ + goto abort_due_to_error; + } + } + }else{ + /* res might be negative because the table is empty. Check to + ** see if this is the case. + */ + res = sqlite3BtreeEof(pC->uc.pCursor); + } + } +seek_not_found: + assert( pOp->p2>0 ); + VdbeBranchTaken(res!=0,2); + if( res ){ + goto jump_to_p2; + }else if( eqOnly ){ + assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT ); + pOp++; /* Skip the OP_IdxLt or OP_IdxGT that follows */ + } + break; +} + + +/* Opcode: SeekScan P1 P2 * * * +** Synopsis: Scan-ahead up to P1 rows +** +** This opcode is a prefix opcode to OP_SeekGE. In other words, this +** opcode must be immediately followed by OP_SeekGE. This constraint is +** checked by assert() statements. +** +** This opcode uses the P1 through P4 operands of the subsequent +** OP_SeekGE. In the text that follows, the operands of the subsequent +** OP_SeekGE opcode are denoted as SeekOP.P1 through SeekOP.P4. Only +** the P1 and P2 operands of this opcode are also used, and are called +** This.P1 and This.P2. +** +** This opcode helps to optimize IN operators on a multi-column index +** where the IN operator is on the later terms of the index by avoiding +** unnecessary seeks on the btree, substituting steps to the next row +** of the b-tree instead. A correct answer is obtained if this opcode +** is omitted or is a no-op. +** +** The SeekGE.P3 and SeekGE.P4 operands identify an unpacked key which +** is the desired entry that we want the cursor SeekGE.P1 to be pointing +** to. Call this SeekGE.P4/P5 row the "target". +** +** If the SeekGE.P1 cursor is not currently pointing to a valid row, +** then this opcode is a no-op and control passes through into the OP_SeekGE. +** +** If the SeekGE.P1 cursor is pointing to a valid row, then that row +** might be the target row, or it might be near and slightly before the +** target row. This opcode attempts to position the cursor on the target +** row by, perhaps by invoking sqlite3BtreeStep() on the cursor +** between 0 and This.P1 times. +** +** There are three possible outcomes from this opcode:
      +** +**
    1. If after This.P1 steps, the cursor is still point to a place that +** is earlier in the btree than the target row, +** then fall through into the subsquence OP_SeekGE opcode. +** +**
    2. If the cursor is successfully moved to the target row by 0 or more +** sqlite3BtreeNext() calls, then jump to This.P2, which will land just +** past the OP_IdxGT opcode that follows the OP_SeekGE. +** +**
    3. If the cursor ends up past the target row (indicating the the target +** row does not exist in the btree) then jump to SeekOP.P2. +**
    +*/ +case OP_SeekScan: { + VdbeCursor *pC; + int res; + int nStep; + UnpackedRecord r; + + assert( pOp[1].opcode==OP_SeekGE ); + + /* pOp->p2 points to the first instruction past the OP_IdxGT that + ** follows the OP_SeekGE. */ + assert( pOp->p2>=(int)(pOp-aOp)+2 ); + assert( aOp[pOp->p2-1].opcode==OP_IdxGT ); + assert( pOp[1].p1==aOp[pOp->p2-1].p1 ); + assert( pOp[1].p2==aOp[pOp->p2-1].p2 ); + assert( pOp[1].p3==aOp[pOp->p2-1].p3 ); + + assert( pOp->p1>0 ); + pC = p->apCsr[pOp[1].p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( !pC->isTable ); + if( !sqlite3BtreeCursorIsValidNN(pC->uc.pCursor) ){ +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + printf("... cursor not valid - fall through\n"); + } +#endif + break; + } + nStep = pOp->p1; + assert( nStep>=1 ); + r.pKeyInfo = pC->pKeyInfo; + r.nField = (u16)pOp[1].p4.i; + r.default_rc = 0; + r.aMem = &aMem[pOp[1].p3]; +#ifdef SQLITE_DEBUG + { + int i; + for(i=0; i0 ){ + seekscan_search_fail: +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + printf("... %d steps and then skip\n", pOp->p1 - nStep); + } +#endif + VdbeBranchTaken(1,3); + pOp++; + goto jump_to_p2; + } + if( res==0 ){ +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + printf("... %d steps and then success\n", pOp->p1 - nStep); + } +#endif + VdbeBranchTaken(2,3); + goto jump_to_p2; + break; + } + if( nStep<=0 ){ +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + printf("... fall through after %d steps\n", pOp->p1); + } +#endif + VdbeBranchTaken(0,3); + break; + } + nStep--; + rc = sqlite3BtreeNext(pC->uc.pCursor, 0); + if( rc ){ + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + goto seekscan_search_fail; + }else{ + goto abort_due_to_error; + } + } + } + + break; +} + + +/* Opcode: SeekHit P1 P2 P3 * * +** Synopsis: set P2<=seekHit<=P3 +** +** Increase or decrease the seekHit value for cursor P1, if necessary, +** so that it is no less than P2 and no greater than P3. +** +** The seekHit integer represents the maximum of terms in an index for which +** there is known to be at least one match. If the seekHit value is smaller +** than the total number of equality terms in an index lookup, then the +** OP_IfNoHope opcode might run to see if the IN loop can be abandoned +** early, thus saving work. This is part of the IN-early-out optimization. +** +** P1 must be a valid b-tree cursor. +*/ +case OP_SeekHit: { + VdbeCursor *pC; + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pOp->p3>=pOp->p2 ); + if( pC->seekHitp2 ){ + pC->seekHit = pOp->p2; + }else if( pC->seekHit>pOp->p3 ){ + pC->seekHit = pOp->p3; + } + break; +} + +/* Opcode: IfNotOpen P1 P2 * * * +** Synopsis: if( !csr[P1] ) goto P2 +** +** If cursor P1 is not open, jump to instruction P2. Otherwise, fall through. +*/ +case OP_IfNotOpen: { /* jump */ + assert( pOp->p1>=0 && pOp->p1nCursor ); + VdbeBranchTaken(p->apCsr[pOp->p1]==0, 2); + if( !p->apCsr[pOp->p1] ){ + goto jump_to_p2_and_check_for_interrupt; + } + break; +} + +/* Opcode: Found P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If P4==0 then register P3 holds a blob constructed by MakeRecord. If +** P4>0 then register P3 is the first of P4 registers that form an unpacked +** record. +** +** Cursor P1 is on an index btree. If the record identified by P3 and P4 +** is a prefix of any entry in P1 then a jump is made to P2 and +** P1 is left pointing at the matching entry. +** +** This operation leaves the cursor in a state where it can be +** advanced in the forward direction. The Next instruction will work, +** but not the Prev instruction. +** +** See also: NotFound, NoConflict, NotExists. SeekGe +*/ +/* Opcode: NotFound P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If P4==0 then register P3 holds a blob constructed by MakeRecord. If +** P4>0 then register P3 is the first of P4 registers that form an unpacked +** record. +** +** Cursor P1 is on an index btree. If the record identified by P3 and P4 +** is not the prefix of any entry in P1 then a jump is made to P2. If P1 +** does contain an entry whose prefix matches the P3/P4 record then control +** falls through to the next instruction and P1 is left pointing at the +** matching entry. +** +** This operation leaves the cursor in a state where it cannot be +** advanced in either direction. In other words, the Next and Prev +** opcodes do not work after this operation. +** +** See also: Found, NotExists, NoConflict, IfNoHope +*/ +/* Opcode: IfNoHope P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** Register P3 is the first of P4 registers that form an unpacked +** record. Cursor P1 is an index btree. P2 is a jump destination. +** In other words, the operands to this opcode are the same as the +** operands to OP_NotFound and OP_IdxGT. +** +** This opcode is an optimization attempt only. If this opcode always +** falls through, the correct answer is still obtained, but extra works +** is performed. +** +** A value of N in the seekHit flag of cursor P1 means that there exists +** a key P3:N that will match some record in the index. We want to know +** if it is possible for a record P3:P4 to match some record in the +** index. If it is not possible, we can skips some work. So if seekHit +** is less than P4, attempt to find out if a match is possible by running +** OP_NotFound. +** +** This opcode is used in IN clause processing for a multi-column key. +** If an IN clause is attached to an element of the key other than the +** left-most element, and if there are no matches on the most recent +** seek over the whole key, then it might be that one of the key element +** to the left is prohibiting a match, and hence there is "no hope" of +** any match regardless of how many IN clause elements are checked. +** In such a case, we abandon the IN clause search early, using this +** opcode. The opcode name comes from the fact that the +** jump is taken if there is "no hope" of achieving a match. +** +** See also: NotFound, SeekHit +*/ +/* Opcode: NoConflict P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If P4==0 then register P3 holds a blob constructed by MakeRecord. If +** P4>0 then register P3 is the first of P4 registers that form an unpacked +** record. +** +** Cursor P1 is on an index btree. If the record identified by P3 and P4 +** contains any NULL value, jump immediately to P2. If all terms of the +** record are not-NULL then a check is done to determine if any row in the +** P1 index btree has a matching key prefix. If there are no matches, jump +** immediately to P2. If there is a match, fall through and leave the P1 +** cursor pointing to the matching row. +** +** This opcode is similar to OP_NotFound with the exceptions that the +** branch is always taken if any part of the search key input is NULL. +** +** This operation leaves the cursor in a state where it cannot be +** advanced in either direction. In other words, the Next and Prev +** opcodes do not work after this operation. +** +** See also: NotFound, Found, NotExists +*/ +case OP_IfNoHope: { /* jump, in3 */ + VdbeCursor *pC; + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + if( pC->seekHit>=pOp->p4.i ) break; + /* 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 */ + int alreadyExists; + int takeJump; + int ii; + VdbeCursor *pC; + int res; + UnpackedRecord *pFree; + UnpackedRecord *pIdxKey; + UnpackedRecord r; + +#ifdef SQLITE_TEST + if( pOp->opcode!=OP_NoConflict ) sqlite3_found_count++; +#endif + + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( pOp->p4type==P4_INT32 ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); +#ifdef SQLITE_DEBUG + pC->seekOp = pOp->opcode; +#endif + pIn3 = &aMem[pOp->p3]; + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->uc.pCursor!=0 ); + assert( pC->isTable==0 ); + if( pOp->p4.i>0 ){ + r.pKeyInfo = pC->pKeyInfo; + r.nField = (u16)pOp->p4.i; + r.aMem = pIn3; +#ifdef SQLITE_DEBUG + for(ii=0; iip3+ii, &r.aMem[ii]); + } +#endif + pIdxKey = &r; + pFree = 0; + }else{ + assert( pIn3->flags & MEM_Blob ); + rc = ExpandBlob(pIn3); + assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); + if( rc ) goto no_mem; + pFree = pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo); + if( pIdxKey==0 ) goto no_mem; + sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey); + } + pIdxKey->default_rc = 0; + takeJump = 0; + if( pOp->opcode==OP_NoConflict ){ + /* For the OP_NoConflict opcode, take the jump if any of the + ** input fields are NULL, since any key with a NULL will not + ** conflict */ + for(ii=0; iinField; ii++){ + if( pIdxKey->aMem[ii].flags & MEM_Null ){ + takeJump = 1; + break; + } + } + } + rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, pIdxKey, 0, 0, &res); + if( pFree ) sqlite3DbFreeNN(db, pFree); + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + pC->seekResult = res; + alreadyExists = (res==0); + pC->nullRow = 1-alreadyExists; + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + if( pOp->opcode==OP_Found ){ + VdbeBranchTaken(alreadyExists!=0,2); + if( alreadyExists ) goto jump_to_p2; + }else{ + VdbeBranchTaken(takeJump||alreadyExists==0,2); + if( takeJump || !alreadyExists ) goto jump_to_p2; + if( pOp->opcode==OP_IfNoHope ) pC->seekHit = pOp->p4.i; + } + break; +} + +/* Opcode: SeekRowid P1 P2 P3 * * +** Synopsis: intkey=r[P3] +** +** P1 is the index of a cursor open on an SQL table btree (with integer +** keys). If register P3 does not contain an integer or if P1 does not +** contain a record with rowid P3 then jump immediately to P2. +** Or, if P2 is 0, raise an SQLITE_CORRUPT error. If P1 does contain +** a record with rowid P3 then +** leave the cursor pointing at that record and fall through to the next +** instruction. +** +** The OP_NotExists opcode performs the same operation, but with OP_NotExists +** the P3 register must be guaranteed to contain an integer value. With this +** opcode, register P3 might not contain an integer. +** +** The OP_NotFound opcode performs the same operation on index btrees +** (with arbitrary multi-value keys). +** +** This opcode leaves the cursor in a state where it cannot be advanced +** in either direction. In other words, the Next and Prev opcodes will +** not work following this opcode. +** +** See also: Found, NotFound, NoConflict, SeekRowid +*/ +/* Opcode: NotExists P1 P2 P3 * * +** Synopsis: intkey=r[P3] +** +** P1 is the index of a cursor open on an SQL table btree (with integer +** keys). P3 is an integer rowid. If P1 does not contain a record with +** rowid P3 then jump immediately to P2. Or, if P2 is 0, raise an +** SQLITE_CORRUPT error. If P1 does contain a record with rowid P3 then +** leave the cursor pointing at that record and fall through to the next +** instruction. +** +** The OP_SeekRowid opcode performs the same operation but also allows the +** P3 register to contain a non-integer value, in which case the jump is +** always taken. This opcode requires that P3 always contain an integer. +** +** The OP_NotFound opcode performs the same operation on index btrees +** (with arbitrary multi-value keys). +** +** This opcode leaves the cursor in a state where it cannot be advanced +** in either direction. In other words, the Next and Prev opcodes will +** not work following this opcode. +** +** See also: Found, NotFound, NoConflict, SeekRowid +*/ +case OP_SeekRowid: { /* jump, in3 */ + VdbeCursor *pC; + BtCursor *pCrsr; + int res; + u64 iKey; + + pIn3 = &aMem[pOp->p3]; + testcase( pIn3->flags & MEM_Int ); + testcase( pIn3->flags & MEM_IntReal ); + testcase( pIn3->flags & MEM_Real ); + testcase( (pIn3->flags & (MEM_Str|MEM_Int))==MEM_Str ); + if( (pIn3->flags & (MEM_Int|MEM_IntReal))==0 ){ + /* If pIn3->u.i does not contain an integer, compute iKey as the + ** integer value of pIn3. Jump to P2 if pIn3 cannot be converted + ** into an integer without loss of information. Take care to avoid + ** changing the datatype of pIn3, however, as it is used by other + ** parts of the prepared statement. */ + Mem x = pIn3[0]; + applyAffinity(&x, SQLITE_AFF_NUMERIC, encoding); + if( (x.flags & MEM_Int)==0 ) goto jump_to_p2; + iKey = x.u.i; + goto notExistsWithKey; + } + /* Fall through into OP_NotExists */ + /* no break */ deliberate_fall_through +case OP_NotExists: /* jump, in3 */ + pIn3 = &aMem[pOp->p3]; + assert( (pIn3->flags & MEM_Int)!=0 || pOp->opcode==OP_SeekRowid ); + assert( pOp->p1>=0 && pOp->p1nCursor ); + iKey = pIn3->u.i; +notExistsWithKey: + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); +#ifdef SQLITE_DEBUG + if( pOp->opcode==OP_SeekRowid ) pC->seekOp = OP_SeekRowid; +#endif + assert( pC->isTable ); + assert( pC->eCurType==CURTYPE_BTREE ); + pCrsr = pC->uc.pCursor; + assert( pCrsr!=0 ); + res = 0; + rc = sqlite3BtreeMovetoUnpacked(pCrsr, 0, iKey, 0, &res); + assert( rc==SQLITE_OK || res==0 ); + pC->movetoTarget = iKey; /* Used by OP_Delete */ + pC->nullRow = 0; + pC->cacheStatus = CACHE_STALE; + pC->deferredMoveto = 0; + VdbeBranchTaken(res!=0,2); + pC->seekResult = res; + if( res!=0 ){ + assert( rc==SQLITE_OK ); + if( pOp->p2==0 ){ + rc = SQLITE_CORRUPT_BKPT; + }else{ + goto jump_to_p2; + } + } + if( rc ) goto abort_due_to_error; + break; +} + +/* Opcode: Sequence P1 P2 * * * +** Synopsis: r[P2]=cursor[P1].ctr++ +** +** Find the next available sequence number for cursor P1. +** Write the sequence number into register P2. +** The sequence number on the cursor is incremented after this +** instruction. +*/ +case OP_Sequence: { /* out2 */ + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( p->apCsr[pOp->p1]!=0 ); + assert( p->apCsr[pOp->p1]->eCurType!=CURTYPE_VTAB ); + pOut = out2Prerelease(p, pOp); + pOut->u.i = p->apCsr[pOp->p1]->seqCount++; + break; +} + + +/* Opcode: NewRowid P1 P2 P3 * * +** Synopsis: r[P2]=rowid +** +** Get a new integer record number (a.k.a "rowid") used as the key to a table. +** The record number is not previously used as a key in the database +** table that cursor P1 points to. The new record number is written +** written to register P2. +** +** If P3>0 then P3 is a register in the root frame of this VDBE that holds +** the largest previously generated record number. No new record numbers are +** allowed to be less than this value. When this value reaches its maximum, +** an SQLITE_FULL error is generated. The P3 register is updated with the ' +** generated record number. This P3 mechanism is used to help implement the +** AUTOINCREMENT feature. +*/ +case OP_NewRowid: { /* out2 */ + i64 v; /* The new rowid */ + VdbeCursor *pC; /* Cursor of table to get the new rowid */ + int res; /* Result of an sqlite3BtreeLast() */ + int cnt; /* Counter to limit the number of searches */ + Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */ + VdbeFrame *pFrame; /* Root frame of VDBE */ + + v = 0; + res = 0; + pOut = out2Prerelease(p, pOp); + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->isTable ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->uc.pCursor!=0 ); + { + /* The next rowid or record number (different terms for the same + ** thing) is obtained in a two-step algorithm. + ** + ** First we attempt to find the largest existing rowid and add one + ** to that. But if the largest existing rowid is already the maximum + ** positive integer, we have to fall through to the second + ** probabilistic algorithm + ** + ** The second algorithm is to select a rowid at random and see if + ** it already exists in the table. If it does not exist, we have + ** succeeded. If the random rowid does exist, we select a new one + ** and try again, up to 100 times. + */ + assert( pC->isTable ); + +#ifdef SQLITE_32BIT_ROWID +# define MAX_ROWID 0x7fffffff +#else + /* Some compilers complain about constants of the form 0x7fffffffffffffff. + ** Others complain about 0x7ffffffffffffffffLL. The following macro seems + ** to provide the constant while making all compilers happy. + */ +# define MAX_ROWID (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff ) +#endif + + if( !pC->useRandomRowid ){ + rc = sqlite3BtreeLast(pC->uc.pCursor, &res); + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + if( res ){ + v = 1; /* IMP: R-61914-48074 */ + }else{ + assert( sqlite3BtreeCursorIsValid(pC->uc.pCursor) ); + v = sqlite3BtreeIntegerKey(pC->uc.pCursor); + if( v>=MAX_ROWID ){ + pC->useRandomRowid = 1; + }else{ + v++; /* IMP: R-29538-34987 */ + } + } + } + +#ifndef SQLITE_OMIT_AUTOINCREMENT + if( pOp->p3 ){ + /* Assert that P3 is a valid memory cell. */ + assert( pOp->p3>0 ); + if( p->pFrame ){ + for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent); + /* Assert that P3 is a valid memory cell. */ + assert( pOp->p3<=pFrame->nMem ); + pMem = &pFrame->aMem[pOp->p3]; + }else{ + /* Assert that P3 is a valid memory cell. */ + assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); + pMem = &aMem[pOp->p3]; + memAboutToChange(p, pMem); + } + assert( memIsValid(pMem) ); + + REGISTER_TRACE(pOp->p3, pMem); + sqlite3VdbeMemIntegerify(pMem); + assert( (pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */ + if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){ + rc = SQLITE_FULL; /* IMP: R-17817-00630 */ + goto abort_due_to_error; + } + if( vu.i+1 ){ + v = pMem->u.i + 1; + } + pMem->u.i = v; + } +#endif + if( pC->useRandomRowid ){ + /* IMPLEMENTATION-OF: R-07677-41881 If the largest ROWID is equal to the + ** largest possible integer (9223372036854775807) then the database + ** engine starts picking positive candidate ROWIDs at random until + ** it finds one that is not previously used. */ + assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is + ** an AUTOINCREMENT table. */ + cnt = 0; + do{ + sqlite3_randomness(sizeof(v), &v); + v &= (MAX_ROWID>>1); v++; /* Ensure that v is greater than zero */ + }while( ((rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)v, + 0, &res))==SQLITE_OK) + && (res==0) + && (++cnt<100)); + if( rc ) goto abort_due_to_error; + if( res==0 ){ + rc = SQLITE_FULL; /* IMP: R-38219-53002 */ + goto abort_due_to_error; + } + assert( v>0 ); /* EV: R-40812-03570 */ + } + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + } + pOut->u.i = v; + break; +} + +/* Opcode: Insert P1 P2 P3 P4 P5 +** Synopsis: intkey=r[P3] data=r[P2] +** +** Write an entry into the table of cursor P1. A new entry is +** created if it doesn't already exist or the data for an existing +** entry is overwritten. The data is the value MEM_Blob stored in register +** number P2. The key is stored in register P3. The key must +** be a MEM_Int. +** +** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is +** incremented (otherwise not). If the OPFLAG_LASTROWID flag of P5 is set, +** then rowid is stored for subsequent return by the +** sqlite3_last_insert_rowid() function (otherwise it is unmodified). +** +** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might +** run faster by avoiding an unnecessary seek on cursor P1. However, +** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior +** seeks on the cursor or if the most recent seek used a key equal to P3. +** +** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an +** UPDATE operation. Otherwise (if the flag is clear) then this opcode +** is part of an INSERT operation. The difference is only important to +** the update hook. +** +** Parameter P4 may point to a Table structure, or may be NULL. If it is +** not NULL, then the update-hook (sqlite3.xUpdateCallback) is invoked +** following a successful insert. +** +** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically +** allocated, then ownership of P2 is transferred to the pseudo-cursor +** and register P2 becomes ephemeral. If the cursor is changed, the +** value of register P2 will then change. Make sure this does not +** cause any problems.) +** +** This instruction only works on tables. The equivalent instruction +** for indices is OP_IdxInsert. +*/ +case OP_Insert: { + Mem *pData; /* MEM cell holding data for the record to be inserted */ + Mem *pKey; /* MEM cell holding key for the record */ + VdbeCursor *pC; /* Cursor to table into which insert is written */ + int seekResult; /* Result of prior seek or 0 if no USESEEKRESULT flag */ + const char *zDb; /* database name - used by the update hook */ + Table *pTab; /* Table structure - used by update and pre-update hooks */ + BtreePayload x; /* Payload to be inserted */ + + pData = &aMem[pOp->p2]; + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( memIsValid(pData) ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->deferredMoveto==0 ); + assert( pC->uc.pCursor!=0 ); + assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable ); + assert( pOp->p4type==P4_TABLE || pOp->p4type>=P4_STATIC ); + REGISTER_TRACE(pOp->p2, pData); + sqlite3VdbeIncrWriteCounter(p, pC); + + pKey = &aMem[pOp->p3]; + assert( pKey->flags & MEM_Int ); + assert( memIsValid(pKey) ); + REGISTER_TRACE(pOp->p3, pKey); + x.nKey = pKey->u.i; + + if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){ + assert( pC->iDb>=0 ); + zDb = db->aDb[pC->iDb].zDbSName; + pTab = pOp->p4.pTab; + assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) ); + }else{ + pTab = 0; + zDb = 0; /* Not needed. Silence a compiler warning. */ + } + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + /* Invoke the pre-update hook, if any */ + if( pTab ){ + if( db->xPreUpdateCallback && !(pOp->p5 & OPFLAG_ISUPDATE) ){ + sqlite3VdbePreUpdateHook(p, pC, SQLITE_INSERT, zDb, pTab, x.nKey,pOp->p2); + } + if( db->xUpdateCallback==0 || pTab->aCol==0 ){ + /* Prevent post-update hook from running in cases when it should not */ + pTab = 0; + } + } + if( pOp->p5 & OPFLAG_ISNOOP ) break; +#endif + + if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++; + if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = x.nKey; + assert( (pData->flags & (MEM_Blob|MEM_Str))!=0 || pData->n==0 ); + x.pData = pData->z; + x.nData = pData->n; + seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0); + if( pData->flags & MEM_Zero ){ + x.nZero = pData->u.nZero; + }else{ + x.nZero = 0; + } + x.pKey = 0; + rc = sqlite3BtreeInsert(pC->uc.pCursor, &x, + (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION)), seekResult + ); + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + + /* Invoke the update-hook if required. */ + if( rc ) goto abort_due_to_error; + if( pTab ){ + assert( db->xUpdateCallback!=0 ); + assert( pTab->aCol!=0 ); + db->xUpdateCallback(db->pUpdateArg, + (pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT, + zDb, pTab->zName, x.nKey); + } + break; +} + +/* Opcode: Delete P1 P2 P3 P4 P5 +** +** Delete the record at which the P1 cursor is currently pointing. +** +** If the OPFLAG_SAVEPOSITION bit of the P5 parameter is set, then +** the cursor will be left pointing at either the next or the previous +** record in the table. If it is left pointing at the next record, then +** the next Next instruction will be a no-op. As a result, in this case +** it is ok to delete a record from within a Next loop. If +** OPFLAG_SAVEPOSITION bit of P5 is clear, then the cursor will be +** left in an undefined state. +** +** If the OPFLAG_AUXDELETE bit is set on P5, that indicates that this +** delete one of several associated with deleting a table row and all its +** associated index entries. Exactly one of those deletes is the "primary" +** delete. The others are all on OPFLAG_FORDELETE cursors or else are +** marked with the AUXDELETE flag. +** +** If the OPFLAG_NCHANGE flag of P2 (NB: P2 not P5) is set, then the row +** change count is incremented (otherwise not). +** +** P1 must not be pseudo-table. It has to be a real table with +** multiple rows. +** +** If P4 is not NULL then it points to a Table object. In this case either +** the update or pre-update hook, or both, may be invoked. The P1 cursor must +** have been positioned using OP_NotFound prior to invoking this opcode in +** this case. Specifically, if one is configured, the pre-update hook is +** invoked if P4 is not NULL. The update-hook is invoked if one is configured, +** P4 is not NULL, and the OPFLAG_NCHANGE flag is set in P2. +** +** If the OPFLAG_ISUPDATE flag is set in P2, then P3 contains the address +** of the memory cell that contains the value that the rowid of the row will +** be set to by the update. +*/ +case OP_Delete: { + VdbeCursor *pC; + const char *zDb; + Table *pTab; + int opflags; + + opflags = pOp->p2; + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->uc.pCursor!=0 ); + assert( pC->deferredMoveto==0 ); + sqlite3VdbeIncrWriteCounter(p, pC); + +#ifdef SQLITE_DEBUG + if( pOp->p4type==P4_TABLE + && HasRowid(pOp->p4.pTab) + && pOp->p5==0 + && sqlite3BtreeCursorIsValidNN(pC->uc.pCursor) + ){ + /* If p5 is zero, the seek operation that positioned the cursor prior to + ** OP_Delete will have also set the pC->movetoTarget field to the rowid of + ** the row that is being deleted */ + i64 iKey = sqlite3BtreeIntegerKey(pC->uc.pCursor); + assert( CORRUPT_DB || pC->movetoTarget==iKey ); + } +#endif + + /* If the update-hook or pre-update-hook will be invoked, set zDb to + ** the name of the db to pass as to it. Also set local pTab to a copy + ** of p4.pTab. Finally, if p5 is true, indicating that this cursor was + ** last moved with OP_Next or OP_Prev, not Seek or NotFound, set + ** VdbeCursor.movetoTarget to the current rowid. */ + if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){ + assert( pC->iDb>=0 ); + assert( pOp->p4.pTab!=0 ); + zDb = db->aDb[pC->iDb].zDbSName; + pTab = pOp->p4.pTab; + if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){ + pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor); + } + }else{ + zDb = 0; /* Not needed. Silence a compiler warning. */ + pTab = 0; /* Not needed. Silence a compiler warning. */ + } + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + /* Invoke the pre-update-hook if required. */ + if( db->xPreUpdateCallback && pOp->p4.pTab ){ + assert( !(opflags & OPFLAG_ISUPDATE) + || HasRowid(pTab)==0 + || (aMem[pOp->p3].flags & MEM_Int) + ); + sqlite3VdbePreUpdateHook(p, pC, + (opflags & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_DELETE, + zDb, pTab, pC->movetoTarget, + pOp->p3 + ); + } + if( opflags & OPFLAG_ISNOOP ) break; +#endif + + /* Only flags that can be set are SAVEPOISTION and AUXDELETE */ + assert( (pOp->p5 & ~(OPFLAG_SAVEPOSITION|OPFLAG_AUXDELETE))==0 ); + assert( OPFLAG_SAVEPOSITION==BTREE_SAVEPOSITION ); + assert( OPFLAG_AUXDELETE==BTREE_AUXDELETE ); + +#ifdef SQLITE_DEBUG + if( p->pFrame==0 ){ + if( pC->isEphemeral==0 + && (pOp->p5 & OPFLAG_AUXDELETE)==0 + && (pC->wrFlag & OPFLAG_FORDELETE)==0 + ){ + nExtraDelete++; + } + if( pOp->p2 & OPFLAG_NCHANGE ){ + nExtraDelete--; + } + } +#endif + + rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5); + pC->cacheStatus = CACHE_STALE; + pC->seekResult = 0; + if( rc ) goto abort_due_to_error; + + /* Invoke the update-hook if required. */ + if( opflags & OPFLAG_NCHANGE ){ + p->nChange++; + if( db->xUpdateCallback && HasRowid(pTab) ){ + db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName, + pC->movetoTarget); + assert( pC->iDb>=0 ); + } + } + + break; +} +/* Opcode: ResetCount * * * * * +** +** The value of the change counter is copied to the database handle +** change counter (returned by subsequent calls to sqlite3_changes()). +** Then the VMs internal change counter resets to 0. +** This is used by trigger programs. +*/ +case OP_ResetCount: { + sqlite3VdbeSetChanges(db, p->nChange); + p->nChange = 0; + break; +} + +/* Opcode: SorterCompare P1 P2 P3 P4 +** Synopsis: if key(P1)!=trim(r[P3],P4) goto P2 +** +** P1 is a sorter cursor. This instruction compares a prefix of the +** record blob in register P3 against a prefix of the entry that +** the sorter cursor currently points to. Only the first P4 fields +** of r[P3] and the sorter record are compared. +** +** If either P3 or the sorter contains a NULL in one of their significant +** fields (not counting the P4 fields at the end which are ignored) then +** the comparison is assumed to be equal. +** +** Fall through to next instruction if the two records compare equal to +** each other. Jump to P2 if they are different. +*/ +case OP_SorterCompare: { + VdbeCursor *pC; + int res; + int nKeyCol; + + pC = p->apCsr[pOp->p1]; + assert( isSorter(pC) ); + assert( pOp->p4type==P4_INT32 ); + pIn3 = &aMem[pOp->p3]; + nKeyCol = pOp->p4.i; + res = 0; + rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res); + VdbeBranchTaken(res!=0,2); + if( rc ) goto abort_due_to_error; + if( res ) goto jump_to_p2; + break; +}; + +/* Opcode: SorterData P1 P2 P3 * * +** Synopsis: r[P2]=data +** +** Write into register P2 the current sorter data for sorter cursor P1. +** Then clear the column header cache on cursor P3. +** +** This opcode is normally use to move a record out of the sorter and into +** a register that is the source for a pseudo-table cursor created using +** OpenPseudo. That pseudo-table cursor is the one that is identified by +** parameter P3. Clearing the P3 column cache as part of this opcode saves +** us from having to issue a separate NullRow instruction to clear that cache. +*/ +case OP_SorterData: { + VdbeCursor *pC; + + pOut = &aMem[pOp->p2]; + pC = p->apCsr[pOp->p1]; + assert( isSorter(pC) ); + rc = sqlite3VdbeSorterRowkey(pC, pOut); + assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) ); + assert( pOp->p1>=0 && pOp->p1nCursor ); + if( rc ) goto abort_due_to_error; + p->apCsr[pOp->p3]->cacheStatus = CACHE_STALE; + break; +} + +/* Opcode: RowData P1 P2 P3 * * +** Synopsis: r[P2]=data +** +** Write into register P2 the complete row content for the row at +** which cursor P1 is currently pointing. +** There is no interpretation of the data. +** It is just copied onto the P2 register exactly as +** it is found in the database file. +** +** If cursor P1 is an index, then the content is the key of the row. +** If cursor P2 is a table, then the content extracted is the data. +** +** If the P1 cursor must be pointing to a valid row (not a NULL row) +** of a real table, not a pseudo-table. +** +** If P3!=0 then this opcode is allowed to make an ephemeral pointer +** into the database page. That means that the content of the output +** register will be invalidated as soon as the cursor moves - including +** moves caused by other cursors that "save" the current cursors +** position in order that they can write to the same table. If P3==0 +** then a copy of the data is made into memory. P3!=0 is faster, but +** P3==0 is safer. +** +** If P3!=0 then the content of the P2 register is unsuitable for use +** in OP_Result and any OP_Result will invalidate the P2 register content. +** The P2 register content is invalidated by opcodes like OP_Function or +** by any use of another cursor pointing to the same table. +*/ +case OP_RowData: { + VdbeCursor *pC; + BtCursor *pCrsr; + u32 n; + + pOut = out2Prerelease(p, pOp); + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( isSorter(pC)==0 ); + assert( pC->nullRow==0 ); + assert( pC->uc.pCursor!=0 ); + pCrsr = pC->uc.pCursor; + + /* The OP_RowData opcodes always follow OP_NotExists or + ** OP_SeekRowid or OP_Rewind/Op_Next with no intervening instructions + ** that might invalidate the cursor. + ** If this where not the case, on of the following assert()s + ** would fail. Should this ever change (because of changes in the code + ** generator) then the fix would be to insert a call to + ** sqlite3VdbeCursorMoveto(). + */ + assert( pC->deferredMoveto==0 ); + assert( sqlite3BtreeCursorIsValid(pCrsr) ); + + n = sqlite3BtreePayloadSize(pCrsr); + if( n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){ + goto too_big; + } + testcase( n==0 ); + rc = sqlite3VdbeMemFromBtreeZeroOffset(pCrsr, n, pOut); + if( rc ) goto abort_due_to_error; + if( !pOp->p3 ) Deephemeralize(pOut); + UPDATE_MAX_BLOBSIZE(pOut); + REGISTER_TRACE(pOp->p2, pOut); + break; +} + +/* Opcode: Rowid P1 P2 * * * +** Synopsis: r[P2]=rowid +** +** Store in register P2 an integer which is the key of the table entry that +** P1 is currently point to. +** +** P1 can be either an ordinary table or a virtual table. There used to +** 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 */ + VdbeCursor *pC; + i64 v; + sqlite3_vtab *pVtab; + const sqlite3_module *pModule; + + pOut = out2Prerelease(p, pOp); + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow ); + if( pC->nullRow ){ + pOut->flags = MEM_Null; + break; + }else if( pC->deferredMoveto ){ + v = pC->movetoTarget; +#ifndef SQLITE_OMIT_VIRTUALTABLE + }else if( pC->eCurType==CURTYPE_VTAB ){ + assert( pC->uc.pVCur!=0 ); + pVtab = pC->uc.pVCur->pVtab; + pModule = pVtab->pModule; + assert( pModule->xRowid ); + rc = pModule->xRowid(pC->uc.pVCur, &v); + sqlite3VtabImportErrmsg(p, pVtab); + if( rc ) goto abort_due_to_error; +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + }else{ + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->uc.pCursor!=0 ); + rc = sqlite3VdbeCursorRestore(pC); + if( rc ) goto abort_due_to_error; + if( pC->nullRow ){ + pOut->flags = MEM_Null; + break; + } + v = sqlite3BtreeIntegerKey(pC->uc.pCursor); + } + pOut->u.i = v; + break; +} + +/* Opcode: NullRow P1 * * * * +** +** Move the cursor P1 to a null row. Any OP_Column operations +** that occur while the cursor is on the null row will always +** write a NULL. +*/ +case OP_NullRow: { + VdbeCursor *pC; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + pC->nullRow = 1; + pC->cacheStatus = CACHE_STALE; + if( pC->eCurType==CURTYPE_BTREE ){ + assert( pC->uc.pCursor!=0 ); + sqlite3BtreeClearCursor(pC->uc.pCursor); + } +#ifdef SQLITE_DEBUG + if( pC->seekOp==0 ) pC->seekOp = OP_NullRow; +#endif + break; +} + +/* Opcode: SeekEnd P1 * * * * +** +** Position cursor P1 at the end of the btree for the purpose of +** appending a new entry onto the btree. +** +** It is assumed that the cursor is used only for appending and so +** if the cursor is valid, then the cursor must already be pointing +** at the end of the btree and so no changes are made to +** the cursor. +*/ +/* Opcode: Last P1 P2 * * * +** +** The next use of the Rowid or Column or Prev instruction for P1 +** will refer to the last entry in the database table or index. +** If the table or index is empty and P2>0, then jump immediately to P2. +** If P2 is 0 or if the table or index is not empty, fall through +** to the following instruction. +** +** This opcode leaves the cursor configured to move in reverse order, +** 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 */ + VdbeCursor *pC; + BtCursor *pCrsr; + int res; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + pCrsr = pC->uc.pCursor; + res = 0; + assert( pCrsr!=0 ); +#ifdef SQLITE_DEBUG + pC->seekOp = pOp->opcode; +#endif + if( pOp->opcode==OP_SeekEnd ){ + assert( pOp->p2==0 ); + pC->seekResult = -1; + if( sqlite3BtreeCursorIsValidNN(pCrsr) ){ + break; + } + } + rc = sqlite3BtreeLast(pCrsr, &res); + pC->nullRow = (u8)res; + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + if( rc ) goto abort_due_to_error; + if( pOp->p2>0 ){ + VdbeBranchTaken(res!=0,2); + if( res ) goto jump_to_p2; + } + break; +} + +/* Opcode: IfSmaller P1 P2 P3 * * +** +** Estimate the number of rows in the table P1. Jump to P2 if that +** estimate is less than approximately 2**(0.1*P3). +*/ +case OP_IfSmaller: { /* jump */ + VdbeCursor *pC; + BtCursor *pCrsr; + int res; + i64 sz; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + pCrsr = pC->uc.pCursor; + assert( pCrsr ); + rc = sqlite3BtreeFirst(pCrsr, &res); + if( rc ) goto abort_due_to_error; + if( res==0 ){ + sz = sqlite3BtreeRowCountEst(pCrsr); + if( ALWAYS(sz>=0) && sqlite3LogEst((u64)sz)p3 ) res = 1; + } + VdbeBranchTaken(res!=0,2); + if( res ) goto jump_to_p2; + break; +} + + +/* Opcode: SorterSort P1 P2 * * * +** +** After all records have been inserted into the Sorter object +** identified by P1, invoke this opcode to actually do the sorting. +** Jump to P2 if there are no records to be sorted. +** +** This opcode is an alias for OP_Sort and OP_Rewind that is used +** for Sorter objects. +*/ +/* Opcode: Sort P1 P2 * * * +** +** This opcode does exactly the same thing as OP_Rewind except that +** it increments an undocumented global variable used for testing. +** +** Sorting is accomplished by writing records into a sorting index, +** then rewinding that index and playing it back from beginning to +** end. We use the OP_Sort opcode instead of OP_Rewind to do the +** rewinding so that the global variable will be incremented and +** regression tests can determine whether or not the optimizer is +** correctly optimizing out sorts. +*/ +case OP_SorterSort: /* jump */ +case OP_Sort: { /* jump */ +#ifdef SQLITE_TEST + sqlite3_sort_count++; + sqlite3_search_count--; +#endif + p->aCounter[SQLITE_STMTSTATUS_SORT]++; + /* Fall through into OP_Rewind */ + /* no break */ deliberate_fall_through +} +/* Opcode: Rewind P1 P2 * * * +** +** The next use of the Rowid or Column or Next instruction for P1 +** will refer to the first entry in the database table or index. +** If the table or index is empty, jump immediately to P2. +** If the table or index is not empty, fall through to the following +** instruction. +** +** This opcode leaves the cursor configured to move in forward order, +** from the beginning toward the end. In other words, the cursor is +** configured to use Next, not Prev. +*/ +case OP_Rewind: { /* jump */ + VdbeCursor *pC; + BtCursor *pCrsr; + int res; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( pOp->p5==0 ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) ); + res = 1; +#ifdef SQLITE_DEBUG + pC->seekOp = OP_Rewind; +#endif + if( isSorter(pC) ){ + rc = sqlite3VdbeSorterRewind(pC, &res); + }else{ + assert( pC->eCurType==CURTYPE_BTREE ); + pCrsr = pC->uc.pCursor; + assert( pCrsr ); + rc = sqlite3BtreeFirst(pCrsr, &res); + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + } + if( rc ) goto abort_due_to_error; + pC->nullRow = (u8)res; + assert( pOp->p2>0 && pOp->p2nOp ); + VdbeBranchTaken(res!=0,2); + if( res ) goto jump_to_p2; + break; +} + +/* Opcode: Next P1 P2 P3 P4 P5 +** +** Advance cursor P1 so that it points to the next key/data pair in its +** table or index. If there are no more key/value pairs then fall through +** to the following instruction. But if the cursor advance was successful, +** jump immediately to P2. +** +** The Next opcode is only valid following an SeekGT, SeekGE, or +** OP_Rewind opcode used to position the cursor. Next is not allowed +** to follow SeekLT, SeekLE, or OP_Last. +** +** The P1 cursor must be for a real table, not a pseudo-table. P1 must have +** been opened prior to this opcode or the program will segfault. +** +** The P3 value is a hint to the btree implementation. If P3==1, that +** means P1 is an SQL index and that this instruction could have been +** omitted if that index had been unique. P3 is usually 0. P3 is +** always either 0 or 1. +** +** P4 is always of type P4_ADVANCE. The function pointer points to +** sqlite3BtreeNext(). +** +** If P5 is positive and the jump is taken, then event counter +** number P5-1 in the prepared statement is incremented. +** +** See also: Prev +*/ +/* Opcode: Prev P1 P2 P3 P4 P5 +** +** Back up cursor P1 so that it points to the previous key/data pair in its +** table or index. If there is no previous key/value pairs then fall through +** to the following instruction. But if the cursor backup was successful, +** jump immediately to P2. +** +** +** The Prev opcode is only valid following an SeekLT, SeekLE, or +** OP_Last opcode used to position the cursor. Prev is not allowed +** to follow SeekGT, SeekGE, or OP_Rewind. +** +** The P1 cursor must be for a real table, not a pseudo-table. If P1 is +** not open then the behavior is undefined. +** +** The P3 value is a hint to the btree implementation. If P3==1, that +** means P1 is an SQL index and that this instruction could have been +** omitted if that index had been unique. P3 is usually 0. P3 is +** always either 0 or 1. +** +** P4 is always of type P4_ADVANCE. The function pointer points to +** sqlite3BtreePrevious(). +** +** If P5 is positive and the jump is taken, then event counter +** number P5-1 in the prepared statement is incremented. +*/ +/* Opcode: SorterNext P1 P2 * * P5 +** +** This opcode works just like OP_Next except that P1 must be a +** sorter object for which the OP_SorterSort opcode has been +** invoked. This opcode advances the cursor to the next sorted +** record, or jumps to P2 if there are no more sorted records. +*/ +case OP_SorterNext: { /* jump */ + VdbeCursor *pC; + + pC = p->apCsr[pOp->p1]; + assert( isSorter(pC) ); + rc = sqlite3VdbeSorterNext(db, pC); + goto next_tail; +case OP_Prev: /* jump */ +case OP_Next: /* jump */ + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( pOp->p5aCounter) ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->deferredMoveto==0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlite3BtreeNext ); + assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlite3BtreePrevious ); + + /* The Next opcode is only used after SeekGT, SeekGE, Rewind, and Found. + ** The Prev opcode is only used after SeekLT, SeekLE, and Last. */ + assert( pOp->opcode!=OP_Next + || pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE + || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found + || pC->seekOp==OP_NullRow|| pC->seekOp==OP_SeekRowid + || pC->seekOp==OP_IfNoHope); + assert( pOp->opcode!=OP_Prev + || pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE + || pC->seekOp==OP_Last || pC->seekOp==OP_IfNoHope + || pC->seekOp==OP_NullRow); + + rc = pOp->p4.xAdvance(pC->uc.pCursor, pOp->p3); +next_tail: + pC->cacheStatus = CACHE_STALE; + VdbeBranchTaken(rc==SQLITE_OK,2); + if( rc==SQLITE_OK ){ + pC->nullRow = 0; + p->aCounter[pOp->p5]++; +#ifdef SQLITE_TEST + sqlite3_search_count++; +#endif + goto jump_to_p2_and_check_for_interrupt; + } + if( rc!=SQLITE_DONE ) goto abort_due_to_error; + rc = SQLITE_OK; + pC->nullRow = 1; + goto check_for_interrupt; +} + +/* Opcode: IdxInsert P1 P2 P3 P4 P5 +** Synopsis: key=r[P2] +** +** Register P2 holds an SQL index key made using the +** MakeRecord instructions. This opcode writes that key +** into the index P1. Data for the entry is nil. +** +** If P4 is not zero, then it is the number of values in the unpacked +** key of reg(P2). In that case, P3 is the index of the first register +** for the unpacked key. The availability of the unpacked key can sometimes +** be an optimization. +** +** If P5 has the OPFLAG_APPEND bit set, that is a hint to the b-tree layer +** that this insert is likely to be an append. +** +** If P5 has the OPFLAG_NCHANGE bit set, then the change counter is +** incremented by this instruction. If the OPFLAG_NCHANGE bit is clear, +** then the change counter is unchanged. +** +** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might +** run faster by avoiding an unnecessary seek on cursor P1. However, +** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior +** seeks on the cursor or if the most recent seek used a key equivalent +** to P2. +** +** This instruction only works for indices. The equivalent instruction +** for tables is OP_Insert. +*/ +case OP_IdxInsert: { /* in2 */ + VdbeCursor *pC; + BtreePayload x; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + sqlite3VdbeIncrWriteCounter(p, pC); + assert( pC!=0 ); + assert( !isSorter(pC) ); + pIn2 = &aMem[pOp->p2]; + assert( pIn2->flags & MEM_Blob ); + if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++; + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->isTable==0 ); + rc = ExpandBlob(pIn2); + if( rc ) goto abort_due_to_error; + x.nKey = pIn2->n; + x.pKey = pIn2->z; + x.aMem = aMem + pOp->p3; + x.nMem = (u16)pOp->p4.i; + rc = sqlite3BtreeInsert(pC->uc.pCursor, &x, + (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION)), + ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0) + ); + assert( pC->deferredMoveto==0 ); + pC->cacheStatus = CACHE_STALE; + if( rc) goto abort_due_to_error; + break; +} + +/* Opcode: SorterInsert P1 P2 * * * +** Synopsis: key=r[P2] +** +** Register P2 holds an SQL index key made using the +** MakeRecord instructions. This opcode writes that key +** into the sorter P1. Data for the entry is nil. +*/ +case OP_SorterInsert: { /* in2 */ + VdbeCursor *pC; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + sqlite3VdbeIncrWriteCounter(p, pC); + assert( pC!=0 ); + assert( isSorter(pC) ); + pIn2 = &aMem[pOp->p2]; + assert( pIn2->flags & MEM_Blob ); + assert( pC->isTable==0 ); + rc = ExpandBlob(pIn2); + if( rc ) goto abort_due_to_error; + rc = sqlite3VdbeSorterWrite(pC, pIn2); + if( rc) goto abort_due_to_error; + break; +} + +/* Opcode: IdxDelete P1 P2 P3 * P5 +** Synopsis: key=r[P2@P3] +** +** The content of P3 registers starting at register P2 form +** an unpacked index key. This opcode removes that entry from the +** index opened by cursor P1. +** +** If P5 is not zero, then raise an SQLITE_CORRUPT_INDEX error +** if no matching index entry is found. This happens when running +** an UPDATE or DELETE statement and the index entry to be updated +** or deleted is not found. For some uses of IdxDelete +** (example: the EXCEPT operator) it does not matter that no matching +** entry is found. For those cases, P5 is zero. +*/ +case OP_IdxDelete: { + VdbeCursor *pC; + BtCursor *pCrsr; + int res; + UnpackedRecord r; + + assert( pOp->p3>0 ); + assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem+1 - p->nCursor)+1 ); + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + sqlite3VdbeIncrWriteCounter(p, pC); + pCrsr = pC->uc.pCursor; + assert( pCrsr!=0 ); + r.pKeyInfo = pC->pKeyInfo; + r.nField = (u16)pOp->p3; + r.default_rc = 0; + r.aMem = &aMem[pOp->p2]; + rc = sqlite3BtreeMovetoUnpacked(pCrsr, &r, 0, 0, &res); + if( rc ) goto abort_due_to_error; + if( res==0 ){ + rc = sqlite3BtreeDelete(pCrsr, BTREE_AUXDELETE); + if( rc ) goto abort_due_to_error; + }else if( pOp->p5 ){ + rc = SQLITE_CORRUPT_INDEX; + goto abort_due_to_error; + } + assert( pC->deferredMoveto==0 ); + pC->cacheStatus = CACHE_STALE; + pC->seekResult = 0; + break; +} + +/* Opcode: DeferredSeek P1 * P3 P4 * +** Synopsis: Move P3 to P1.rowid if needed +** +** P1 is an open index cursor and P3 is a cursor on the corresponding +** table. This opcode does a deferred seek of the P3 table cursor +** to the row that corresponds to the current row of P1. +** +** This is a deferred seek. Nothing actually happens until +** the cursor is used to read a record. That way, if no reads +** occur, no unnecessary I/O happens. +** +** P4 may be an array of integers (type P4_INTARRAY) containing +** one entry for each column in the P3 table. If array entry a(i) +** is non-zero, then reading column a(i)-1 from cursor P3 is +** equivalent to performing the deferred seek and then reading column i +** from P1. This information is stored in P3 and used to redirect +** reads against P3 over to P1, thus possibly avoiding the need to +** seek and read cursor P3. +*/ +/* Opcode: IdxRowid P1 P2 * * * +** Synopsis: r[P2]=rowid +** +** Write into register P2 an integer which is the last entry in the record at +** the end of the index key pointed to by cursor P1. This integer should be +** the rowid of the table entry to which this index entry points. +** +** See also: Rowid, MakeRecord. +*/ +case OP_DeferredSeek: +case OP_IdxRowid: { /* out2 */ + VdbeCursor *pC; /* The P1 index cursor */ + VdbeCursor *pTabCur; /* The P2 table cursor (OP_DeferredSeek only) */ + i64 rowid; /* Rowid that P1 current points to */ + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->uc.pCursor!=0 ); + assert( pC->isTable==0 ); + assert( pC->deferredMoveto==0 ); + assert( !pC->nullRow || pOp->opcode==OP_IdxRowid ); + + /* The IdxRowid and Seek opcodes are combined because of the commonality + ** of sqlite3VdbeCursorRestore() and sqlite3VdbeIdxRowid(). */ + rc = sqlite3VdbeCursorRestore(pC); + + /* sqlite3VbeCursorRestore() can only fail if the record has been deleted + ** out from under the cursor. That will never happens for an IdxRowid + ** or Seek opcode */ + if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error; + + if( !pC->nullRow ){ + rowid = 0; /* Not needed. Only used to silence a warning. */ + rc = sqlite3VdbeIdxRowid(db, pC->uc.pCursor, &rowid); + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + if( pOp->opcode==OP_DeferredSeek ){ + assert( pOp->p3>=0 && pOp->p3nCursor ); + pTabCur = p->apCsr[pOp->p3]; + assert( pTabCur!=0 ); + assert( pTabCur->eCurType==CURTYPE_BTREE ); + assert( pTabCur->uc.pCursor!=0 ); + assert( pTabCur->isTable ); + pTabCur->nullRow = 0; + pTabCur->movetoTarget = rowid; + pTabCur->deferredMoveto = 1; + assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 ); + pTabCur->aAltMap = pOp->p4.ai; + pTabCur->pAltCursor = pC; + }else{ + pOut = out2Prerelease(p, pOp); + pOut->u.i = rowid; + } + }else{ + assert( pOp->opcode==OP_IdxRowid ); + sqlite3VdbeMemSetNull(&aMem[pOp->p2]); + } + break; +} + +/* Opcode: FinishSeek P1 * * * * +** +** If cursor P1 was previously moved via OP_DeferredSeek, complete that +** 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 */ + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + if( pC->deferredMoveto ){ + rc = sqlite3VdbeFinishMoveto(pC); + if( rc ) goto abort_due_to_error; + } + break; +} + +/* Opcode: IdxGE P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** The P4 register values beginning with P3 form an unpacked index +** key that omits the PRIMARY KEY. Compare this key value against the index +** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID +** fields at the end. +** +** If the P1 index entry is greater than or equal to the key value +** then jump to P2. Otherwise fall through to the next instruction. +*/ +/* Opcode: IdxGT P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** The P4 register values beginning with P3 form an unpacked index +** key that omits the PRIMARY KEY. Compare this key value against the index +** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID +** fields at the end. +** +** If the P1 index entry is greater than the key value +** then jump to P2. Otherwise fall through to the next instruction. +*/ +/* Opcode: IdxLT P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** The P4 register values beginning with P3 form an unpacked index +** key that omits the PRIMARY KEY or ROWID. Compare this key value against +** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or +** ROWID on the P1 index. +** +** If the P1 index entry is less than the key value then jump to P2. +** Otherwise fall through to the next instruction. +*/ +/* Opcode: IdxLE P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** The P4 register values beginning with P3 form an unpacked index +** key that omits the PRIMARY KEY or ROWID. Compare this key value against +** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or +** ROWID on the P1 index. +** +** 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 */ + VdbeCursor *pC; + int res; + UnpackedRecord r; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->isOrdered ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->uc.pCursor!=0); + assert( pC->deferredMoveto==0 ); + assert( pOp->p4type==P4_INT32 ); + r.pKeyInfo = pC->pKeyInfo; + r.nField = (u16)pOp->p4.i; + if( pOp->opcodeopcode==OP_IdxLE || pOp->opcode==OP_IdxGT ); + r.default_rc = -1; + }else{ + assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxLT ); + r.default_rc = 0; + } + r.aMem = &aMem[pOp->p3]; +#ifdef SQLITE_DEBUG + { + int i; + for(i=0; ip3+i, &aMem[pOp->p3+i]); + } + } +#endif + + /* Inlined version of sqlite3VdbeIdxKeyCompare() */ + { + i64 nCellKey = 0; + BtCursor *pCur; + Mem m; + + assert( pC->eCurType==CURTYPE_BTREE ); + pCur = pC->uc.pCursor; + assert( sqlite3BtreeCursorIsValid(pCur) ); + nCellKey = sqlite3BtreePayloadSize(pCur); + /* nCellKey will always be between 0 and 0xffffffff because of the way + ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */ + if( nCellKey<=0 || nCellKey>0x7fffffff ){ + rc = SQLITE_CORRUPT_BKPT; + goto abort_due_to_error; + } + sqlite3VdbeMemInit(&m, db, 0); + rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m); + if( rc ) goto abort_due_to_error; + res = sqlite3VdbeRecordCompareWithSkip(m.n, m.z, &r, 0); + sqlite3VdbeMemRelease(&m); + } + /* End of inlined sqlite3VdbeIdxKeyCompare() */ + + assert( (OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1) ); + if( (pOp->opcode&1)==(OP_IdxLT&1) ){ + assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT ); + res = -res; + }else{ + assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxGT ); + res++; + } + VdbeBranchTaken(res>0,2); + assert( rc==SQLITE_OK ); + if( res>0 ) goto jump_to_p2; + break; +} + +/* Opcode: Destroy P1 P2 P3 * * +** +** Delete an entire database table or index whose root page in the database +** file is given by P1. +** +** The table being destroyed is in the main database file if P3==0. If +** P3==1 then the table to be clear is in the auxiliary database file +** that is used to store tables create using CREATE TEMPORARY TABLE. +** +** If AUTOVACUUM is enabled then it is possible that another root page +** might be moved into the newly deleted root page in order to keep all +** root pages contiguous at the beginning of the database. The former +** value of the root page that moved - its value before the move occurred - +** is stored in register P2. If no page movement was required (because the +** table being dropped was already the last one in the database) then a +** zero is stored in register P2. If AUTOVACUUM is disabled then a zero +** is stored in register P2. +** +** This opcode throws an error if there are any active reader VMs when +** it is invoked. This is done to avoid the difficulty associated with +** updating existing cursors when a root page is moved in an AUTOVACUUM +** database. This error is thrown even if the database is not an AUTOVACUUM +** db in order to avoid introducing an incompatibility between autovacuum +** and non-autovacuum modes. +** +** See also: Clear +*/ +case OP_Destroy: { /* out2 */ + int iMoved; + int iDb; + + sqlite3VdbeIncrWriteCounter(p, 0); + assert( p->readOnly==0 ); + assert( pOp->p1>1 ); + pOut = out2Prerelease(p, pOp); + pOut->flags = MEM_Null; + if( db->nVdbeRead > db->nVDestroy+1 ){ + rc = SQLITE_LOCKED; + p->errorAction = OE_Abort; + goto abort_due_to_error; + }else{ + iDb = pOp->p3; + assert( DbMaskTest(p->btreeMask, iDb) ); + iMoved = 0; /* Not needed. Only to silence a warning. */ + rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved); + pOut->flags = MEM_Int; + pOut->u.i = iMoved; + if( rc ) goto abort_due_to_error; +#ifndef SQLITE_OMIT_AUTOVACUUM + if( iMoved!=0 ){ + sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1); + /* All OP_Destroy operations occur on the same btree */ + assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 ); + resetSchemaOnFault = iDb+1; + } +#endif + } + break; +} + +/* Opcode: Clear P1 P2 P3 +** +** Delete all contents of the database table or index whose root page +** in the database file is given by P1. But, unlike Destroy, do not +** remove the table or index from the database file. +** +** The table being clear is in the main database file if P2==0. If +** P2==1 then the table to be clear is in the auxiliary database file +** that is used to store tables create using CREATE TEMPORARY TABLE. +** +** If the P3 value is non-zero, then the table referred to must be an +** intkey table (an SQL table, not an index). In this case the row change +** count is incremented by the number of rows in the table being cleared. +** If P3 is greater than zero, then the value stored in register P3 is +** also incremented by the number of rows in the table being cleared. +** +** See also: Destroy +*/ +case OP_Clear: { + int nChange; + + sqlite3VdbeIncrWriteCounter(p, 0); + nChange = 0; + assert( p->readOnly==0 ); + assert( DbMaskTest(p->btreeMask, pOp->p2) ); + rc = sqlite3BtreeClearTable( + db->aDb[pOp->p2].pBt, (u32)pOp->p1, (pOp->p3 ? &nChange : 0) + ); + if( pOp->p3 ){ + p->nChange += nChange; + if( pOp->p3>0 ){ + assert( memIsValid(&aMem[pOp->p3]) ); + memAboutToChange(p, &aMem[pOp->p3]); + aMem[pOp->p3].u.i += nChange; + } + } + if( rc ) goto abort_due_to_error; + break; +} + +/* Opcode: ResetSorter P1 * * * * +** +** Delete all contents from the ephemeral table or sorter +** that is open on cursor P1. +** +** This opcode only works for cursors used for sorting and +** opened with OP_OpenEphemeral or OP_SorterOpen. +*/ +case OP_ResetSorter: { + VdbeCursor *pC; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + if( isSorter(pC) ){ + sqlite3VdbeSorterReset(db, pC->uc.pSorter); + }else{ + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->isEphemeral ); + rc = sqlite3BtreeClearTableOfCursor(pC->uc.pCursor); + if( rc ) goto abort_due_to_error; + } + break; +} + +/* Opcode: CreateBtree P1 P2 P3 * * +** Synopsis: r[P2]=root iDb=P1 flags=P3 +** +** Allocate a new b-tree in the main database file if P1==0 or in the +** TEMP database file if P1==1 or in an attached database if +** P1>1. The P3 argument must be 1 (BTREE_INTKEY) for a rowid table +** it must be 2 (BTREE_BLOBKEY) for an index or WITHOUT ROWID table. +** The root page number of the new b-tree is stored in register P2. +*/ +case OP_CreateBtree: { /* out2 */ + Pgno pgno; + Db *pDb; + + sqlite3VdbeIncrWriteCounter(p, 0); + pOut = out2Prerelease(p, pOp); + pgno = 0; + assert( pOp->p3==BTREE_INTKEY || pOp->p3==BTREE_BLOBKEY ); + assert( pOp->p1>=0 && pOp->p1nDb ); + assert( DbMaskTest(p->btreeMask, pOp->p1) ); + assert( p->readOnly==0 ); + pDb = &db->aDb[pOp->p1]; + assert( pDb->pBt!=0 ); + rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, pOp->p3); + if( rc ) goto abort_due_to_error; + pOut->u.i = pgno; + break; +} + +/* Opcode: SqlExec * * * P4 * +** +** Run the SQL statement or statements specified in the P4 string. +*/ +case OP_SqlExec: { + sqlite3VdbeIncrWriteCounter(p, 0); + db->nSqlExec++; + rc = sqlite3_exec(db, pOp->p4.z, 0, 0, 0); + db->nSqlExec--; + if( rc ) goto abort_due_to_error; + break; +} + +/* Opcode: ParseSchema P1 * * P4 * +** +** Read and parse all entries from the schema table of database P1 +** that match the WHERE clause P4. If P4 is a NULL pointer, then the +** entire schema for P1 is reparsed. +** +** This opcode invokes the parser to create a new virtual machine, +** then runs the new virtual machine. It is thus a re-entrant opcode. +*/ +case OP_ParseSchema: { + int iDb; + const char *zSchema; + char *zSql; + InitData initData; + + /* Any prepared statement that invokes this opcode will hold mutexes + ** on every btree. This is a prerequisite for invoking + ** sqlite3InitCallback(). + */ +#ifdef SQLITE_DEBUG + for(iDb=0; iDbnDb; iDb++){ + assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) ); + } +#endif + + iDb = pOp->p1; + assert( iDb>=0 && iDbnDb ); + assert( DbHasProperty(db, iDb, DB_SchemaLoaded) ); + +#ifndef SQLITE_OMIT_ALTERTABLE + if( pOp->p4.z==0 ){ + sqlite3SchemaClear(db->aDb[iDb].pSchema); + db->mDbFlags &= ~DBFLAG_SchemaKnownOk; + rc = sqlite3InitOne(db, iDb, &p->zErrMsg, INITFLAG_AlterTable); + db->mDbFlags |= DBFLAG_SchemaChange; + p->expired = 0; + }else +#endif + { + zSchema = DFLT_SCHEMA_TABLE; + initData.db = db; + initData.iDb = iDb; + initData.pzErrMsg = &p->zErrMsg; + initData.mInitFlags = 0; + initData.mxPage = sqlite3BtreeLastPage(db->aDb[iDb].pBt); + zSql = sqlite3MPrintf(db, + "SELECT*FROM\"%w\".%s WHERE %s ORDER BY rowid", + db->aDb[iDb].zDbSName, zSchema, pOp->p4.z); + if( zSql==0 ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + assert( db->init.busy==0 ); + db->init.busy = 1; + initData.rc = SQLITE_OK; + initData.nInitRow = 0; + assert( !db->mallocFailed ); + rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0); + if( rc==SQLITE_OK ) rc = initData.rc; + if( rc==SQLITE_OK && initData.nInitRow==0 ){ + /* The OP_ParseSchema opcode with a non-NULL P4 argument should parse + ** at least one SQL statement. Any less than that indicates that + ** the sqlite_schema table is corrupt. */ + rc = SQLITE_CORRUPT_BKPT; + } + sqlite3DbFreeNN(db, zSql); + db->init.busy = 0; + } + } + if( rc ){ + sqlite3ResetAllSchemasOfConnection(db); + if( rc==SQLITE_NOMEM ){ + goto no_mem; + } + goto abort_due_to_error; + } + break; +} + +#if !defined(SQLITE_OMIT_ANALYZE) +/* Opcode: LoadAnalysis P1 * * * * +** +** Read the sqlite_stat1 table for database P1 and load the content +** of that table into the internal index hash table. This will cause +** the analysis to be used when preparing all subsequent queries. +*/ +case OP_LoadAnalysis: { + assert( pOp->p1>=0 && pOp->p1nDb ); + rc = sqlite3AnalysisLoad(db, pOp->p1); + if( rc ) goto abort_due_to_error; + break; +} +#endif /* !defined(SQLITE_OMIT_ANALYZE) */ + +/* Opcode: DropTable P1 * * P4 * +** +** Remove the internal (in-memory) data structures that describe +** the table named P4 in database P1. This is called after a table +** is dropped from disk (using the Destroy opcode) in order to keep +** the internal representation of the +** schema consistent with what is on disk. +*/ +case OP_DropTable: { + sqlite3VdbeIncrWriteCounter(p, 0); + sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z); + break; +} + +/* Opcode: DropIndex P1 * * P4 * +** +** Remove the internal (in-memory) data structures that describe +** the index named P4 in database P1. This is called after an index +** is dropped from disk (using the Destroy opcode) +** in order to keep the internal representation of the +** schema consistent with what is on disk. +*/ +case OP_DropIndex: { + sqlite3VdbeIncrWriteCounter(p, 0); + sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z); + break; +} + +/* Opcode: DropTrigger P1 * * P4 * +** +** Remove the internal (in-memory) data structures that describe +** the trigger named P4 in database P1. This is called after a trigger +** is dropped from disk (using the Destroy opcode) in order to keep +** the internal representation of the +** schema consistent with what is on disk. +*/ +case OP_DropTrigger: { + sqlite3VdbeIncrWriteCounter(p, 0); + sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z); + break; +} + + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK +/* Opcode: IntegrityCk P1 P2 P3 P4 P5 +** +** Do an analysis of the currently open database. Store in +** register P1 the text of an error message describing any problems. +** If no problems are found, store a NULL in register P1. +** +** The register P3 contains one less than the maximum number of allowed errors. +** At most reg(P3) errors will be reported. +** In other words, the analysis stops as soon as reg(P1) errors are +** seen. Reg(P1) is updated with the number of errors remaining. +** +** The root page numbers of all tables in the database are integers +** stored in P4_INTARRAY argument. +** +** If P5 is not zero, the check is done on the auxiliary database +** file, not the main database file. +** +** This opcode is used to implement the integrity_check pragma. +*/ +case OP_IntegrityCk: { + int nRoot; /* Number of tables to check. (Number of root pages.) */ + Pgno *aRoot; /* Array of rootpage numbers for tables to be checked */ + int nErr; /* Number of errors reported */ + char *z; /* Text of the error report */ + Mem *pnErr; /* Register keeping track of errors remaining */ + + assert( p->bIsReader ); + nRoot = pOp->p2; + aRoot = pOp->p4.ai; + assert( nRoot>0 ); + assert( aRoot[0]==(Pgno)nRoot ); + assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); + pnErr = &aMem[pOp->p3]; + assert( (pnErr->flags & MEM_Int)!=0 ); + assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 ); + pIn1 = &aMem[pOp->p1]; + assert( pOp->p5nDb ); + assert( DbMaskTest(p->btreeMask, pOp->p5) ); + z = sqlite3BtreeIntegrityCheck(db, db->aDb[pOp->p5].pBt, &aRoot[1], nRoot, + (int)pnErr->u.i+1, &nErr); + sqlite3VdbeMemSetNull(pIn1); + if( nErr==0 ){ + assert( z==0 ); + }else if( z==0 ){ + goto no_mem; + }else{ + pnErr->u.i -= nErr-1; + sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free); + } + UPDATE_MAX_BLOBSIZE(pIn1); + sqlite3VdbeChangeEncoding(pIn1, encoding); + goto check_for_interrupt; +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +/* Opcode: RowSetAdd P1 P2 * * * +** Synopsis: rowset(P1)=r[P2] +** +** Insert the integer value held by register P2 into a RowSet object +** held in register P1. +** +** An assertion fails if P2 is not an integer. +*/ +case OP_RowSetAdd: { /* in1, in2 */ + pIn1 = &aMem[pOp->p1]; + pIn2 = &aMem[pOp->p2]; + assert( (pIn2->flags & MEM_Int)!=0 ); + if( (pIn1->flags & MEM_Blob)==0 ){ + if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem; + } + assert( sqlite3VdbeMemIsRowSet(pIn1) ); + sqlite3RowSetInsert((RowSet*)pIn1->z, pIn2->u.i); + break; +} + +/* Opcode: RowSetRead P1 P2 P3 * * +** Synopsis: r[P3]=rowset(P1) +** +** Extract the smallest value from the RowSet object in P1 +** and put that value into register P3. +** Or, if RowSet object P1 is initially empty, leave P3 +** unchanged and jump to instruction P2. +*/ +case OP_RowSetRead: { /* jump, in1, out3 */ + i64 val; + + pIn1 = &aMem[pOp->p1]; + assert( (pIn1->flags & MEM_Blob)==0 || sqlite3VdbeMemIsRowSet(pIn1) ); + if( (pIn1->flags & MEM_Blob)==0 + || sqlite3RowSetNext((RowSet*)pIn1->z, &val)==0 + ){ + /* The boolean index is empty */ + sqlite3VdbeMemSetNull(pIn1); + VdbeBranchTaken(1,2); + goto jump_to_p2_and_check_for_interrupt; + }else{ + /* A value was pulled from the index */ + VdbeBranchTaken(0,2); + sqlite3VdbeMemSetInt64(&aMem[pOp->p3], val); + } + goto check_for_interrupt; +} + +/* Opcode: RowSetTest P1 P2 P3 P4 +** Synopsis: if r[P3] in rowset(P1) goto P2 +** +** Register P3 is assumed to hold a 64-bit integer value. If register P1 +** contains a RowSet object and that RowSet object contains +** the value held in P3, jump to register P2. Otherwise, insert the +** integer in P3 into the RowSet and continue on to the +** next opcode. +** +** The RowSet object is optimized for the case where sets of integers +** are inserted in distinct phases, which each set contains no duplicates. +** Each set is identified by a unique P4 value. The first set +** must have P4==0, the final set must have P4==-1, and for all other sets +** must have P4>0. +** +** This allows optimizations: (a) when P4==0 there is no need to test +** the RowSet object for P3, as it is guaranteed not to contain it, +** (b) when P4==-1 there is no need to insert the value, as it will +** never be tested for, and (c) when a value that is part of set X is +** inserted, there is no need to search to see if the same value was +** previously inserted as part of set X (only if it was previously +** inserted as part of some other set). +*/ +case OP_RowSetTest: { /* jump, in1, in3 */ + int iSet; + int exists; + + pIn1 = &aMem[pOp->p1]; + pIn3 = &aMem[pOp->p3]; + iSet = pOp->p4.i; + assert( pIn3->flags&MEM_Int ); + + /* If there is anything other than a rowset object in memory cell P1, + ** delete it now and initialize P1 with an empty rowset + */ + if( (pIn1->flags & MEM_Blob)==0 ){ + if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem; + } + assert( sqlite3VdbeMemIsRowSet(pIn1) ); + assert( pOp->p4type==P4_INT32 ); + assert( iSet==-1 || iSet>=0 ); + if( iSet ){ + exists = sqlite3RowSetTest((RowSet*)pIn1->z, iSet, pIn3->u.i); + VdbeBranchTaken(exists!=0,2); + if( exists ) goto jump_to_p2; + } + if( iSet>=0 ){ + sqlite3RowSetInsert((RowSet*)pIn1->z, pIn3->u.i); + } + break; +} + + +#ifndef SQLITE_OMIT_TRIGGER + +/* Opcode: Program P1 P2 P3 P4 P5 +** +** Execute the trigger program passed as P4 (type P4_SUBPROGRAM). +** +** P1 contains the address of the memory cell that contains the first memory +** cell in an array of values used as arguments to the sub-program. P2 +** contains the address to jump to if the sub-program throws an IGNORE +** exception using the RAISE() function. Register P3 contains the address +** of a memory cell in this (the parent) VM that is used to allocate the +** memory required by the sub-vdbe at runtime. +** +** P4 is a pointer to the VM containing the trigger program. +** +** If P5 is non-zero, then recursive program invocation is enabled. +*/ +case OP_Program: { /* jump */ + int nMem; /* Number of memory registers for sub-program */ + int nByte; /* Bytes of runtime space required for sub-program */ + Mem *pRt; /* Register to allocate runtime space */ + Mem *pMem; /* Used to iterate through memory cells */ + Mem *pEnd; /* Last memory cell in new array */ + VdbeFrame *pFrame; /* New vdbe frame to execute in */ + SubProgram *pProgram; /* Sub-program to execute */ + void *t; /* Token identifying trigger */ + + pProgram = pOp->p4.pProgram; + pRt = &aMem[pOp->p3]; + assert( pProgram->nOp>0 ); + + /* If the p5 flag is clear, then recursive invocation of triggers is + ** disabled for backwards compatibility (p5 is set if this sub-program + ** is really a trigger, not a foreign key action, and the flag set + ** and cleared by the "PRAGMA recursive_triggers" command is clear). + ** + ** It is recursive invocation of triggers, at the SQL level, that is + ** disabled. In some cases a single trigger may generate more than one + ** SubProgram (if the trigger may be executed with more than one different + ** ON CONFLICT algorithm). SubProgram structures associated with a + ** single trigger all have the same value for the SubProgram.token + ** variable. */ + if( pOp->p5 ){ + t = pProgram->token; + for(pFrame=p->pFrame; pFrame && pFrame->token!=t; pFrame=pFrame->pParent); + if( pFrame ) break; + } + + if( p->nFrame>=db->aLimit[SQLITE_LIMIT_TRIGGER_DEPTH] ){ + rc = SQLITE_ERROR; + sqlite3VdbeError(p, "too many levels of trigger recursion"); + goto abort_due_to_error; + } + + /* Register pRt is used to store the memory required to save the state + ** of the current program, and the memory required at runtime to execute + ** the trigger program. If this trigger has been fired before, then pRt + ** is already allocated. Otherwise, it must be initialized. */ + if( (pRt->flags&MEM_Blob)==0 ){ + /* SubProgram.nMem is set to the number of memory cells used by the + ** program stored in SubProgram.aOp. As well as these, one memory + ** cell is required for each cursor used by the program. Set local + ** variable nMem (and later, VdbeFrame.nChildMem) to this value. + */ + nMem = pProgram->nMem + pProgram->nCsr; + assert( nMem>0 ); + if( pProgram->nCsr==0 ) nMem++; + nByte = ROUND8(sizeof(VdbeFrame)) + + nMem * sizeof(Mem) + + pProgram->nCsr * sizeof(VdbeCursor*) + + (pProgram->nOp + 7)/8; + pFrame = sqlite3DbMallocZero(db, nByte); + if( !pFrame ){ + goto no_mem; + } + sqlite3VdbeMemRelease(pRt); + pRt->flags = MEM_Blob|MEM_Dyn; + pRt->z = (char*)pFrame; + pRt->n = nByte; + pRt->xDel = sqlite3VdbeFrameMemDel; + + pFrame->v = p; + pFrame->nChildMem = nMem; + pFrame->nChildCsr = pProgram->nCsr; + pFrame->pc = (int)(pOp - aOp); + pFrame->aMem = p->aMem; + pFrame->nMem = p->nMem; + pFrame->apCsr = p->apCsr; + pFrame->nCursor = p->nCursor; + pFrame->aOp = p->aOp; + pFrame->nOp = p->nOp; + pFrame->token = pProgram->token; +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + pFrame->anExec = p->anExec; +#endif +#ifdef SQLITE_DEBUG + pFrame->iFrameMagic = SQLITE_FRAME_MAGIC; +#endif + + pEnd = &VdbeFrameMem(pFrame)[pFrame->nChildMem]; + for(pMem=VdbeFrameMem(pFrame); pMem!=pEnd; pMem++){ + pMem->flags = MEM_Undefined; + pMem->db = db; + } + }else{ + pFrame = (VdbeFrame*)pRt->z; + assert( pRt->xDel==sqlite3VdbeFrameMemDel ); + assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem + || (pProgram->nCsr==0 && pProgram->nMem+1==pFrame->nChildMem) ); + assert( pProgram->nCsr==pFrame->nChildCsr ); + assert( (int)(pOp - aOp)==pFrame->pc ); + } + + p->nFrame++; + pFrame->pParent = p->pFrame; + pFrame->lastRowid = db->lastRowid; + pFrame->nChange = p->nChange; + pFrame->nDbChange = p->db->nChange; + assert( pFrame->pAuxData==0 ); + pFrame->pAuxData = p->pAuxData; + p->pAuxData = 0; + p->nChange = 0; + p->pFrame = pFrame; + p->aMem = aMem = VdbeFrameMem(pFrame); + p->nMem = pFrame->nChildMem; + p->nCursor = (u16)pFrame->nChildCsr; + p->apCsr = (VdbeCursor **)&aMem[p->nMem]; + pFrame->aOnce = (u8*)&p->apCsr[pProgram->nCsr]; + memset(pFrame->aOnce, 0, (pProgram->nOp + 7)/8); + p->aOp = aOp = pProgram->aOp; + p->nOp = pProgram->nOp; +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + p->anExec = 0; +#endif +#ifdef SQLITE_DEBUG + /* Verify that second and subsequent executions of the same trigger do not + ** try to reuse register values from the first use. */ + { + int i; + for(i=0; inMem; i++){ + aMem[i].pScopyFrom = 0; /* Prevent false-positive AboutToChange() errs */ + MemSetTypeFlag(&aMem[i], MEM_Undefined); /* Fault if this reg is reused */ + } + } +#endif + pOp = &aOp[-1]; + goto check_for_interrupt; +} + +/* Opcode: Param P1 P2 * * * +** +** This opcode is only ever present in sub-programs called via the +** OP_Program instruction. Copy a value currently stored in a memory +** cell of the calling (parent) frame to cell P2 in the current frames +** address space. This is used by trigger programs to access the new.* +** and old.* values. +** +** The address of the cell in the parent frame is determined by adding +** the value of the P1 argument to the value of the P1 argument to the +** calling OP_Program instruction. +*/ +case OP_Param: { /* out2 */ + VdbeFrame *pFrame; + Mem *pIn; + pOut = out2Prerelease(p, pOp); + pFrame = p->pFrame; + pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1]; + sqlite3VdbeMemShallowCopy(pOut, pIn, MEM_Ephem); + break; +} + +#endif /* #ifndef SQLITE_OMIT_TRIGGER */ + +#ifndef SQLITE_OMIT_FOREIGN_KEY +/* Opcode: FkCounter P1 P2 * * * +** Synopsis: fkctr[P1]+=P2 +** +** Increment a "constraint counter" by P2 (P2 may be negative or positive). +** If P1 is non-zero, the database constraint counter is incremented +** (deferred foreign key constraints). Otherwise, if P1 is zero, the +** statement counter is incremented (immediate foreign key constraints). +*/ +case OP_FkCounter: { + if( db->flags & SQLITE_DeferFKs ){ + db->nDeferredImmCons += pOp->p2; + }else if( pOp->p1 ){ + db->nDeferredCons += pOp->p2; + }else{ + p->nFkConstraint += pOp->p2; + } + break; +} + +/* Opcode: FkIfZero P1 P2 * * * +** Synopsis: if fkctr[P1]==0 goto P2 +** +** This opcode tests if a foreign key constraint-counter is currently zero. +** If so, jump to instruction P2. Otherwise, fall through to the next +** instruction. +** +** If P1 is non-zero, then the jump is taken if the database constraint-counter +** is zero (the one that counts deferred constraint violations). If P1 is +** zero, the jump is taken if the statement constraint-counter is zero +** (immediate foreign key constraint violations). +*/ +case OP_FkIfZero: { /* jump */ + if( pOp->p1 ){ + VdbeBranchTaken(db->nDeferredCons==0 && db->nDeferredImmCons==0, 2); + if( db->nDeferredCons==0 && db->nDeferredImmCons==0 ) goto jump_to_p2; + }else{ + VdbeBranchTaken(p->nFkConstraint==0 && db->nDeferredImmCons==0, 2); + if( p->nFkConstraint==0 && db->nDeferredImmCons==0 ) goto jump_to_p2; + } + break; +} +#endif /* #ifndef SQLITE_OMIT_FOREIGN_KEY */ + +#ifndef SQLITE_OMIT_AUTOINCREMENT +/* Opcode: MemMax P1 P2 * * * +** Synopsis: r[P1]=max(r[P1],r[P2]) +** +** P1 is a register in the root frame of this VM (the root frame is +** different from the current frame if this instruction is being executed +** within a sub-program). Set the value of register P1 to the maximum of +** its current value and the value in register P2. +** +** This instruction throws an error if the memory cell is not initially +** an integer. +*/ +case OP_MemMax: { /* in2 */ + VdbeFrame *pFrame; + if( p->pFrame ){ + for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent); + pIn1 = &pFrame->aMem[pOp->p1]; + }else{ + pIn1 = &aMem[pOp->p1]; + } + assert( memIsValid(pIn1) ); + sqlite3VdbeMemIntegerify(pIn1); + pIn2 = &aMem[pOp->p2]; + sqlite3VdbeMemIntegerify(pIn2); + if( pIn1->u.iu.i){ + pIn1->u.i = pIn2->u.i; + } + break; +} +#endif /* SQLITE_OMIT_AUTOINCREMENT */ + +/* Opcode: IfPos P1 P2 P3 * * +** Synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 +** +** Register P1 must contain an integer. +** If the value of register P1 is 1 or greater, subtract P3 from the +** value in P1 and jump to P2. +** +** If the initial value of register P1 is less than 1, then the +** value is unchanged and control passes through to the next instruction. +*/ +case OP_IfPos: { /* jump, in1 */ + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags&MEM_Int ); + VdbeBranchTaken( pIn1->u.i>0, 2); + if( pIn1->u.i>0 ){ + pIn1->u.i -= pOp->p3; + goto jump_to_p2; + } + break; +} + +/* Opcode: OffsetLimit P1 P2 P3 * * +** Synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) +** +** This opcode performs a commonly used computation associated with +** LIMIT and OFFSET process. r[P1] holds the limit counter. r[P3] +** holds the offset counter. The opcode computes the combined value +** of the LIMIT and OFFSET and stores that value in r[P2]. The r[P2] +** value computed is the total number of rows that will need to be +** visited in order to complete the query. +** +** If r[P3] is zero or negative, that means there is no OFFSET +** and r[P2] is set to be the value of the LIMIT, r[P1]. +** +** if r[P1] is zero or negative, that means there is no LIMIT +** and r[P2] is set to -1. +** +** Otherwise, r[P2] is set to the sum of r[P1] and r[P3]. +*/ +case OP_OffsetLimit: { /* in1, out2, in3 */ + i64 x; + pIn1 = &aMem[pOp->p1]; + pIn3 = &aMem[pOp->p3]; + pOut = out2Prerelease(p, pOp); + assert( pIn1->flags & MEM_Int ); + assert( pIn3->flags & MEM_Int ); + x = pIn1->u.i; + if( x<=0 || sqlite3AddInt64(&x, pIn3->u.i>0?pIn3->u.i:0) ){ + /* If the LIMIT is less than or equal to zero, loop forever. This + ** is documented. But also, if the LIMIT+OFFSET exceeds 2^63 then + ** also loop forever. This is undocumented. In fact, one could argue + ** that the loop should terminate. But assuming 1 billion iterations + ** per second (far exceeding the capabilities of any current hardware) + ** it would take nearly 300 years to actually reach the limit. So + ** looping forever is a reasonable approximation. */ + pOut->u.i = -1; + }else{ + pOut->u.i = x; + } + break; +} + +/* Opcode: IfNotZero P1 P2 * * * +** Synopsis: if r[P1]!=0 then r[P1]--, goto P2 +** +** Register P1 must contain an integer. If the content of register P1 is +** initially greater than zero, then decrement the value in register P1. +** If it is non-zero (negative or positive) and then also jump to P2. +** If register P1 is initially zero, leave it unchanged and fall through. +*/ +case OP_IfNotZero: { /* jump, in1 */ + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags&MEM_Int ); + VdbeBranchTaken(pIn1->u.i<0, 2); + if( pIn1->u.i ){ + if( pIn1->u.i>0 ) pIn1->u.i--; + goto jump_to_p2; + } + break; +} + +/* Opcode: DecrJumpZero P1 P2 * * * +** Synopsis: if (--r[P1])==0 goto P2 +** +** Register P1 must hold an integer. Decrement the value in P1 +** and jump to P2 if the new value is exactly zero. +*/ +case OP_DecrJumpZero: { /* jump, in1 */ + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags&MEM_Int ); + if( pIn1->u.i>SMALLEST_INT64 ) pIn1->u.i--; + VdbeBranchTaken(pIn1->u.i==0, 2); + if( pIn1->u.i==0 ) goto jump_to_p2; + break; +} + + +/* Opcode: AggStep * P2 P3 P4 P5 +** Synopsis: accum=r[P3] step(r[P2@P5]) +** +** Execute the xStep function for an aggregate. +** The function has P5 arguments. P4 is a pointer to the +** FuncDef structure that specifies the function. Register P3 is the +** accumulator. +** +** The P5 arguments are taken from register P2 and its +** successors. +*/ +/* Opcode: AggInverse * P2 P3 P4 P5 +** Synopsis: accum=r[P3] inverse(r[P2@P5]) +** +** Execute the xInverse function for an aggregate. +** The function has P5 arguments. P4 is a pointer to the +** FuncDef structure that specifies the function. Register P3 is the +** accumulator. +** +** The P5 arguments are taken from register P2 and its +** successors. +*/ +/* Opcode: AggStep1 P1 P2 P3 P4 P5 +** Synopsis: accum=r[P3] step(r[P2@P5]) +** +** Execute the xStep (if P1==0) or xInverse (if P1!=0) function for an +** aggregate. The function has P5 arguments. P4 is a pointer to the +** FuncDef structure that specifies the function. Register P3 is the +** accumulator. +** +** The P5 arguments are taken from register P2 and its +** successors. +** +** This opcode is initially coded as OP_AggStep0. On first evaluation, +** the FuncDef stored in P4 is converted into an sqlite3_context and +** the opcode is changed. In this way, the initialization of the +** sqlite3_context only happens once, instead of on each call to the +** step function. +*/ +case OP_AggInverse: +case OP_AggStep: { + int n; + sqlite3_context *pCtx; + + assert( pOp->p4type==P4_FUNCDEF ); + n = pOp->p5; + assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); + assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) ); + assert( pOp->p3p2 || pOp->p3>=pOp->p2+n ); + pCtx = sqlite3DbMallocRawNN(db, n*sizeof(sqlite3_value*) + + (sizeof(pCtx[0]) + sizeof(Mem) - sizeof(sqlite3_value*))); + if( pCtx==0 ) goto no_mem; + pCtx->pMem = 0; + pCtx->pOut = (Mem*)&(pCtx->argv[n]); + sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null); + pCtx->pFunc = pOp->p4.pFunc; + pCtx->iOp = (int)(pOp - aOp); + pCtx->pVdbe = p; + pCtx->skipFlag = 0; + pCtx->isError = 0; + pCtx->argc = n; + pOp->p4type = P4_FUNCCTX; + pOp->p4.pCtx = pCtx; + + /* OP_AggInverse must have P1==1 and OP_AggStep must have P1==0 */ + assert( pOp->p1==(pOp->opcode==OP_AggInverse) ); + + pOp->opcode = OP_AggStep1; + /* Fall through into OP_AggStep */ + /* no break */ deliberate_fall_through +} +case OP_AggStep1: { + int i; + sqlite3_context *pCtx; + Mem *pMem; + + assert( pOp->p4type==P4_FUNCCTX ); + pCtx = pOp->p4.pCtx; + pMem = &aMem[pOp->p3]; + +#ifdef SQLITE_DEBUG + if( pOp->p1 ){ + /* This is an OP_AggInverse call. Verify that xStep has always + ** been called at least once prior to any xInverse call. */ + assert( pMem->uTemp==0x1122e0e3 ); + }else{ + /* This is an OP_AggStep call. Mark it as such. */ + pMem->uTemp = 0x1122e0e3; + } +#endif + + /* If this function is inside of a trigger, the register array in aMem[] + ** might change from one evaluation to the next. The next block of code + ** checks to see if the register array has changed, and if so it + ** reinitializes the relavant parts of the sqlite3_context object */ + if( pCtx->pMem != pMem ){ + pCtx->pMem = pMem; + for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i]; + } + +#ifdef SQLITE_DEBUG + for(i=0; iargc; i++){ + assert( memIsValid(pCtx->argv[i]) ); + REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]); + } +#endif + + pMem->n++; + assert( pCtx->pOut->flags==MEM_Null ); + assert( pCtx->isError==0 ); + assert( pCtx->skipFlag==0 ); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( pOp->p1 ){ + (pCtx->pFunc->xInverse)(pCtx,pCtx->argc,pCtx->argv); + }else +#endif + (pCtx->pFunc->xSFunc)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */ + + if( pCtx->isError ){ + if( pCtx->isError>0 ){ + sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut)); + rc = pCtx->isError; + } + if( pCtx->skipFlag ){ + assert( pOp[-1].opcode==OP_CollSeq ); + i = pOp[-1].p1; + if( i ) sqlite3VdbeMemSetInt64(&aMem[i], 1); + pCtx->skipFlag = 0; + } + sqlite3VdbeMemRelease(pCtx->pOut); + pCtx->pOut->flags = MEM_Null; + pCtx->isError = 0; + if( rc ) goto abort_due_to_error; + } + assert( pCtx->pOut->flags==MEM_Null ); + assert( pCtx->skipFlag==0 ); + break; +} + +/* Opcode: AggFinal P1 P2 * P4 * +** Synopsis: accum=r[P1] N=P2 +** +** P1 is the memory location that is the accumulator for an aggregate +** or window function. Execute the finalizer function +** for an aggregate and store the result in P1. +** +** P2 is the number of arguments that the step function takes and +** P4 is a pointer to the FuncDef for this function. The P2 +** argument is not used by this opcode. It is only there to disambiguate +** functions that can take varying numbers of arguments. The +** P4 argument is only needed for the case where +** the step function was not previously called. +*/ +/* Opcode: AggValue * P2 P3 P4 * +** Synopsis: r[P3]=value N=P2 +** +** Invoke the xValue() function and store the result in register P3. +** +** P2 is the number of arguments that the step function takes and +** P4 is a pointer to the FuncDef for this function. The P2 +** argument is not used by this opcode. It is only there to disambiguate +** functions that can take varying numbers of arguments. The +** P4 argument is only needed for the case where +** the step function was not previously called. +*/ +case OP_AggValue: +case OP_AggFinal: { + Mem *pMem; + assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); + assert( pOp->p3==0 || pOp->opcode==OP_AggValue ); + pMem = &aMem[pOp->p1]; + assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 ); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( pOp->p3 ){ + memAboutToChange(p, &aMem[pOp->p3]); + rc = sqlite3VdbeMemAggValue(pMem, &aMem[pOp->p3], pOp->p4.pFunc); + pMem = &aMem[pOp->p3]; + }else +#endif + { + rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc); + } + + if( rc ){ + sqlite3VdbeError(p, "%s", sqlite3_value_text(pMem)); + goto abort_due_to_error; + } + sqlite3VdbeChangeEncoding(pMem, encoding); + UPDATE_MAX_BLOBSIZE(pMem); + if( sqlite3VdbeMemTooBig(pMem) ){ + goto too_big; + } + break; +} + +#ifndef SQLITE_OMIT_WAL +/* Opcode: Checkpoint P1 P2 P3 * * +** +** Checkpoint database P1. This is a no-op if P1 is not currently in +** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL, +** RESTART, or TRUNCATE. Write 1 or 0 into mem[P3] if the checkpoint returns +** SQLITE_BUSY or not, respectively. Write the number of pages in the +** WAL after the checkpoint into mem[P3+1] and the number of pages +** in the WAL that have been checkpointed after the checkpoint +** completes into mem[P3+2]. However on an error, mem[P3+1] and +** mem[P3+2] are initialized to -1. +*/ +case OP_Checkpoint: { + int i; /* Loop counter */ + int aRes[3]; /* Results */ + Mem *pMem; /* Write results here */ + + assert( p->readOnly==0 ); + aRes[0] = 0; + aRes[1] = aRes[2] = -1; + assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE + || pOp->p2==SQLITE_CHECKPOINT_FULL + || pOp->p2==SQLITE_CHECKPOINT_RESTART + || pOp->p2==SQLITE_CHECKPOINT_TRUNCATE + ); + rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &aRes[1], &aRes[2]); + if( rc ){ + if( rc!=SQLITE_BUSY ) goto abort_due_to_error; + rc = SQLITE_OK; + aRes[0] = 1; + } + for(i=0, pMem = &aMem[pOp->p3]; i<3; i++, pMem++){ + sqlite3VdbeMemSetInt64(pMem, (i64)aRes[i]); + } + break; +}; +#endif + +#ifndef SQLITE_OMIT_PRAGMA +/* Opcode: JournalMode P1 P2 P3 * * +** +** Change the journal mode of database P1 to P3. P3 must be one of the +** PAGER_JOURNALMODE_XXX values. If changing between the various rollback +** modes (delete, truncate, persist, off and memory), this is a simple +** operation. No IO is required. +** +** If changing into or out of WAL mode the procedure is more complicated. +** +** Write a string containing the final journal-mode to register P2. +*/ +case OP_JournalMode: { /* out2 */ + Btree *pBt; /* Btree to change journal mode of */ + Pager *pPager; /* Pager associated with pBt */ + int eNew; /* New journal mode */ + int eOld; /* The old journal mode */ +#ifndef SQLITE_OMIT_WAL + const char *zFilename; /* Name of database file for pPager */ +#endif + + pOut = out2Prerelease(p, pOp); + eNew = pOp->p3; + assert( eNew==PAGER_JOURNALMODE_DELETE + || eNew==PAGER_JOURNALMODE_TRUNCATE + || eNew==PAGER_JOURNALMODE_PERSIST + || eNew==PAGER_JOURNALMODE_OFF + || eNew==PAGER_JOURNALMODE_MEMORY + || eNew==PAGER_JOURNALMODE_WAL + || eNew==PAGER_JOURNALMODE_QUERY + ); + assert( pOp->p1>=0 && pOp->p1nDb ); + assert( p->readOnly==0 ); + + pBt = db->aDb[pOp->p1].pBt; + pPager = sqlite3BtreePager(pBt); + eOld = sqlite3PagerGetJournalMode(pPager); + if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld; + if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld; + +#ifndef SQLITE_OMIT_WAL + zFilename = sqlite3PagerFilename(pPager, 1); + + /* Do not allow a transition to journal_mode=WAL for a database + ** in temporary storage or if the VFS does not support shared memory + */ + if( eNew==PAGER_JOURNALMODE_WAL + && (sqlite3Strlen30(zFilename)==0 /* Temp file */ + || !sqlite3PagerWalSupported(pPager)) /* No shared-memory support */ + ){ + eNew = eOld; + } + + if( (eNew!=eOld) + && (eOld==PAGER_JOURNALMODE_WAL || eNew==PAGER_JOURNALMODE_WAL) + ){ + if( !db->autoCommit || db->nVdbeRead>1 ){ + rc = SQLITE_ERROR; + sqlite3VdbeError(p, + "cannot change %s wal mode from within a transaction", + (eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of") + ); + goto abort_due_to_error; + }else{ + + if( eOld==PAGER_JOURNALMODE_WAL ){ + /* If leaving WAL mode, close the log file. If successful, the call + ** to PagerCloseWal() checkpoints and deletes the write-ahead-log + ** file. An EXCLUSIVE lock may still be held on the database file + ** after a successful return. + */ + rc = sqlite3PagerCloseWal(pPager, db); + if( rc==SQLITE_OK ){ + sqlite3PagerSetJournalMode(pPager, eNew); + } + }else if( eOld==PAGER_JOURNALMODE_MEMORY ){ + /* Cannot transition directly from MEMORY to WAL. Use mode OFF + ** as an intermediate */ + sqlite3PagerSetJournalMode(pPager, PAGER_JOURNALMODE_OFF); + } + + /* Open a transaction on the database file. Regardless of the journal + ** mode, this transaction always uses a rollback journal. + */ + assert( sqlite3BtreeTxnState(pBt)!=SQLITE_TXN_WRITE ); + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeSetVersion(pBt, (eNew==PAGER_JOURNALMODE_WAL ? 2 : 1)); + } + } + } +#endif /* ifndef SQLITE_OMIT_WAL */ + + if( rc ) eNew = eOld; + eNew = sqlite3PagerSetJournalMode(pPager, eNew); + + pOut->flags = MEM_Str|MEM_Static|MEM_Term; + pOut->z = (char *)sqlite3JournalModename(eNew); + pOut->n = sqlite3Strlen30(pOut->z); + pOut->enc = SQLITE_UTF8; + sqlite3VdbeChangeEncoding(pOut, encoding); + if( rc ) goto abort_due_to_error; + break; +}; +#endif /* SQLITE_OMIT_PRAGMA */ + +#if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH) +/* Opcode: Vacuum P1 P2 * * * +** +** Vacuum the entire database P1. P1 is 0 for "main", and 2 or more +** for an attached database. The "temp" database may not be vacuumed. +** +** If P2 is not zero, then it is a register holding a string which is +** the file into which the result of vacuum should be written. When +** P2 is zero, the vacuum overwrites the original database. +*/ +case OP_Vacuum: { + assert( p->readOnly==0 ); + rc = sqlite3RunVacuum(&p->zErrMsg, db, pOp->p1, + pOp->p2 ? &aMem[pOp->p2] : 0); + if( rc ) goto abort_due_to_error; + break; +} +#endif + +#if !defined(SQLITE_OMIT_AUTOVACUUM) +/* Opcode: IncrVacuum P1 P2 * * * +** +** Perform a single step of the incremental vacuum procedure on +** the P1 database. If the vacuum has finished, jump to instruction +** P2. Otherwise, fall through to the next instruction. +*/ +case OP_IncrVacuum: { /* jump */ + Btree *pBt; + + assert( pOp->p1>=0 && pOp->p1nDb ); + assert( DbMaskTest(p->btreeMask, pOp->p1) ); + assert( p->readOnly==0 ); + pBt = db->aDb[pOp->p1].pBt; + rc = sqlite3BtreeIncrVacuum(pBt); + VdbeBranchTaken(rc==SQLITE_DONE,2); + if( rc ){ + if( rc!=SQLITE_DONE ) goto abort_due_to_error; + rc = SQLITE_OK; + goto jump_to_p2; + } + break; +} +#endif + +/* Opcode: Expire P1 P2 * * * +** +** Cause precompiled statements to expire. When an expired statement +** is executed using sqlite3_step() it will either automatically +** reprepare itself (if it was originally created using sqlite3_prepare_v2()) +** or it will fail with SQLITE_SCHEMA. +** +** If P1 is 0, then all SQL statements become expired. If P1 is non-zero, +** then only the currently executing statement is expired. +** +** If P2 is 0, then SQL statements are expired immediately. If P2 is 1, +** then running SQL statements are allowed to continue to run to completion. +** The P2==1 case occurs when a CREATE INDEX or similar schema change happens +** that might help the statement run faster but which does not affect the +** correctness of operation. +*/ +case OP_Expire: { + assert( pOp->p2==0 || pOp->p2==1 ); + if( !pOp->p1 ){ + sqlite3ExpirePreparedStatements(db, pOp->p2); + }else{ + p->expired = pOp->p2+1; + } + break; +} + +/* Opcode: CursorLock P1 * * * * +** +** Lock the btree to which cursor P1 is pointing so that the btree cannot be +** written by an other cursor. +*/ +case OP_CursorLock: { + VdbeCursor *pC; + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + sqlite3BtreeCursorPin(pC->uc.pCursor); + break; +} + +/* Opcode: CursorUnlock P1 * * * * +** +** Unlock the btree to which cursor P1 is pointing so that it can be +** written by other cursors. +*/ +case OP_CursorUnlock: { + VdbeCursor *pC; + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + sqlite3BtreeCursorUnpin(pC->uc.pCursor); + break; +} + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* Opcode: TableLock P1 P2 P3 P4 * +** Synopsis: iDb=P1 root=P2 write=P3 +** +** Obtain a lock on a particular table. This instruction is only used when +** the shared-cache feature is enabled. +** +** P1 is the index of the database in sqlite3.aDb[] of the database +** on which the lock is acquired. A readlock is obtained if P3==0 or +** a write lock if P3==1. +** +** P2 contains the root-page of the table to lock. +** +** P4 contains a pointer to the name of the table being locked. This is only +** used to generate an error message if the lock cannot be obtained. +*/ +case OP_TableLock: { + u8 isWriteLock = (u8)pOp->p3; + if( isWriteLock || 0==(db->flags&SQLITE_ReadUncommit) ){ + int p1 = pOp->p1; + assert( p1>=0 && p1nDb ); + assert( DbMaskTest(p->btreeMask, p1) ); + assert( isWriteLock==0 || isWriteLock==1 ); + rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock); + if( rc ){ + if( (rc&0xFF)==SQLITE_LOCKED ){ + const char *z = pOp->p4.z; + sqlite3VdbeError(p, "database table is locked: %s", z); + } + goto abort_due_to_error; + } + } + break; +} +#endif /* SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VBegin * * * P4 * +** +** P4 may be a pointer to an sqlite3_vtab structure. If so, call the +** xBegin method for that table. +** +** Also, whether or not P4 is set, check that this is not being called from +** within a callback to a virtual table xSync() method. If it is, the error +** code will be set to SQLITE_LOCKED. +*/ +case OP_VBegin: { + VTable *pVTab; + pVTab = pOp->p4.pVtab; + rc = sqlite3VtabBegin(db, pVTab); + if( pVTab ) sqlite3VtabImportErrmsg(p, pVTab->pVtab); + if( rc ) goto abort_due_to_error; + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VCreate P1 P2 * * * +** +** P2 is a register that holds the name of a virtual table in database +** P1. Call the xCreate method for that table. +*/ +case OP_VCreate: { + Mem sMem; /* For storing the record being decoded */ + const char *zTab; /* Name of the virtual table */ + + memset(&sMem, 0, sizeof(sMem)); + sMem.db = db; + /* Because P2 is always a static string, it is impossible for the + ** sqlite3VdbeMemCopy() to fail */ + assert( (aMem[pOp->p2].flags & MEM_Str)!=0 ); + assert( (aMem[pOp->p2].flags & MEM_Static)!=0 ); + rc = sqlite3VdbeMemCopy(&sMem, &aMem[pOp->p2]); + assert( rc==SQLITE_OK ); + zTab = (const char*)sqlite3_value_text(&sMem); + assert( zTab || db->mallocFailed ); + if( zTab ){ + rc = sqlite3VtabCallCreate(db, pOp->p1, zTab, &p->zErrMsg); + } + sqlite3VdbeMemRelease(&sMem); + if( rc ) goto abort_due_to_error; + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VDestroy P1 * * P4 * +** +** P4 is the name of a virtual table in database P1. Call the xDestroy method +** of that table. +*/ +case OP_VDestroy: { + db->nVDestroy++; + rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z); + db->nVDestroy--; + assert( p->errorAction==OE_Abort && p->usesStmtJournal ); + if( rc ) goto abort_due_to_error; + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VOpen P1 * * P4 * +** +** P4 is a pointer to a virtual table object, an sqlite3_vtab structure. +** P1 is a cursor number. This opcode opens a cursor to the virtual +** table and stores that cursor in P1. +*/ +case OP_VOpen: { + VdbeCursor *pCur; + sqlite3_vtab_cursor *pVCur; + sqlite3_vtab *pVtab; + const sqlite3_module *pModule; + + assert( p->bIsReader ); + pCur = 0; + pVCur = 0; + pVtab = pOp->p4.pVtab->pVtab; + if( pVtab==0 || NEVER(pVtab->pModule==0) ){ + rc = SQLITE_LOCKED; + goto abort_due_to_error; + } + pModule = pVtab->pModule; + rc = pModule->xOpen(pVtab, &pVCur); + sqlite3VtabImportErrmsg(p, pVtab); + if( rc ) goto abort_due_to_error; + + /* Initialize sqlite3_vtab_cursor base class */ + pVCur->pVtab = pVtab; + + /* Initialize vdbe cursor object */ + pCur = allocateCursor(p, pOp->p1, 0, -1, CURTYPE_VTAB); + if( pCur ){ + pCur->uc.pVCur = pVCur; + pVtab->nRef++; + }else{ + assert( db->mallocFailed ); + pModule->xClose(pVCur); + goto no_mem; + } + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VFilter P1 P2 P3 P4 * +** Synopsis: iplan=r[P3] zplan='P4' +** +** P1 is a cursor opened using VOpen. P2 is an address to jump to if +** the filtered result set is empty. +** +** P4 is either NULL or a string that was generated by the xBestIndex +** method of the module. The interpretation of the P4 string is left +** to the module implementation. +** +** This opcode invokes the xFilter method on the virtual table specified +** by P1. The integer query plan parameter to xFilter is stored in register +** P3. Register P3+1 stores the argc parameter to be passed to the +** xFilter method. Registers P3+2..P3+1+argc are the argc +** additional parameters which are passed to +** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter. +** +** A jump is made to P2 if the result set after filtering would be empty. +*/ +case OP_VFilter: { /* jump */ + int nArg; + int iQuery; + const sqlite3_module *pModule; + Mem *pQuery; + Mem *pArgc; + sqlite3_vtab_cursor *pVCur; + sqlite3_vtab *pVtab; + VdbeCursor *pCur; + int res; + int i; + Mem **apArg; + + pQuery = &aMem[pOp->p3]; + pArgc = &pQuery[1]; + pCur = p->apCsr[pOp->p1]; + assert( memIsValid(pQuery) ); + REGISTER_TRACE(pOp->p3, pQuery); + assert( pCur->eCurType==CURTYPE_VTAB ); + pVCur = pCur->uc.pVCur; + pVtab = pVCur->pVtab; + pModule = pVtab->pModule; + + /* Grab the index number and argc parameters */ + assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int ); + nArg = (int)pArgc->u.i; + iQuery = (int)pQuery->u.i; + + /* Invoke the xFilter method */ + res = 0; + apArg = p->apArg; + for(i = 0; ixFilter(pVCur, iQuery, pOp->p4.z, nArg, apArg); + sqlite3VtabImportErrmsg(p, pVtab); + if( rc ) goto abort_due_to_error; + res = pModule->xEof(pVCur); + pCur->nullRow = 0; + VdbeBranchTaken(res!=0,2); + if( res ) goto jump_to_p2; + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VColumn P1 P2 P3 * P5 +** Synopsis: r[P3]=vcolumn(P2) +** +** Store in register P3 the value of the P2-th column of +** the current row of the virtual-table of cursor P1. +** +** If the VColumn opcode is being used to fetch the value of +** an unchanging column during an UPDATE operation, then the P5 +** value is OPFLAG_NOCHNG. This will cause the sqlite3_vtab_nochange() +** function to return true inside the xColumn method of the virtual +** table implementation. The P5 column might also contain other +** bits (OPFLAG_LENGTHARG or OPFLAG_TYPEOFARG) but those bits are +** unused by OP_VColumn. +*/ +case OP_VColumn: { + sqlite3_vtab *pVtab; + const sqlite3_module *pModule; + Mem *pDest; + sqlite3_context sContext; + + VdbeCursor *pCur = p->apCsr[pOp->p1]; + assert( pCur->eCurType==CURTYPE_VTAB ); + assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); + pDest = &aMem[pOp->p3]; + memAboutToChange(p, pDest); + if( pCur->nullRow ){ + sqlite3VdbeMemSetNull(pDest); + break; + } + pVtab = pCur->uc.pVCur->pVtab; + pModule = pVtab->pModule; + assert( pModule->xColumn ); + memset(&sContext, 0, sizeof(sContext)); + sContext.pOut = pDest; + assert( pOp->p5==OPFLAG_NOCHNG || pOp->p5==0 ); + if( pOp->p5 & OPFLAG_NOCHNG ){ + sqlite3VdbeMemSetNull(pDest); + pDest->flags = MEM_Null|MEM_Zero; + pDest->u.nZero = 0; + }else{ + MemSetTypeFlag(pDest, MEM_Null); + } + rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2); + sqlite3VtabImportErrmsg(p, pVtab); + if( sContext.isError>0 ){ + sqlite3VdbeError(p, "%s", sqlite3_value_text(pDest)); + rc = sContext.isError; + } + sqlite3VdbeChangeEncoding(pDest, encoding); + REGISTER_TRACE(pOp->p3, pDest); + UPDATE_MAX_BLOBSIZE(pDest); + + if( sqlite3VdbeMemTooBig(pDest) ){ + goto too_big; + } + if( rc ) goto abort_due_to_error; + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VNext P1 P2 * * * +** +** Advance virtual table P1 to the next row in its result set and +** 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 */ + sqlite3_vtab *pVtab; + const sqlite3_module *pModule; + int res; + VdbeCursor *pCur; + + res = 0; + pCur = p->apCsr[pOp->p1]; + assert( pCur->eCurType==CURTYPE_VTAB ); + if( pCur->nullRow ){ + break; + } + pVtab = pCur->uc.pVCur->pVtab; + pModule = pVtab->pModule; + assert( pModule->xNext ); + + /* Invoke the xNext() method of the module. There is no way for the + ** underlying implementation to return an error if one occurs during + ** xNext(). Instead, if an error occurs, true is returned (indicating that + ** data is available) and the error code returned when xColumn or + ** some other method is next invoked on the save virtual table cursor. + */ + rc = pModule->xNext(pCur->uc.pVCur); + sqlite3VtabImportErrmsg(p, pVtab); + if( rc ) goto abort_due_to_error; + res = pModule->xEof(pCur->uc.pVCur); + VdbeBranchTaken(!res,2); + if( !res ){ + /* If there is data, jump to P2 */ + goto jump_to_p2_and_check_for_interrupt; + } + goto check_for_interrupt; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VRename P1 * * P4 * +** +** P4 is a pointer to a virtual table object, an sqlite3_vtab structure. +** This opcode invokes the corresponding xRename method. The value +** in register P1 is passed as the zName argument to the xRename method. +*/ +case OP_VRename: { + sqlite3_vtab *pVtab; + Mem *pName; + int isLegacy; + + isLegacy = (db->flags & SQLITE_LegacyAlter); + db->flags |= SQLITE_LegacyAlter; + pVtab = pOp->p4.pVtab->pVtab; + pName = &aMem[pOp->p1]; + assert( pVtab->pModule->xRename ); + assert( memIsValid(pName) ); + assert( p->readOnly==0 ); + REGISTER_TRACE(pOp->p1, pName); + assert( pName->flags & MEM_Str ); + testcase( pName->enc==SQLITE_UTF8 ); + testcase( pName->enc==SQLITE_UTF16BE ); + testcase( pName->enc==SQLITE_UTF16LE ); + rc = sqlite3VdbeChangeEncoding(pName, SQLITE_UTF8); + if( rc ) goto abort_due_to_error; + rc = pVtab->pModule->xRename(pVtab, pName->z); + if( isLegacy==0 ) db->flags &= ~(u64)SQLITE_LegacyAlter; + sqlite3VtabImportErrmsg(p, pVtab); + p->expired = 0; + if( rc ) goto abort_due_to_error; + break; +} +#endif + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VUpdate P1 P2 P3 P4 P5 +** Synopsis: data=r[P3@P2] +** +** P4 is a pointer to a virtual table object, an sqlite3_vtab structure. +** This opcode invokes the corresponding xUpdate method. P2 values +** are contiguous memory cells starting at P3 to pass to the xUpdate +** invocation. The value in register (P3+P2-1) corresponds to the +** p2th element of the argv array passed to xUpdate. +** +** The xUpdate method will do a DELETE or an INSERT or both. +** The argv[0] element (which corresponds to memory cell P3) +** is the rowid of a row to delete. If argv[0] is NULL then no +** deletion occurs. The argv[1] element is the rowid of the new +** row. This can be NULL to have the virtual table select the new +** rowid for itself. The subsequent elements in the array are +** the values of columns in the new row. +** +** If P2==1 then no insert is performed. argv[0] is the rowid of +** a row to delete. +** +** P1 is a boolean flag. If it is set to true and the xUpdate call +** is successful, then the value returned by sqlite3_last_insert_rowid() +** is set to the value of the rowid for the row just inserted. +** +** P5 is the error actions (OE_Replace, OE_Fail, OE_Ignore, etc) to +** apply in the case of a constraint failure on an insert or update. +*/ +case OP_VUpdate: { + sqlite3_vtab *pVtab; + const sqlite3_module *pModule; + int nArg; + int i; + sqlite_int64 rowid; + Mem **apArg; + Mem *pX; + + assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback + || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace + ); + assert( p->readOnly==0 ); + if( db->mallocFailed ) goto no_mem; + sqlite3VdbeIncrWriteCounter(p, 0); + pVtab = pOp->p4.pVtab->pVtab; + if( pVtab==0 || NEVER(pVtab->pModule==0) ){ + rc = SQLITE_LOCKED; + goto abort_due_to_error; + } + pModule = pVtab->pModule; + nArg = pOp->p2; + assert( pOp->p4type==P4_VTAB ); + if( ALWAYS(pModule->xUpdate) ){ + u8 vtabOnConflict = db->vtabOnConflict; + apArg = p->apArg; + pX = &aMem[pOp->p3]; + for(i=0; ivtabOnConflict = pOp->p5; + rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid); + db->vtabOnConflict = vtabOnConflict; + sqlite3VtabImportErrmsg(p, pVtab); + if( rc==SQLITE_OK && pOp->p1 ){ + assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) ); + db->lastRowid = rowid; + } + if( (rc&0xff)==SQLITE_CONSTRAINT && pOp->p4.pVtab->bConstraint ){ + if( pOp->p5==OE_Ignore ){ + rc = SQLITE_OK; + }else{ + p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5); + } + }else{ + p->nChange++; + } + if( rc ) goto abort_due_to_error; + } + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* Opcode: Pagecount P1 P2 * * * +** +** Write the current number of pages in database P1 to memory cell P2. +*/ +case OP_Pagecount: { /* out2 */ + pOut = out2Prerelease(p, pOp); + pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt); + break; +} +#endif + + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* Opcode: MaxPgcnt P1 P2 P3 * * +** +** Try to set the maximum page count for database P1 to the value in P3. +** Do not let the maximum page count fall below the current page count and +** do not change the maximum page count value if P3==0. +** +** Store the maximum page count after the change in register P2. +*/ +case OP_MaxPgcnt: { /* out2 */ + unsigned int newMax; + Btree *pBt; + + pOut = out2Prerelease(p, pOp); + pBt = db->aDb[pOp->p1].pBt; + newMax = 0; + if( pOp->p3 ){ + newMax = sqlite3BtreeLastPage(pBt); + if( newMax < (unsigned)pOp->p3 ) newMax = (unsigned)pOp->p3; + } + pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax); + break; +} +#endif + +/* Opcode: Function P1 P2 P3 P4 * +** Synopsis: r[P3]=func(r[P2@NP]) +** +** Invoke a user function (P4 is a pointer to an sqlite3_context object that +** contains a pointer to the function to be run) with arguments taken +** from register P2 and successors. The number of arguments is in +** the sqlite3_context object that P4 points to. +** The result of the function is stored +** in register P3. Register P3 must not be one of the function inputs. +** +** P1 is a 32-bit bitmask indicating whether or not each argument to the +** function was determined to be constant at compile time. If the first +** argument was constant then bit 0 of P1 is set. This is used to determine +** whether meta data associated with a user function argument using the +** sqlite3_set_auxdata() API may be safely retained until the next +** invocation of this opcode. +** +** See also: AggStep, AggFinal, PureFunc +*/ +/* Opcode: PureFunc P1 P2 P3 P4 * +** Synopsis: r[P3]=func(r[P2@NP]) +** +** Invoke a user function (P4 is a pointer to an sqlite3_context object that +** contains a pointer to the function to be run) with arguments taken +** from register P2 and successors. The number of arguments is in +** the sqlite3_context object that P4 points to. +** The result of the function is stored +** in register P3. Register P3 must not be one of the function inputs. +** +** P1 is a 32-bit bitmask indicating whether or not each argument to the +** function was determined to be constant at compile time. If the first +** argument was constant then bit 0 of P1 is set. This is used to determine +** whether meta data associated with a user function argument using the +** sqlite3_set_auxdata() API may be safely retained until the next +** invocation of this opcode. +** +** This opcode works exactly like OP_Function. The only difference is in +** its name. This opcode is used in places where the function must be +** purely non-deterministic. Some built-in date/time functions can be +** either determinitic of non-deterministic, depending on their arguments. +** When those function are used in a non-deterministic way, they will check +** to see if they were called using OP_PureFunc instead of OP_Function, and +** if they were, they throw an error. +** +** See also: AggStep, AggFinal, Function +*/ +case OP_PureFunc: /* group */ +case OP_Function: { /* group */ + int i; + sqlite3_context *pCtx; + + assert( pOp->p4type==P4_FUNCCTX ); + pCtx = pOp->p4.pCtx; + + /* If this function is inside of a trigger, the register array in aMem[] + ** might change from one evaluation to the next. The next block of code + ** checks to see if the register array has changed, and if so it + ** reinitializes the relavant parts of the sqlite3_context object */ + pOut = &aMem[pOp->p3]; + if( pCtx->pOut != pOut ){ + pCtx->pVdbe = p; + pCtx->pOut = pOut; + for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i]; + } + assert( pCtx->pVdbe==p ); + + memAboutToChange(p, pOut); +#ifdef SQLITE_DEBUG + for(i=0; iargc; i++){ + assert( memIsValid(pCtx->argv[i]) ); + REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]); + } +#endif + MemSetTypeFlag(pOut, MEM_Null); + assert( pCtx->isError==0 ); + (*pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/* IMP: R-24505-23230 */ + + /* If the function returned an error, throw an exception */ + if( pCtx->isError ){ + if( pCtx->isError>0 ){ + sqlite3VdbeError(p, "%s", sqlite3_value_text(pOut)); + rc = pCtx->isError; + } + sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1); + pCtx->isError = 0; + if( rc ) goto abort_due_to_error; + } + + /* Copy the result of the function into register P3 */ + if( pOut->flags & (MEM_Str|MEM_Blob) ){ + sqlite3VdbeChangeEncoding(pOut, encoding); + if( sqlite3VdbeMemTooBig(pOut) ) goto too_big; + } + + REGISTER_TRACE(pOp->p3, pOut); + UPDATE_MAX_BLOBSIZE(pOut); + break; +} + +/* Opcode: Trace P1 P2 * P4 * +** +** Write P4 on the statement trace output if statement tracing is +** enabled. +** +** Operand P1 must be 0x7fffffff and P2 must positive. +*/ +/* Opcode: Init P1 P2 P3 P4 * +** Synopsis: Start at P2 +** +** Programs contain a single instance of this opcode as the very first +** opcode. +** +** If tracing is enabled (by the sqlite3_trace()) interface, then +** the UTF-8 string contained in P4 is emitted on the trace callback. +** Or if P4 is blank, use the string returned by sqlite3_sql(). +** +** If P2 is not zero, jump to instruction P2. +** +** Increment the value of P1 so that OP_Once opcodes will jump the +** first time they are evaluated for this run. +** +** If P3 is not zero, then it is an address to jump to if an SQLITE_CORRUPT +** error is encountered. +*/ +case OP_Trace: +case OP_Init: { /* jump */ + int i; +#ifndef SQLITE_OMIT_TRACE + char *zTrace; +#endif + + /* If the P4 argument is not NULL, then it must be an SQL comment string. + ** The "--" string is broken up to prevent false-positives with srcck1.c. + ** + ** This assert() provides evidence for: + ** EVIDENCE-OF: R-50676-09860 The callback can compute the same text that + ** would have been returned by the legacy sqlite3_trace() interface by + ** using the X argument when X begins with "--" and invoking + ** sqlite3_expanded_sql(P) otherwise. + */ + assert( pOp->p4.z==0 || strncmp(pOp->p4.z, "-" "- ", 3)==0 ); + + /* OP_Init is always instruction 0 */ + assert( pOp==p->aOp || pOp->opcode==OP_Trace ); + +#ifndef SQLITE_OMIT_TRACE + if( (db->mTrace & (SQLITE_TRACE_STMT|SQLITE_TRACE_LEGACY))!=0 + && !p->doingRerun + && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0 + ){ +#ifndef SQLITE_OMIT_DEPRECATED + if( db->mTrace & SQLITE_TRACE_LEGACY ){ + char *z = sqlite3VdbeExpandSql(p, zTrace); + db->trace.xLegacy(db->pTraceArg, z); + sqlite3_free(z); + }else +#endif + if( db->nVdbeExec>1 ){ + char *z = sqlite3MPrintf(db, "-- %s", zTrace); + (void)db->trace.xV2(SQLITE_TRACE_STMT, db->pTraceArg, p, z); + sqlite3DbFree(db, z); + }else{ + (void)db->trace.xV2(SQLITE_TRACE_STMT, db->pTraceArg, p, zTrace); + } + } +#ifdef SQLITE_USE_FCNTL_TRACE + zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql); + if( zTrace ){ + int j; + for(j=0; jnDb; j++){ + if( DbMaskTest(p->btreeMask, j)==0 ) continue; + sqlite3_file_control(db, db->aDb[j].zDbSName, SQLITE_FCNTL_TRACE, zTrace); + } + } +#endif /* SQLITE_USE_FCNTL_TRACE */ +#ifdef SQLITE_DEBUG + if( (db->flags & SQLITE_SqlTrace)!=0 + && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0 + ){ + sqlite3DebugPrintf("SQL-trace: %s\n", zTrace); + } +#endif /* SQLITE_DEBUG */ +#endif /* SQLITE_OMIT_TRACE */ + assert( pOp->p2>0 ); + if( pOp->p1>=sqlite3GlobalConfig.iOnceResetThreshold ){ + if( pOp->opcode==OP_Trace ) break; + for(i=1; inOp; i++){ + if( p->aOp[i].opcode==OP_Once ) p->aOp[i].p1 = 0; + } + pOp->p1 = 0; + } + pOp->p1++; + p->aCounter[SQLITE_STMTSTATUS_RUN]++; + goto jump_to_p2; +} + +#ifdef SQLITE_ENABLE_CURSOR_HINTS +/* Opcode: CursorHint P1 * * P4 * +** +** Provide a hint to cursor P1 that it only needs to return rows that +** satisfy the Expr in P4. TK_REGISTER terms in the P4 expression refer +** to values currently held in registers. TK_COLUMN terms in the P4 +** expression refer to columns in the b-tree to which cursor P1 is pointing. +*/ +case OP_CursorHint: { + VdbeCursor *pC; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( pOp->p4type==P4_EXPR ); + pC = p->apCsr[pOp->p1]; + if( pC ){ + assert( pC->eCurType==CURTYPE_BTREE ); + sqlite3BtreeCursorHint(pC->uc.pCursor, BTREE_HINT_RANGE, + pOp->p4.pExpr, aMem); + } + break; +} +#endif /* SQLITE_ENABLE_CURSOR_HINTS */ + +#ifdef SQLITE_DEBUG +/* Opcode: Abortable * * * * * +** +** Verify that an Abort can happen. Assert if an Abort at this point +** might cause database corruption. This opcode only appears in debugging +** builds. +** +** An Abort is safe if either there have been no writes, or if there is +** an active statement journal. +*/ +case OP_Abortable: { + sqlite3VdbeAssertAbortable(p); + break; +} +#endif + +#ifdef SQLITE_DEBUG +/* Opcode: ReleaseReg P1 P2 P3 * P5 +** Synopsis: release r[P1@P2] mask P3 +** +** Release registers from service. Any content that was in the +** the registers is unreliable after this opcode completes. +** +** The registers released will be the P2 registers starting at P1, +** except if bit ii of P3 set, then do not release register P1+ii. +** In other words, P3 is a mask of registers to preserve. +** +** Releasing a register clears the Mem.pScopyFrom pointer. That means +** that if the content of the released register was set using OP_SCopy, +** a change to the value of the source register for the OP_SCopy will no longer +** generate an assertion fault in sqlite3VdbeMemAboutToChange(). +** +** If P5 is set, then all released registers have their type set +** to MEM_Undefined so that any subsequent attempt to read the released +** register (before it is reinitialized) will generate an assertion fault. +** +** P5 ought to be set on every call to this opcode. +** However, there are places in the code generator will release registers +** before their are used, under the (valid) assumption that the registers +** will not be reallocated for some other purpose before they are used and +** hence are safe to release. +** +** This opcode is only available in testing and debugging builds. It is +** not generated for release builds. The purpose of this opcode is to help +** validate the generated bytecode. This opcode does not actually contribute +** to computing an answer. +*/ +case OP_ReleaseReg: { + Mem *pMem; + int i; + u32 constMask; + assert( pOp->p1>0 ); + assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 ); + pMem = &aMem[pOp->p1]; + constMask = pOp->p3; + for(i=0; ip2; i++, pMem++){ + if( i>=32 || (constMask & MASKBIT32(i))==0 ){ + pMem->pScopyFrom = 0; + if( i<32 && pOp->p5 ) MemSetTypeFlag(pMem, MEM_Undefined); + } + } + break; +} +#endif + +/* Opcode: Noop * * * * * +** +** Do nothing. This instruction is often useful as a jump +** destination. +*/ +/* +** The magic Explain opcode are only inserted when explain==2 (which +** is to say when the EXPLAIN QUERY PLAN syntax is used.) +** This opcode records information from the optimizer. It is the +** the same as a no-op. This opcodesnever appears in a real VM program. +*/ +default: { /* This is really OP_Noop, OP_Explain */ + assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain ); + + break; +} + +/***************************************************************************** +** The cases of the switch statement above this line should all be indented +** by 6 spaces. But the left-most 6 spaces have been removed to improve the +** readability. From this point on down, the normal indentation rules are +** restored. +*****************************************************************************/ + } + +#ifdef VDBE_PROFILE + { + u64 endTime = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime(); + if( endTime>start ) pOrigOp->cycles += endTime - start; + pOrigOp->cnt++; + } +#endif + + /* The following code adds nothing to the actual functionality + ** of the program. It is only here for testing and debugging. + ** On the other hand, it does burn CPU cycles every time through + ** the evaluator loop. So we can leave it out when NDEBUG is defined. + */ +#ifndef NDEBUG + assert( pOp>=&aOp[-1] && pOp<&aOp[p->nOp-1] ); + +#ifdef SQLITE_DEBUG + if( db->flags & SQLITE_VdbeTrace ){ + u8 opProperty = sqlite3OpcodeProperty[pOrigOp->opcode]; + if( rc!=0 ) printf("rc=%d\n",rc); + if( opProperty & (OPFLG_OUT2) ){ + registerTrace(pOrigOp->p2, &aMem[pOrigOp->p2]); + } + if( opProperty & OPFLG_OUT3 ){ + registerTrace(pOrigOp->p3, &aMem[pOrigOp->p3]); + } + if( opProperty==0xff ){ + /* Never happens. This code exists to avoid a harmless linkage + ** warning aboud sqlite3VdbeRegisterDump() being defined but not + ** used. */ + sqlite3VdbeRegisterDump(p); + } + } +#endif /* SQLITE_DEBUG */ +#endif /* NDEBUG */ + } /* The end of the for(;;) loop the loops through opcodes */ + + /* If we reach this point, it means that execution is finished with + ** an error of some kind. + */ +abort_due_to_error: + if( db->mallocFailed ){ + rc = SQLITE_NOMEM_BKPT; + }else if( rc==SQLITE_IOERR_CORRUPTFS ){ + rc = SQLITE_CORRUPT_BKPT; + } + assert( rc ); + if( p->zErrMsg==0 && rc!=SQLITE_IOERR_NOMEM ){ + sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc)); + } + p->rc = rc; + sqlite3SystemError(db, rc); + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(rc, "statement aborts at %d: [%s] %s", + (int)(pOp - aOp), p->zSql, p->zErrMsg); + sqlite3VdbeHalt(p); + if( rc==SQLITE_IOERR_NOMEM ) sqlite3OomFault(db); + rc = SQLITE_ERROR; + if( resetSchemaOnFault>0 ){ + sqlite3ResetOneSchema(db, resetSchemaOnFault-1); + } + + /* This is the only way out of this procedure. We have to + ** release the mutexes on btrees that were acquired at the + ** top. */ +vdbe_return: +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + while( nVmStep>=nProgressLimit && db->xProgress!=0 ){ + nProgressLimit += db->nProgressOps; + if( db->xProgress(db->pProgressArg) ){ + nProgressLimit = LARGEST_UINT64; + rc = SQLITE_INTERRUPT; + goto abort_due_to_error; + } + } +#endif + p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep; + sqlite3VdbeLeave(p); + assert( rc!=SQLITE_OK || nExtraDelete==0 + || sqlite3_strlike("DELETE%",p->zSql,0)!=0 + ); + return rc; + + /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH + ** is encountered. + */ +too_big: + sqlite3VdbeError(p, "string or blob too big"); + rc = SQLITE_TOOBIG; + goto abort_due_to_error; + + /* Jump to here if a malloc() fails. + */ +no_mem: + sqlite3OomFault(db); + sqlite3VdbeError(p, "out of memory"); + rc = SQLITE_NOMEM_BKPT; + goto abort_due_to_error; + + /* Jump to here if the sqlite3_interrupt() API sets the interrupt + ** flag. + */ +abort_due_to_interrupt: + assert( AtomicLoad(&db->u1.isInterrupted) ); + rc = SQLITE_INTERRUPT; + goto abort_due_to_error; +} + + +/************** End of vdbe.c ************************************************/ +/************** Begin file vdbeblob.c ****************************************/ +/* +** 2007 May 1 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code used to implement incremental BLOB I/O. +*/ + +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +#ifndef SQLITE_OMIT_INCRBLOB + +/* +** Valid sqlite3_blob* handles point to Incrblob structures. +*/ +typedef struct Incrblob Incrblob; +struct Incrblob { + int nByte; /* Size of open blob, in bytes */ + int iOffset; /* Byte offset of blob in cursor data */ + u16 iCol; /* Table column this handle is open on */ + BtCursor *pCsr; /* Cursor pointing at blob row */ + sqlite3_stmt *pStmt; /* Statement holding cursor open */ + sqlite3 *db; /* The associated database */ + char *zDb; /* Database name */ + Table *pTab; /* Table object */ +}; + + +/* +** This function is used by both blob_open() and blob_reopen(). It seeks +** the b-tree cursor associated with blob handle p to point to row iRow. +** If successful, SQLITE_OK is returned and subsequent calls to +** sqlite3_blob_read() or sqlite3_blob_write() access the specified row. +** +** If an error occurs, or if the specified row does not exist or does not +** contain a value of type TEXT or BLOB in the column nominated when the +** blob handle was opened, then an error code is returned and *pzErr may +** be set to point to a buffer containing an error message. It is the +** responsibility of the caller to free the error message buffer using +** sqlite3DbFree(). +** +** If an error does occur, then the b-tree cursor is closed. All subsequent +** calls to sqlite3_blob_read(), blob_write() or blob_reopen() will +** immediately return SQLITE_ABORT. +*/ +static int blobSeekToRow(Incrblob *p, sqlite3_int64 iRow, char **pzErr){ + int rc; /* Error code */ + char *zErr = 0; /* Error message */ + Vdbe *v = (Vdbe *)p->pStmt; + + /* Set the value of register r[1] in the SQL statement to integer iRow. + ** This is done directly as a performance optimization + */ + v->aMem[1].flags = MEM_Int; + v->aMem[1].u.i = iRow; + + /* If the statement has been run before (and is paused at the OP_ResultRow) + ** then back it up to the point where it does the OP_NotExists. This could + ** have been down with an extra OP_Goto, but simply setting the program + ** counter is faster. */ + if( v->pc>4 ){ + v->pc = 4; + assert( v->aOp[v->pc].opcode==OP_NotExists ); + rc = sqlite3VdbeExec(v); + }else{ + rc = sqlite3_step(p->pStmt); + } + if( rc==SQLITE_ROW ){ + VdbeCursor *pC = v->apCsr[0]; + u32 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0; + testcase( pC->nHdrParsed==p->iCol ); + testcase( pC->nHdrParsed==p->iCol+1 ); + if( type<12 ){ + zErr = sqlite3MPrintf(p->db, "cannot open value of type %s", + type==0?"null": type==7?"real": "integer" + ); + rc = SQLITE_ERROR; + sqlite3_finalize(p->pStmt); + p->pStmt = 0; + }else{ + p->iOffset = pC->aType[p->iCol + pC->nField]; + p->nByte = sqlite3VdbeSerialTypeLen(type); + p->pCsr = pC->uc.pCursor; + sqlite3BtreeIncrblobCursor(p->pCsr); + } + } + + if( rc==SQLITE_ROW ){ + rc = SQLITE_OK; + }else if( p->pStmt ){ + rc = sqlite3_finalize(p->pStmt); + p->pStmt = 0; + if( rc==SQLITE_OK ){ + zErr = sqlite3MPrintf(p->db, "no such rowid: %lld", iRow); + rc = SQLITE_ERROR; + }else{ + zErr = sqlite3MPrintf(p->db, "%s", sqlite3_errmsg(p->db)); + } + } + + assert( rc!=SQLITE_OK || zErr==0 ); + assert( rc!=SQLITE_ROW && rc!=SQLITE_DONE ); + + *pzErr = zErr; + return rc; +} + +/* +** Open a blob handle. +*/ +SQLITE_API int sqlite3_blob_open( + sqlite3* db, /* The database connection */ + const char *zDb, /* The attached database containing the blob */ + const char *zTable, /* The table containing the blob */ + const char *zColumn, /* The column containing the blob */ + sqlite_int64 iRow, /* The row containing the glob */ + int wrFlag, /* True -> read/write access, false -> read-only */ + sqlite3_blob **ppBlob /* Handle for accessing the blob returned here */ +){ + int nAttempt = 0; + int iCol; /* Index of zColumn in row-record */ + int rc = SQLITE_OK; + char *zErr = 0; + Table *pTab; + Incrblob *pBlob = 0; + Parse sParse; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( ppBlob==0 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + *ppBlob = 0; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zTable==0 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + wrFlag = !!wrFlag; /* wrFlag = (wrFlag ? 1 : 0); */ + + sqlite3_mutex_enter(db->mutex); + + pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob)); + do { + memset(&sParse, 0, sizeof(Parse)); + if( !pBlob ) goto blob_open_out; + sParse.db = db; + sqlite3DbFree(db, zErr); + zErr = 0; + + sqlite3BtreeEnterAll(db); + pTab = sqlite3LocateTable(&sParse, 0, zTable, zDb); + if( pTab && IsVirtual(pTab) ){ + pTab = 0; + sqlite3ErrorMsg(&sParse, "cannot open virtual table: %s", zTable); + } + if( pTab && !HasRowid(pTab) ){ + pTab = 0; + sqlite3ErrorMsg(&sParse, "cannot open table without rowid: %s", zTable); + } +#ifndef SQLITE_OMIT_VIEW + if( pTab && pTab->pSelect ){ + pTab = 0; + sqlite3ErrorMsg(&sParse, "cannot open view: %s", zTable); + } +#endif + if( !pTab ){ + if( sParse.zErrMsg ){ + sqlite3DbFree(db, zErr); + zErr = sParse.zErrMsg; + sParse.zErrMsg = 0; + } + rc = SQLITE_ERROR; + sqlite3BtreeLeaveAll(db); + goto blob_open_out; + } + pBlob->pTab = pTab; + pBlob->zDb = db->aDb[sqlite3SchemaToIndex(db, pTab->pSchema)].zDbSName; + + /* Now search pTab for the exact column. */ + for(iCol=0; iColnCol; iCol++) { + if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){ + break; + } + } + if( iCol==pTab->nCol ){ + sqlite3DbFree(db, zErr); + zErr = sqlite3MPrintf(db, "no such column: \"%s\"", zColumn); + rc = SQLITE_ERROR; + sqlite3BtreeLeaveAll(db); + goto blob_open_out; + } + + /* If the value is being opened for writing, check that the + ** column is not indexed, and that it is not part of a foreign key. + */ + if( wrFlag ){ + const char *zFault = 0; + Index *pIdx; +#ifndef SQLITE_OMIT_FOREIGN_KEY + if( db->flags&SQLITE_ForeignKeys ){ + /* Check that the column is not part of an FK child key definition. It + ** is not necessary to check if it is part of a parent key, as parent + ** key columns must be indexed. The check below will pick up this + ** case. */ + FKey *pFKey; + for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){ + int j; + for(j=0; jnCol; j++){ + if( pFKey->aCol[j].iFrom==iCol ){ + zFault = "foreign key"; + } + } + } + } +#endif + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int j; + for(j=0; jnKeyCol; j++){ + /* FIXME: Be smarter about indexes that use expressions */ + if( pIdx->aiColumn[j]==iCol || pIdx->aiColumn[j]==XN_EXPR ){ + zFault = "indexed"; + } + } + } + if( zFault ){ + sqlite3DbFree(db, zErr); + zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault); + rc = SQLITE_ERROR; + sqlite3BtreeLeaveAll(db); + goto blob_open_out; + } + } + + pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(&sParse); + assert( pBlob->pStmt || db->mallocFailed ); + if( pBlob->pStmt ){ + + /* This VDBE program seeks a btree cursor to the identified + ** db/table/row entry. The reason for using a vdbe program instead + ** of writing code to use the b-tree layer directly is that the + ** vdbe program will take advantage of the various transaction, + ** locking and error handling infrastructure built into the vdbe. + ** + ** After seeking the cursor, the vdbe executes an OP_ResultRow. + ** Code external to the Vdbe then "borrows" the b-tree cursor and + ** uses it to implement the blob_read(), blob_write() and + ** blob_bytes() functions. + ** + ** The sqlite3_blob_close() function finalizes the vdbe program, + ** which closes the b-tree cursor and (possibly) commits the + ** transaction. + */ + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList openBlob[] = { + {OP_TableLock, 0, 0, 0}, /* 0: Acquire a read or write lock */ + {OP_OpenRead, 0, 0, 0}, /* 1: Open a cursor */ + /* blobSeekToRow() will initialize r[1] to the desired rowid */ + {OP_NotExists, 0, 5, 1}, /* 2: Seek the cursor to rowid=r[1] */ + {OP_Column, 0, 0, 1}, /* 3 */ + {OP_ResultRow, 1, 0, 0}, /* 4 */ + {OP_Halt, 0, 0, 0}, /* 5 */ + }; + Vdbe *v = (Vdbe *)pBlob->pStmt; + int iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + VdbeOp *aOp; + + sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, wrFlag, + pTab->pSchema->schema_cookie, + pTab->pSchema->iGeneration); + sqlite3VdbeChangeP5(v, 1); + assert( sqlite3VdbeCurrentAddr(v)==2 || db->mallocFailed ); + aOp = sqlite3VdbeAddOpList(v, ArraySize(openBlob), openBlob, iLn); + + /* Make sure a mutex is held on the table to be accessed */ + sqlite3VdbeUsesBtree(v, iDb); + + if( db->mallocFailed==0 ){ + assert( aOp!=0 ); + /* Configure the OP_TableLock instruction */ +#ifdef SQLITE_OMIT_SHARED_CACHE + aOp[0].opcode = OP_Noop; +#else + aOp[0].p1 = iDb; + aOp[0].p2 = pTab->tnum; + aOp[0].p3 = wrFlag; + sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT); + } + if( db->mallocFailed==0 ){ +#endif + + /* Remove either the OP_OpenWrite or OpenRead. Set the P2 + ** parameter of the other to pTab->tnum. */ + if( wrFlag ) aOp[1].opcode = OP_OpenWrite; + aOp[1].p2 = pTab->tnum; + aOp[1].p3 = iDb; + + /* Configure the number of columns. Configure the cursor to + ** think that the table has one more column than it really + ** does. An OP_Column to retrieve this imaginary column will + ** always return an SQL NULL. This is useful because it means + ** we can invoke OP_Column to fill in the vdbe cursors type + ** and offset cache without causing any IO. + */ + aOp[1].p4type = P4_INT32; + aOp[1].p4.i = pTab->nCol+1; + aOp[3].p2 = pTab->nCol; + + sParse.nVar = 0; + sParse.nMem = 1; + sParse.nTab = 1; + sqlite3VdbeMakeReady(v, &sParse); + } + } + + pBlob->iCol = iCol; + pBlob->db = db; + sqlite3BtreeLeaveAll(db); + if( db->mallocFailed ){ + goto blob_open_out; + } + rc = blobSeekToRow(pBlob, iRow, &zErr); + } while( (++nAttempt)mallocFailed==0 ){ + *ppBlob = (sqlite3_blob *)pBlob; + }else{ + if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt); + sqlite3DbFree(db, pBlob); + } + sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr); + sqlite3DbFree(db, zErr); + sqlite3ParserReset(&sParse); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Close a blob handle that was previously created using +** sqlite3_blob_open(). +*/ +SQLITE_API int sqlite3_blob_close(sqlite3_blob *pBlob){ + Incrblob *p = (Incrblob *)pBlob; + int rc; + sqlite3 *db; + + if( p ){ + sqlite3_stmt *pStmt = p->pStmt; + db = p->db; + sqlite3_mutex_enter(db->mutex); + sqlite3DbFree(db, p); + sqlite3_mutex_leave(db->mutex); + rc = sqlite3_finalize(pStmt); + }else{ + rc = SQLITE_OK; + } + return rc; +} + +/* +** Perform a read or write operation on a blob +*/ +static int blobReadWrite( + sqlite3_blob *pBlob, + void *z, + int n, + int iOffset, + int (*xCall)(BtCursor*, u32, u32, void*) +){ + int rc; + Incrblob *p = (Incrblob *)pBlob; + Vdbe *v; + sqlite3 *db; + + if( p==0 ) return SQLITE_MISUSE_BKPT; + db = p->db; + sqlite3_mutex_enter(db->mutex); + v = (Vdbe*)p->pStmt; + + if( n<0 || iOffset<0 || ((sqlite3_int64)iOffset+n)>p->nByte ){ + /* Request is out of range. Return a transient error. */ + rc = SQLITE_ERROR; + }else if( v==0 ){ + /* If there is no statement handle, then the blob-handle has + ** already been invalidated. Return SQLITE_ABORT in this case. + */ + rc = SQLITE_ABORT; + }else{ + /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is + ** returned, clean-up the statement handle. + */ + assert( db == v->db ); + sqlite3BtreeEnterCursor(p->pCsr); + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + if( xCall==sqlite3BtreePutData && db->xPreUpdateCallback ){ + /* If a pre-update hook is registered and this is a write cursor, + ** invoke it here. + ** + ** TODO: The preupdate-hook is passed SQLITE_DELETE, even though this + ** operation should really be an SQLITE_UPDATE. This is probably + ** incorrect, but is convenient because at this point the new.* values + ** are not easily obtainable. And for the sessions module, an + ** SQLITE_UPDATE where the PK columns do not change is handled in the + ** same way as an SQLITE_DELETE (the SQLITE_DELETE code is actually + ** slightly more efficient). Since you cannot write to a PK column + ** using the incremental-blob API, this works. For the sessions module + ** anyhow. + */ + sqlite3_int64 iKey; + iKey = sqlite3BtreeIntegerKey(p->pCsr); + sqlite3VdbePreUpdateHook( + v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1 + ); + } +#endif + + rc = xCall(p->pCsr, iOffset+p->iOffset, n, z); + sqlite3BtreeLeaveCursor(p->pCsr); + if( rc==SQLITE_ABORT ){ + sqlite3VdbeFinalize(v); + p->pStmt = 0; + }else{ + v->rc = rc; + } + } + sqlite3Error(db, rc); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Read data from a blob handle. +*/ +SQLITE_API int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){ + return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreePayloadChecked); +} + +/* +** Write data to a blob handle. +*/ +SQLITE_API int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){ + return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData); +} + +/* +** Query a blob handle for the size of the data. +** +** The Incrblob.nByte field is fixed for the lifetime of the Incrblob +** so no mutex is required for access. +*/ +SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *pBlob){ + Incrblob *p = (Incrblob *)pBlob; + return (p && p->pStmt) ? p->nByte : 0; +} + +/* +** Move an existing blob handle to point to a different row of the same +** database table. +** +** If an error occurs, or if the specified row does not exist or does not +** contain a blob or text value, then an error code is returned and the +** database handle error code and message set. If this happens, then all +** subsequent calls to sqlite3_blob_xxx() functions (except blob_close()) +** immediately return SQLITE_ABORT. +*/ +SQLITE_API int sqlite3_blob_reopen(sqlite3_blob *pBlob, sqlite3_int64 iRow){ + int rc; + Incrblob *p = (Incrblob *)pBlob; + sqlite3 *db; + + if( p==0 ) return SQLITE_MISUSE_BKPT; + db = p->db; + sqlite3_mutex_enter(db->mutex); + + if( p->pStmt==0 ){ + /* If there is no statement handle, then the blob-handle has + ** already been invalidated. Return SQLITE_ABORT in this case. + */ + rc = SQLITE_ABORT; + }else{ + char *zErr; + rc = blobSeekToRow(p, iRow, &zErr); + if( rc!=SQLITE_OK ){ + sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr); + sqlite3DbFree(db, zErr); + } + assert( rc!=SQLITE_SCHEMA ); + } + + rc = sqlite3ApiExit(db, rc); + assert( rc==SQLITE_OK || p->pStmt==0 ); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +#endif /* #ifndef SQLITE_OMIT_INCRBLOB */ + +/************** End of vdbeblob.c ********************************************/ +/************** Begin file vdbesort.c ****************************************/ +/* +** 2011-07-09 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code for the VdbeSorter object, used in concert with +** a VdbeCursor to sort large numbers of keys for CREATE INDEX statements +** or by SELECT statements with ORDER BY clauses that cannot be satisfied +** using indexes and without LIMIT clauses. +** +** The VdbeSorter object implements a multi-threaded external merge sort +** algorithm that is efficient even if the number of elements being sorted +** exceeds the available memory. +** +** Here is the (internal, non-API) interface between this module and the +** rest of the SQLite system: +** +** sqlite3VdbeSorterInit() Create a new VdbeSorter object. +** +** sqlite3VdbeSorterWrite() Add a single new row to the VdbeSorter +** object. The row is a binary blob in the +** OP_MakeRecord format that contains both +** the ORDER BY key columns and result columns +** in the case of a SELECT w/ ORDER BY, or +** the complete record for an index entry +** in the case of a CREATE INDEX. +** +** sqlite3VdbeSorterRewind() Sort all content previously added. +** Position the read cursor on the +** first sorted element. +** +** sqlite3VdbeSorterNext() Advance the read cursor to the next sorted +** element. +** +** sqlite3VdbeSorterRowkey() Return the complete binary blob for the +** row currently under the read cursor. +** +** sqlite3VdbeSorterCompare() Compare the binary blob for the row +** currently under the read cursor against +** another binary blob X and report if +** X is strictly less than the read cursor. +** Used to enforce uniqueness in a +** CREATE UNIQUE INDEX statement. +** +** sqlite3VdbeSorterClose() Close the VdbeSorter object and reclaim +** all resources. +** +** sqlite3VdbeSorterReset() Refurbish the VdbeSorter for reuse. This +** is like Close() followed by Init() only +** much faster. +** +** The interfaces above must be called in a particular order. Write() can +** only occur in between Init()/Reset() and Rewind(). Next(), Rowkey(), and +** Compare() can only occur in between Rewind() and Close()/Reset(). i.e. +** +** Init() +** for each record: Write() +** Rewind() +** Rowkey()/Compare() +** Next() +** Close() +** +** Algorithm: +** +** Records passed to the sorter via calls to Write() are initially held +** unsorted in main memory. Assuming the amount of memory used never exceeds +** a threshold, when Rewind() is called the set of records is sorted using +** an in-memory merge sort. In this case, no temporary files are required +** and subsequent calls to Rowkey(), Next() and Compare() read records +** directly from main memory. +** +** If the amount of space used to store records in main memory exceeds the +** threshold, then the set of records currently in memory are sorted and +** written to a temporary file in "Packed Memory Array" (PMA) format. +** A PMA created at this point is known as a "level-0 PMA". Higher levels +** of PMAs may be created by merging existing PMAs together - for example +** merging two or more level-0 PMAs together creates a level-1 PMA. +** +** The threshold for the amount of main memory to use before flushing +** records to a PMA is roughly the same as the limit configured for the +** page-cache of the main database. Specifically, the threshold is set to +** the value returned by "PRAGMA main.page_size" multipled by +** that returned by "PRAGMA main.cache_size", in bytes. +** +** If the sorter is running in single-threaded mode, then all PMAs generated +** are appended to a single temporary file. Or, if the sorter is running in +** multi-threaded mode then up to (N+1) temporary files may be opened, where +** N is the configured number of worker threads. In this case, instead of +** sorting the records and writing the PMA to a temporary file itself, the +** calling thread usually launches a worker thread to do so. Except, if +** there are already N worker threads running, the main thread does the work +** itself. +** +** The sorter is running in multi-threaded mode if (a) the library was built +** with pre-processor symbol SQLITE_MAX_WORKER_THREADS set to a value greater +** than zero, and (b) worker threads have been enabled at runtime by calling +** "PRAGMA threads=N" with some value of N greater than 0. +** +** When Rewind() is called, any data remaining in memory is flushed to a +** final PMA. So at this point the data is stored in some number of sorted +** PMAs within temporary files on disk. +** +** If there are fewer than SORTER_MAX_MERGE_COUNT PMAs in total and the +** sorter is running in single-threaded mode, then these PMAs are merged +** incrementally as keys are retreived from the sorter by the VDBE. The +** MergeEngine object, described in further detail below, performs this +** merge. +** +** Or, if running in multi-threaded mode, then a background thread is +** launched to merge the existing PMAs. Once the background thread has +** merged T bytes of data into a single sorted PMA, the main thread +** begins reading keys from that PMA while the background thread proceeds +** with merging the next T bytes of data. And so on. +** +** Parameter T is set to half the value of the memory threshold used +** by Write() above to determine when to create a new PMA. +** +** If there are more than SORTER_MAX_MERGE_COUNT PMAs in total when +** Rewind() is called, then a hierarchy of incremental-merges is used. +** First, T bytes of data from the first SORTER_MAX_MERGE_COUNT PMAs on +** disk are merged together. Then T bytes of data from the second set, and +** so on, such that no operation ever merges more than SORTER_MAX_MERGE_COUNT +** PMAs at a time. This done is to improve locality. +** +** If running in multi-threaded mode and there are more than +** SORTER_MAX_MERGE_COUNT PMAs on disk when Rewind() is called, then more +** than one background thread may be created. Specifically, there may be +** one background thread for each temporary file on disk, and one background +** thread to merge the output of each of the others to a single PMA for +** the main thread to read from. +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +/* +** If SQLITE_DEBUG_SORTER_THREADS is defined, this module outputs various +** messages to stderr that may be helpful in understanding the performance +** characteristics of the sorter in multi-threaded mode. +*/ +#if 0 +# define SQLITE_DEBUG_SORTER_THREADS 1 +#endif + +/* +** Hard-coded maximum amount of data to accumulate in memory before flushing +** to a level 0 PMA. The purpose of this limit is to prevent various integer +** overflows. 512MiB. +*/ +#define SQLITE_MAX_PMASZ (1<<29) + +/* +** Private objects used by the sorter +*/ +typedef struct MergeEngine MergeEngine; /* Merge PMAs together */ +typedef struct PmaReader PmaReader; /* Incrementally read one PMA */ +typedef struct PmaWriter PmaWriter; /* Incrementally write one PMA */ +typedef struct SorterRecord SorterRecord; /* A record being sorted */ +typedef struct SortSubtask SortSubtask; /* A sub-task in the sort process */ +typedef struct SorterFile SorterFile; /* Temporary file object wrapper */ +typedef struct SorterList SorterList; /* In-memory list of records */ +typedef struct IncrMerger IncrMerger; /* Read & merge multiple PMAs */ + +/* +** A container for a temp file handle and the current amount of data +** stored in the file. +*/ +struct SorterFile { + sqlite3_file *pFd; /* File handle */ + i64 iEof; /* Bytes of data stored in pFd */ +}; + +/* +** An in-memory list of objects to be sorted. +** +** If aMemory==0 then each object is allocated separately and the objects +** are connected using SorterRecord.u.pNext. If aMemory!=0 then all objects +** are stored in the aMemory[] bulk memory, one right after the other, and +** are connected using SorterRecord.u.iNext. +*/ +struct SorterList { + SorterRecord *pList; /* Linked list of records */ + u8 *aMemory; /* If non-NULL, bulk memory to hold pList */ + int szPMA; /* Size of pList as PMA in bytes */ +}; + +/* +** The MergeEngine object is used to combine two or more smaller PMAs into +** one big PMA using a merge operation. Separate PMAs all need to be +** combined into one big PMA in order to be able to step through the sorted +** records in order. +** +** The aReadr[] array contains a PmaReader object for each of the PMAs being +** merged. An aReadr[] object either points to a valid key or else is at EOF. +** ("EOF" means "End Of File". When aReadr[] is at EOF there is no more data.) +** For the purposes of the paragraphs below, we assume that the array is +** actually N elements in size, where N is the smallest power of 2 greater +** to or equal to the number of PMAs being merged. The extra aReadr[] elements +** are treated as if they are empty (always at EOF). +** +** The aTree[] array is also N elements in size. The value of N is stored in +** the MergeEngine.nTree variable. +** +** The final (N/2) elements of aTree[] contain the results of comparing +** pairs of PMA keys together. Element i contains the result of +** comparing aReadr[2*i-N] and aReadr[2*i-N+1]. Whichever key is smaller, the +** aTree element is set to the index of it. +** +** For the purposes of this comparison, EOF is considered greater than any +** other key value. If the keys are equal (only possible with two EOF +** values), it doesn't matter which index is stored. +** +** The (N/4) elements of aTree[] that precede the final (N/2) described +** above contains the index of the smallest of each block of 4 PmaReaders +** And so on. So that aTree[1] contains the index of the PmaReader that +** currently points to the smallest key value. aTree[0] is unused. +** +** Example: +** +** aReadr[0] -> Banana +** aReadr[1] -> Feijoa +** aReadr[2] -> Elderberry +** aReadr[3] -> Currant +** aReadr[4] -> Grapefruit +** aReadr[5] -> Apple +** aReadr[6] -> Durian +** aReadr[7] -> EOF +** +** aTree[] = { X, 5 0, 5 0, 3, 5, 6 } +** +** The current element is "Apple" (the value of the key indicated by +** PmaReader 5). When the Next() operation is invoked, PmaReader 5 will +** be advanced to the next key in its segment. Say the next key is +** "Eggplant": +** +** aReadr[5] -> Eggplant +** +** The contents of aTree[] are updated first by comparing the new PmaReader +** 5 key to the current key of PmaReader 4 (still "Grapefruit"). The PmaReader +** 5 value is still smaller, so aTree[6] is set to 5. And so on up the tree. +** The value of PmaReader 6 - "Durian" - is now smaller than that of PmaReader +** 5, so aTree[3] is set to 6. Key 0 is smaller than key 6 (Bananafile2. And instead of using a +** background thread to prepare data for the PmaReader, with a single +** threaded IncrMerger the allocate part of pTask->file2 is "refilled" with +** keys from pMerger by the calling thread whenever the PmaReader runs out +** of data. +*/ +struct IncrMerger { + SortSubtask *pTask; /* Task that owns this merger */ + MergeEngine *pMerger; /* Merge engine thread reads data from */ + i64 iStartOff; /* Offset to start writing file at */ + int mxSz; /* Maximum bytes of data to store */ + int bEof; /* Set to true when merge is finished */ + int bUseThread; /* True to use a bg thread for this object */ + SorterFile aFile[2]; /* aFile[0] for reading, [1] for writing */ +}; + +/* +** An instance of this object is used for writing a PMA. +** +** The PMA is written one record at a time. Each record is of an arbitrary +** size. But I/O is more efficient if it occurs in page-sized blocks where +** each block is aligned on a page boundary. This object caches writes to +** the PMA so that aligned, page-size blocks are written. +*/ +struct PmaWriter { + int eFWErr; /* Non-zero if in an error state */ + u8 *aBuffer; /* Pointer to write buffer */ + int nBuffer; /* Size of write buffer in bytes */ + int iBufStart; /* First byte of buffer to write */ + int iBufEnd; /* Last byte of buffer to write */ + i64 iWriteOff; /* Offset of start of buffer in file */ + sqlite3_file *pFd; /* File handle to write to */ +}; + +/* +** This object is the header on a single record while that record is being +** held in memory and prior to being written out as part of a PMA. +** +** How the linked list is connected depends on how memory is being managed +** by this module. If using a separate allocation for each in-memory record +** (VdbeSorter.list.aMemory==0), then the list is always connected using the +** SorterRecord.u.pNext pointers. +** +** Or, if using the single large allocation method (VdbeSorter.list.aMemory!=0), +** then while records are being accumulated the list is linked using the +** SorterRecord.u.iNext offset. This is because the aMemory[] array may +** be sqlite3Realloc()ed while records are being accumulated. Once the VM +** has finished passing records to the sorter, or when the in-memory buffer +** is full, the list is sorted. As part of the sorting process, it is +** converted to use the SorterRecord.u.pNext pointers. See function +** vdbeSorterSort() for details. +*/ +struct SorterRecord { + int nVal; /* Size of the record in bytes */ + union { + SorterRecord *pNext; /* Pointer to next record in list */ + int iNext; /* Offset within aMemory of next record */ + } u; + /* The data for the record immediately follows this header */ +}; + +/* Return a pointer to the buffer containing the record data for SorterRecord +** object p. Should be used as if: +** +** void *SRVAL(SorterRecord *p) { return (void*)&p[1]; } +*/ +#define SRVAL(p) ((void*)((SorterRecord*)(p) + 1)) + + +/* Maximum number of PMAs that a single MergeEngine can merge */ +#define SORTER_MAX_MERGE_COUNT 16 + +static int vdbeIncrSwap(IncrMerger*); +static void vdbeIncrFree(IncrMerger *); + +/* +** Free all memory belonging to the PmaReader object passed as the +** argument. All structure fields are set to zero before returning. +*/ +static void vdbePmaReaderClear(PmaReader *pReadr){ + sqlite3_free(pReadr->aAlloc); + sqlite3_free(pReadr->aBuffer); + if( pReadr->aMap ) sqlite3OsUnfetch(pReadr->pFd, 0, pReadr->aMap); + vdbeIncrFree(pReadr->pIncr); + memset(pReadr, 0, sizeof(PmaReader)); +} + +/* +** Read the next nByte bytes of data from the PMA p. +** If successful, set *ppOut to point to a buffer containing the data +** and return SQLITE_OK. Otherwise, if an error occurs, return an SQLite +** error code. +** +** The buffer returned in *ppOut is only valid until the +** next call to this function. +*/ +static int vdbePmaReadBlob( + PmaReader *p, /* PmaReader from which to take the blob */ + int nByte, /* Bytes of data to read */ + u8 **ppOut /* OUT: Pointer to buffer containing data */ +){ + int iBuf; /* Offset within buffer to read from */ + int nAvail; /* Bytes of data available in buffer */ + + if( p->aMap ){ + *ppOut = &p->aMap[p->iReadOff]; + p->iReadOff += nByte; + return SQLITE_OK; + } + + assert( p->aBuffer ); + + /* If there is no more data to be read from the buffer, read the next + ** p->nBuffer bytes of data from the file into it. Or, if there are less + ** than p->nBuffer bytes remaining in the PMA, read all remaining data. */ + iBuf = p->iReadOff % p->nBuffer; + if( iBuf==0 ){ + int nRead; /* Bytes to read from disk */ + int rc; /* sqlite3OsRead() return code */ + + /* Determine how many bytes of data to read. */ + if( (p->iEof - p->iReadOff) > (i64)p->nBuffer ){ + nRead = p->nBuffer; + }else{ + nRead = (int)(p->iEof - p->iReadOff); + } + assert( nRead>0 ); + + /* Readr data from the file. Return early if an error occurs. */ + rc = sqlite3OsRead(p->pFd, p->aBuffer, nRead, p->iReadOff); + assert( rc!=SQLITE_IOERR_SHORT_READ ); + if( rc!=SQLITE_OK ) return rc; + } + nAvail = p->nBuffer - iBuf; + + if( nByte<=nAvail ){ + /* The requested data is available in the in-memory buffer. In this + ** case there is no need to make a copy of the data, just return a + ** pointer into the buffer to the caller. */ + *ppOut = &p->aBuffer[iBuf]; + p->iReadOff += nByte; + }else{ + /* The requested data is not all available in the in-memory buffer. + ** In this case, allocate space at p->aAlloc[] to copy the requested + ** range into. Then return a copy of pointer p->aAlloc to the caller. */ + int nRem; /* Bytes remaining to copy */ + + /* Extend the p->aAlloc[] allocation if required. */ + if( p->nAllocnAlloc); + while( nByte>nNew ) nNew = nNew*2; + aNew = sqlite3Realloc(p->aAlloc, nNew); + if( !aNew ) return SQLITE_NOMEM_BKPT; + p->nAlloc = nNew; + p->aAlloc = aNew; + } + + /* Copy as much data as is available in the buffer into the start of + ** p->aAlloc[]. */ + memcpy(p->aAlloc, &p->aBuffer[iBuf], nAvail); + p->iReadOff += nAvail; + nRem = nByte - nAvail; + + /* The following loop copies up to p->nBuffer bytes per iteration into + ** the p->aAlloc[] buffer. */ + while( nRem>0 ){ + int rc; /* vdbePmaReadBlob() return code */ + int nCopy; /* Number of bytes to copy */ + u8 *aNext; /* Pointer to buffer to copy data from */ + + nCopy = nRem; + if( nRem>p->nBuffer ) nCopy = p->nBuffer; + rc = vdbePmaReadBlob(p, nCopy, &aNext); + if( rc!=SQLITE_OK ) return rc; + assert( aNext!=p->aAlloc ); + memcpy(&p->aAlloc[nByte - nRem], aNext, nCopy); + nRem -= nCopy; + } + + *ppOut = p->aAlloc; + } + + return SQLITE_OK; +} + +/* +** Read a varint from the stream of data accessed by p. Set *pnOut to +** the value read. +*/ +static int vdbePmaReadVarint(PmaReader *p, u64 *pnOut){ + int iBuf; + + if( p->aMap ){ + p->iReadOff += sqlite3GetVarint(&p->aMap[p->iReadOff], pnOut); + }else{ + iBuf = p->iReadOff % p->nBuffer; + if( iBuf && (p->nBuffer-iBuf)>=9 ){ + p->iReadOff += sqlite3GetVarint(&p->aBuffer[iBuf], pnOut); + }else{ + u8 aVarint[16], *a; + int i = 0, rc; + do{ + rc = vdbePmaReadBlob(p, 1, &a); + if( rc ) return rc; + aVarint[(i++)&0xf] = a[0]; + }while( (a[0]&0x80)!=0 ); + sqlite3GetVarint(aVarint, pnOut); + } + } + + return SQLITE_OK; +} + +/* +** Attempt to memory map file pFile. If successful, set *pp to point to the +** new mapping and return SQLITE_OK. If the mapping is not attempted +** (because the file is too large or the VFS layer is configured not to use +** mmap), return SQLITE_OK and set *pp to NULL. +** +** Or, if an error occurs, return an SQLite error code. The final value of +** *pp is undefined in this case. +*/ +static int vdbeSorterMapFile(SortSubtask *pTask, SorterFile *pFile, u8 **pp){ + int rc = SQLITE_OK; + if( pFile->iEof<=(i64)(pTask->pSorter->db->nMaxSorterMmap) ){ + sqlite3_file *pFd = pFile->pFd; + if( pFd->pMethods->iVersion>=3 ){ + rc = sqlite3OsFetch(pFd, 0, (int)pFile->iEof, (void**)pp); + testcase( rc!=SQLITE_OK ); + } + } + return rc; +} + +/* +** Attach PmaReader pReadr to file pFile (if it is not already attached to +** that file) and seek it to offset iOff within the file. Return SQLITE_OK +** if successful, or an SQLite error code if an error occurs. +*/ +static int vdbePmaReaderSeek( + SortSubtask *pTask, /* Task context */ + PmaReader *pReadr, /* Reader whose cursor is to be moved */ + SorterFile *pFile, /* Sorter file to read from */ + i64 iOff /* Offset in pFile */ +){ + int rc = SQLITE_OK; + + assert( pReadr->pIncr==0 || pReadr->pIncr->bEof==0 ); + + if( sqlite3FaultSim(201) ) return SQLITE_IOERR_READ; + if( pReadr->aMap ){ + sqlite3OsUnfetch(pReadr->pFd, 0, pReadr->aMap); + pReadr->aMap = 0; + } + pReadr->iReadOff = iOff; + pReadr->iEof = pFile->iEof; + pReadr->pFd = pFile->pFd; + + rc = vdbeSorterMapFile(pTask, pFile, &pReadr->aMap); + if( rc==SQLITE_OK && pReadr->aMap==0 ){ + int pgsz = pTask->pSorter->pgsz; + int iBuf = pReadr->iReadOff % pgsz; + if( pReadr->aBuffer==0 ){ + pReadr->aBuffer = (u8*)sqlite3Malloc(pgsz); + if( pReadr->aBuffer==0 ) rc = SQLITE_NOMEM_BKPT; + pReadr->nBuffer = pgsz; + } + if( rc==SQLITE_OK && iBuf ){ + int nRead = pgsz - iBuf; + if( (pReadr->iReadOff + nRead) > pReadr->iEof ){ + nRead = (int)(pReadr->iEof - pReadr->iReadOff); + } + rc = sqlite3OsRead( + pReadr->pFd, &pReadr->aBuffer[iBuf], nRead, pReadr->iReadOff + ); + testcase( rc!=SQLITE_OK ); + } + } + + return rc; +} + +/* +** Advance PmaReader pReadr to the next key in its PMA. Return SQLITE_OK if +** no error occurs, or an SQLite error code if one does. +*/ +static int vdbePmaReaderNext(PmaReader *pReadr){ + int rc = SQLITE_OK; /* Return Code */ + u64 nRec = 0; /* Size of record in bytes */ + + + if( pReadr->iReadOff>=pReadr->iEof ){ + IncrMerger *pIncr = pReadr->pIncr; + int bEof = 1; + if( pIncr ){ + rc = vdbeIncrSwap(pIncr); + if( rc==SQLITE_OK && pIncr->bEof==0 ){ + rc = vdbePmaReaderSeek( + pIncr->pTask, pReadr, &pIncr->aFile[0], pIncr->iStartOff + ); + bEof = 0; + } + } + + if( bEof ){ + /* This is an EOF condition */ + vdbePmaReaderClear(pReadr); + testcase( rc!=SQLITE_OK ); + return rc; + } + } + + if( rc==SQLITE_OK ){ + rc = vdbePmaReadVarint(pReadr, &nRec); + } + if( rc==SQLITE_OK ){ + pReadr->nKey = (int)nRec; + rc = vdbePmaReadBlob(pReadr, (int)nRec, &pReadr->aKey); + testcase( rc!=SQLITE_OK ); + } + + return rc; +} + +/* +** Initialize PmaReader pReadr to scan through the PMA stored in file pFile +** starting at offset iStart and ending at offset iEof-1. This function +** leaves the PmaReader pointing to the first key in the PMA (or EOF if the +** PMA is empty). +** +** If the pnByte parameter is NULL, then it is assumed that the file +** contains a single PMA, and that that PMA omits the initial length varint. +*/ +static int vdbePmaReaderInit( + SortSubtask *pTask, /* Task context */ + SorterFile *pFile, /* Sorter file to read from */ + i64 iStart, /* Start offset in pFile */ + PmaReader *pReadr, /* PmaReader to populate */ + i64 *pnByte /* IN/OUT: Increment this value by PMA size */ +){ + int rc; + + assert( pFile->iEof>iStart ); + assert( pReadr->aAlloc==0 && pReadr->nAlloc==0 ); + assert( pReadr->aBuffer==0 ); + assert( pReadr->aMap==0 ); + + rc = vdbePmaReaderSeek(pTask, pReadr, pFile, iStart); + if( rc==SQLITE_OK ){ + u64 nByte = 0; /* Size of PMA in bytes */ + rc = vdbePmaReadVarint(pReadr, &nByte); + pReadr->iEof = pReadr->iReadOff + nByte; + *pnByte += nByte; + } + + if( rc==SQLITE_OK ){ + rc = vdbePmaReaderNext(pReadr); + } + return rc; +} + +/* +** A version of vdbeSorterCompare() that assumes that it has already been +** determined that the first field of key1 is equal to the first field of +** key2. +*/ +static int vdbeSorterCompareTail( + SortSubtask *pTask, /* Subtask context (for pKeyInfo) */ + int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */ + const void *pKey1, int nKey1, /* Left side of comparison */ + const void *pKey2, int nKey2 /* Right side of comparison */ +){ + UnpackedRecord *r2 = pTask->pUnpacked; + if( *pbKey2Cached==0 ){ + sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2); + *pbKey2Cached = 1; + } + return sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, r2, 1); +} + +/* +** Compare key1 (buffer pKey1, size nKey1 bytes) with key2 (buffer pKey2, +** size nKey2 bytes). Use (pTask->pKeyInfo) for the collation sequences +** used by the comparison. Return the result of the comparison. +** +** If IN/OUT parameter *pbKey2Cached is true when this function is called, +** it is assumed that (pTask->pUnpacked) contains the unpacked version +** of key2. If it is false, (pTask->pUnpacked) is populated with the unpacked +** version of key2 and *pbKey2Cached set to true before returning. +** +** If an OOM error is encountered, (pTask->pUnpacked->error_rc) is set +** to SQLITE_NOMEM. +*/ +static int vdbeSorterCompare( + SortSubtask *pTask, /* Subtask context (for pKeyInfo) */ + int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */ + const void *pKey1, int nKey1, /* Left side of comparison */ + const void *pKey2, int nKey2 /* Right side of comparison */ +){ + UnpackedRecord *r2 = pTask->pUnpacked; + if( !*pbKey2Cached ){ + sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2); + *pbKey2Cached = 1; + } + return sqlite3VdbeRecordCompare(nKey1, pKey1, r2); +} + +/* +** A specially optimized version of vdbeSorterCompare() that assumes that +** the first field of each key is a TEXT value and that the collation +** sequence to compare them with is BINARY. +*/ +static int vdbeSorterCompareText( + SortSubtask *pTask, /* Subtask context (for pKeyInfo) */ + int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */ + const void *pKey1, int nKey1, /* Left side of comparison */ + const void *pKey2, int nKey2 /* Right side of comparison */ +){ + const u8 * const p1 = (const u8 * const)pKey1; + const u8 * const p2 = (const u8 * const)pKey2; + const u8 * const v1 = &p1[ p1[0] ]; /* Pointer to value 1 */ + const u8 * const v2 = &p2[ p2[0] ]; /* Pointer to value 2 */ + + int n1; + int n2; + int res; + + getVarint32NR(&p1[1], n1); + getVarint32NR(&p2[1], n2); + res = memcmp(v1, v2, (MIN(n1, n2) - 13)/2); + if( res==0 ){ + res = n1 - n2; + } + + if( res==0 ){ + if( pTask->pSorter->pKeyInfo->nKeyField>1 ){ + res = vdbeSorterCompareTail( + pTask, pbKey2Cached, pKey1, nKey1, pKey2, nKey2 + ); + } + }else{ + assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) ); + if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){ + res = res * -1; + } + } + + return res; +} + +/* +** A specially optimized version of vdbeSorterCompare() that assumes that +** the first field of each key is an INTEGER value. +*/ +static int vdbeSorterCompareInt( + SortSubtask *pTask, /* Subtask context (for pKeyInfo) */ + int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */ + const void *pKey1, int nKey1, /* Left side of comparison */ + const void *pKey2, int nKey2 /* Right side of comparison */ +){ + const u8 * const p1 = (const u8 * const)pKey1; + const u8 * const p2 = (const u8 * const)pKey2; + const int s1 = p1[1]; /* Left hand serial type */ + const int s2 = p2[1]; /* Right hand serial type */ + const u8 * const v1 = &p1[ p1[0] ]; /* Pointer to value 1 */ + const u8 * const v2 = &p2[ p2[0] ]; /* Pointer to value 2 */ + int res; /* Return value */ + + assert( (s1>0 && s1<7) || s1==8 || s1==9 ); + assert( (s2>0 && s2<7) || s2==8 || s2==9 ); + + if( s1==s2 ){ + /* The two values have the same sign. Compare using memcmp(). */ + static const u8 aLen[] = {0, 1, 2, 3, 4, 6, 8, 0, 0, 0 }; + const u8 n = aLen[s1]; + int i; + res = 0; + for(i=0; i7 && s2>7 ){ + res = s1 - s2; + }else{ + if( s2>7 ){ + res = +1; + }else if( s1>7 ){ + res = -1; + }else{ + res = s1 - s2; + } + assert( res!=0 ); + + if( res>0 ){ + if( *v1 & 0x80 ) res = -1; + }else{ + if( *v2 & 0x80 ) res = +1; + } + } + + if( res==0 ){ + if( pTask->pSorter->pKeyInfo->nKeyField>1 ){ + res = vdbeSorterCompareTail( + pTask, pbKey2Cached, pKey1, nKey1, pKey2, nKey2 + ); + } + }else if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){ + assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) ); + res = res * -1; + } + + return res; +} + +/* +** Initialize the temporary index cursor just opened as a sorter cursor. +** +** Usually, the sorter module uses the value of (pCsr->pKeyInfo->nKeyField) +** to determine the number of fields that should be compared from the +** records being sorted. However, if the value passed as argument nField +** is non-zero and the sorter is able to guarantee a stable sort, nField +** is used instead. This is used when sorting records for a CREATE INDEX +** statement. In this case, keys are always delivered to the sorter in +** order of the primary key, which happens to be make up the final part +** of the records being sorted. So if the sort is stable, there is never +** any reason to compare PK fields and they can be ignored for a small +** performance boost. +** +** The sorter can guarantee a stable sort when running in single-threaded +** mode, but not in multi-threaded mode. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterInit( + sqlite3 *db, /* Database connection (for malloc()) */ + int nField, /* Number of key fields in each record */ + VdbeCursor *pCsr /* Cursor that holds the new sorter */ +){ + int pgsz; /* Page size of main database */ + int i; /* Used to iterate through aTask[] */ + VdbeSorter *pSorter; /* The new sorter */ + KeyInfo *pKeyInfo; /* Copy of pCsr->pKeyInfo with db==0 */ + int szKeyInfo; /* Size of pCsr->pKeyInfo in bytes */ + int sz; /* Size of pSorter in bytes */ + int rc = SQLITE_OK; +#if SQLITE_MAX_WORKER_THREADS==0 +# define nWorker 0 +#else + int nWorker; +#endif + + /* Initialize the upper limit on the number of worker threads */ +#if SQLITE_MAX_WORKER_THREADS>0 + if( sqlite3TempInMemory(db) || sqlite3GlobalConfig.bCoreMutex==0 ){ + nWorker = 0; + }else{ + nWorker = db->aLimit[SQLITE_LIMIT_WORKER_THREADS]; + } +#endif + + /* Do not allow the total number of threads (main thread + all workers) + ** to exceed the maximum merge count */ +#if SQLITE_MAX_WORKER_THREADS>=SORTER_MAX_MERGE_COUNT + if( nWorker>=SORTER_MAX_MERGE_COUNT ){ + nWorker = SORTER_MAX_MERGE_COUNT-1; + } +#endif + + assert( pCsr->pKeyInfo && pCsr->pBtx==0 ); + assert( pCsr->eCurType==CURTYPE_SORTER ); + szKeyInfo = sizeof(KeyInfo) + (pCsr->pKeyInfo->nKeyField-1)*sizeof(CollSeq*); + sz = sizeof(VdbeSorter) + nWorker * sizeof(SortSubtask); + + pSorter = (VdbeSorter*)sqlite3DbMallocZero(db, sz + szKeyInfo); + pCsr->uc.pSorter = pSorter; + if( pSorter==0 ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + Btree *pBt = db->aDb[0].pBt; + pSorter->pKeyInfo = pKeyInfo = (KeyInfo*)((u8*)pSorter + sz); + memcpy(pKeyInfo, pCsr->pKeyInfo, szKeyInfo); + pKeyInfo->db = 0; + if( nField && nWorker==0 ){ + pKeyInfo->nKeyField = nField; + } + sqlite3BtreeEnter(pBt); + pSorter->pgsz = pgsz = sqlite3BtreeGetPageSize(pBt); + sqlite3BtreeLeave(pBt); + pSorter->nTask = nWorker + 1; + pSorter->iPrev = (u8)(nWorker - 1); + pSorter->bUseThreads = (pSorter->nTask>1); + pSorter->db = db; + for(i=0; inTask; i++){ + SortSubtask *pTask = &pSorter->aTask[i]; + pTask->pSorter = pSorter; + } + + if( !sqlite3TempInMemory(db) ){ + i64 mxCache; /* Cache size in bytes*/ + u32 szPma = sqlite3GlobalConfig.szPma; + pSorter->mnPmaSize = szPma * pgsz; + + mxCache = db->aDb[0].pSchema->cache_size; + if( mxCache<0 ){ + /* A negative cache-size value C indicates that the cache is abs(C) + ** KiB in size. */ + mxCache = mxCache * -1024; + }else{ + mxCache = mxCache * pgsz; + } + mxCache = MIN(mxCache, SQLITE_MAX_PMASZ); + pSorter->mxPmaSize = MAX(pSorter->mnPmaSize, (int)mxCache); + + /* Avoid large memory allocations if the application has requested + ** SQLITE_CONFIG_SMALL_MALLOC. */ + if( sqlite3GlobalConfig.bSmallMalloc==0 ){ + assert( pSorter->iMemory==0 ); + pSorter->nMemory = pgsz; + pSorter->list.aMemory = (u8*)sqlite3Malloc(pgsz); + if( !pSorter->list.aMemory ) rc = SQLITE_NOMEM_BKPT; + } + } + + if( pKeyInfo->nAllField<13 + && (pKeyInfo->aColl[0]==0 || pKeyInfo->aColl[0]==db->pDfltColl) + && (pKeyInfo->aSortFlags[0] & KEYINFO_ORDER_BIGNULL)==0 + ){ + pSorter->typeMask = SORTER_TYPE_INTEGER | SORTER_TYPE_TEXT; + } + } + + return rc; +} +#undef nWorker /* Defined at the top of this function */ + +/* +** Free the list of sorted records starting at pRecord. +*/ +static void vdbeSorterRecordFree(sqlite3 *db, SorterRecord *pRecord){ + SorterRecord *p; + SorterRecord *pNext; + for(p=pRecord; p; p=pNext){ + pNext = p->u.pNext; + sqlite3DbFree(db, p); + } +} + +/* +** Free all resources owned by the object indicated by argument pTask. All +** fields of *pTask are zeroed before returning. +*/ +static void vdbeSortSubtaskCleanup(sqlite3 *db, SortSubtask *pTask){ + sqlite3DbFree(db, pTask->pUnpacked); +#if SQLITE_MAX_WORKER_THREADS>0 + /* pTask->list.aMemory can only be non-zero if it was handed memory + ** from the main thread. That only occurs SQLITE_MAX_WORKER_THREADS>0 */ + if( pTask->list.aMemory ){ + sqlite3_free(pTask->list.aMemory); + }else +#endif + { + assert( pTask->list.aMemory==0 ); + vdbeSorterRecordFree(0, pTask->list.pList); + } + if( pTask->file.pFd ){ + sqlite3OsCloseFree(pTask->file.pFd); + } + if( pTask->file2.pFd ){ + sqlite3OsCloseFree(pTask->file2.pFd); + } + memset(pTask, 0, sizeof(SortSubtask)); +} + +#ifdef SQLITE_DEBUG_SORTER_THREADS +static void vdbeSorterWorkDebug(SortSubtask *pTask, const char *zEvent){ + i64 t; + int iTask = (pTask - pTask->pSorter->aTask); + sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t); + fprintf(stderr, "%lld:%d %s\n", t, iTask, zEvent); +} +static void vdbeSorterRewindDebug(const char *zEvent){ + i64 t; + sqlite3OsCurrentTimeInt64(sqlite3_vfs_find(0), &t); + fprintf(stderr, "%lld:X %s\n", t, zEvent); +} +static void vdbeSorterPopulateDebug( + SortSubtask *pTask, + const char *zEvent +){ + i64 t; + int iTask = (pTask - pTask->pSorter->aTask); + sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t); + fprintf(stderr, "%lld:bg%d %s\n", t, iTask, zEvent); +} +static void vdbeSorterBlockDebug( + SortSubtask *pTask, + int bBlocked, + const char *zEvent +){ + if( bBlocked ){ + i64 t; + sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t); + fprintf(stderr, "%lld:main %s\n", t, zEvent); + } +} +#else +# define vdbeSorterWorkDebug(x,y) +# define vdbeSorterRewindDebug(y) +# define vdbeSorterPopulateDebug(x,y) +# define vdbeSorterBlockDebug(x,y,z) +#endif + +#if SQLITE_MAX_WORKER_THREADS>0 +/* +** Join thread pTask->thread. +*/ +static int vdbeSorterJoinThread(SortSubtask *pTask){ + int rc = SQLITE_OK; + if( pTask->pThread ){ +#ifdef SQLITE_DEBUG_SORTER_THREADS + int bDone = pTask->bDone; +#endif + void *pRet = SQLITE_INT_TO_PTR(SQLITE_ERROR); + vdbeSorterBlockDebug(pTask, !bDone, "enter"); + (void)sqlite3ThreadJoin(pTask->pThread, &pRet); + vdbeSorterBlockDebug(pTask, !bDone, "exit"); + rc = SQLITE_PTR_TO_INT(pRet); + assert( pTask->bDone==1 ); + pTask->bDone = 0; + pTask->pThread = 0; + } + return rc; +} + +/* +** Launch a background thread to run xTask(pIn). +*/ +static int vdbeSorterCreateThread( + SortSubtask *pTask, /* Thread will use this task object */ + void *(*xTask)(void*), /* Routine to run in a separate thread */ + void *pIn /* Argument passed into xTask() */ +){ + assert( pTask->pThread==0 && pTask->bDone==0 ); + return sqlite3ThreadCreate(&pTask->pThread, xTask, pIn); +} + +/* +** Join all outstanding threads launched by SorterWrite() to create +** level-0 PMAs. +*/ +static int vdbeSorterJoinAll(VdbeSorter *pSorter, int rcin){ + int rc = rcin; + int i; + + /* This function is always called by the main user thread. + ** + ** If this function is being called after SorterRewind() has been called, + ** it is possible that thread pSorter->aTask[pSorter->nTask-1].pThread + ** is currently attempt to join one of the other threads. To avoid a race + ** condition where this thread also attempts to join the same object, join + ** thread pSorter->aTask[pSorter->nTask-1].pThread first. */ + for(i=pSorter->nTask-1; i>=0; i--){ + SortSubtask *pTask = &pSorter->aTask[i]; + int rc2 = vdbeSorterJoinThread(pTask); + if( rc==SQLITE_OK ) rc = rc2; + } + return rc; +} +#else +# define vdbeSorterJoinAll(x,rcin) (rcin) +# define vdbeSorterJoinThread(pTask) SQLITE_OK +#endif + +/* +** Allocate a new MergeEngine object capable of handling up to +** nReader PmaReader inputs. +** +** nReader is automatically rounded up to the next power of two. +** nReader may not exceed SORTER_MAX_MERGE_COUNT even after rounding up. +*/ +static MergeEngine *vdbeMergeEngineNew(int nReader){ + int N = 2; /* Smallest power of two >= nReader */ + int nByte; /* Total bytes of space to allocate */ + MergeEngine *pNew; /* Pointer to allocated object to return */ + + assert( nReader<=SORTER_MAX_MERGE_COUNT ); + + while( NnTree = N; + pNew->pTask = 0; + pNew->aReadr = (PmaReader*)&pNew[1]; + pNew->aTree = (int*)&pNew->aReadr[N]; + } + return pNew; +} + +/* +** Free the MergeEngine object passed as the only argument. +*/ +static void vdbeMergeEngineFree(MergeEngine *pMerger){ + int i; + if( pMerger ){ + for(i=0; inTree; i++){ + vdbePmaReaderClear(&pMerger->aReadr[i]); + } + } + sqlite3_free(pMerger); +} + +/* +** Free all resources associated with the IncrMerger object indicated by +** the first argument. +*/ +static void vdbeIncrFree(IncrMerger *pIncr){ + if( pIncr ){ +#if SQLITE_MAX_WORKER_THREADS>0 + if( pIncr->bUseThread ){ + vdbeSorterJoinThread(pIncr->pTask); + if( pIncr->aFile[0].pFd ) sqlite3OsCloseFree(pIncr->aFile[0].pFd); + if( pIncr->aFile[1].pFd ) sqlite3OsCloseFree(pIncr->aFile[1].pFd); + } +#endif + vdbeMergeEngineFree(pIncr->pMerger); + sqlite3_free(pIncr); + } +} + +/* +** Reset a sorting cursor back to its original empty state. +*/ +SQLITE_PRIVATE void sqlite3VdbeSorterReset(sqlite3 *db, VdbeSorter *pSorter){ + int i; + (void)vdbeSorterJoinAll(pSorter, SQLITE_OK); + assert( pSorter->bUseThreads || pSorter->pReader==0 ); +#if SQLITE_MAX_WORKER_THREADS>0 + if( pSorter->pReader ){ + vdbePmaReaderClear(pSorter->pReader); + sqlite3DbFree(db, pSorter->pReader); + pSorter->pReader = 0; + } +#endif + vdbeMergeEngineFree(pSorter->pMerger); + pSorter->pMerger = 0; + for(i=0; inTask; i++){ + SortSubtask *pTask = &pSorter->aTask[i]; + vdbeSortSubtaskCleanup(db, pTask); + pTask->pSorter = pSorter; + } + if( pSorter->list.aMemory==0 ){ + vdbeSorterRecordFree(0, pSorter->list.pList); + } + pSorter->list.pList = 0; + pSorter->list.szPMA = 0; + pSorter->bUsePMA = 0; + pSorter->iMemory = 0; + pSorter->mxKeysize = 0; + sqlite3DbFree(db, pSorter->pUnpacked); + pSorter->pUnpacked = 0; +} + +/* +** Free any cursor components allocated by sqlite3VdbeSorterXXX routines. +*/ +SQLITE_PRIVATE void sqlite3VdbeSorterClose(sqlite3 *db, VdbeCursor *pCsr){ + VdbeSorter *pSorter; + assert( pCsr->eCurType==CURTYPE_SORTER ); + pSorter = pCsr->uc.pSorter; + if( pSorter ){ + sqlite3VdbeSorterReset(db, pSorter); + sqlite3_free(pSorter->list.aMemory); + sqlite3DbFree(db, pSorter); + pCsr->uc.pSorter = 0; + } +} + +#if SQLITE_MAX_MMAP_SIZE>0 +/* +** The first argument is a file-handle open on a temporary file. The file +** is guaranteed to be nByte bytes or smaller in size. This function +** attempts to extend the file to nByte bytes in size and to ensure that +** the VFS has memory mapped it. +** +** Whether or not the file does end up memory mapped of course depends on +** the specific VFS implementation. +*/ +static void vdbeSorterExtendFile(sqlite3 *db, sqlite3_file *pFd, i64 nByte){ + if( nByte<=(i64)(db->nMaxSorterMmap) && pFd->pMethods->iVersion>=3 ){ + void *p = 0; + int chunksize = 4*1024; + sqlite3OsFileControlHint(pFd, SQLITE_FCNTL_CHUNK_SIZE, &chunksize); + sqlite3OsFileControlHint(pFd, SQLITE_FCNTL_SIZE_HINT, &nByte); + sqlite3OsFetch(pFd, 0, (int)nByte, &p); + sqlite3OsUnfetch(pFd, 0, p); + } +} +#else +# define vdbeSorterExtendFile(x,y,z) +#endif + +/* +** Allocate space for a file-handle and open a temporary file. If successful, +** set *ppFd to point to the malloc'd file-handle and return SQLITE_OK. +** Otherwise, set *ppFd to 0 and return an SQLite error code. +*/ +static int vdbeSorterOpenTempFile( + sqlite3 *db, /* Database handle doing sort */ + i64 nExtend, /* Attempt to extend file to this size */ + sqlite3_file **ppFd +){ + int rc; + if( sqlite3FaultSim(202) ) return SQLITE_IOERR_ACCESS; + rc = sqlite3OsOpenMalloc(db->pVfs, 0, ppFd, + SQLITE_OPEN_TEMP_JOURNAL | + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | + SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE, &rc + ); + if( rc==SQLITE_OK ){ + i64 max = SQLITE_MAX_MMAP_SIZE; + sqlite3OsFileControlHint(*ppFd, SQLITE_FCNTL_MMAP_SIZE, (void*)&max); + if( nExtend>0 ){ + vdbeSorterExtendFile(db, *ppFd, nExtend); + } + } + return rc; +} + +/* +** If it has not already been allocated, allocate the UnpackedRecord +** structure at pTask->pUnpacked. Return SQLITE_OK if successful (or +** if no allocation was required), or SQLITE_NOMEM otherwise. +*/ +static int vdbeSortAllocUnpacked(SortSubtask *pTask){ + if( pTask->pUnpacked==0 ){ + pTask->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pTask->pSorter->pKeyInfo); + if( pTask->pUnpacked==0 ) return SQLITE_NOMEM_BKPT; + pTask->pUnpacked->nField = pTask->pSorter->pKeyInfo->nKeyField; + pTask->pUnpacked->errCode = 0; + } + return SQLITE_OK; +} + + +/* +** Merge the two sorted lists p1 and p2 into a single list. +*/ +static SorterRecord *vdbeSorterMerge( + SortSubtask *pTask, /* Calling thread context */ + SorterRecord *p1, /* First list to merge */ + SorterRecord *p2 /* Second list to merge */ +){ + SorterRecord *pFinal = 0; + SorterRecord **pp = &pFinal; + int bCached = 0; + + assert( p1!=0 && p2!=0 ); + for(;;){ + int res; + res = pTask->xCompare( + pTask, &bCached, SRVAL(p1), p1->nVal, SRVAL(p2), p2->nVal + ); + + if( res<=0 ){ + *pp = p1; + pp = &p1->u.pNext; + p1 = p1->u.pNext; + if( p1==0 ){ + *pp = p2; + break; + } + }else{ + *pp = p2; + pp = &p2->u.pNext; + p2 = p2->u.pNext; + bCached = 0; + if( p2==0 ){ + *pp = p1; + break; + } + } + } + return pFinal; +} + +/* +** Return the SorterCompare function to compare values collected by the +** sorter object passed as the only argument. +*/ +static SorterCompare vdbeSorterGetCompare(VdbeSorter *p){ + if( p->typeMask==SORTER_TYPE_INTEGER ){ + return vdbeSorterCompareInt; + }else if( p->typeMask==SORTER_TYPE_TEXT ){ + return vdbeSorterCompareText; + } + return vdbeSorterCompare; +} + +/* +** Sort the linked list of records headed at pTask->pList. Return +** SQLITE_OK if successful, or an SQLite error code (i.e. SQLITE_NOMEM) if +** an error occurs. +*/ +static int vdbeSorterSort(SortSubtask *pTask, SorterList *pList){ + int i; + SorterRecord *p; + int rc; + SorterRecord *aSlot[64]; + + rc = vdbeSortAllocUnpacked(pTask); + if( rc!=SQLITE_OK ) return rc; + + p = pList->pList; + pTask->xCompare = vdbeSorterGetCompare(pTask->pSorter); + memset(aSlot, 0, sizeof(aSlot)); + + while( p ){ + SorterRecord *pNext; + if( pList->aMemory ){ + if( (u8*)p==pList->aMemory ){ + pNext = 0; + }else{ + assert( p->u.iNextaMemory) ); + pNext = (SorterRecord*)&pList->aMemory[p->u.iNext]; + } + }else{ + pNext = p->u.pNext; + } + + p->u.pNext = 0; + for(i=0; aSlot[i]; i++){ + p = vdbeSorterMerge(pTask, p, aSlot[i]); + aSlot[i] = 0; + } + aSlot[i] = p; + p = pNext; + } + + p = 0; + for(i=0; ipList = p; + + assert( pTask->pUnpacked->errCode==SQLITE_OK + || pTask->pUnpacked->errCode==SQLITE_NOMEM + ); + return pTask->pUnpacked->errCode; +} + +/* +** Initialize a PMA-writer object. +*/ +static void vdbePmaWriterInit( + sqlite3_file *pFd, /* File handle to write to */ + PmaWriter *p, /* Object to populate */ + int nBuf, /* Buffer size */ + i64 iStart /* Offset of pFd to begin writing at */ +){ + memset(p, 0, sizeof(PmaWriter)); + p->aBuffer = (u8*)sqlite3Malloc(nBuf); + if( !p->aBuffer ){ + p->eFWErr = SQLITE_NOMEM_BKPT; + }else{ + p->iBufEnd = p->iBufStart = (iStart % nBuf); + p->iWriteOff = iStart - p->iBufStart; + p->nBuffer = nBuf; + p->pFd = pFd; + } +} + +/* +** Write nData bytes of data to the PMA. Return SQLITE_OK +** if successful, or an SQLite error code if an error occurs. +*/ +static void vdbePmaWriteBlob(PmaWriter *p, u8 *pData, int nData){ + int nRem = nData; + while( nRem>0 && p->eFWErr==0 ){ + int nCopy = nRem; + if( nCopy>(p->nBuffer - p->iBufEnd) ){ + nCopy = p->nBuffer - p->iBufEnd; + } + + memcpy(&p->aBuffer[p->iBufEnd], &pData[nData-nRem], nCopy); + p->iBufEnd += nCopy; + if( p->iBufEnd==p->nBuffer ){ + p->eFWErr = sqlite3OsWrite(p->pFd, + &p->aBuffer[p->iBufStart], p->iBufEnd - p->iBufStart, + p->iWriteOff + p->iBufStart + ); + p->iBufStart = p->iBufEnd = 0; + p->iWriteOff += p->nBuffer; + } + assert( p->iBufEndnBuffer ); + + nRem -= nCopy; + } +} + +/* +** Flush any buffered data to disk and clean up the PMA-writer object. +** The results of using the PMA-writer after this call are undefined. +** Return SQLITE_OK if flushing the buffered data succeeds or is not +** required. Otherwise, return an SQLite error code. +** +** Before returning, set *piEof to the offset immediately following the +** last byte written to the file. +*/ +static int vdbePmaWriterFinish(PmaWriter *p, i64 *piEof){ + int rc; + if( p->eFWErr==0 && ALWAYS(p->aBuffer) && p->iBufEnd>p->iBufStart ){ + p->eFWErr = sqlite3OsWrite(p->pFd, + &p->aBuffer[p->iBufStart], p->iBufEnd - p->iBufStart, + p->iWriteOff + p->iBufStart + ); + } + *piEof = (p->iWriteOff + p->iBufEnd); + sqlite3_free(p->aBuffer); + rc = p->eFWErr; + memset(p, 0, sizeof(PmaWriter)); + return rc; +} + +/* +** Write value iVal encoded as a varint to the PMA. Return +** SQLITE_OK if successful, or an SQLite error code if an error occurs. +*/ +static void vdbePmaWriteVarint(PmaWriter *p, u64 iVal){ + int nByte; + u8 aByte[10]; + nByte = sqlite3PutVarint(aByte, iVal); + vdbePmaWriteBlob(p, aByte, nByte); +} + +/* +** Write the current contents of in-memory linked-list pList to a level-0 +** PMA in the temp file belonging to sub-task pTask. Return SQLITE_OK if +** successful, or an SQLite error code otherwise. +** +** The format of a PMA is: +** +** * A varint. This varint contains the total number of bytes of content +** in the PMA (not including the varint itself). +** +** * One or more records packed end-to-end in order of ascending keys. +** Each record consists of a varint followed by a blob of data (the +** key). The varint is the number of bytes in the blob of data. +*/ +static int vdbeSorterListToPMA(SortSubtask *pTask, SorterList *pList){ + sqlite3 *db = pTask->pSorter->db; + int rc = SQLITE_OK; /* Return code */ + PmaWriter writer; /* Object used to write to the file */ + +#ifdef SQLITE_DEBUG + /* Set iSz to the expected size of file pTask->file after writing the PMA. + ** This is used by an assert() statement at the end of this function. */ + i64 iSz = pList->szPMA + sqlite3VarintLen(pList->szPMA) + pTask->file.iEof; +#endif + + vdbeSorterWorkDebug(pTask, "enter"); + memset(&writer, 0, sizeof(PmaWriter)); + assert( pList->szPMA>0 ); + + /* If the first temporary PMA file has not been opened, open it now. */ + if( pTask->file.pFd==0 ){ + rc = vdbeSorterOpenTempFile(db, 0, &pTask->file.pFd); + assert( rc!=SQLITE_OK || pTask->file.pFd ); + assert( pTask->file.iEof==0 ); + assert( pTask->nPMA==0 ); + } + + /* Try to get the file to memory map */ + if( rc==SQLITE_OK ){ + vdbeSorterExtendFile(db, pTask->file.pFd, pTask->file.iEof+pList->szPMA+9); + } + + /* Sort the list */ + if( rc==SQLITE_OK ){ + rc = vdbeSorterSort(pTask, pList); + } + + if( rc==SQLITE_OK ){ + SorterRecord *p; + SorterRecord *pNext = 0; + + vdbePmaWriterInit(pTask->file.pFd, &writer, pTask->pSorter->pgsz, + pTask->file.iEof); + pTask->nPMA++; + vdbePmaWriteVarint(&writer, pList->szPMA); + for(p=pList->pList; p; p=pNext){ + pNext = p->u.pNext; + vdbePmaWriteVarint(&writer, p->nVal); + vdbePmaWriteBlob(&writer, SRVAL(p), p->nVal); + if( pList->aMemory==0 ) sqlite3_free(p); + } + pList->pList = p; + rc = vdbePmaWriterFinish(&writer, &pTask->file.iEof); + } + + vdbeSorterWorkDebug(pTask, "exit"); + assert( rc!=SQLITE_OK || pList->pList==0 ); + assert( rc!=SQLITE_OK || pTask->file.iEof==iSz ); + return rc; +} + +/* +** Advance the MergeEngine to its next entry. +** Set *pbEof to true there is no next entry because +** the MergeEngine has reached the end of all its inputs. +** +** Return SQLITE_OK if successful or an error code if an error occurs. +*/ +static int vdbeMergeEngineStep( + MergeEngine *pMerger, /* The merge engine to advance to the next row */ + int *pbEof /* Set TRUE at EOF. Set false for more content */ +){ + int rc; + int iPrev = pMerger->aTree[1];/* Index of PmaReader to advance */ + SortSubtask *pTask = pMerger->pTask; + + /* Advance the current PmaReader */ + rc = vdbePmaReaderNext(&pMerger->aReadr[iPrev]); + + /* Update contents of aTree[] */ + if( rc==SQLITE_OK ){ + int i; /* Index of aTree[] to recalculate */ + PmaReader *pReadr1; /* First PmaReader to compare */ + PmaReader *pReadr2; /* Second PmaReader to compare */ + int bCached = 0; + + /* Find the first two PmaReaders to compare. The one that was just + ** advanced (iPrev) and the one next to it in the array. */ + pReadr1 = &pMerger->aReadr[(iPrev & 0xFFFE)]; + pReadr2 = &pMerger->aReadr[(iPrev | 0x0001)]; + + for(i=(pMerger->nTree+iPrev)/2; i>0; i=i/2){ + /* Compare pReadr1 and pReadr2. Store the result in variable iRes. */ + int iRes; + if( pReadr1->pFd==0 ){ + iRes = +1; + }else if( pReadr2->pFd==0 ){ + iRes = -1; + }else{ + iRes = pTask->xCompare(pTask, &bCached, + pReadr1->aKey, pReadr1->nKey, pReadr2->aKey, pReadr2->nKey + ); + } + + /* If pReadr1 contained the smaller value, set aTree[i] to its index. + ** Then set pReadr2 to the next PmaReader to compare to pReadr1. In this + ** case there is no cache of pReadr2 in pTask->pUnpacked, so set + ** pKey2 to point to the record belonging to pReadr2. + ** + ** Alternatively, if pReadr2 contains the smaller of the two values, + ** set aTree[i] to its index and update pReadr1. If vdbeSorterCompare() + ** was actually called above, then pTask->pUnpacked now contains + ** a value equivalent to pReadr2. So set pKey2 to NULL to prevent + ** vdbeSorterCompare() from decoding pReadr2 again. + ** + ** If the two values were equal, then the value from the oldest + ** PMA should be considered smaller. The VdbeSorter.aReadr[] array + ** is sorted from oldest to newest, so pReadr1 contains older values + ** than pReadr2 iff (pReadr1aTree[i] = (int)(pReadr1 - pMerger->aReadr); + pReadr2 = &pMerger->aReadr[ pMerger->aTree[i ^ 0x0001] ]; + bCached = 0; + }else{ + if( pReadr1->pFd ) bCached = 0; + pMerger->aTree[i] = (int)(pReadr2 - pMerger->aReadr); + pReadr1 = &pMerger->aReadr[ pMerger->aTree[i ^ 0x0001] ]; + } + } + *pbEof = (pMerger->aReadr[pMerger->aTree[1]].pFd==0); + } + + return (rc==SQLITE_OK ? pTask->pUnpacked->errCode : rc); +} + +#if SQLITE_MAX_WORKER_THREADS>0 +/* +** The main routine for background threads that write level-0 PMAs. +*/ +static void *vdbeSorterFlushThread(void *pCtx){ + SortSubtask *pTask = (SortSubtask*)pCtx; + int rc; /* Return code */ + assert( pTask->bDone==0 ); + rc = vdbeSorterListToPMA(pTask, &pTask->list); + pTask->bDone = 1; + return SQLITE_INT_TO_PTR(rc); +} +#endif /* SQLITE_MAX_WORKER_THREADS>0 */ + +/* +** Flush the current contents of VdbeSorter.list to a new PMA, possibly +** using a background thread. +*/ +static int vdbeSorterFlushPMA(VdbeSorter *pSorter){ +#if SQLITE_MAX_WORKER_THREADS==0 + pSorter->bUsePMA = 1; + return vdbeSorterListToPMA(&pSorter->aTask[0], &pSorter->list); +#else + int rc = SQLITE_OK; + int i; + SortSubtask *pTask = 0; /* Thread context used to create new PMA */ + int nWorker = (pSorter->nTask-1); + + /* Set the flag to indicate that at least one PMA has been written. + ** Or will be, anyhow. */ + pSorter->bUsePMA = 1; + + /* Select a sub-task to sort and flush the current list of in-memory + ** records to disk. If the sorter is running in multi-threaded mode, + ** round-robin between the first (pSorter->nTask-1) tasks. Except, if + ** the background thread from a sub-tasks previous turn is still running, + ** skip it. If the first (pSorter->nTask-1) sub-tasks are all still busy, + ** fall back to using the final sub-task. The first (pSorter->nTask-1) + ** sub-tasks are prefered as they use background threads - the final + ** sub-task uses the main thread. */ + for(i=0; iiPrev + i + 1) % nWorker; + pTask = &pSorter->aTask[iTest]; + if( pTask->bDone ){ + rc = vdbeSorterJoinThread(pTask); + } + if( rc!=SQLITE_OK || pTask->pThread==0 ) break; + } + + if( rc==SQLITE_OK ){ + if( i==nWorker ){ + /* Use the foreground thread for this operation */ + rc = vdbeSorterListToPMA(&pSorter->aTask[nWorker], &pSorter->list); + }else{ + /* Launch a background thread for this operation */ + u8 *aMem; + void *pCtx; + + assert( pTask!=0 ); + assert( pTask->pThread==0 && pTask->bDone==0 ); + assert( pTask->list.pList==0 ); + assert( pTask->list.aMemory==0 || pSorter->list.aMemory!=0 ); + + aMem = pTask->list.aMemory; + pCtx = (void*)pTask; + pSorter->iPrev = (u8)(pTask - pSorter->aTask); + pTask->list = pSorter->list; + pSorter->list.pList = 0; + pSorter->list.szPMA = 0; + if( aMem ){ + pSorter->list.aMemory = aMem; + pSorter->nMemory = sqlite3MallocSize(aMem); + }else if( pSorter->list.aMemory ){ + pSorter->list.aMemory = sqlite3Malloc(pSorter->nMemory); + if( !pSorter->list.aMemory ) return SQLITE_NOMEM_BKPT; + } + + rc = vdbeSorterCreateThread(pTask, vdbeSorterFlushThread, pCtx); + } + } + + return rc; +#endif /* SQLITE_MAX_WORKER_THREADS!=0 */ +} + +/* +** Add a record to the sorter. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterWrite( + const VdbeCursor *pCsr, /* Sorter cursor */ + Mem *pVal /* Memory cell containing record */ +){ + VdbeSorter *pSorter; + int rc = SQLITE_OK; /* Return Code */ + SorterRecord *pNew; /* New list element */ + int bFlush; /* True to flush contents of memory to PMA */ + int nReq; /* Bytes of memory required */ + int nPMA; /* Bytes of PMA space required */ + int t; /* serial type of first record field */ + + assert( pCsr->eCurType==CURTYPE_SORTER ); + pSorter = pCsr->uc.pSorter; + getVarint32NR((const u8*)&pVal->z[1], t); + if( t>0 && t<10 && t!=7 ){ + pSorter->typeMask &= SORTER_TYPE_INTEGER; + }else if( t>10 && (t & 0x01) ){ + pSorter->typeMask &= SORTER_TYPE_TEXT; + }else{ + pSorter->typeMask = 0; + } + + assert( pSorter ); + + /* Figure out whether or not the current contents of memory should be + ** flushed to a PMA before continuing. If so, do so. + ** + ** If using the single large allocation mode (pSorter->aMemory!=0), then + ** flush the contents of memory to a new PMA if (a) at least one value is + ** already in memory and (b) the new value will not fit in memory. + ** + ** Or, if using separate allocations for each record, flush the contents + ** of memory to a PMA if either of the following are true: + ** + ** * The total memory allocated for the in-memory list is greater + ** than (page-size * cache-size), or + ** + ** * The total memory allocated for the in-memory list is greater + ** than (page-size * 10) and sqlite3HeapNearlyFull() returns true. + */ + nReq = pVal->n + sizeof(SorterRecord); + nPMA = pVal->n + sqlite3VarintLen(pVal->n); + if( pSorter->mxPmaSize ){ + if( pSorter->list.aMemory ){ + bFlush = pSorter->iMemory && (pSorter->iMemory+nReq) > pSorter->mxPmaSize; + }else{ + bFlush = ( + (pSorter->list.szPMA > pSorter->mxPmaSize) + || (pSorter->list.szPMA > pSorter->mnPmaSize && sqlite3HeapNearlyFull()) + ); + } + if( bFlush ){ + rc = vdbeSorterFlushPMA(pSorter); + pSorter->list.szPMA = 0; + pSorter->iMemory = 0; + assert( rc!=SQLITE_OK || pSorter->list.pList==0 ); + } + } + + pSorter->list.szPMA += nPMA; + if( nPMA>pSorter->mxKeysize ){ + pSorter->mxKeysize = nPMA; + } + + if( pSorter->list.aMemory ){ + int nMin = pSorter->iMemory + nReq; + + if( nMin>pSorter->nMemory ){ + u8 *aNew; + sqlite3_int64 nNew = 2 * (sqlite3_int64)pSorter->nMemory; + int iListOff = -1; + if( pSorter->list.pList ){ + iListOff = (u8*)pSorter->list.pList - pSorter->list.aMemory; + } + while( nNew < nMin ) nNew = nNew*2; + if( nNew > pSorter->mxPmaSize ) nNew = pSorter->mxPmaSize; + if( nNew < nMin ) nNew = nMin; + aNew = sqlite3Realloc(pSorter->list.aMemory, nNew); + if( !aNew ) return SQLITE_NOMEM_BKPT; + if( iListOff>=0 ){ + pSorter->list.pList = (SorterRecord*)&aNew[iListOff]; + } + pSorter->list.aMemory = aNew; + pSorter->nMemory = nNew; + } + + pNew = (SorterRecord*)&pSorter->list.aMemory[pSorter->iMemory]; + pSorter->iMemory += ROUND8(nReq); + if( pSorter->list.pList ){ + pNew->u.iNext = (int)((u8*)(pSorter->list.pList) - pSorter->list.aMemory); + } + }else{ + pNew = (SorterRecord *)sqlite3Malloc(nReq); + if( pNew==0 ){ + return SQLITE_NOMEM_BKPT; + } + pNew->u.pNext = pSorter->list.pList; + } + + memcpy(SRVAL(pNew), pVal->z, pVal->n); + pNew->nVal = pVal->n; + pSorter->list.pList = pNew; + + return rc; +} + +/* +** Read keys from pIncr->pMerger and populate pIncr->aFile[1]. The format +** of the data stored in aFile[1] is the same as that used by regular PMAs, +** except that the number-of-bytes varint is omitted from the start. +*/ +static int vdbeIncrPopulate(IncrMerger *pIncr){ + int rc = SQLITE_OK; + int rc2; + i64 iStart = pIncr->iStartOff; + SorterFile *pOut = &pIncr->aFile[1]; + SortSubtask *pTask = pIncr->pTask; + MergeEngine *pMerger = pIncr->pMerger; + PmaWriter writer; + assert( pIncr->bEof==0 ); + + vdbeSorterPopulateDebug(pTask, "enter"); + + vdbePmaWriterInit(pOut->pFd, &writer, pTask->pSorter->pgsz, iStart); + while( rc==SQLITE_OK ){ + int dummy; + PmaReader *pReader = &pMerger->aReadr[ pMerger->aTree[1] ]; + int nKey = pReader->nKey; + i64 iEof = writer.iWriteOff + writer.iBufEnd; + + /* Check if the output file is full or if the input has been exhausted. + ** In either case exit the loop. */ + if( pReader->pFd==0 ) break; + if( (iEof + nKey + sqlite3VarintLen(nKey))>(iStart + pIncr->mxSz) ) break; + + /* Write the next key to the output. */ + vdbePmaWriteVarint(&writer, nKey); + vdbePmaWriteBlob(&writer, pReader->aKey, nKey); + assert( pIncr->pMerger->pTask==pTask ); + rc = vdbeMergeEngineStep(pIncr->pMerger, &dummy); + } + + rc2 = vdbePmaWriterFinish(&writer, &pOut->iEof); + if( rc==SQLITE_OK ) rc = rc2; + vdbeSorterPopulateDebug(pTask, "exit"); + return rc; +} + +#if SQLITE_MAX_WORKER_THREADS>0 +/* +** The main routine for background threads that populate aFile[1] of +** multi-threaded IncrMerger objects. +*/ +static void *vdbeIncrPopulateThread(void *pCtx){ + IncrMerger *pIncr = (IncrMerger*)pCtx; + void *pRet = SQLITE_INT_TO_PTR( vdbeIncrPopulate(pIncr) ); + pIncr->pTask->bDone = 1; + return pRet; +} + +/* +** Launch a background thread to populate aFile[1] of pIncr. +*/ +static int vdbeIncrBgPopulate(IncrMerger *pIncr){ + void *p = (void*)pIncr; + assert( pIncr->bUseThread ); + return vdbeSorterCreateThread(pIncr->pTask, vdbeIncrPopulateThread, p); +} +#endif + +/* +** This function is called when the PmaReader corresponding to pIncr has +** finished reading the contents of aFile[0]. Its purpose is to "refill" +** aFile[0] such that the PmaReader should start rereading it from the +** beginning. +** +** For single-threaded objects, this is accomplished by literally reading +** keys from pIncr->pMerger and repopulating aFile[0]. +** +** For multi-threaded objects, all that is required is to wait until the +** background thread is finished (if it is not already) and then swap +** aFile[0] and aFile[1] in place. If the contents of pMerger have not +** been exhausted, this function also launches a new background thread +** to populate the new aFile[1]. +** +** SQLITE_OK is returned on success, or an SQLite error code otherwise. +*/ +static int vdbeIncrSwap(IncrMerger *pIncr){ + int rc = SQLITE_OK; + +#if SQLITE_MAX_WORKER_THREADS>0 + if( pIncr->bUseThread ){ + rc = vdbeSorterJoinThread(pIncr->pTask); + + if( rc==SQLITE_OK ){ + SorterFile f0 = pIncr->aFile[0]; + pIncr->aFile[0] = pIncr->aFile[1]; + pIncr->aFile[1] = f0; + } + + if( rc==SQLITE_OK ){ + if( pIncr->aFile[0].iEof==pIncr->iStartOff ){ + pIncr->bEof = 1; + }else{ + rc = vdbeIncrBgPopulate(pIncr); + } + } + }else +#endif + { + rc = vdbeIncrPopulate(pIncr); + pIncr->aFile[0] = pIncr->aFile[1]; + if( pIncr->aFile[0].iEof==pIncr->iStartOff ){ + pIncr->bEof = 1; + } + } + + return rc; +} + +/* +** Allocate and return a new IncrMerger object to read data from pMerger. +** +** If an OOM condition is encountered, return NULL. In this case free the +** pMerger argument before returning. +*/ +static int vdbeIncrMergerNew( + SortSubtask *pTask, /* The thread that will be using the new IncrMerger */ + MergeEngine *pMerger, /* The MergeEngine that the IncrMerger will control */ + IncrMerger **ppOut /* Write the new IncrMerger here */ +){ + int rc = SQLITE_OK; + IncrMerger *pIncr = *ppOut = (IncrMerger*) + (sqlite3FaultSim(100) ? 0 : sqlite3MallocZero(sizeof(*pIncr))); + if( pIncr ){ + pIncr->pMerger = pMerger; + pIncr->pTask = pTask; + pIncr->mxSz = MAX(pTask->pSorter->mxKeysize+9,pTask->pSorter->mxPmaSize/2); + pTask->file2.iEof += pIncr->mxSz; + }else{ + vdbeMergeEngineFree(pMerger); + rc = SQLITE_NOMEM_BKPT; + } + return rc; +} + +#if SQLITE_MAX_WORKER_THREADS>0 +/* +** Set the "use-threads" flag on object pIncr. +*/ +static void vdbeIncrMergerSetThreads(IncrMerger *pIncr){ + pIncr->bUseThread = 1; + pIncr->pTask->file2.iEof -= pIncr->mxSz; +} +#endif /* SQLITE_MAX_WORKER_THREADS>0 */ + + + +/* +** Recompute pMerger->aTree[iOut] by comparing the next keys on the +** two PmaReaders that feed that entry. Neither of the PmaReaders +** are advanced. This routine merely does the comparison. +*/ +static void vdbeMergeEngineCompare( + MergeEngine *pMerger, /* Merge engine containing PmaReaders to compare */ + int iOut /* Store the result in pMerger->aTree[iOut] */ +){ + int i1; + int i2; + int iRes; + PmaReader *p1; + PmaReader *p2; + + assert( iOutnTree && iOut>0 ); + + if( iOut>=(pMerger->nTree/2) ){ + i1 = (iOut - pMerger->nTree/2) * 2; + i2 = i1 + 1; + }else{ + i1 = pMerger->aTree[iOut*2]; + i2 = pMerger->aTree[iOut*2+1]; + } + + p1 = &pMerger->aReadr[i1]; + p2 = &pMerger->aReadr[i2]; + + if( p1->pFd==0 ){ + iRes = i2; + }else if( p2->pFd==0 ){ + iRes = i1; + }else{ + SortSubtask *pTask = pMerger->pTask; + int bCached = 0; + int res; + assert( pTask->pUnpacked!=0 ); /* from vdbeSortSubtaskMain() */ + res = pTask->xCompare( + pTask, &bCached, p1->aKey, p1->nKey, p2->aKey, p2->nKey + ); + if( res<=0 ){ + iRes = i1; + }else{ + iRes = i2; + } + } + + pMerger->aTree[iOut] = iRes; +} + +/* +** Allowed values for the eMode parameter to vdbeMergeEngineInit() +** and vdbePmaReaderIncrMergeInit(). +** +** Only INCRINIT_NORMAL is valid in single-threaded builds (when +** SQLITE_MAX_WORKER_THREADS==0). The other values are only used +** when there exists one or more separate worker threads. +*/ +#define INCRINIT_NORMAL 0 +#define INCRINIT_TASK 1 +#define INCRINIT_ROOT 2 + +/* +** Forward reference required as the vdbeIncrMergeInit() and +** vdbePmaReaderIncrInit() routines are called mutually recursively when +** building a merge tree. +*/ +static int vdbePmaReaderIncrInit(PmaReader *pReadr, int eMode); + +/* +** Initialize the MergeEngine object passed as the second argument. Once this +** function returns, the first key of merged data may be read from the +** MergeEngine object in the usual fashion. +** +** If argument eMode is INCRINIT_ROOT, then it is assumed that any IncrMerge +** objects attached to the PmaReader objects that the merger reads from have +** already been populated, but that they have not yet populated aFile[0] and +** set the PmaReader objects up to read from it. In this case all that is +** required is to call vdbePmaReaderNext() on each PmaReader to point it at +** its first key. +** +** Otherwise, if eMode is any value other than INCRINIT_ROOT, then use +** vdbePmaReaderIncrMergeInit() to initialize each PmaReader that feeds data +** to pMerger. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +static int vdbeMergeEngineInit( + SortSubtask *pTask, /* Thread that will run pMerger */ + MergeEngine *pMerger, /* MergeEngine to initialize */ + int eMode /* One of the INCRINIT_XXX constants */ +){ + int rc = SQLITE_OK; /* Return code */ + int i; /* For looping over PmaReader objects */ + int nTree; /* Number of subtrees to merge */ + + /* Failure to allocate the merge would have been detected prior to + ** invoking this routine */ + assert( pMerger!=0 ); + + /* eMode is always INCRINIT_NORMAL in single-threaded mode */ + assert( SQLITE_MAX_WORKER_THREADS>0 || eMode==INCRINIT_NORMAL ); + + /* Verify that the MergeEngine is assigned to a single thread */ + assert( pMerger->pTask==0 ); + pMerger->pTask = pTask; + + nTree = pMerger->nTree; + for(i=0; i0 && eMode==INCRINIT_ROOT ){ + /* PmaReaders should be normally initialized in order, as if they are + ** reading from the same temp file this makes for more linear file IO. + ** However, in the INCRINIT_ROOT case, if PmaReader aReadr[nTask-1] is + ** in use it will block the vdbePmaReaderNext() call while it uses + ** the main thread to fill its buffer. So calling PmaReaderNext() + ** on this PmaReader before any of the multi-threaded PmaReaders takes + ** better advantage of multi-processor hardware. */ + rc = vdbePmaReaderNext(&pMerger->aReadr[nTree-i-1]); + }else{ + rc = vdbePmaReaderIncrInit(&pMerger->aReadr[i], INCRINIT_NORMAL); + } + if( rc!=SQLITE_OK ) return rc; + } + + for(i=pMerger->nTree-1; i>0; i--){ + vdbeMergeEngineCompare(pMerger, i); + } + return pTask->pUnpacked->errCode; +} + +/* +** The PmaReader passed as the first argument is guaranteed to be an +** incremental-reader (pReadr->pIncr!=0). This function serves to open +** and/or initialize the temp file related fields of the IncrMerge +** object at (pReadr->pIncr). +** +** If argument eMode is set to INCRINIT_NORMAL, then all PmaReaders +** in the sub-tree headed by pReadr are also initialized. Data is then +** loaded into the buffers belonging to pReadr and it is set to point to +** the first key in its range. +** +** If argument eMode is set to INCRINIT_TASK, then pReadr is guaranteed +** to be a multi-threaded PmaReader and this function is being called in a +** background thread. In this case all PmaReaders in the sub-tree are +** initialized as for INCRINIT_NORMAL and the aFile[1] buffer belonging to +** pReadr is populated. However, pReadr itself is not set up to point +** to its first key. A call to vdbePmaReaderNext() is still required to do +** that. +** +** The reason this function does not call vdbePmaReaderNext() immediately +** in the INCRINIT_TASK case is that vdbePmaReaderNext() assumes that it has +** to block on thread (pTask->thread) before accessing aFile[1]. But, since +** this entire function is being run by thread (pTask->thread), that will +** lead to the current background thread attempting to join itself. +** +** Finally, if argument eMode is set to INCRINIT_ROOT, it may be assumed +** that pReadr->pIncr is a multi-threaded IncrMerge objects, and that all +** child-trees have already been initialized using IncrInit(INCRINIT_TASK). +** In this case vdbePmaReaderNext() is called on all child PmaReaders and +** the current PmaReader set to point to the first key in its range. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +static int vdbePmaReaderIncrMergeInit(PmaReader *pReadr, int eMode){ + int rc = SQLITE_OK; + IncrMerger *pIncr = pReadr->pIncr; + SortSubtask *pTask = pIncr->pTask; + sqlite3 *db = pTask->pSorter->db; + + /* eMode is always INCRINIT_NORMAL in single-threaded mode */ + assert( SQLITE_MAX_WORKER_THREADS>0 || eMode==INCRINIT_NORMAL ); + + rc = vdbeMergeEngineInit(pTask, pIncr->pMerger, eMode); + + /* Set up the required files for pIncr. A multi-theaded IncrMerge object + ** requires two temp files to itself, whereas a single-threaded object + ** only requires a region of pTask->file2. */ + if( rc==SQLITE_OK ){ + int mxSz = pIncr->mxSz; +#if SQLITE_MAX_WORKER_THREADS>0 + if( pIncr->bUseThread ){ + rc = vdbeSorterOpenTempFile(db, mxSz, &pIncr->aFile[0].pFd); + if( rc==SQLITE_OK ){ + rc = vdbeSorterOpenTempFile(db, mxSz, &pIncr->aFile[1].pFd); + } + }else +#endif + /*if( !pIncr->bUseThread )*/{ + if( pTask->file2.pFd==0 ){ + assert( pTask->file2.iEof>0 ); + rc = vdbeSorterOpenTempFile(db, pTask->file2.iEof, &pTask->file2.pFd); + pTask->file2.iEof = 0; + } + if( rc==SQLITE_OK ){ + pIncr->aFile[1].pFd = pTask->file2.pFd; + pIncr->iStartOff = pTask->file2.iEof; + pTask->file2.iEof += mxSz; + } + } + } + +#if SQLITE_MAX_WORKER_THREADS>0 + if( rc==SQLITE_OK && pIncr->bUseThread ){ + /* Use the current thread to populate aFile[1], even though this + ** PmaReader is multi-threaded. If this is an INCRINIT_TASK object, + ** then this function is already running in background thread + ** pIncr->pTask->thread. + ** + ** If this is the INCRINIT_ROOT object, then it is running in the + ** main VDBE thread. But that is Ok, as that thread cannot return + ** control to the VDBE or proceed with anything useful until the + ** first results are ready from this merger object anyway. + */ + assert( eMode==INCRINIT_ROOT || eMode==INCRINIT_TASK ); + rc = vdbeIncrPopulate(pIncr); + } +#endif + + if( rc==SQLITE_OK && (SQLITE_MAX_WORKER_THREADS==0 || eMode!=INCRINIT_TASK) ){ + rc = vdbePmaReaderNext(pReadr); + } + + return rc; +} + +#if SQLITE_MAX_WORKER_THREADS>0 +/* +** The main routine for vdbePmaReaderIncrMergeInit() operations run in +** background threads. +*/ +static void *vdbePmaReaderBgIncrInit(void *pCtx){ + PmaReader *pReader = (PmaReader*)pCtx; + void *pRet = SQLITE_INT_TO_PTR( + vdbePmaReaderIncrMergeInit(pReader,INCRINIT_TASK) + ); + pReader->pIncr->pTask->bDone = 1; + return pRet; +} +#endif + +/* +** If the PmaReader passed as the first argument is not an incremental-reader +** (if pReadr->pIncr==0), then this function is a no-op. Otherwise, it invokes +** the vdbePmaReaderIncrMergeInit() function with the parameters passed to +** this routine to initialize the incremental merge. +** +** If the IncrMerger object is multi-threaded (IncrMerger.bUseThread==1), +** then a background thread is launched to call vdbePmaReaderIncrMergeInit(). +** Or, if the IncrMerger is single threaded, the same function is called +** using the current thread. +*/ +static int vdbePmaReaderIncrInit(PmaReader *pReadr, int eMode){ + IncrMerger *pIncr = pReadr->pIncr; /* Incremental merger */ + int rc = SQLITE_OK; /* Return code */ + if( pIncr ){ +#if SQLITE_MAX_WORKER_THREADS>0 + assert( pIncr->bUseThread==0 || eMode==INCRINIT_TASK ); + if( pIncr->bUseThread ){ + void *pCtx = (void*)pReadr; + rc = vdbeSorterCreateThread(pIncr->pTask, vdbePmaReaderBgIncrInit, pCtx); + }else +#endif + { + rc = vdbePmaReaderIncrMergeInit(pReadr, eMode); + } + } + return rc; +} + +/* +** Allocate a new MergeEngine object to merge the contents of nPMA level-0 +** PMAs from pTask->file. If no error occurs, set *ppOut to point to +** the new object and return SQLITE_OK. Or, if an error does occur, set *ppOut +** to NULL and return an SQLite error code. +** +** When this function is called, *piOffset is set to the offset of the +** first PMA to read from pTask->file. Assuming no error occurs, it is +** set to the offset immediately following the last byte of the last +** PMA before returning. If an error does occur, then the final value of +** *piOffset is undefined. +*/ +static int vdbeMergeEngineLevel0( + SortSubtask *pTask, /* Sorter task to read from */ + int nPMA, /* Number of PMAs to read */ + i64 *piOffset, /* IN/OUT: Readr offset in pTask->file */ + MergeEngine **ppOut /* OUT: New merge-engine */ +){ + MergeEngine *pNew; /* Merge engine to return */ + i64 iOff = *piOffset; + int i; + int rc = SQLITE_OK; + + *ppOut = pNew = vdbeMergeEngineNew(nPMA); + if( pNew==0 ) rc = SQLITE_NOMEM_BKPT; + + for(i=0; iaReadr[i]; + rc = vdbePmaReaderInit(pTask, &pTask->file, iOff, pReadr, &nDummy); + iOff = pReadr->iEof; + } + + if( rc!=SQLITE_OK ){ + vdbeMergeEngineFree(pNew); + *ppOut = 0; + } + *piOffset = iOff; + return rc; +} + +/* +** Return the depth of a tree comprising nPMA PMAs, assuming a fanout of +** SORTER_MAX_MERGE_COUNT. The returned value does not include leaf nodes. +** +** i.e. +** +** nPMA<=16 -> TreeDepth() == 0 +** nPMA<=256 -> TreeDepth() == 1 +** nPMA<=65536 -> TreeDepth() == 2 +*/ +static int vdbeSorterTreeDepth(int nPMA){ + int nDepth = 0; + i64 nDiv = SORTER_MAX_MERGE_COUNT; + while( nDiv < (i64)nPMA ){ + nDiv = nDiv * SORTER_MAX_MERGE_COUNT; + nDepth++; + } + return nDepth; +} + +/* +** pRoot is the root of an incremental merge-tree with depth nDepth (according +** to vdbeSorterTreeDepth()). pLeaf is the iSeq'th leaf to be added to the +** tree, counting from zero. This function adds pLeaf to the tree. +** +** If successful, SQLITE_OK is returned. If an error occurs, an SQLite error +** code is returned and pLeaf is freed. +*/ +static int vdbeSorterAddToTree( + SortSubtask *pTask, /* Task context */ + int nDepth, /* Depth of tree according to TreeDepth() */ + int iSeq, /* Sequence number of leaf within tree */ + MergeEngine *pRoot, /* Root of tree */ + MergeEngine *pLeaf /* Leaf to add to tree */ +){ + int rc = SQLITE_OK; + int nDiv = 1; + int i; + MergeEngine *p = pRoot; + IncrMerger *pIncr; + + rc = vdbeIncrMergerNew(pTask, pLeaf, &pIncr); + + for(i=1; iaReadr[iIter]; + + if( pReadr->pIncr==0 ){ + MergeEngine *pNew = vdbeMergeEngineNew(SORTER_MAX_MERGE_COUNT); + if( pNew==0 ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + rc = vdbeIncrMergerNew(pTask, pNew, &pReadr->pIncr); + } + } + if( rc==SQLITE_OK ){ + p = pReadr->pIncr->pMerger; + nDiv = nDiv / SORTER_MAX_MERGE_COUNT; + } + } + + if( rc==SQLITE_OK ){ + p->aReadr[iSeq % SORTER_MAX_MERGE_COUNT].pIncr = pIncr; + }else{ + vdbeIncrFree(pIncr); + } + return rc; +} + +/* +** This function is called as part of a SorterRewind() operation on a sorter +** that has already written two or more level-0 PMAs to one or more temp +** files. It builds a tree of MergeEngine/IncrMerger/PmaReader objects that +** can be used to incrementally merge all PMAs on disk. +** +** If successful, SQLITE_OK is returned and *ppOut set to point to the +** MergeEngine object at the root of the tree before returning. Or, if an +** error occurs, an SQLite error code is returned and the final value +** of *ppOut is undefined. +*/ +static int vdbeSorterMergeTreeBuild( + VdbeSorter *pSorter, /* The VDBE cursor that implements the sort */ + MergeEngine **ppOut /* Write the MergeEngine here */ +){ + MergeEngine *pMain = 0; + int rc = SQLITE_OK; + int iTask; + +#if SQLITE_MAX_WORKER_THREADS>0 + /* If the sorter uses more than one task, then create the top-level + ** MergeEngine here. This MergeEngine will read data from exactly + ** one PmaReader per sub-task. */ + assert( pSorter->bUseThreads || pSorter->nTask==1 ); + if( pSorter->nTask>1 ){ + pMain = vdbeMergeEngineNew(pSorter->nTask); + if( pMain==0 ) rc = SQLITE_NOMEM_BKPT; + } +#endif + + for(iTask=0; rc==SQLITE_OK && iTasknTask; iTask++){ + SortSubtask *pTask = &pSorter->aTask[iTask]; + assert( pTask->nPMA>0 || SQLITE_MAX_WORKER_THREADS>0 ); + if( SQLITE_MAX_WORKER_THREADS==0 || pTask->nPMA ){ + MergeEngine *pRoot = 0; /* Root node of tree for this task */ + int nDepth = vdbeSorterTreeDepth(pTask->nPMA); + i64 iReadOff = 0; + + if( pTask->nPMA<=SORTER_MAX_MERGE_COUNT ){ + rc = vdbeMergeEngineLevel0(pTask, pTask->nPMA, &iReadOff, &pRoot); + }else{ + int i; + int iSeq = 0; + pRoot = vdbeMergeEngineNew(SORTER_MAX_MERGE_COUNT); + if( pRoot==0 ) rc = SQLITE_NOMEM_BKPT; + for(i=0; inPMA && rc==SQLITE_OK; i += SORTER_MAX_MERGE_COUNT){ + MergeEngine *pMerger = 0; /* New level-0 PMA merger */ + int nReader; /* Number of level-0 PMAs to merge */ + + nReader = MIN(pTask->nPMA - i, SORTER_MAX_MERGE_COUNT); + rc = vdbeMergeEngineLevel0(pTask, nReader, &iReadOff, &pMerger); + if( rc==SQLITE_OK ){ + rc = vdbeSorterAddToTree(pTask, nDepth, iSeq++, pRoot, pMerger); + } + } + } + + if( rc==SQLITE_OK ){ +#if SQLITE_MAX_WORKER_THREADS>0 + if( pMain!=0 ){ + rc = vdbeIncrMergerNew(pTask, pRoot, &pMain->aReadr[iTask].pIncr); + }else +#endif + { + assert( pMain==0 ); + pMain = pRoot; + } + }else{ + vdbeMergeEngineFree(pRoot); + } + } + } + + if( rc!=SQLITE_OK ){ + vdbeMergeEngineFree(pMain); + pMain = 0; + } + *ppOut = pMain; + return rc; +} + +/* +** This function is called as part of an sqlite3VdbeSorterRewind() operation +** on a sorter that has written two or more PMAs to temporary files. It sets +** up either VdbeSorter.pMerger (for single threaded sorters) or pReader +** (for multi-threaded sorters) so that it can be used to iterate through +** all records stored in the sorter. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +static int vdbeSorterSetupMerge(VdbeSorter *pSorter){ + int rc; /* Return code */ + SortSubtask *pTask0 = &pSorter->aTask[0]; + MergeEngine *pMain = 0; +#if SQLITE_MAX_WORKER_THREADS + sqlite3 *db = pTask0->pSorter->db; + int i; + SorterCompare xCompare = vdbeSorterGetCompare(pSorter); + for(i=0; inTask; i++){ + pSorter->aTask[i].xCompare = xCompare; + } +#endif + + rc = vdbeSorterMergeTreeBuild(pSorter, &pMain); + if( rc==SQLITE_OK ){ +#if SQLITE_MAX_WORKER_THREADS + assert( pSorter->bUseThreads==0 || pSorter->nTask>1 ); + if( pSorter->bUseThreads ){ + int iTask; + PmaReader *pReadr = 0; + SortSubtask *pLast = &pSorter->aTask[pSorter->nTask-1]; + rc = vdbeSortAllocUnpacked(pLast); + if( rc==SQLITE_OK ){ + pReadr = (PmaReader*)sqlite3DbMallocZero(db, sizeof(PmaReader)); + pSorter->pReader = pReadr; + if( pReadr==0 ) rc = SQLITE_NOMEM_BKPT; + } + if( rc==SQLITE_OK ){ + rc = vdbeIncrMergerNew(pLast, pMain, &pReadr->pIncr); + if( rc==SQLITE_OK ){ + vdbeIncrMergerSetThreads(pReadr->pIncr); + for(iTask=0; iTask<(pSorter->nTask-1); iTask++){ + IncrMerger *pIncr; + if( (pIncr = pMain->aReadr[iTask].pIncr) ){ + vdbeIncrMergerSetThreads(pIncr); + assert( pIncr->pTask!=pLast ); + } + } + for(iTask=0; rc==SQLITE_OK && iTasknTask; iTask++){ + /* Check that: + ** + ** a) The incremental merge object is configured to use the + ** right task, and + ** b) If it is using task (nTask-1), it is configured to run + ** in single-threaded mode. This is important, as the + ** root merge (INCRINIT_ROOT) will be using the same task + ** object. + */ + PmaReader *p = &pMain->aReadr[iTask]; + assert( p->pIncr==0 || ( + (p->pIncr->pTask==&pSorter->aTask[iTask]) /* a */ + && (iTask!=pSorter->nTask-1 || p->pIncr->bUseThread==0) /* b */ + )); + rc = vdbePmaReaderIncrInit(p, INCRINIT_TASK); + } + } + pMain = 0; + } + if( rc==SQLITE_OK ){ + rc = vdbePmaReaderIncrMergeInit(pReadr, INCRINIT_ROOT); + } + }else +#endif + { + rc = vdbeMergeEngineInit(pTask0, pMain, INCRINIT_NORMAL); + pSorter->pMerger = pMain; + pMain = 0; + } + } + + if( rc!=SQLITE_OK ){ + vdbeMergeEngineFree(pMain); + } + return rc; +} + + +/* +** Once the sorter has been populated by calls to sqlite3VdbeSorterWrite, +** this function is called to prepare for iterating through the records +** in sorted order. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterRewind(const VdbeCursor *pCsr, int *pbEof){ + VdbeSorter *pSorter; + int rc = SQLITE_OK; /* Return code */ + + assert( pCsr->eCurType==CURTYPE_SORTER ); + pSorter = pCsr->uc.pSorter; + assert( pSorter ); + + /* If no data has been written to disk, then do not do so now. Instead, + ** sort the VdbeSorter.pRecord list. The vdbe layer will read data directly + ** from the in-memory list. */ + if( pSorter->bUsePMA==0 ){ + if( pSorter->list.pList ){ + *pbEof = 0; + rc = vdbeSorterSort(&pSorter->aTask[0], &pSorter->list); + }else{ + *pbEof = 1; + } + return rc; + } + + /* Write the current in-memory list to a PMA. When the VdbeSorterWrite() + ** function flushes the contents of memory to disk, it immediately always + ** creates a new list consisting of a single key immediately afterwards. + ** So the list is never empty at this point. */ + assert( pSorter->list.pList ); + rc = vdbeSorterFlushPMA(pSorter); + + /* Join all threads */ + rc = vdbeSorterJoinAll(pSorter, rc); + + vdbeSorterRewindDebug("rewind"); + + /* Assuming no errors have occurred, set up a merger structure to + ** incrementally read and merge all remaining PMAs. */ + assert( pSorter->pReader==0 ); + if( rc==SQLITE_OK ){ + rc = vdbeSorterSetupMerge(pSorter); + *pbEof = 0; + } + + vdbeSorterRewindDebug("rewinddone"); + return rc; +} + +/* +** Advance to the next element in the sorter. Return value: +** +** SQLITE_OK success +** SQLITE_DONE end of data +** otherwise some kind of error. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *db, const VdbeCursor *pCsr){ + VdbeSorter *pSorter; + int rc; /* Return code */ + + assert( pCsr->eCurType==CURTYPE_SORTER ); + pSorter = pCsr->uc.pSorter; + assert( pSorter->bUsePMA || (pSorter->pReader==0 && pSorter->pMerger==0) ); + if( pSorter->bUsePMA ){ + assert( pSorter->pReader==0 || pSorter->pMerger==0 ); + assert( pSorter->bUseThreads==0 || pSorter->pReader ); + assert( pSorter->bUseThreads==1 || pSorter->pMerger ); +#if SQLITE_MAX_WORKER_THREADS>0 + if( pSorter->bUseThreads ){ + rc = vdbePmaReaderNext(pSorter->pReader); + if( rc==SQLITE_OK && pSorter->pReader->pFd==0 ) rc = SQLITE_DONE; + }else +#endif + /*if( !pSorter->bUseThreads )*/ { + int res = 0; + assert( pSorter->pMerger!=0 ); + assert( pSorter->pMerger->pTask==(&pSorter->aTask[0]) ); + rc = vdbeMergeEngineStep(pSorter->pMerger, &res); + if( rc==SQLITE_OK && res ) rc = SQLITE_DONE; + } + }else{ + SorterRecord *pFree = pSorter->list.pList; + pSorter->list.pList = pFree->u.pNext; + pFree->u.pNext = 0; + if( pSorter->list.aMemory==0 ) vdbeSorterRecordFree(db, pFree); + rc = pSorter->list.pList ? SQLITE_OK : SQLITE_DONE; + } + return rc; +} + +/* +** Return a pointer to a buffer owned by the sorter that contains the +** current key. +*/ +static void *vdbeSorterRowkey( + const VdbeSorter *pSorter, /* Sorter object */ + int *pnKey /* OUT: Size of current key in bytes */ +){ + void *pKey; + if( pSorter->bUsePMA ){ + PmaReader *pReader; +#if SQLITE_MAX_WORKER_THREADS>0 + if( pSorter->bUseThreads ){ + pReader = pSorter->pReader; + }else +#endif + /*if( !pSorter->bUseThreads )*/{ + pReader = &pSorter->pMerger->aReadr[pSorter->pMerger->aTree[1]]; + } + *pnKey = pReader->nKey; + pKey = pReader->aKey; + }else{ + *pnKey = pSorter->list.pList->nVal; + pKey = SRVAL(pSorter->list.pList); + } + return pKey; +} + +/* +** Copy the current sorter key into the memory cell pOut. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *pCsr, Mem *pOut){ + VdbeSorter *pSorter; + void *pKey; int nKey; /* Sorter key to copy into pOut */ + + assert( pCsr->eCurType==CURTYPE_SORTER ); + pSorter = pCsr->uc.pSorter; + pKey = vdbeSorterRowkey(pSorter, &nKey); + if( sqlite3VdbeMemClearAndResize(pOut, nKey) ){ + return SQLITE_NOMEM_BKPT; + } + pOut->n = nKey; + MemSetTypeFlag(pOut, MEM_Blob); + memcpy(pOut->z, pKey, nKey); + + return SQLITE_OK; +} + +/* +** Compare the key in memory cell pVal with the key that the sorter cursor +** passed as the first argument currently points to. For the purposes of +** the comparison, ignore the rowid field at the end of each record. +** +** If the sorter cursor key contains any NULL values, consider it to be +** less than pVal. Even if pVal also contains NULL values. +** +** If an error occurs, return an SQLite error code (i.e. SQLITE_NOMEM). +** Otherwise, set *pRes to a negative, zero or positive value if the +** key in pVal is smaller than, equal to or larger than the current sorter +** key. +** +** This routine forms the core of the OP_SorterCompare opcode, which in +** turn is used to verify uniqueness when constructing a UNIQUE INDEX. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterCompare( + const VdbeCursor *pCsr, /* Sorter cursor */ + Mem *pVal, /* Value to compare to current sorter key */ + int nKeyCol, /* Compare this many columns */ + int *pRes /* OUT: Result of comparison */ +){ + VdbeSorter *pSorter; + UnpackedRecord *r2; + KeyInfo *pKeyInfo; + int i; + void *pKey; int nKey; /* Sorter key to compare pVal with */ + + assert( pCsr->eCurType==CURTYPE_SORTER ); + pSorter = pCsr->uc.pSorter; + r2 = pSorter->pUnpacked; + pKeyInfo = pCsr->pKeyInfo; + if( r2==0 ){ + r2 = pSorter->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pKeyInfo); + if( r2==0 ) return SQLITE_NOMEM_BKPT; + r2->nField = nKeyCol; + } + assert( r2->nField==nKeyCol ); + + pKey = vdbeSorterRowkey(pSorter, &nKey); + sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, r2); + for(i=0; iaMem[i].flags & MEM_Null ){ + *pRes = -1; + return SQLITE_OK; + } + } + + *pRes = sqlite3VdbeRecordCompare(pVal->n, pVal->z, r2); + return SQLITE_OK; +} + +/************** End of vdbesort.c ********************************************/ +/************** Begin file vdbevtab.c ****************************************/ +/* +** 2020-03-23 +** +** 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 virtual-tables for examining the bytecode content +** of a prepared statement. +*/ +/* #include "sqliteInt.h" */ +#if defined(SQLITE_ENABLE_BYTECODE_VTAB) && !defined(SQLITE_OMIT_VIRTUALTABLE) +/* #include "vdbeInt.h" */ + +/* An instance of the bytecode() table-valued function. +*/ +typedef struct bytecodevtab bytecodevtab; +struct bytecodevtab { + sqlite3_vtab base; /* Base class - must be first */ + sqlite3 *db; /* Database connection */ + int bTablesUsed; /* 2 for tables_used(). 0 for bytecode(). */ +}; + +/* A cursor for scanning through the bytecode +*/ +typedef struct bytecodevtab_cursor bytecodevtab_cursor; +struct bytecodevtab_cursor { + sqlite3_vtab_cursor base; /* Base class - must be first */ + sqlite3_stmt *pStmt; /* The statement whose bytecode is displayed */ + int iRowid; /* The rowid of the output table */ + int iAddr; /* Address */ + int needFinalize; /* Cursors owns pStmt and must finalize it */ + int showSubprograms; /* Provide a listing of subprograms */ + Op *aOp; /* Operand array */ + char *zP4; /* Rendered P4 value */ + const char *zType; /* tables_used.type */ + const char *zSchema; /* tables_used.schema */ + const char *zName; /* tables_used.name */ + Mem sub; /* Subprograms */ +}; + +/* +** Create a new bytecode() table-valued function. +*/ +static int bytecodevtabConnect( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + bytecodevtab *pNew; + int rc; + int isTabUsed = pAux!=0; + const char *azSchema[2] = { + /* bytecode() schema */ + "CREATE TABLE x(" + "addr INT," + "opcode TEXT," + "p1 INT," + "p2 INT," + "p3 INT," + "p4 TEXT," + "p5 INT," + "comment TEXT," + "subprog TEXT," + "stmt HIDDEN" + ");", + + /* Tables_used() schema */ + "CREATE TABLE x(" + "type TEXT," + "schema TEXT," + "name TEXT," + "wr INT," + "subprog TEXT," + "stmt HIDDEN" + ");" + }; + + rc = sqlite3_declare_vtab(db, azSchema[isTabUsed]); + if( rc==SQLITE_OK ){ + pNew = sqlite3_malloc( sizeof(*pNew) ); + *ppVtab = (sqlite3_vtab*)pNew; + if( pNew==0 ) return SQLITE_NOMEM; + memset(pNew, 0, sizeof(*pNew)); + pNew->db = db; + pNew->bTablesUsed = isTabUsed*2; + } + return rc; +} + +/* +** This method is the destructor for bytecodevtab objects. +*/ +static int bytecodevtabDisconnect(sqlite3_vtab *pVtab){ + bytecodevtab *p = (bytecodevtab*)pVtab; + sqlite3_free(p); + return SQLITE_OK; +} + +/* +** Constructor for a new bytecodevtab_cursor object. +*/ +static int bytecodevtabOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ + bytecodevtab *pVTab = (bytecodevtab*)p; + bytecodevtab_cursor *pCur; + pCur = sqlite3_malloc( sizeof(*pCur) ); + if( pCur==0 ) return SQLITE_NOMEM; + memset(pCur, 0, sizeof(*pCur)); + sqlite3VdbeMemInit(&pCur->sub, pVTab->db, 1); + *ppCursor = &pCur->base; + return SQLITE_OK; +} + +/* +** Clear all internal content from a bytecodevtab cursor. +*/ +static void bytecodevtabCursorClear(bytecodevtab_cursor *pCur){ + sqlite3_free(pCur->zP4); + pCur->zP4 = 0; + sqlite3VdbeMemRelease(&pCur->sub); + sqlite3VdbeMemSetNull(&pCur->sub); + if( pCur->needFinalize ){ + sqlite3_finalize(pCur->pStmt); + } + pCur->pStmt = 0; + pCur->needFinalize = 0; + pCur->zType = 0; + pCur->zSchema = 0; + pCur->zName = 0; +} + +/* +** Destructor for a bytecodevtab_cursor. +*/ +static int bytecodevtabClose(sqlite3_vtab_cursor *cur){ + bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur; + bytecodevtabCursorClear(pCur); + sqlite3_free(pCur); + return SQLITE_OK; +} + + +/* +** Advance a bytecodevtab_cursor to its next row of output. +*/ +static int bytecodevtabNext(sqlite3_vtab_cursor *cur){ + bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur; + bytecodevtab *pTab = (bytecodevtab*)cur->pVtab; + int rc; + if( pCur->zP4 ){ + sqlite3_free(pCur->zP4); + pCur->zP4 = 0; + } + if( pCur->zName ){ + pCur->zName = 0; + pCur->zType = 0; + pCur->zSchema = 0; + } + rc = sqlite3VdbeNextOpcode( + (Vdbe*)pCur->pStmt, + pCur->showSubprograms ? &pCur->sub : 0, + pTab->bTablesUsed, + &pCur->iRowid, + &pCur->iAddr, + &pCur->aOp); + if( rc!=SQLITE_OK ){ + sqlite3VdbeMemSetNull(&pCur->sub); + pCur->aOp = 0; + } + return SQLITE_OK; +} + +/* +** Return TRUE if the cursor has been moved off of the last +** row of output. +*/ +static int bytecodevtabEof(sqlite3_vtab_cursor *cur){ + bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur; + return pCur->aOp==0; +} + +/* +** Return values of columns for the row at which the bytecodevtab_cursor +** is currently pointing. +*/ +static int bytecodevtabColumn( + sqlite3_vtab_cursor *cur, /* The cursor */ + sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ + int i /* Which column to return */ +){ + bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur; + bytecodevtab *pVTab = (bytecodevtab*)cur->pVtab; + Op *pOp = pCur->aOp + pCur->iAddr; + if( pVTab->bTablesUsed ){ + if( i==4 ){ + i = 8; + }else{ + if( i<=2 && pCur->zType==0 ){ + Schema *pSchema; + HashElem *k; + int iDb = pOp->p3; + Pgno iRoot = (Pgno)pOp->p2; + sqlite3 *db = pVTab->db; + pSchema = db->aDb[iDb].pSchema; + pCur->zSchema = db->aDb[iDb].zDbSName; + for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){ + Table *pTab = (Table*)sqliteHashData(k); + if( !IsVirtual(pTab) && pTab->tnum==iRoot ){ + pCur->zName = pTab->zName; + pCur->zType = "table"; + break; + } + } + if( pCur->zName==0 ){ + for(k=sqliteHashFirst(&pSchema->idxHash); k; k=sqliteHashNext(k)){ + Index *pIdx = (Index*)sqliteHashData(k); + if( pIdx->tnum==iRoot ){ + pCur->zName = pIdx->zName; + pCur->zType = "index"; + } + } + } + } + i += 10; + } + } + switch( i ){ + case 0: /* addr */ + sqlite3_result_int(ctx, pCur->iAddr); + break; + case 1: /* opcode */ + sqlite3_result_text(ctx, (char*)sqlite3OpcodeName(pOp->opcode), + -1, SQLITE_STATIC); + break; + case 2: /* p1 */ + sqlite3_result_int(ctx, pOp->p1); + break; + case 3: /* p2 */ + sqlite3_result_int(ctx, pOp->p2); + break; + case 4: /* p3 */ + sqlite3_result_int(ctx, pOp->p3); + break; + case 5: /* p4 */ + case 7: /* comment */ + if( pCur->zP4==0 ){ + pCur->zP4 = sqlite3VdbeDisplayP4(pVTab->db, pOp); + } + if( i==5 ){ + sqlite3_result_text(ctx, pCur->zP4, -1, SQLITE_STATIC); + }else{ +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + char *zCom = sqlite3VdbeDisplayComment(pVTab->db, pOp, pCur->zP4); + sqlite3_result_text(ctx, zCom, -1, sqlite3_free); +#endif + } + break; + case 6: /* p5 */ + sqlite3_result_int(ctx, pOp->p5); + break; + case 8: { /* subprog */ + Op *aOp = pCur->aOp; + assert( aOp[0].opcode==OP_Init ); + assert( aOp[0].p4.z==0 || strncmp(aOp[0].p4.z,"-" "- ",3)==0 ); + if( pCur->iRowid==pCur->iAddr+1 ){ + break; /* Result is NULL for the main program */ + }else if( aOp[0].p4.z!=0 ){ + sqlite3_result_text(ctx, aOp[0].p4.z+3, -1, SQLITE_STATIC); + }else{ + sqlite3_result_text(ctx, "(FK)", 4, SQLITE_STATIC); + } + break; + } + case 10: /* tables_used.type */ + sqlite3_result_text(ctx, pCur->zType, -1, SQLITE_STATIC); + break; + case 11: /* tables_used.schema */ + sqlite3_result_text(ctx, pCur->zSchema, -1, SQLITE_STATIC); + break; + case 12: /* tables_used.name */ + sqlite3_result_text(ctx, pCur->zName, -1, SQLITE_STATIC); + break; + case 13: /* tables_used.wr */ + sqlite3_result_int(ctx, pOp->opcode==OP_OpenWrite); + break; + } + return SQLITE_OK; +} + +/* +** Return the rowid for the current row. In this implementation, the +** rowid is the same as the output value. +*/ +static int bytecodevtabRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ + bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur; + *pRowid = pCur->iRowid; + return SQLITE_OK; +} + +/* +** Initialize a cursor. +** +** idxNum==0 means show all subprograms +** idxNum==1 means show only the main bytecode and omit subprograms. +*/ +static int bytecodevtabFilter( + sqlite3_vtab_cursor *pVtabCursor, + int idxNum, const char *idxStr, + int argc, sqlite3_value **argv +){ + bytecodevtab_cursor *pCur = (bytecodevtab_cursor *)pVtabCursor; + bytecodevtab *pVTab = (bytecodevtab *)pVtabCursor->pVtab; + int rc = SQLITE_OK; + + bytecodevtabCursorClear(pCur); + pCur->iRowid = 0; + pCur->iAddr = 0; + pCur->showSubprograms = idxNum==0; + assert( argc==1 ); + if( sqlite3_value_type(argv[0])==SQLITE_TEXT ){ + const char *zSql = (const char*)sqlite3_value_text(argv[0]); + if( zSql==0 ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v2(pVTab->db, zSql, -1, &pCur->pStmt, 0); + pCur->needFinalize = 1; + } + }else{ + pCur->pStmt = (sqlite3_stmt*)sqlite3_value_pointer(argv[0],"stmt-pointer"); + } + if( pCur->pStmt==0 ){ + pVTab->base.zErrMsg = sqlite3_mprintf( + "argument to %s() is not a valid SQL statement", + pVTab->bTablesUsed ? "tables_used" : "bytecode" + ); + rc = SQLITE_ERROR; + }else{ + bytecodevtabNext(pVtabCursor); + } + return rc; +} + +/* +** We must have a single stmt=? constraint that will be passed through +** into the xFilter method. If there is no valid stmt=? constraint, +** then return an SQLITE_CONSTRAINT error. +*/ +static int bytecodevtabBestIndex( + sqlite3_vtab *tab, + sqlite3_index_info *pIdxInfo +){ + int i; + int rc = SQLITE_CONSTRAINT; + struct sqlite3_index_constraint *p; + bytecodevtab *pVTab = (bytecodevtab*)tab; + int iBaseCol = pVTab->bTablesUsed ? 4 : 8; + pIdxInfo->estimatedCost = (double)100; + pIdxInfo->estimatedRows = 100; + pIdxInfo->idxNum = 0; + for(i=0, p=pIdxInfo->aConstraint; inConstraint; i++, p++){ + if( p->usable==0 ) continue; + if( p->op==SQLITE_INDEX_CONSTRAINT_EQ && p->iColumn==iBaseCol+1 ){ + rc = SQLITE_OK; + pIdxInfo->aConstraintUsage[i].omit = 1; + pIdxInfo->aConstraintUsage[i].argvIndex = 1; + } + if( p->op==SQLITE_INDEX_CONSTRAINT_ISNULL && p->iColumn==iBaseCol ){ + pIdxInfo->aConstraintUsage[i].omit = 1; + pIdxInfo->idxNum = 1; + } + } + return rc; +} + +/* +** This following structure defines all the methods for the +** virtual table. +*/ +static sqlite3_module bytecodevtabModule = { + /* iVersion */ 0, + /* xCreate */ 0, + /* xConnect */ bytecodevtabConnect, + /* xBestIndex */ bytecodevtabBestIndex, + /* xDisconnect */ bytecodevtabDisconnect, + /* xDestroy */ 0, + /* xOpen */ bytecodevtabOpen, + /* xClose */ bytecodevtabClose, + /* xFilter */ bytecodevtabFilter, + /* xNext */ bytecodevtabNext, + /* xEof */ bytecodevtabEof, + /* xColumn */ bytecodevtabColumn, + /* xRowid */ bytecodevtabRowid, + /* xUpdate */ 0, + /* xBegin */ 0, + /* xSync */ 0, + /* xCommit */ 0, + /* xRollback */ 0, + /* xFindMethod */ 0, + /* xRename */ 0, + /* xSavepoint */ 0, + /* xRelease */ 0, + /* xRollbackTo */ 0, + /* xShadowName */ 0 +}; + + +SQLITE_PRIVATE int sqlite3VdbeBytecodeVtabInit(sqlite3 *db){ + int rc; + rc = sqlite3_create_module(db, "bytecode", &bytecodevtabModule, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3_create_module(db, "tables_used", &bytecodevtabModule, &db); + } + return rc; +} +#elif defined(SQLITE_ENABLE_BYTECODE_VTAB) +SQLITE_PRIVATE int sqlite3VdbeBytecodeVtabInit(sqlite3 *db){ return SQLITE_OK; } +#endif /* SQLITE_ENABLE_BYTECODE_VTAB */ + +/************** End of vdbevtab.c ********************************************/ +/************** Begin file memjournal.c **************************************/ +/* +** 2008 October 7 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code use to implement an in-memory rollback journal. +** The in-memory rollback journal is used to journal transactions for +** ":memory:" databases and when the journal_mode=MEMORY pragma is used. +** +** Update: The in-memory journal is also used to temporarily cache +** smaller journals that are not critical for power-loss recovery. +** For example, statement journals that are not too big will be held +** entirely in memory, thus reducing the number of file I/O calls, and +** more importantly, reducing temporary file creation events. If these +** journals become too large for memory, they are spilled to disk. But +** in the common case, they are usually small and no file I/O needs to +** occur. +*/ +/* #include "sqliteInt.h" */ + +/* Forward references to internal structures */ +typedef struct MemJournal MemJournal; +typedef struct FilePoint FilePoint; +typedef struct FileChunk FileChunk; + +/* +** The rollback journal is composed of a linked list of these structures. +** +** The zChunk array is always at least 8 bytes in size - usually much more. +** Its actual size is stored in the MemJournal.nChunkSize variable. +*/ +struct FileChunk { + FileChunk *pNext; /* Next chunk in the journal */ + u8 zChunk[8]; /* Content of this chunk */ +}; + +/* +** By default, allocate this many bytes of memory for each FileChunk object. +*/ +#define MEMJOURNAL_DFLT_FILECHUNKSIZE 1024 + +/* +** For chunk size nChunkSize, return the number of bytes that should +** be allocated for each FileChunk structure. +*/ +#define fileChunkSize(nChunkSize) (sizeof(FileChunk) + ((nChunkSize)-8)) + +/* +** An instance of this object serves as a cursor into the rollback journal. +** The cursor can be either for reading or writing. +*/ +struct FilePoint { + sqlite3_int64 iOffset; /* Offset from the beginning of the file */ + FileChunk *pChunk; /* Specific chunk into which cursor points */ +}; + +/* +** This structure is a subclass of sqlite3_file. Each open memory-journal +** is an instance of this class. +*/ +struct MemJournal { + const sqlite3_io_methods *pMethod; /* Parent class. MUST BE FIRST */ + int nChunkSize; /* In-memory chunk-size */ + + int nSpill; /* Bytes of data before flushing */ + int nSize; /* Bytes of data currently in memory */ + FileChunk *pFirst; /* Head of in-memory chunk-list */ + FilePoint endpoint; /* Pointer to the end of the file */ + FilePoint readpoint; /* Pointer to the end of the last xRead() */ + + int flags; /* xOpen flags */ + sqlite3_vfs *pVfs; /* The "real" underlying VFS */ + const char *zJournal; /* Name of the journal file */ +}; + +/* +** Read data from the in-memory journal file. This is the implementation +** of the sqlite3_vfs.xRead method. +*/ +static int memjrnlRead( + sqlite3_file *pJfd, /* The journal file from which to read */ + void *zBuf, /* Put the results here */ + int iAmt, /* Number of bytes to read */ + sqlite_int64 iOfst /* Begin reading at this offset */ +){ + MemJournal *p = (MemJournal *)pJfd; + u8 *zOut = zBuf; + int nRead = iAmt; + int iChunkOffset; + FileChunk *pChunk; + + if( (iAmt+iOfst)>p->endpoint.iOffset ){ + return SQLITE_IOERR_SHORT_READ; + } + assert( p->readpoint.iOffset==0 || p->readpoint.pChunk!=0 ); + if( p->readpoint.iOffset!=iOfst || iOfst==0 ){ + sqlite3_int64 iOff = 0; + for(pChunk=p->pFirst; + ALWAYS(pChunk) && (iOff+p->nChunkSize)<=iOfst; + pChunk=pChunk->pNext + ){ + iOff += p->nChunkSize; + } + }else{ + pChunk = p->readpoint.pChunk; + assert( pChunk!=0 ); + } + + iChunkOffset = (int)(iOfst%p->nChunkSize); + do { + int iSpace = p->nChunkSize - iChunkOffset; + int nCopy = MIN(nRead, (p->nChunkSize - iChunkOffset)); + memcpy(zOut, (u8*)pChunk->zChunk + iChunkOffset, nCopy); + zOut += nCopy; + nRead -= iSpace; + iChunkOffset = 0; + } while( nRead>=0 && (pChunk=pChunk->pNext)!=0 && nRead>0 ); + p->readpoint.iOffset = pChunk ? iOfst+iAmt : 0; + p->readpoint.pChunk = pChunk; + + return SQLITE_OK; +} + +/* +** Free the list of FileChunk structures headed at MemJournal.pFirst. +*/ +static void memjrnlFreeChunks(MemJournal *p){ + FileChunk *pIter; + FileChunk *pNext; + for(pIter=p->pFirst; pIter; pIter=pNext){ + pNext = pIter->pNext; + sqlite3_free(pIter); + } + p->pFirst = 0; +} + +/* +** Flush the contents of memory to a real file on disk. +*/ +static int memjrnlCreateFile(MemJournal *p){ + int rc; + sqlite3_file *pReal = (sqlite3_file*)p; + MemJournal copy = *p; + + memset(p, 0, sizeof(MemJournal)); + rc = sqlite3OsOpen(copy.pVfs, copy.zJournal, pReal, copy.flags, 0); + if( rc==SQLITE_OK ){ + int nChunk = copy.nChunkSize; + i64 iOff = 0; + FileChunk *pIter; + for(pIter=copy.pFirst; pIter; pIter=pIter->pNext){ + if( iOff + nChunk > copy.endpoint.iOffset ){ + nChunk = copy.endpoint.iOffset - iOff; + } + rc = sqlite3OsWrite(pReal, (u8*)pIter->zChunk, nChunk, iOff); + if( rc ) break; + iOff += nChunk; + } + if( rc==SQLITE_OK ){ + /* No error has occurred. Free the in-memory buffers. */ + memjrnlFreeChunks(©); + } + } + if( rc!=SQLITE_OK ){ + /* If an error occurred while creating or writing to the file, restore + ** the original before returning. This way, SQLite uses the in-memory + ** journal data to roll back changes made to the internal page-cache + ** before this function was called. */ + sqlite3OsClose(pReal); + *p = copy; + } + return rc; +} + + +/* +** Write data to the file. +*/ +static int memjrnlWrite( + sqlite3_file *pJfd, /* The journal file into which to write */ + const void *zBuf, /* Take data to be written from here */ + int iAmt, /* Number of bytes to write */ + sqlite_int64 iOfst /* Begin writing at this offset into the file */ +){ + MemJournal *p = (MemJournal *)pJfd; + int nWrite = iAmt; + u8 *zWrite = (u8 *)zBuf; + + /* If the file should be created now, create it and write the new data + ** into the file on disk. */ + if( p->nSpill>0 && (iAmt+iOfst)>p->nSpill ){ + int rc = memjrnlCreateFile(p); + if( rc==SQLITE_OK ){ + rc = sqlite3OsWrite(pJfd, zBuf, iAmt, iOfst); + } + return rc; + } + + /* If the contents of this write should be stored in memory */ + else{ + /* An in-memory journal file should only ever be appended to. Random + ** access writes are not required. The only exception to this is when + ** the in-memory journal is being used by a connection using the + ** atomic-write optimization. In this case the first 28 bytes of the + ** journal file may be written as part of committing the transaction. */ + assert( iOfst==p->endpoint.iOffset || iOfst==0 ); +#if defined(SQLITE_ENABLE_ATOMIC_WRITE) \ + || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE) + if( iOfst==0 && p->pFirst ){ + assert( p->nChunkSize>iAmt ); + memcpy((u8*)p->pFirst->zChunk, zBuf, iAmt); + }else +#else + assert( iOfst>0 || p->pFirst==0 ); +#endif + { + while( nWrite>0 ){ + FileChunk *pChunk = p->endpoint.pChunk; + int iChunkOffset = (int)(p->endpoint.iOffset%p->nChunkSize); + int iSpace = MIN(nWrite, p->nChunkSize - iChunkOffset); + + if( iChunkOffset==0 ){ + /* New chunk is required to extend the file. */ + FileChunk *pNew = sqlite3_malloc(fileChunkSize(p->nChunkSize)); + if( !pNew ){ + return SQLITE_IOERR_NOMEM_BKPT; + } + pNew->pNext = 0; + if( pChunk ){ + assert( p->pFirst ); + pChunk->pNext = pNew; + }else{ + assert( !p->pFirst ); + p->pFirst = pNew; + } + p->endpoint.pChunk = pNew; + } + + memcpy((u8*)p->endpoint.pChunk->zChunk + iChunkOffset, zWrite, iSpace); + zWrite += iSpace; + nWrite -= iSpace; + p->endpoint.iOffset += iSpace; + } + p->nSize = iAmt + iOfst; + } + } + + return SQLITE_OK; +} + +/* +** Truncate the file. +** +** If the journal file is already on disk, truncate it there. Or, if it +** is still in main memory but is being truncated to zero bytes in size, +** ignore +*/ +static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){ + MemJournal *p = (MemJournal *)pJfd; + if( ALWAYS(size==0) ){ + memjrnlFreeChunks(p); + p->nSize = 0; + p->endpoint.pChunk = 0; + p->endpoint.iOffset = 0; + p->readpoint.pChunk = 0; + p->readpoint.iOffset = 0; + } + return SQLITE_OK; +} + +/* +** Close the file. +*/ +static int memjrnlClose(sqlite3_file *pJfd){ + MemJournal *p = (MemJournal *)pJfd; + memjrnlFreeChunks(p); + return SQLITE_OK; +} + +/* +** Sync the file. +** +** If the real file has been created, call its xSync method. Otherwise, +** syncing an in-memory journal is a no-op. +*/ +static int memjrnlSync(sqlite3_file *pJfd, int flags){ + UNUSED_PARAMETER2(pJfd, flags); + return SQLITE_OK; +} + +/* +** Query the size of the file in bytes. +*/ +static int memjrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){ + MemJournal *p = (MemJournal *)pJfd; + *pSize = (sqlite_int64) p->endpoint.iOffset; + return SQLITE_OK; +} + +/* +** Table of methods for MemJournal sqlite3_file object. +*/ +static const struct sqlite3_io_methods MemJournalMethods = { + 1, /* iVersion */ + memjrnlClose, /* xClose */ + memjrnlRead, /* xRead */ + memjrnlWrite, /* xWrite */ + memjrnlTruncate, /* xTruncate */ + memjrnlSync, /* xSync */ + memjrnlFileSize, /* xFileSize */ + 0, /* xLock */ + 0, /* xUnlock */ + 0, /* xCheckReservedLock */ + 0, /* xFileControl */ + 0, /* xSectorSize */ + 0, /* xDeviceCharacteristics */ + 0, /* xShmMap */ + 0, /* xShmLock */ + 0, /* xShmBarrier */ + 0, /* xShmUnmap */ + 0, /* xFetch */ + 0 /* xUnfetch */ +}; + +/* +** Open a journal file. +** +** The behaviour of the journal file depends on the value of parameter +** nSpill. If nSpill is 0, then the journal file is always create and +** accessed using the underlying VFS. If nSpill is less than zero, then +** all content is always stored in main-memory. Finally, if nSpill is a +** positive value, then the journal file is initially created in-memory +** but may be flushed to disk later on. In this case the journal file is +** flushed to disk either when it grows larger than nSpill bytes in size, +** or when sqlite3JournalCreate() is called. +*/ +SQLITE_PRIVATE int sqlite3JournalOpen( + sqlite3_vfs *pVfs, /* The VFS to use for actual file I/O */ + const char *zName, /* Name of the journal file */ + sqlite3_file *pJfd, /* Preallocated, blank file handle */ + int flags, /* Opening flags */ + int nSpill /* Bytes buffered before opening the file */ +){ + MemJournal *p = (MemJournal*)pJfd; + + /* Zero the file-handle object. If nSpill was passed zero, initialize + ** it using the sqlite3OsOpen() function of the underlying VFS. In this + ** case none of the code in this module is executed as a result of calls + ** made on the journal file-handle. */ + memset(p, 0, sizeof(MemJournal)); + if( nSpill==0 ){ + return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0); + } + + if( nSpill>0 ){ + p->nChunkSize = nSpill; + }else{ + p->nChunkSize = 8 + MEMJOURNAL_DFLT_FILECHUNKSIZE - sizeof(FileChunk); + assert( MEMJOURNAL_DFLT_FILECHUNKSIZE==fileChunkSize(p->nChunkSize) ); + } + + pJfd->pMethods = (const sqlite3_io_methods*)&MemJournalMethods; + p->nSpill = nSpill; + p->flags = flags; + p->zJournal = zName; + p->pVfs = pVfs; + return SQLITE_OK; +} + +/* +** Open an in-memory journal file. +*/ +SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *pJfd){ + sqlite3JournalOpen(0, 0, pJfd, 0, -1); +} + +#if defined(SQLITE_ENABLE_ATOMIC_WRITE) \ + || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE) +/* +** If the argument p points to a MemJournal structure that is not an +** in-memory-only journal file (i.e. is one that was opened with a +ve +** nSpill parameter or as SQLITE_OPEN_MAIN_JOURNAL), and the underlying +** file has not yet been created, create it now. +*/ +SQLITE_PRIVATE int sqlite3JournalCreate(sqlite3_file *pJfd){ + int rc = SQLITE_OK; + MemJournal *p = (MemJournal*)pJfd; + if( pJfd->pMethods==&MemJournalMethods && ( +#ifdef SQLITE_ENABLE_ATOMIC_WRITE + p->nSpill>0 +#else + /* While this appears to not be possible without ATOMIC_WRITE, the + ** paths are complex, so it seems prudent to leave the test in as + ** a NEVER(), in case our analysis is subtly flawed. */ + NEVER(p->nSpill>0) +#endif +#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE + || (p->flags & SQLITE_OPEN_MAIN_JOURNAL) +#endif + )){ + rc = memjrnlCreateFile(p); + } + return rc; +} +#endif + +/* +** The file-handle passed as the only argument is open on a journal file. +** Return true if this "journal file" is currently stored in heap memory, +** or false otherwise. +*/ +SQLITE_PRIVATE int sqlite3JournalIsInMemory(sqlite3_file *p){ + return p->pMethods==&MemJournalMethods; +} + +/* +** Return the number of bytes required to store a JournalFile that uses vfs +** pVfs to create the underlying on-disk files. +*/ +SQLITE_PRIVATE int sqlite3JournalSize(sqlite3_vfs *pVfs){ + return MAX(pVfs->szOsFile, (int)sizeof(MemJournal)); +} + +/************** End of memjournal.c ******************************************/ +/************** Begin file walker.c ******************************************/ +/* +** 2008 August 16 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains routines used for walking the parser tree for +** an SQL statement. +*/ +/* #include "sqliteInt.h" */ +/* #include */ +/* #include */ + + +#if !defined(SQLITE_OMIT_WINDOWFUNC) +/* +** Walk all expressions linked into the list of Window objects passed +** as the second argument. +*/ +static int walkWindowList(Walker *pWalker, Window *pList){ + Window *pWin; + for(pWin=pList; pWin; pWin=pWin->pNextWin){ + int rc; + rc = sqlite3WalkExprList(pWalker, pWin->pOrderBy); + if( rc ) return WRC_Abort; + rc = sqlite3WalkExprList(pWalker, pWin->pPartition); + if( rc ) return WRC_Abort; + rc = sqlite3WalkExpr(pWalker, pWin->pFilter); + if( rc ) return WRC_Abort; + + /* The next two are purely for calls to sqlite3RenameExprUnmap() + ** within sqlite3WindowOffsetExpr(). Because of constraints imposed + ** by sqlite3WindowOffsetExpr(), they can never fail. The results do + ** not matter anyhow. */ + rc = sqlite3WalkExpr(pWalker, pWin->pStart); + if( NEVER(rc) ) return WRC_Abort; + rc = sqlite3WalkExpr(pWalker, pWin->pEnd); + if( NEVER(rc) ) return WRC_Abort; + } + return WRC_Continue; +} +#endif + +/* +** Walk an expression tree. Invoke the callback once for each node +** of the expression, while descending. (In other words, the callback +** is invoked before visiting children.) +** +** The return value from the callback should be one of the WRC_* +** constants to specify how to proceed with the walk. +** +** WRC_Continue Continue descending down the tree. +** +** WRC_Prune Do not descend into child nodes, but allow +** the walk to continue with sibling nodes. +** +** WRC_Abort Do no more callbacks. Unwind the stack and +** return from the top-level walk call. +** +** The return value from this routine is WRC_Abort to abandon the tree walk +** and WRC_Continue to continue. +*/ +static SQLITE_NOINLINE int walkExpr(Walker *pWalker, Expr *pExpr){ + int rc; + testcase( ExprHasProperty(pExpr, EP_TokenOnly) ); + testcase( ExprHasProperty(pExpr, EP_Reduced) ); + while(1){ + rc = pWalker->xExprCallback(pWalker, pExpr); + if( rc ) return rc & WRC_Abort; + if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){ + assert( pExpr->x.pList==0 || pExpr->pRight==0 ); + if( pExpr->pLeft && walkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort; + if( pExpr->pRight ){ + assert( !ExprHasProperty(pExpr, EP_WinFunc) ); + pExpr = pExpr->pRight; + continue; + }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + assert( !ExprHasProperty(pExpr, EP_WinFunc) ); + if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort; + }else{ + if( pExpr->x.pList ){ + if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort; + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + if( walkWindowList(pWalker, pExpr->y.pWin) ) return WRC_Abort; + } +#endif + } + } + break; + } + return WRC_Continue; +} +SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){ + return pExpr ? walkExpr(pWalker,pExpr) : WRC_Continue; +} + +/* +** Call sqlite3WalkExpr() for every expression in list p or until +** an abort request is seen. +*/ +SQLITE_PRIVATE int sqlite3WalkExprList(Walker *pWalker, ExprList *p){ + int i; + struct ExprList_item *pItem; + if( p ){ + for(i=p->nExpr, pItem=p->a; i>0; i--, pItem++){ + if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort; + } + } + return WRC_Continue; +} + +/* +** Walk all expressions associated with SELECT statement p. Do +** not invoke the SELECT callback on p, but do (of course) invoke +** any expr callbacks and SELECT callbacks that come from subqueries. +** Return WRC_Abort or WRC_Continue. +*/ +SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker *pWalker, Select *p){ + if( sqlite3WalkExprList(pWalker, p->pEList) ) return WRC_Abort; + if( sqlite3WalkExpr(pWalker, p->pWhere) ) return WRC_Abort; + if( sqlite3WalkExprList(pWalker, p->pGroupBy) ) return WRC_Abort; + if( sqlite3WalkExpr(pWalker, p->pHaving) ) return WRC_Abort; + if( sqlite3WalkExprList(pWalker, p->pOrderBy) ) return WRC_Abort; + if( sqlite3WalkExpr(pWalker, p->pLimit) ) return WRC_Abort; +#if !defined(SQLITE_OMIT_WINDOWFUNC) && !defined(SQLITE_OMIT_ALTERTABLE) + { + Parse *pParse = pWalker->pParse; + if( pParse && IN_RENAME_OBJECT ){ + /* The following may return WRC_Abort if there are unresolvable + ** symbols (e.g. a table that does not exist) in a window definition. */ + int rc = walkWindowList(pWalker, p->pWinDefn); + return rc; + } + } +#endif + return WRC_Continue; +} + +/* +** Walk the parse trees associated with all subqueries in the +** FROM clause of SELECT statement p. Do not invoke the select +** callback on p, but do invoke it on each FROM clause subquery +** and on any subqueries further down in the tree. Return +** WRC_Abort or WRC_Continue; +*/ +SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker *pWalker, Select *p){ + SrcList *pSrc; + int i; + struct SrcList_item *pItem; + + pSrc = p->pSrc; + if( pSrc ){ + for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){ + if( pItem->pSelect && sqlite3WalkSelect(pWalker, pItem->pSelect) ){ + return WRC_Abort; + } + if( pItem->fg.isTabFunc + && sqlite3WalkExprList(pWalker, pItem->u1.pFuncArg) + ){ + return WRC_Abort; + } + } + } + return WRC_Continue; +} + +/* +** Call sqlite3WalkExpr() for every expression in Select statement p. +** Invoke sqlite3WalkSelect() for subqueries in the FROM clause and +** on the compound select chain, p->pPrior. +** +** If it is not NULL, the xSelectCallback() callback is invoked before +** the walk of the expressions and FROM clause. The xSelectCallback2() +** method is invoked following the walk of the expressions and FROM clause, +** but only if both xSelectCallback and xSelectCallback2 are both non-NULL +** and if the expressions and FROM clause both return WRC_Continue; +** +** Return WRC_Continue under normal conditions. Return WRC_Abort if +** there is an abort request. +** +** If the Walker does not have an xSelectCallback() then this routine +** is a no-op returning WRC_Continue. +*/ +SQLITE_PRIVATE int sqlite3WalkSelect(Walker *pWalker, Select *p){ + int rc; + if( p==0 ) return WRC_Continue; + if( pWalker->xSelectCallback==0 ) return WRC_Continue; + do{ + rc = pWalker->xSelectCallback(pWalker, p); + if( rc ) return rc & WRC_Abort; + if( sqlite3WalkSelectExpr(pWalker, p) + || sqlite3WalkSelectFrom(pWalker, p) + ){ + return WRC_Abort; + } + if( pWalker->xSelectCallback2 ){ + pWalker->xSelectCallback2(pWalker, p); + } + p = p->pPrior; + }while( p!=0 ); + return WRC_Continue; +} + +/* Increase the walkerDepth when entering a subquery, and +** descrease when leaving the subquery. +*/ +SQLITE_PRIVATE int sqlite3WalkerDepthIncrease(Walker *pWalker, Select *pSelect){ + UNUSED_PARAMETER(pSelect); + pWalker->walkerDepth++; + return WRC_Continue; +} +SQLITE_PRIVATE void sqlite3WalkerDepthDecrease(Walker *pWalker, Select *pSelect){ + UNUSED_PARAMETER(pSelect); + pWalker->walkerDepth--; +} + + +/* +** No-op routine for the parse-tree walker. +** +** When this routine is the Walker.xExprCallback then expression trees +** are walked without any actions being taken at each node. Presumably, +** when this routine is used for Walker.xExprCallback then +** Walker.xSelectCallback is set to do something useful for every +** subquery in the parser tree. +*/ +SQLITE_PRIVATE int sqlite3ExprWalkNoop(Walker *NotUsed, Expr *NotUsed2){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + return WRC_Continue; +} + +/* +** No-op routine for the parse-tree walker for SELECT statements. +** subquery in the parser tree. +*/ +SQLITE_PRIVATE int sqlite3SelectWalkNoop(Walker *NotUsed, Select *NotUsed2){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + return WRC_Continue; +} + +/************** End of walker.c **********************************************/ +/************** Begin file resolve.c *****************************************/ +/* +** 2008 August 18 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains routines used for walking the parser tree and +** resolve all identifiers by associating them with a particular +** table and column. +*/ +/* #include "sqliteInt.h" */ + +/* +** Magic table number to mean the EXCLUDED table in an UPSERT statement. +*/ +#define EXCLUDED_TABLE_NUMBER 2 + +/* +** Walk the expression tree pExpr and increase the aggregate function +** depth (the Expr.op2 field) by N on every TK_AGG_FUNCTION node. +** This needs to occur when copying a TK_AGG_FUNCTION node from an +** outer query into an inner subquery. +** +** incrAggFunctionDepth(pExpr,n) is the main routine. incrAggDepth(..) +** is a helper function - a callback for the tree walker. +** +** See also the sqlite3WindowExtraAggFuncDepth() routine in window.c +*/ +static int incrAggDepth(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n; + return WRC_Continue; +} +static void incrAggFunctionDepth(Expr *pExpr, int N){ + if( N>0 ){ + Walker w; + memset(&w, 0, sizeof(w)); + w.xExprCallback = incrAggDepth; + w.u.n = N; + sqlite3WalkExpr(&w, pExpr); + } +} + +/* +** Turn the pExpr expression into an alias for the iCol-th column of the +** result set in pEList. +** +** If the reference is followed by a COLLATE operator, then make sure +** the COLLATE operator is preserved. For example: +** +** SELECT a+b, c+d FROM t1 ORDER BY 1 COLLATE nocase; +** +** Should be transformed into: +** +** SELECT a+b, c+d FROM t1 ORDER BY (a+b) COLLATE nocase; +** +** The nSubquery parameter specifies how many levels of subquery the +** alias is removed from the original expression. The usual value is +** zero but it might be more if the alias is contained within a subquery +** of the original expression. The Expr.op2 field of TK_AGG_FUNCTION +** structures must be increased by the nSubquery amount. +*/ +static void resolveAlias( + Parse *pParse, /* Parsing context */ + ExprList *pEList, /* A result set */ + int iCol, /* A column in the result set. 0..pEList->nExpr-1 */ + Expr *pExpr, /* Transform this into an alias to the result set */ + const char *zType, /* "GROUP" or "ORDER" or "" */ + int nSubquery /* Number of subqueries that the label is moving */ +){ + Expr *pOrig; /* The iCol-th column of the result set */ + Expr *pDup; /* Copy of pOrig */ + sqlite3 *db; /* The database connection */ + + assert( iCol>=0 && iColnExpr ); + pOrig = pEList->a[iCol].pExpr; + assert( pOrig!=0 ); + db = pParse->db; + pDup = sqlite3ExprDup(db, pOrig, 0); + if( pDup!=0 ){ + if( zType[0]!='G' ) incrAggFunctionDepth(pDup, nSubquery); + if( pExpr->op==TK_COLLATE ){ + pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken); + } + + /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This + ** prevents ExprDelete() from deleting the Expr structure itself, + ** allowing it to be repopulated by the memcpy() on the following line. + ** The pExpr->u.zToken might point into memory that will be freed by the + ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to + ** make a copy of the token before doing the sqlite3DbFree(). + */ + ExprSetProperty(pExpr, EP_Static); + sqlite3ExprDelete(db, pExpr); + memcpy(pExpr, pDup, sizeof(*pExpr)); + if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){ + assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 ); + pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken); + pExpr->flags |= EP_MemToken; + } + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + if( pExpr->y.pWin!=0 ){ + pExpr->y.pWin->pOwner = pExpr; + }else{ + assert( db->mallocFailed ); + } + } + sqlite3DbFree(db, pDup); + } + ExprSetProperty(pExpr, EP_Alias); +} + + +/* +** Return TRUE if the name zCol occurs anywhere in the USING clause. +** +** Return FALSE if the USING clause is NULL or if it does not contain +** zCol. +*/ +static int nameInUsingClause(IdList *pUsing, const char *zCol){ + if( pUsing ){ + int k; + for(k=0; knId; k++){ + if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1; + } + } + return 0; +} + +/* +** Subqueries stores the original database, table and column names for their +** result sets in ExprList.a[].zSpan, in the form "DATABASE.TABLE.COLUMN". +** Check to see if the zSpan given to this routine matches the zDb, zTab, +** and zCol. If any of zDb, zTab, and zCol are NULL then those fields will +** match anything. +*/ +SQLITE_PRIVATE int sqlite3MatchEName( + const struct ExprList_item *pItem, + const char *zCol, + const char *zTab, + const char *zDb +){ + int n; + const char *zSpan; + if( pItem->eEName!=ENAME_TAB ) return 0; + zSpan = pItem->zEName; + for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){} + if( zDb && (sqlite3StrNICmp(zSpan, zDb, n)!=0 || zDb[n]!=0) ){ + return 0; + } + zSpan += n+1; + for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){} + if( zTab && (sqlite3StrNICmp(zSpan, zTab, n)!=0 || zTab[n]!=0) ){ + return 0; + } + zSpan += n+1; + if( zCol && sqlite3StrICmp(zSpan, zCol)!=0 ){ + return 0; + } + return 1; +} + +/* +** Return TRUE if the double-quoted string mis-feature should be supported. +*/ +static int areDoubleQuotedStringsEnabled(sqlite3 *db, NameContext *pTopNC){ + if( db->init.busy ) return 1; /* Always support for legacy schemas */ + if( pTopNC->ncFlags & NC_IsDDL ){ + /* Currently parsing a DDL statement */ + if( sqlite3WritableSchema(db) && (db->flags & SQLITE_DqsDML)!=0 ){ + return 1; + } + return (db->flags & SQLITE_DqsDDL)!=0; + }else{ + /* Currently parsing a DML statement */ + return (db->flags & SQLITE_DqsDML)!=0; + } +} + +/* +** The argument is guaranteed to be a non-NULL Expr node of type TK_COLUMN. +** return the appropriate colUsed mask. +*/ +SQLITE_PRIVATE Bitmask sqlite3ExprColUsed(Expr *pExpr){ + int n; + Table *pExTab; + + n = pExpr->iColumn; + pExTab = pExpr->y.pTab; + assert( pExTab!=0 ); + if( (pExTab->tabFlags & TF_HasGenerated)!=0 + && (pExTab->aCol[n].colFlags & COLFLAG_GENERATED)!=0 + ){ + testcase( pExTab->nCol==BMS-1 ); + testcase( pExTab->nCol==BMS ); + return pExTab->nCol>=BMS ? ALLBITS : MASKBIT(pExTab->nCol)-1; + }else{ + testcase( n==BMS-1 ); + testcase( n==BMS ); + if( n>=BMS ) n = BMS-1; + return ((Bitmask)1)<iDb Set the index in db->aDb[] of the database X +** (even if X is implied). +** pExpr->iTable Set to the cursor number for the table obtained +** from pSrcList. +** pExpr->y.pTab Points to the Table structure of X.Y (even if +** X and/or Y are implied.) +** pExpr->iColumn Set to the column number within the table. +** pExpr->op Set to TK_COLUMN. +** pExpr->pLeft Any expression this points to is deleted +** pExpr->pRight Any expression this points to is deleted. +** +** The zDb variable is the name of the database (the "X"). This value may be +** NULL meaning that name is of the form Y.Z or Z. Any available database +** can be used. The zTable variable is the name of the table (the "Y"). This +** value can be NULL if zDb is also NULL. If zTable is NULL it +** means that the form of the name is Z and that columns from any table +** can be used. +** +** If the name cannot be resolved unambiguously, leave an error message +** in pParse and return WRC_Abort. Return WRC_Prune on success. +*/ +static int lookupName( + Parse *pParse, /* The parsing context */ + const char *zDb, /* Name of the database containing table, or NULL */ + const char *zTab, /* Name of table containing column, or NULL */ + const char *zCol, /* Name of the column. */ + NameContext *pNC, /* The name context used to resolve the name */ + Expr *pExpr /* Make this EXPR node point to the selected column */ +){ + int i, j; /* Loop counters */ + int cnt = 0; /* Number of matching column names */ + int cntTab = 0; /* Number of matching table names */ + int nSubquery = 0; /* How many levels of subquery */ + sqlite3 *db = pParse->db; /* The database connection */ + struct SrcList_item *pItem; /* Use for looping over pSrcList items */ + struct SrcList_item *pMatch = 0; /* The matching pSrcList item */ + NameContext *pTopNC = pNC; /* First namecontext in the list */ + Schema *pSchema = 0; /* Schema of the expression */ + int eNewExprOp = TK_COLUMN; /* New value for pExpr->op on success */ + Table *pTab = 0; /* Table hold the row */ + Column *pCol; /* A column of pTab */ + + assert( pNC ); /* the name context cannot be NULL. */ + assert( zCol ); /* The Z in X.Y.Z cannot be NULL */ + assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); + + /* Initialize the node to no-match */ + pExpr->iTable = -1; + ExprSetVVAProperty(pExpr, EP_NoReduce); + + /* Translate the schema name in zDb into a pointer to the corresponding + ** schema. If not found, pSchema will remain NULL and nothing will match + ** resulting in an appropriate error message toward the end of this routine + */ + if( zDb ){ + testcase( pNC->ncFlags & NC_PartIdx ); + testcase( pNC->ncFlags & NC_IsCheck ); + if( (pNC->ncFlags & (NC_PartIdx|NC_IsCheck))!=0 ){ + /* Silently ignore database qualifiers inside CHECK constraints and + ** partial indices. Do not raise errors because that might break + ** legacy and because it does not hurt anything to just ignore the + ** database name. */ + zDb = 0; + }else{ + for(i=0; inDb; i++){ + assert( db->aDb[i].zDbSName ); + if( sqlite3StrICmp(db->aDb[i].zDbSName,zDb)==0 ){ + pSchema = db->aDb[i].pSchema; + break; + } + } + if( i==db->nDb && sqlite3StrICmp("main", zDb)==0 ){ + /* This branch is taken when the main database has been renamed + ** using SQLITE_DBCONFIG_MAINDBNAME. */ + pSchema = db->aDb[0].pSchema; + zDb = db->aDb[0].zDbSName; + } + } + } + + /* Start at the inner-most context and move outward until a match is found */ + assert( pNC && cnt==0 ); + do{ + ExprList *pEList; + SrcList *pSrcList = pNC->pSrcList; + + if( pSrcList ){ + for(i=0, pItem=pSrcList->a; inSrc; i++, pItem++){ + u8 hCol; + pTab = pItem->pTab; + assert( pTab!=0 && pTab->zName!=0 ); + assert( pTab->nCol>0 ); + if( pItem->pSelect && (pItem->pSelect->selFlags & SF_NestedFrom)!=0 ){ + int hit = 0; + pEList = pItem->pSelect->pEList; + for(j=0; jnExpr; j++){ + if( sqlite3MatchEName(&pEList->a[j], zCol, zTab, zDb) ){ + cnt++; + cntTab = 2; + pMatch = pItem; + pExpr->iColumn = j; + hit = 1; + } + } + if( hit || zTab==0 ) continue; + } + if( zDb && pTab->pSchema!=pSchema ){ + continue; + } + if( zTab ){ + const char *zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName; + assert( zTabName!=0 ); + if( sqlite3StrICmp(zTabName, zTab)!=0 ){ + continue; + } + if( IN_RENAME_OBJECT && pItem->zAlias ){ + sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab); + } + } + if( 0==(cntTab++) ){ + pMatch = pItem; + } + hCol = sqlite3StrIHash(zCol); + for(j=0, pCol=pTab->aCol; jnCol; j++, pCol++){ + if( pCol->hName==hCol && sqlite3StrICmp(pCol->zName, zCol)==0 ){ + /* If there has been exactly one prior match and this match + ** is for the right-hand table of a NATURAL JOIN or is in a + ** USING clause, then skip this match. + */ + if( cnt==1 ){ + if( pItem->fg.jointype & JT_NATURAL ) continue; + if( nameInUsingClause(pItem->pUsing, zCol) ) continue; + } + cnt++; + pMatch = pItem; + /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */ + pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j; + break; + } + } + } + if( pMatch ){ + pExpr->iTable = pMatch->iCursor; + pExpr->y.pTab = pMatch->pTab; + /* RIGHT JOIN not (yet) supported */ + assert( (pMatch->fg.jointype & JT_RIGHT)==0 ); + if( (pMatch->fg.jointype & JT_LEFT)!=0 ){ + ExprSetProperty(pExpr, EP_CanBeNull); + } + pSchema = pExpr->y.pTab->pSchema; + } + } /* if( pSrcList ) */ + +#if !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) + /* If we have not already resolved the name, then maybe + ** it is a new.* or old.* trigger argument reference. Or + ** maybe it is an excluded.* from an upsert. + */ + if( zDb==0 && zTab!=0 && cntTab==0 ){ + pTab = 0; +#ifndef SQLITE_OMIT_TRIGGER + if( pParse->pTriggerTab!=0 ){ + int op = pParse->eTriggerOp; + assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT ); + if( op!=TK_DELETE && sqlite3StrICmp("new",zTab) == 0 ){ + pExpr->iTable = 1; + pTab = pParse->pTriggerTab; + }else if( op!=TK_INSERT && sqlite3StrICmp("old",zTab)==0 ){ + pExpr->iTable = 0; + pTab = pParse->pTriggerTab; + } + } +#endif /* SQLITE_OMIT_TRIGGER */ +#ifndef SQLITE_OMIT_UPSERT + if( (pNC->ncFlags & NC_UUpsert)!=0 ){ + Upsert *pUpsert = pNC->uNC.pUpsert; + if( pUpsert && sqlite3StrICmp("excluded",zTab)==0 ){ + pTab = pUpsert->pUpsertSrc->a[0].pTab; + pExpr->iTable = EXCLUDED_TABLE_NUMBER; + } + } +#endif /* SQLITE_OMIT_UPSERT */ + + if( pTab ){ + int iCol; + u8 hCol = sqlite3StrIHash(zCol); + pSchema = pTab->pSchema; + cntTab++; + for(iCol=0, pCol=pTab->aCol; iColnCol; iCol++, pCol++){ + if( pCol->hName==hCol && sqlite3StrICmp(pCol->zName, zCol)==0 ){ + if( iCol==pTab->iPKey ){ + iCol = -1; + } + break; + } + } + if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){ + /* IMP: R-51414-32910 */ + iCol = -1; + } + if( iColnCol ){ + cnt++; +#ifndef SQLITE_OMIT_UPSERT + if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){ + testcase( iCol==(-1) ); + if( IN_RENAME_OBJECT ){ + pExpr->iColumn = iCol; + pExpr->y.pTab = pTab; + eNewExprOp = TK_COLUMN; + }else{ + pExpr->iTable = pNC->uNC.pUpsert->regData + + sqlite3TableColumnToStorage(pTab, iCol); + eNewExprOp = TK_REGISTER; + ExprSetProperty(pExpr, EP_Alias); + } + }else +#endif /* SQLITE_OMIT_UPSERT */ + { +#ifndef SQLITE_OMIT_TRIGGER + if( iCol<0 ){ + pExpr->affExpr = SQLITE_AFF_INTEGER; + }else if( pExpr->iTable==0 ){ + testcase( iCol==31 ); + testcase( iCol==32 ); + pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<y.pTab = pTab; + pExpr->iColumn = (i16)iCol; + eNewExprOp = TK_TRIGGER; +#endif /* SQLITE_OMIT_TRIGGER */ + } + } + } + } +#endif /* !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) */ + + /* + ** Perhaps the name is a reference to the ROWID + */ + if( cnt==0 + && cntTab==1 + && pMatch + && (pNC->ncFlags & (NC_IdxExpr|NC_GenCol))==0 + && sqlite3IsRowid(zCol) + && VisibleRowid(pMatch->pTab) + ){ + cnt = 1; + pExpr->iColumn = -1; + pExpr->affExpr = SQLITE_AFF_INTEGER; + } + + /* + ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z + ** might refer to an result-set alias. This happens, for example, when + ** we are resolving names in the WHERE clause of the following command: + ** + ** SELECT a+b AS x FROM table WHERE x<10; + ** + ** In cases like this, replace pExpr with a copy of the expression that + ** forms the result set entry ("a+b" in the example) and return immediately. + ** Note that the expression in the result set should have already been + ** resolved by the time the WHERE clause is resolved. + ** + ** The ability to use an output result-set column in the WHERE, GROUP BY, + ** or HAVING clauses, or as part of a larger expression in the ORDER BY + ** clause is not standard SQL. This is a (goofy) SQLite extension, that + ** is supported for backwards compatibility only. Hence, we issue a warning + ** on sqlite3_log() whenever the capability is used. + */ + if( (pNC->ncFlags & NC_UEList)!=0 + && cnt==0 + && zTab==0 + ){ + pEList = pNC->uNC.pEList; + assert( pEList!=0 ); + for(j=0; jnExpr; j++){ + char *zAs = pEList->a[j].zEName; + if( pEList->a[j].eEName==ENAME_NAME + && sqlite3_stricmp(zAs, zCol)==0 + ){ + Expr *pOrig; + assert( pExpr->pLeft==0 && pExpr->pRight==0 ); + assert( pExpr->x.pList==0 ); + assert( pExpr->x.pSelect==0 ); + pOrig = pEList->a[j].pExpr; + if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){ + sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs); + return WRC_Abort; + } + if( ExprHasProperty(pOrig, EP_Win) + && ((pNC->ncFlags&NC_AllowWin)==0 || pNC!=pTopNC ) + ){ + sqlite3ErrorMsg(pParse, "misuse of aliased window function %s",zAs); + return WRC_Abort; + } + if( sqlite3ExprVectorSize(pOrig)!=1 ){ + sqlite3ErrorMsg(pParse, "row value misused"); + return WRC_Abort; + } + resolveAlias(pParse, pEList, j, pExpr, "", nSubquery); + cnt = 1; + pMatch = 0; + assert( zTab==0 && zDb==0 ); + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr); + } + goto lookupname_end; + } + } + } + + /* Advance to the next name context. The loop will exit when either + ** we have a match (cnt>0) or when we run out of name contexts. + */ + if( cnt ) break; + pNC = pNC->pNext; + nSubquery++; + }while( pNC ); + + + /* + ** If X and Y are NULL (in other words if only the column name Z is + ** supplied) and the value of Z is enclosed in double-quotes, then + ** Z is a string literal if it doesn't match any column names. In that + ** case, we need to return right away and not make any changes to + ** pExpr. + ** + ** Because no reference was made to outer contexts, the pNC->nRef + ** fields are not changed in any context. + */ + if( cnt==0 && zTab==0 ){ + assert( pExpr->op==TK_ID ); + if( ExprHasProperty(pExpr,EP_DblQuoted) + && areDoubleQuotedStringsEnabled(db, pTopNC) + ){ + /* If a double-quoted identifier does not match any known column name, + ** then treat it as a string. + ** + ** This hack was added in the early days of SQLite in a misguided attempt + ** to be compatible with MySQL 3.x, which used double-quotes for strings. + ** I now sorely regret putting in this hack. The effect of this hack is + ** that misspelled identifier names are silently converted into strings + ** rather than causing an error, to the frustration of countless + ** programmers. To all those frustrated programmers, my apologies. + ** + ** Someday, I hope to get rid of this hack. Unfortunately there is + ** a huge amount of legacy SQL that uses it. So for now, we just + ** issue a warning. + */ + sqlite3_log(SQLITE_WARNING, + "double-quoted string literal: \"%w\"", zCol); +#ifdef SQLITE_ENABLE_NORMALIZE + sqlite3VdbeAddDblquoteStr(db, pParse->pVdbe, zCol); +#endif + pExpr->op = TK_STRING; + pExpr->y.pTab = 0; + return WRC_Prune; + } + if( sqlite3ExprIdToTrueFalse(pExpr) ){ + return WRC_Prune; + } + } + + /* + ** cnt==0 means there was not match. cnt>1 means there were two or + ** more matches. Either way, we have an error. + */ + if( cnt!=1 ){ + const char *zErr; + zErr = cnt==0 ? "no such column" : "ambiguous column name"; + if( zDb ){ + sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol); + }else if( zTab ){ + sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol); + }else{ + sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol); + } + pParse->checkSchema = 1; + pTopNC->nErr++; + } + + /* If a column from a table in pSrcList is referenced, then record + ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes + ** bit 0 to be set. Column 1 sets bit 1. And so forth. Bit 63 is + ** set if the 63rd or any subsequent column is used. + ** + ** The colUsed mask is an optimization used to help determine if an + ** index is a covering index. The correct answer is still obtained + ** if the mask contains extra set bits. However, it is important to + ** avoid setting bits beyond the maximum column number of the table. + ** (See ticket [b92e5e8ec2cdbaa1]). + ** + ** If a generated column is referenced, set bits for every column + ** of the table. + */ + if( pExpr->iColumn>=0 && pMatch!=0 ){ + pMatch->colUsed |= sqlite3ExprColUsed(pExpr); + } + + /* Clean up and return + */ + sqlite3ExprDelete(db, pExpr->pLeft); + pExpr->pLeft = 0; + sqlite3ExprDelete(db, pExpr->pRight); + pExpr->pRight = 0; + pExpr->op = eNewExprOp; + ExprSetProperty(pExpr, EP_Leaf); +lookupname_end: + if( cnt==1 ){ + assert( pNC!=0 ); + if( !ExprHasProperty(pExpr, EP_Alias) ){ + sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList); + } + /* Increment the nRef value on all name contexts from TopNC up to + ** the point where the name matched. */ + for(;;){ + assert( pTopNC!=0 ); + pTopNC->nRef++; + if( pTopNC==pNC ) break; + pTopNC = pTopNC->pNext; + } + return WRC_Prune; + } else { + return WRC_Abort; + } +} + +/* +** Allocate and return a pointer to an expression to load the column iCol +** from datasource iSrc in SrcList pSrc. +*/ +SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){ + Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0); + if( p ){ + struct SrcList_item *pItem = &pSrc->a[iSrc]; + Table *pTab = p->y.pTab = pItem->pTab; + p->iTable = pItem->iCursor; + if( p->y.pTab->iPKey==iCol ){ + p->iColumn = -1; + }else{ + p->iColumn = (ynVar)iCol; + if( (pTab->tabFlags & TF_HasGenerated)!=0 + && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0 + ){ + testcase( pTab->nCol==63 ); + testcase( pTab->nCol==64 ); + pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1; + }else{ + testcase( iCol==BMS ); + testcase( iCol==BMS-1 ); + pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol); + } + } + } + return p; +} + +/* +** Report an error that an expression is not valid for some set of +** pNC->ncFlags values determined by validMask. +** +** static void notValid( +** Parse *pParse, // Leave error message here +** NameContext *pNC, // The name context +** const char *zMsg, // Type of error +** int validMask, // Set of contexts for which prohibited +** Expr *pExpr // Invalidate this expression on error +** ){...} +** +** As an optimization, since the conditional is almost always false +** (because errors are rare), the conditional is moved outside of the +** function call using a macro. +*/ +static void notValidImpl( + Parse *pParse, /* Leave error message here */ + NameContext *pNC, /* The name context */ + const char *zMsg, /* Type of error */ + Expr *pExpr /* Invalidate this expression on error */ +){ + const char *zIn = "partial index WHERE clauses"; + if( pNC->ncFlags & NC_IdxExpr ) zIn = "index expressions"; +#ifndef SQLITE_OMIT_CHECK + else if( pNC->ncFlags & NC_IsCheck ) zIn = "CHECK constraints"; +#endif +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + else if( pNC->ncFlags & NC_GenCol ) zIn = "generated columns"; +#endif + sqlite3ErrorMsg(pParse, "%s prohibited in %s", zMsg, zIn); + if( pExpr ) pExpr->op = TK_NULL; +} +#define sqlite3ResolveNotValid(P,N,M,X,E) \ + assert( ((X)&~(NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol))==0 ); \ + if( ((N)->ncFlags & (X))!=0 ) notValidImpl(P,N,M,E); + +/* +** Expression p should encode a floating point value between 1.0 and 0.0. +** Return 1024 times this value. Or return -1 if p is not a floating point +** value between 1.0 and 0.0. +*/ +static int exprProbability(Expr *p){ + double r = -1.0; + if( p->op!=TK_FLOAT ) return -1; + sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8); + assert( r>=0.0 ); + if( r>1.0 ) return -1; + return (int)(r*134217728.0); +} + +/* +** This routine is callback for sqlite3WalkExpr(). +** +** Resolve symbolic names into TK_COLUMN operators for the current +** node in the expression tree. Return 0 to continue the search down +** the tree or 2 to abort the tree walk. +** +** This routine also does error checking and name resolution for +** function names. The operator for aggregate functions is changed +** to TK_AGG_FUNCTION. +*/ +static int resolveExprStep(Walker *pWalker, Expr *pExpr){ + NameContext *pNC; + Parse *pParse; + + pNC = pWalker->u.pNC; + assert( pNC!=0 ); + pParse = pNC->pParse; + assert( pParse==pWalker->pParse ); + +#ifndef NDEBUG + if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){ + SrcList *pSrcList = pNC->pSrcList; + int i; + for(i=0; ipSrcList->nSrc; i++){ + assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursornTab); + } + } +#endif + switch( pExpr->op ){ + + /* The special operator TK_ROW means use the rowid for the first + ** column in the FROM clause. This is used by the LIMIT and ORDER BY + ** clause processing on UPDATE and DELETE statements, and by + ** UPDATE ... FROM statement processing. + */ + case TK_ROW: { + SrcList *pSrcList = pNC->pSrcList; + struct SrcList_item *pItem; + assert( pSrcList && pSrcList->nSrc>=1 ); + pItem = pSrcList->a; + pExpr->op = TK_COLUMN; + pExpr->y.pTab = pItem->pTab; + pExpr->iTable = pItem->iCursor; + pExpr->iColumn--; + pExpr->affExpr = SQLITE_AFF_INTEGER; + break; + } + + /* A column name: ID + ** Or table name and column name: ID.ID + ** Or a database, table and column: ID.ID.ID + ** + ** The TK_ID and TK_OUT cases are combined so that there will only + ** be one call to lookupName(). Then the compiler will in-line + ** lookupName() for a size reduction and performance increase. + */ + case TK_ID: + case TK_DOT: { + const char *zColumn; + const char *zTable; + const char *zDb; + Expr *pRight; + + if( pExpr->op==TK_ID ){ + zDb = 0; + zTable = 0; + zColumn = pExpr->u.zToken; + }else{ + Expr *pLeft = pExpr->pLeft; + testcase( pNC->ncFlags & NC_IdxExpr ); + testcase( pNC->ncFlags & NC_GenCol ); + sqlite3ResolveNotValid(pParse, pNC, "the \".\" operator", + NC_IdxExpr|NC_GenCol, 0); + pRight = pExpr->pRight; + if( pRight->op==TK_ID ){ + zDb = 0; + }else{ + assert( pRight->op==TK_DOT ); + zDb = pLeft->u.zToken; + pLeft = pRight->pLeft; + pRight = pRight->pRight; + } + zTable = pLeft->u.zToken; + zColumn = pRight->u.zToken; + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight); + sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft); + } + } + return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr); + } + + /* Resolve function names + */ + case TK_FUNCTION: { + ExprList *pList = pExpr->x.pList; /* The argument list */ + int n = pList ? pList->nExpr : 0; /* Number of arguments */ + int no_such_func = 0; /* True if no such function exists */ + int wrong_num_args = 0; /* True if wrong number of arguments */ + int is_agg = 0; /* True if is an aggregate function */ + int nId; /* Number of characters in function name */ + const char *zId; /* The function name. */ + FuncDef *pDef; /* Information about the function */ + u8 enc = ENC(pParse->db); /* The database encoding */ + int savedAllowFlags = (pNC->ncFlags & (NC_AllowAgg | NC_AllowWin)); +#ifndef SQLITE_OMIT_WINDOWFUNC + Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0); +#endif + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + zId = pExpr->u.zToken; + nId = sqlite3Strlen30(zId); + pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0); + if( pDef==0 ){ + pDef = sqlite3FindFunction(pParse->db, zId, -2, enc, 0); + if( pDef==0 ){ + no_such_func = 1; + }else{ + wrong_num_args = 1; + } + }else{ + is_agg = pDef->xFinalize!=0; + if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){ + ExprSetProperty(pExpr, EP_Unlikely); + if( n==2 ){ + pExpr->iTable = exprProbability(pList->a[1].pExpr); + if( pExpr->iTable<0 ){ + sqlite3ErrorMsg(pParse, + "second argument to likelihood() must be a " + "constant between 0.0 and 1.0"); + pNC->nErr++; + } + }else{ + /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is + ** equivalent to likelihood(X, 0.0625). + ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is + ** short-hand for likelihood(X,0.0625). + ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand + ** for likelihood(X,0.9375). + ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent + ** to likelihood(X,0.9375). */ + /* TUNING: unlikely() probability is 0.0625. likely() is 0.9375 */ + pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120; + } + } +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0); + if( auth!=SQLITE_OK ){ + if( auth==SQLITE_DENY ){ + sqlite3ErrorMsg(pParse, "not authorized to use function: %s", + pDef->zName); + pNC->nErr++; + } + pExpr->op = TK_NULL; + return WRC_Prune; + } + } +#endif + if( pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG) ){ + /* For the purposes of the EP_ConstFunc flag, date and time + ** functions and other functions that change slowly are considered + ** constant because they are constant for the duration of one query. + ** This allows them to be factored out of inner loops. */ + ExprSetProperty(pExpr,EP_ConstFunc); + } + if( (pDef->funcFlags & SQLITE_FUNC_CONSTANT)==0 ){ + /* Clearly non-deterministic functions like random(), but also + ** date/time functions that use 'now', and other functions like + ** sqlite_version() that might change over time cannot be used + ** in an index or generated column. Curiously, they can be used + ** in a CHECK constraint. SQLServer, MySQL, and PostgreSQL all + ** all this. */ + sqlite3ResolveNotValid(pParse, pNC, "non-deterministic functions", + NC_IdxExpr|NC_PartIdx|NC_GenCol, 0); + }else{ + assert( (NC_SelfRef & 0xff)==NC_SelfRef ); /* Must fit in 8 bits */ + pExpr->op2 = pNC->ncFlags & NC_SelfRef; + if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL); + } + if( (pDef->funcFlags & SQLITE_FUNC_INTERNAL)!=0 + && pParse->nested==0 + && (pParse->db->mDbFlags & DBFLAG_InternalFunc)==0 + ){ + /* Internal-use-only functions are disallowed unless the + ** SQL is being compiled using sqlite3NestedParse() or + ** the SQLITE_TESTCTRL_INTERNAL_FUNCTIONS test-control has be + ** used to activate internal functionsn for testing purposes */ + no_such_func = 1; + pDef = 0; + }else + if( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0 + && !IN_RENAME_OBJECT + ){ + sqlite3ExprFunctionUsable(pParse, pExpr, pDef); + } + } + + if( 0==IN_RENAME_OBJECT ){ +#ifndef SQLITE_OMIT_WINDOWFUNC + assert( is_agg==0 || (pDef->funcFlags & SQLITE_FUNC_MINMAX) + || (pDef->xValue==0 && pDef->xInverse==0) + || (pDef->xValue && pDef->xInverse && pDef->xSFunc && pDef->xFinalize) + ); + if( pDef && pDef->xValue==0 && pWin ){ + sqlite3ErrorMsg(pParse, + "%.*s() may not be used as a window function", nId, zId + ); + pNC->nErr++; + }else if( + (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) + || (is_agg && (pDef->funcFlags&SQLITE_FUNC_WINDOW) && !pWin) + || (is_agg && pWin && (pNC->ncFlags & NC_AllowWin)==0) + ){ + const char *zType; + if( (pDef->funcFlags & SQLITE_FUNC_WINDOW) || pWin ){ + zType = "window"; + }else{ + zType = "aggregate"; + } + sqlite3ErrorMsg(pParse, "misuse of %s function %.*s()",zType,nId,zId); + pNC->nErr++; + is_agg = 0; + } +#else + if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) ){ + sqlite3ErrorMsg(pParse,"misuse of aggregate function %.*s()",nId,zId); + pNC->nErr++; + is_agg = 0; + } +#endif + else if( no_such_func && pParse->db->init.busy==0 +#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION + && pParse->explain==0 +#endif + ){ + sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId); + pNC->nErr++; + }else if( wrong_num_args ){ + sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()", + nId, zId); + pNC->nErr++; + } +#ifndef SQLITE_OMIT_WINDOWFUNC + else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){ + sqlite3ErrorMsg(pParse, + "FILTER may not be used with non-aggregate %.*s()", + nId, zId + ); + pNC->nErr++; + } +#endif + if( is_agg ){ + /* Window functions may not be arguments of aggregate functions. + ** Or arguments of other window functions. But aggregate functions + ** may be arguments for window functions. */ +#ifndef SQLITE_OMIT_WINDOWFUNC + pNC->ncFlags &= ~(NC_AllowWin | (!pWin ? NC_AllowAgg : 0)); +#else + pNC->ncFlags &= ~NC_AllowAgg; +#endif + } + } +#ifndef SQLITE_OMIT_WINDOWFUNC + else if( ExprHasProperty(pExpr, EP_WinFunc) ){ + is_agg = 1; + } +#endif + sqlite3WalkExprList(pWalker, pList); + if( is_agg ){ +#ifndef SQLITE_OMIT_WINDOWFUNC + if( pWin ){ + Select *pSel = pNC->pWinSelect; + assert( pWin==pExpr->y.pWin ); + if( IN_RENAME_OBJECT==0 ){ + sqlite3WindowUpdate(pParse, pSel ? pSel->pWinDefn : 0, pWin, pDef); + } + sqlite3WalkExprList(pWalker, pWin->pPartition); + sqlite3WalkExprList(pWalker, pWin->pOrderBy); + sqlite3WalkExpr(pWalker, pWin->pFilter); + sqlite3WindowLink(pSel, pWin); + pNC->ncFlags |= NC_HasWin; + }else +#endif /* SQLITE_OMIT_WINDOWFUNC */ + { + NameContext *pNC2 = pNC; + pExpr->op = TK_AGG_FUNCTION; + pExpr->op2 = 0; +#ifndef SQLITE_OMIT_WINDOWFUNC + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter); + } +#endif + while( pNC2 && !sqlite3FunctionUsesThisSrc(pExpr, pNC2->pSrcList) ){ + pExpr->op2++; + pNC2 = pNC2->pNext; + } + assert( pDef!=0 || IN_RENAME_OBJECT ); + if( pNC2 && pDef ){ + assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg ); + testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 ); + pNC2->ncFlags |= NC_HasAgg | (pDef->funcFlags & SQLITE_FUNC_MINMAX); + + } + } + pNC->ncFlags |= savedAllowFlags; + } + /* FIX ME: Compute pExpr->affinity based on the expected return + ** type of the function + */ + return WRC_Prune; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_SELECT: + case TK_EXISTS: testcase( pExpr->op==TK_EXISTS ); +#endif + case TK_IN: { + testcase( pExpr->op==TK_IN ); + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + int nRef = pNC->nRef; + testcase( pNC->ncFlags & NC_IsCheck ); + testcase( pNC->ncFlags & NC_PartIdx ); + testcase( pNC->ncFlags & NC_IdxExpr ); + testcase( pNC->ncFlags & NC_GenCol ); + sqlite3ResolveNotValid(pParse, pNC, "subqueries", + NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr); + sqlite3WalkSelect(pWalker, pExpr->x.pSelect); + assert( pNC->nRef>=nRef ); + if( nRef!=pNC->nRef ){ + ExprSetProperty(pExpr, EP_VarSelect); + pNC->ncFlags |= NC_VarSelect; + } + } + break; + } + case TK_VARIABLE: { + testcase( pNC->ncFlags & NC_IsCheck ); + testcase( pNC->ncFlags & NC_PartIdx ); + testcase( pNC->ncFlags & NC_IdxExpr ); + testcase( pNC->ncFlags & NC_GenCol ); + sqlite3ResolveNotValid(pParse, pNC, "parameters", + NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr); + break; + } + case TK_IS: + case TK_ISNOT: { + Expr *pRight = sqlite3ExprSkipCollateAndLikely(pExpr->pRight); + assert( !ExprHasProperty(pExpr, EP_Reduced) ); + /* Handle special cases of "x IS TRUE", "x IS FALSE", "x IS NOT TRUE", + ** and "x IS NOT FALSE". */ + if( pRight && (pRight->op==TK_ID || pRight->op==TK_TRUEFALSE) ){ + int rc = resolveExprStep(pWalker, pRight); + if( rc==WRC_Abort ) return WRC_Abort; + if( pRight->op==TK_TRUEFALSE ){ + pExpr->op2 = pExpr->op; + pExpr->op = TK_TRUTH; + return WRC_Continue; + } + } + /* no break */ deliberate_fall_through + } + case TK_BETWEEN: + case TK_EQ: + case TK_NE: + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: { + int nLeft, nRight; + if( pParse->db->mallocFailed ) break; + assert( pExpr->pLeft!=0 ); + nLeft = sqlite3ExprVectorSize(pExpr->pLeft); + if( pExpr->op==TK_BETWEEN ){ + nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr); + if( nRight==nLeft ){ + nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr); + } + }else{ + assert( pExpr->pRight!=0 ); + nRight = sqlite3ExprVectorSize(pExpr->pRight); + } + if( nLeft!=nRight ){ + testcase( pExpr->op==TK_EQ ); + testcase( pExpr->op==TK_NE ); + testcase( pExpr->op==TK_LT ); + testcase( pExpr->op==TK_LE ); + testcase( pExpr->op==TK_GT ); + testcase( pExpr->op==TK_GE ); + testcase( pExpr->op==TK_IS ); + testcase( pExpr->op==TK_ISNOT ); + testcase( pExpr->op==TK_BETWEEN ); + sqlite3ErrorMsg(pParse, "row value misused"); + } + break; + } + } + return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue; +} + +/* +** pEList is a list of expressions which are really the result set of the +** a SELECT statement. pE is a term in an ORDER BY or GROUP BY clause. +** This routine checks to see if pE is a simple identifier which corresponds +** to the AS-name of one of the terms of the expression list. If it is, +** this routine return an integer between 1 and N where N is the number of +** elements in pEList, corresponding to the matching entry. If there is +** no match, or if pE is not a simple identifier, then this routine +** return 0. +** +** pEList has been resolved. pE has not. +*/ +static int resolveAsName( + Parse *pParse, /* Parsing context for error messages */ + ExprList *pEList, /* List of expressions to scan */ + Expr *pE /* Expression we are trying to match */ +){ + int i; /* Loop counter */ + + UNUSED_PARAMETER(pParse); + + if( pE->op==TK_ID ){ + char *zCol = pE->u.zToken; + for(i=0; inExpr; i++){ + if( pEList->a[i].eEName==ENAME_NAME + && sqlite3_stricmp(pEList->a[i].zEName, zCol)==0 + ){ + return i+1; + } + } + } + return 0; +} + +/* +** pE is a pointer to an expression which is a single term in the +** ORDER BY of a compound SELECT. The expression has not been +** name resolved. +** +** At the point this routine is called, we already know that the +** ORDER BY term is not an integer index into the result set. That +** case is handled by the calling routine. +** +** Attempt to match pE against result set columns in the left-most +** SELECT statement. Return the index i of the matching column, +** as an indication to the caller that it should sort by the i-th column. +** The left-most column is 1. In other words, the value returned is the +** same integer value that would be used in the SQL statement to indicate +** the column. +** +** If there is no match, return 0. Return -1 if an error occurs. +*/ +static int resolveOrderByTermToExprList( + Parse *pParse, /* Parsing context for error messages */ + Select *pSelect, /* The SELECT statement with the ORDER BY clause */ + Expr *pE /* The specific ORDER BY term */ +){ + int i; /* Loop counter */ + ExprList *pEList; /* The columns of the result set */ + NameContext nc; /* Name context for resolving pE */ + sqlite3 *db; /* Database connection */ + int rc; /* Return code from subprocedures */ + u8 savedSuppErr; /* Saved value of db->suppressErr */ + + assert( sqlite3ExprIsInteger(pE, &i)==0 ); + pEList = pSelect->pEList; + + /* Resolve all names in the ORDER BY term expression + */ + memset(&nc, 0, sizeof(nc)); + nc.pParse = pParse; + nc.pSrcList = pSelect->pSrc; + nc.uNC.pEList = pEList; + nc.ncFlags = NC_AllowAgg|NC_UEList; + nc.nErr = 0; + db = pParse->db; + savedSuppErr = db->suppressErr; + if( IN_RENAME_OBJECT==0 ) db->suppressErr = 1; + rc = sqlite3ResolveExprNames(&nc, pE); + db->suppressErr = savedSuppErr; + if( rc ) return 0; + + /* Try to match the ORDER BY expression against an expression + ** in the result set. Return an 1-based index of the matching + ** result-set entry. + */ + for(i=0; inExpr; i++){ + if( sqlite3ExprCompare(0, pEList->a[i].pExpr, pE, -1)<2 ){ + return i+1; + } + } + + /* If no match, return 0. */ + return 0; +} + +/* +** Generate an ORDER BY or GROUP BY term out-of-range error. +*/ +static void resolveOutOfRangeError( + Parse *pParse, /* The error context into which to write the error */ + const char *zType, /* "ORDER" or "GROUP" */ + int i, /* The index (1-based) of the term out of range */ + int mx /* Largest permissible value of i */ +){ + sqlite3ErrorMsg(pParse, + "%r %s BY term out of range - should be " + "between 1 and %d", i, zType, mx); +} + +/* +** Analyze the ORDER BY clause in a compound SELECT statement. Modify +** each term of the ORDER BY clause is a constant integer between 1 +** and N where N is the number of columns in the compound SELECT. +** +** ORDER BY terms that are already an integer between 1 and N are +** unmodified. ORDER BY terms that are integers outside the range of +** 1 through N generate an error. ORDER BY terms that are expressions +** are matched against result set expressions of compound SELECT +** beginning with the left-most SELECT and working toward the right. +** At the first match, the ORDER BY expression is transformed into +** the integer column number. +** +** Return the number of errors seen. +*/ +static int resolveCompoundOrderBy( + Parse *pParse, /* Parsing context. Leave error messages here */ + Select *pSelect /* The SELECT statement containing the ORDER BY */ +){ + int i; + ExprList *pOrderBy; + ExprList *pEList; + sqlite3 *db; + int moreToDo = 1; + + pOrderBy = pSelect->pOrderBy; + if( pOrderBy==0 ) return 0; + db = pParse->db; + if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ + sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause"); + return 1; + } + for(i=0; inExpr; i++){ + pOrderBy->a[i].done = 0; + } + pSelect->pNext = 0; + while( pSelect->pPrior ){ + pSelect->pPrior->pNext = pSelect; + pSelect = pSelect->pPrior; + } + while( pSelect && moreToDo ){ + struct ExprList_item *pItem; + moreToDo = 0; + pEList = pSelect->pEList; + assert( pEList!=0 ); + for(i=0, pItem=pOrderBy->a; inExpr; i++, pItem++){ + int iCol = -1; + Expr *pE, *pDup; + if( pItem->done ) continue; + pE = sqlite3ExprSkipCollateAndLikely(pItem->pExpr); + if( NEVER(pE==0) ) continue; + if( sqlite3ExprIsInteger(pE, &iCol) ){ + if( iCol<=0 || iCol>pEList->nExpr ){ + resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr); + return 1; + } + }else{ + iCol = resolveAsName(pParse, pEList, pE); + if( iCol==0 ){ + /* Now test if expression pE matches one of the values returned + ** by pSelect. In the usual case this is done by duplicating the + ** expression, resolving any symbols in it, and then comparing + ** it against each expression returned by the SELECT statement. + ** Once the comparisons are finished, the duplicate expression + ** is deleted. + ** + ** Or, if this is running as part of an ALTER TABLE operation, + ** resolve the symbols in the actual expression, not a duplicate. + ** And, if one of the comparisons is successful, leave the expression + ** as is instead of transforming it to an integer as in the usual + ** case. This allows the code in alter.c to modify column + ** refererences within the ORDER BY expression as required. */ + if( IN_RENAME_OBJECT ){ + pDup = pE; + }else{ + pDup = sqlite3ExprDup(db, pE, 0); + } + if( !db->mallocFailed ){ + assert(pDup); + iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup); + } + if( !IN_RENAME_OBJECT ){ + sqlite3ExprDelete(db, pDup); + } + } + } + if( iCol>0 ){ + /* Convert the ORDER BY term into an integer column number iCol, + ** taking care to preserve the COLLATE clause if it exists */ + if( !IN_RENAME_OBJECT ){ + Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0); + if( pNew==0 ) return 1; + pNew->flags |= EP_IntValue; + pNew->u.iValue = iCol; + if( pItem->pExpr==pE ){ + pItem->pExpr = pNew; + }else{ + Expr *pParent = pItem->pExpr; + assert( pParent->op==TK_COLLATE ); + while( pParent->pLeft->op==TK_COLLATE ) pParent = pParent->pLeft; + assert( pParent->pLeft==pE ); + pParent->pLeft = pNew; + } + sqlite3ExprDelete(db, pE); + pItem->u.x.iOrderByCol = (u16)iCol; + } + pItem->done = 1; + }else{ + moreToDo = 1; + } + } + pSelect = pSelect->pNext; + } + for(i=0; inExpr; i++){ + if( pOrderBy->a[i].done==0 ){ + sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any " + "column in the result set", i+1); + return 1; + } + } + return 0; +} + +/* +** Check every term in the ORDER BY or GROUP BY clause pOrderBy of +** the SELECT statement pSelect. If any term is reference to a +** result set expression (as determined by the ExprList.a.u.x.iOrderByCol +** field) then convert that term into a copy of the corresponding result set +** column. +** +** If any errors are detected, add an error message to pParse and +** return non-zero. Return zero if no errors are seen. +*/ +SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy( + Parse *pParse, /* Parsing context. Leave error messages here */ + Select *pSelect, /* The SELECT statement containing the clause */ + ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */ + const char *zType /* "ORDER" or "GROUP" */ +){ + int i; + sqlite3 *db = pParse->db; + ExprList *pEList; + struct ExprList_item *pItem; + + if( pOrderBy==0 || pParse->db->mallocFailed || IN_RENAME_OBJECT ) return 0; + if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ + sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType); + return 1; + } + pEList = pSelect->pEList; + assert( pEList!=0 ); /* sqlite3SelectNew() guarantees this */ + for(i=0, pItem=pOrderBy->a; inExpr; i++, pItem++){ + if( pItem->u.x.iOrderByCol ){ + if( pItem->u.x.iOrderByCol>pEList->nExpr ){ + resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr); + return 1; + } + resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr, + zType,0); + } + } + return 0; +} + +#ifndef SQLITE_OMIT_WINDOWFUNC +/* +** Walker callback for windowRemoveExprFromSelect(). +*/ +static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){ + UNUSED_PARAMETER(pWalker); + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + Window *pWin = pExpr->y.pWin; + sqlite3WindowUnlinkFromSelect(pWin); + } + return WRC_Continue; +} + +/* +** Remove any Window objects owned by the expression pExpr from the +** Select.pWin list of Select object pSelect. +*/ +static void windowRemoveExprFromSelect(Select *pSelect, Expr *pExpr){ + if( pSelect->pWin ){ + Walker sWalker; + memset(&sWalker, 0, sizeof(Walker)); + sWalker.xExprCallback = resolveRemoveWindowsCb; + sWalker.u.pSelect = pSelect; + sqlite3WalkExpr(&sWalker, pExpr); + } +} +#else +# define windowRemoveExprFromSelect(a, b) +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +/* +** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect. +** The Name context of the SELECT statement is pNC. zType is either +** "ORDER" or "GROUP" depending on which type of clause pOrderBy is. +** +** This routine resolves each term of the clause into an expression. +** If the order-by term is an integer I between 1 and N (where N is the +** number of columns in the result set of the SELECT) then the expression +** in the resolution is a copy of the I-th result-set expression. If +** the order-by term is an identifier that corresponds to the AS-name of +** a result-set expression, then the term resolves to a copy of the +** result-set expression. Otherwise, the expression is resolved in +** the usual way - using sqlite3ResolveExprNames(). +** +** This routine returns the number of errors. If errors occur, then +** an appropriate error message might be left in pParse. (OOM errors +** excepted.) +*/ +static int resolveOrderGroupBy( + NameContext *pNC, /* The name context of the SELECT statement */ + Select *pSelect, /* The SELECT statement holding pOrderBy */ + ExprList *pOrderBy, /* An ORDER BY or GROUP BY clause to resolve */ + const char *zType /* Either "ORDER" or "GROUP", as appropriate */ +){ + int i, j; /* Loop counters */ + int iCol; /* Column number */ + struct ExprList_item *pItem; /* A term of the ORDER BY clause */ + Parse *pParse; /* Parsing context */ + int nResult; /* Number of terms in the result set */ + + if( pOrderBy==0 ) return 0; + nResult = pSelect->pEList->nExpr; + pParse = pNC->pParse; + for(i=0, pItem=pOrderBy->a; inExpr; i++, pItem++){ + Expr *pE = pItem->pExpr; + Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pE); + if( NEVER(pE2==0) ) continue; + if( zType[0]!='G' ){ + iCol = resolveAsName(pParse, pSelect->pEList, pE2); + if( iCol>0 ){ + /* If an AS-name match is found, mark this ORDER BY column as being + ** a copy of the iCol-th result-set column. The subsequent call to + ** sqlite3ResolveOrderGroupBy() will convert the expression to a + ** copy of the iCol-th result-set expression. */ + pItem->u.x.iOrderByCol = (u16)iCol; + continue; + } + } + if( sqlite3ExprIsInteger(pE2, &iCol) ){ + /* The ORDER BY term is an integer constant. Again, set the column + ** number so that sqlite3ResolveOrderGroupBy() will convert the + ** order-by term to a copy of the result-set expression */ + if( iCol<1 || iCol>0xffff ){ + resolveOutOfRangeError(pParse, zType, i+1, nResult); + return 1; + } + pItem->u.x.iOrderByCol = (u16)iCol; + continue; + } + + /* Otherwise, treat the ORDER BY term as an ordinary expression */ + pItem->u.x.iOrderByCol = 0; + if( sqlite3ResolveExprNames(pNC, pE) ){ + return 1; + } + for(j=0; jpEList->nExpr; j++){ + if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){ + /* Since this expresion is being changed into a reference + ** to an identical expression in the result set, remove all Window + ** objects belonging to the expression from the Select.pWin list. */ + windowRemoveExprFromSelect(pSelect, pE); + pItem->u.x.iOrderByCol = j+1; + } + } + } + return sqlite3ResolveOrderGroupBy(pParse, pSelect, pOrderBy, zType); +} + +/* +** Resolve names in the SELECT statement p and all of its descendants. +*/ +static int resolveSelectStep(Walker *pWalker, Select *p){ + NameContext *pOuterNC; /* Context that contains this SELECT */ + NameContext sNC; /* Name context of this SELECT */ + int isCompound; /* True if p is a compound select */ + int nCompound; /* Number of compound terms processed so far */ + Parse *pParse; /* Parsing context */ + int i; /* Loop counter */ + ExprList *pGroupBy; /* The GROUP BY clause */ + Select *pLeftmost; /* Left-most of SELECT of a compound */ + sqlite3 *db; /* Database connection */ + + + assert( p!=0 ); + if( p->selFlags & SF_Resolved ){ + return WRC_Prune; + } + pOuterNC = pWalker->u.pNC; + pParse = pWalker->pParse; + db = pParse->db; + + /* Normally sqlite3SelectExpand() will be called first and will have + ** already expanded this SELECT. However, if this is a subquery within + ** an expression, sqlite3ResolveExprNames() will be called without a + ** prior call to sqlite3SelectExpand(). When that happens, let + ** sqlite3SelectPrep() do all of the processing for this SELECT. + ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and + ** this routine in the correct order. + */ + if( (p->selFlags & SF_Expanded)==0 ){ + sqlite3SelectPrep(pParse, p, pOuterNC); + return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune; + } + + isCompound = p->pPrior!=0; + nCompound = 0; + pLeftmost = p; + while( p ){ + assert( (p->selFlags & SF_Expanded)!=0 ); + assert( (p->selFlags & SF_Resolved)==0 ); + p->selFlags |= SF_Resolved; + + /* Resolve the expressions in the LIMIT and OFFSET clauses. These + ** are not allowed to refer to any names, so pass an empty NameContext. + */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pWinSelect = p; + if( sqlite3ResolveExprNames(&sNC, p->pLimit) ){ + return WRC_Abort; + } + + /* If the SF_Converted flags is set, then this Select object was + ** was created by the convertCompoundSelectToSubquery() function. + ** In this case the ORDER BY clause (p->pOrderBy) should be resolved + ** as if it were part of the sub-query, not the parent. This block + ** moves the pOrderBy down to the sub-query. It will be moved back + ** after the names have been resolved. */ + if( p->selFlags & SF_Converted ){ + Select *pSub = p->pSrc->a[0].pSelect; + assert( p->pSrc->nSrc==1 && p->pOrderBy ); + assert( pSub->pPrior && pSub->pOrderBy==0 ); + pSub->pOrderBy = p->pOrderBy; + p->pOrderBy = 0; + } + + /* Recursively resolve names in all subqueries + */ + for(i=0; ipSrc->nSrc; i++){ + struct SrcList_item *pItem = &p->pSrc->a[i]; + if( pItem->pSelect && (pItem->pSelect->selFlags & SF_Resolved)==0 ){ + NameContext *pNC; /* Used to iterate name contexts */ + int nRef = 0; /* Refcount for pOuterNC and outer contexts */ + const char *zSavedContext = pParse->zAuthContext; + + /* Count the total number of references to pOuterNC and all of its + ** parent contexts. After resolving references to expressions in + ** pItem->pSelect, check if this value has changed. If so, then + ** SELECT statement pItem->pSelect must be correlated. Set the + ** pItem->fg.isCorrelated flag if this is the case. */ + for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef += pNC->nRef; + + if( pItem->zName ) pParse->zAuthContext = pItem->zName; + sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC); + pParse->zAuthContext = zSavedContext; + if( pParse->nErr || db->mallocFailed ) return WRC_Abort; + + for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef -= pNC->nRef; + assert( pItem->fg.isCorrelated==0 && nRef<=0 ); + pItem->fg.isCorrelated = (nRef!=0); + } + } + + /* Set up the local name-context to pass to sqlite3ResolveExprNames() to + ** resolve the result-set expression list. + */ + sNC.ncFlags = NC_AllowAgg|NC_AllowWin; + sNC.pSrcList = p->pSrc; + sNC.pNext = pOuterNC; + + /* Resolve names in the result set. */ + if( sqlite3ResolveExprListNames(&sNC, p->pEList) ) return WRC_Abort; + sNC.ncFlags &= ~NC_AllowWin; + + /* If there are no aggregate functions in the result-set, and no GROUP BY + ** expression, do not allow aggregates in any of the other expressions. + */ + assert( (p->selFlags & SF_Aggregate)==0 ); + pGroupBy = p->pGroupBy; + if( pGroupBy || (sNC.ncFlags & NC_HasAgg)!=0 ){ + assert( NC_MinMaxAgg==SF_MinMaxAgg ); + p->selFlags |= SF_Aggregate | (sNC.ncFlags&NC_MinMaxAgg); + }else{ + sNC.ncFlags &= ~NC_AllowAgg; + } + + /* If a HAVING clause is present, then there must be a GROUP BY clause. + */ + if( p->pHaving && !pGroupBy ){ + sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING"); + return WRC_Abort; + } + + /* Add the output column list to the name-context before parsing the + ** other expressions in the SELECT statement. This is so that + ** expressions in the WHERE clause (etc.) can refer to expressions by + ** aliases in the result set. + ** + ** Minor point: If this is the case, then the expression will be + ** re-evaluated for each reference to it. + */ + assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert))==0 ); + sNC.uNC.pEList = p->pEList; + sNC.ncFlags |= NC_UEList; + if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort; + if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort; + + /* Resolve names in table-valued-function arguments */ + for(i=0; ipSrc->nSrc; i++){ + struct SrcList_item *pItem = &p->pSrc->a[i]; + if( pItem->fg.isTabFunc + && sqlite3ResolveExprListNames(&sNC, pItem->u1.pFuncArg) + ){ + return WRC_Abort; + } + } + + /* The ORDER BY and GROUP BY clauses may not refer to terms in + ** outer queries + */ + sNC.pNext = 0; + sNC.ncFlags |= NC_AllowAgg|NC_AllowWin; + + /* If this is a converted compound query, move the ORDER BY clause from + ** the sub-query back to the parent query. At this point each term + ** within the ORDER BY clause has been transformed to an integer value. + ** These integers will be replaced by copies of the corresponding result + ** set expressions by the call to resolveOrderGroupBy() below. */ + if( p->selFlags & SF_Converted ){ + Select *pSub = p->pSrc->a[0].pSelect; + p->pOrderBy = pSub->pOrderBy; + pSub->pOrderBy = 0; + } + + /* Process the ORDER BY clause for singleton SELECT statements. + ** The ORDER BY clause for compounds SELECT statements is handled + ** below, after all of the result-sets for all of the elements of + ** the compound have been resolved. + ** + ** If there is an ORDER BY clause on a term of a compound-select other + ** than the right-most term, then that is a syntax error. But the error + ** is not detected until much later, and so we need to go ahead and + ** resolve those symbols on the incorrect ORDER BY for consistency. + */ + if( isCompound<=nCompound /* Defer right-most ORDER BY of a compound */ + && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER") + ){ + return WRC_Abort; + } + if( db->mallocFailed ){ + return WRC_Abort; + } + sNC.ncFlags &= ~NC_AllowWin; + + /* Resolve the GROUP BY clause. At the same time, make sure + ** the GROUP BY clause does not contain aggregate functions. + */ + if( pGroupBy ){ + struct ExprList_item *pItem; + + if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){ + return WRC_Abort; + } + for(i=0, pItem=pGroupBy->a; inExpr; i++, pItem++){ + if( ExprHasProperty(pItem->pExpr, EP_Agg) ){ + sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in " + "the GROUP BY clause"); + return WRC_Abort; + } + } + } + +#ifndef SQLITE_OMIT_WINDOWFUNC + if( IN_RENAME_OBJECT ){ + Window *pWin; + for(pWin=p->pWinDefn; pWin; pWin=pWin->pNextWin){ + if( sqlite3ResolveExprListNames(&sNC, pWin->pOrderBy) + || sqlite3ResolveExprListNames(&sNC, pWin->pPartition) + ){ + return WRC_Abort; + } + } + } +#endif + + /* If this is part of a compound SELECT, check that it has the right + ** number of expressions in the select list. */ + if( p->pNext && p->pEList->nExpr!=p->pNext->pEList->nExpr ){ + sqlite3SelectWrongNumTermsError(pParse, p->pNext); + return WRC_Abort; + } + + /* Advance to the next term of the compound + */ + p = p->pPrior; + nCompound++; + } + + /* Resolve the ORDER BY on a compound SELECT after all terms of + ** the compound have been resolved. + */ + if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){ + return WRC_Abort; + } + + return WRC_Prune; +} + +/* +** This routine walks an expression tree and resolves references to +** table columns and result-set columns. At the same time, do error +** checking on function usage and set a flag if any aggregate functions +** are seen. +** +** To resolve table columns references we look for nodes (or subtrees) of the +** form X.Y.Z or Y.Z or just Z where +** +** X: The name of a database. Ex: "main" or "temp" or +** the symbolic name assigned to an ATTACH-ed database. +** +** Y: The name of a table in a FROM clause. Or in a trigger +** one of the special names "old" or "new". +** +** Z: The name of a column in table Y. +** +** The node at the root of the subtree is modified as follows: +** +** Expr.op Changed to TK_COLUMN +** Expr.pTab Points to the Table object for X.Y +** Expr.iColumn The column index in X.Y. -1 for the rowid. +** Expr.iTable The VDBE cursor number for X.Y +** +** +** To resolve result-set references, look for expression nodes of the +** form Z (with no X and Y prefix) where the Z matches the right-hand +** size of an AS clause in the result-set of a SELECT. The Z expression +** is replaced by a copy of the left-hand side of the result-set expression. +** Table-name and function resolution occurs on the substituted expression +** tree. For example, in: +** +** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY x; +** +** The "x" term of the order by is replaced by "a+b" to render: +** +** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY a+b; +** +** Function calls are checked to make sure that the function is +** defined and that the correct number of arguments are specified. +** If the function is an aggregate function, then the NC_HasAgg flag is +** set and the opcode is changed from TK_FUNCTION to TK_AGG_FUNCTION. +** If an expression contains aggregate functions then the EP_Agg +** property on the expression is set. +** +** An error message is left in pParse if anything is amiss. The number +** if errors is returned. +*/ +SQLITE_PRIVATE int sqlite3ResolveExprNames( + NameContext *pNC, /* Namespace to resolve expressions in. */ + Expr *pExpr /* The expression to be analyzed. */ +){ + int savedHasAgg; + Walker w; + + if( pExpr==0 ) return SQLITE_OK; + savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin); + pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin); + w.pParse = pNC->pParse; + w.xExprCallback = resolveExprStep; + w.xSelectCallback = resolveSelectStep; + w.xSelectCallback2 = 0; + w.u.pNC = pNC; +#if SQLITE_MAX_EXPR_DEPTH>0 + w.pParse->nHeight += pExpr->nHeight; + if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){ + return SQLITE_ERROR; + } +#endif + sqlite3WalkExpr(&w, pExpr); +#if SQLITE_MAX_EXPR_DEPTH>0 + w.pParse->nHeight -= pExpr->nHeight; +#endif + assert( EP_Agg==NC_HasAgg ); + assert( EP_Win==NC_HasWin ); + testcase( pNC->ncFlags & NC_HasAgg ); + testcase( pNC->ncFlags & NC_HasWin ); + ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) ); + pNC->ncFlags |= savedHasAgg; + return pNC->nErr>0 || w.pParse->nErr>0; +} + +/* +** Resolve all names for all expression in an expression list. This is +** just like sqlite3ResolveExprNames() except that it works for an expression +** list rather than a single expression. +*/ +SQLITE_PRIVATE int sqlite3ResolveExprListNames( + NameContext *pNC, /* Namespace to resolve expressions in. */ + ExprList *pList /* The expression list to be analyzed. */ +){ + int i; + int savedHasAgg = 0; + Walker w; + if( pList==0 ) return WRC_Continue; + w.pParse = pNC->pParse; + w.xExprCallback = resolveExprStep; + w.xSelectCallback = resolveSelectStep; + w.xSelectCallback2 = 0; + w.u.pNC = pNC; + savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin); + pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin); + for(i=0; inExpr; i++){ + Expr *pExpr = pList->a[i].pExpr; + if( pExpr==0 ) continue; +#if SQLITE_MAX_EXPR_DEPTH>0 + w.pParse->nHeight += pExpr->nHeight; + if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){ + return WRC_Abort; + } +#endif + sqlite3WalkExpr(&w, pExpr); +#if SQLITE_MAX_EXPR_DEPTH>0 + w.pParse->nHeight -= pExpr->nHeight; +#endif + assert( EP_Agg==NC_HasAgg ); + assert( EP_Win==NC_HasWin ); + testcase( pNC->ncFlags & NC_HasAgg ); + testcase( pNC->ncFlags & NC_HasWin ); + if( pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin) ){ + ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) ); + savedHasAgg |= pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin); + pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin); + } + if( pNC->nErr>0 || w.pParse->nErr>0 ) return WRC_Abort; + } + pNC->ncFlags |= savedHasAgg; + return WRC_Continue; +} + +/* +** Resolve all names in all expressions of a SELECT and in all +** decendents of the SELECT, including compounds off of p->pPrior, +** subqueries in expressions, and subqueries used as FROM clause +** terms. +** +** See sqlite3ResolveExprNames() for a description of the kinds of +** transformations that occur. +** +** All SELECT statements should have been expanded using +** sqlite3SelectExpand() prior to invoking this routine. +*/ +SQLITE_PRIVATE void sqlite3ResolveSelectNames( + Parse *pParse, /* The parser context */ + Select *p, /* The SELECT statement being coded. */ + NameContext *pOuterNC /* Name context for parent SELECT statement */ +){ + Walker w; + + assert( p!=0 ); + w.xExprCallback = resolveExprStep; + w.xSelectCallback = resolveSelectStep; + w.xSelectCallback2 = 0; + w.pParse = pParse; + w.u.pNC = pOuterNC; + sqlite3WalkSelect(&w, p); +} + +/* +** Resolve names in expressions that can only reference a single table +** or which cannot reference any tables at all. Examples: +** +** "type" flag +** ------------ +** (1) CHECK constraints NC_IsCheck +** (2) WHERE clauses on partial indices NC_PartIdx +** (3) Expressions in indexes on expressions NC_IdxExpr +** (4) Expression arguments to VACUUM INTO. 0 +** (5) GENERATED ALWAYS as expressions NC_GenCol +** +** In all cases except (4), the Expr.iTable value for Expr.op==TK_COLUMN +** nodes of the expression is set to -1 and the Expr.iColumn value is +** set to the column number. In case (4), TK_COLUMN nodes cause an error. +** +** Any errors cause an error message to be set in pParse. +*/ +SQLITE_PRIVATE int sqlite3ResolveSelfReference( + Parse *pParse, /* Parsing context */ + Table *pTab, /* The table being referenced, or NULL */ + int type, /* NC_IsCheck, NC_PartIdx, NC_IdxExpr, NC_GenCol, or 0 */ + Expr *pExpr, /* Expression to resolve. May be NULL. */ + ExprList *pList /* Expression list to resolve. May be NULL. */ +){ + SrcList sSrc; /* Fake SrcList for pParse->pNewTable */ + NameContext sNC; /* Name context for pParse->pNewTable */ + int rc; + + assert( type==0 || pTab!=0 ); + assert( type==NC_IsCheck || type==NC_PartIdx || type==NC_IdxExpr + || type==NC_GenCol || pTab==0 ); + memset(&sNC, 0, sizeof(sNC)); + memset(&sSrc, 0, sizeof(sSrc)); + if( pTab ){ + sSrc.nSrc = 1; + sSrc.a[0].zName = pTab->zName; + sSrc.a[0].pTab = pTab; + sSrc.a[0].iCursor = -1; + if( pTab->pSchema!=pParse->db->aDb[1].pSchema ){ + /* Cause EP_FromDDL to be set on TK_FUNCTION nodes of non-TEMP + ** schema elements */ + type |= NC_FromDDL; + } + } + sNC.pParse = pParse; + sNC.pSrcList = &sSrc; + sNC.ncFlags = type | NC_IsDDL; + if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc; + if( pList ) rc = sqlite3ResolveExprListNames(&sNC, pList); + return rc; +} + +/************** End of resolve.c *********************************************/ +/************** Begin file expr.c ********************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains routines used for analyzing expressions and +** for generating VDBE code that evaluates expressions in SQLite. +*/ +/* #include "sqliteInt.h" */ + +/* Forward declarations */ +static void exprCodeBetween(Parse*,Expr*,int,void(*)(Parse*,Expr*,int,int),int); +static int exprCodeVector(Parse *pParse, Expr *p, int *piToFree); + +/* +** Return the affinity character for a single column of a table. +*/ +SQLITE_PRIVATE char sqlite3TableColumnAffinity(Table *pTab, int iCol){ + assert( iColnCol ); + return iCol>=0 ? pTab->aCol[iCol].affinity : SQLITE_AFF_INTEGER; +} + +/* +** Return the 'affinity' of the expression pExpr if any. +** +** If pExpr is a column, a reference to a column via an 'AS' alias, +** or a sub-select with a column as the return value, then the +** affinity of that column is returned. Otherwise, 0x00 is returned, +** indicating no affinity for the expression. +** +** i.e. the WHERE clause expressions in the following statements all +** have an affinity: +** +** CREATE TABLE t1(a); +** SELECT * FROM t1 WHERE a; +** SELECT a AS b FROM t1 WHERE b; +** SELECT * FROM t1 WHERE (select a from t1); +*/ +SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){ + int op; + while( ExprHasProperty(pExpr, EP_Skip|EP_IfNullRow) ){ + assert( pExpr->op==TK_COLLATE + || pExpr->op==TK_IF_NULL_ROW + || (pExpr->op==TK_REGISTER && pExpr->op2==TK_IF_NULL_ROW) ); + pExpr = pExpr->pLeft; + assert( pExpr!=0 ); + } + op = pExpr->op; + if( op==TK_SELECT ){ + assert( pExpr->flags&EP_xIsSelect ); + assert( pExpr->x.pSelect!=0 ); + assert( pExpr->x.pSelect->pEList!=0 ); + assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 ); + return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr); + } + if( op==TK_REGISTER ) op = pExpr->op2; +#ifndef SQLITE_OMIT_CAST + if( op==TK_CAST ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + return sqlite3AffinityType(pExpr->u.zToken, 0); + } +#endif + if( (op==TK_AGG_COLUMN || op==TK_COLUMN) && pExpr->y.pTab ){ + return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn); + } + if( op==TK_SELECT_COLUMN ){ + assert( pExpr->pLeft->flags&EP_xIsSelect ); + return sqlite3ExprAffinity( + pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr + ); + } + if( op==TK_VECTOR ){ + return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr); + } + return pExpr->affExpr; +} + +/* +** Set the collating sequence for expression pExpr to be the collating +** sequence named by pToken. Return a pointer to a new Expr node that +** implements the COLLATE operator. +** +** If a memory allocation error occurs, that fact is recorded in pParse->db +** and the pExpr parameter is returned unchanged. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken( + Parse *pParse, /* Parsing context */ + Expr *pExpr, /* Add the "COLLATE" clause to this expression */ + const Token *pCollName, /* Name of collating sequence */ + int dequote /* True to dequote pCollName */ +){ + if( pCollName->n>0 ){ + Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLLATE, pCollName, dequote); + if( pNew ){ + pNew->pLeft = pExpr; + pNew->flags |= EP_Collate|EP_Skip; + pExpr = pNew; + } + } + return pExpr; +} +SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse *pParse, Expr *pExpr, const char *zC){ + Token s; + assert( zC!=0 ); + sqlite3TokenInit(&s, (char*)zC); + return sqlite3ExprAddCollateToken(pParse, pExpr, &s, 0); +} + +/* +** Skip over any TK_COLLATE operators. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr *pExpr){ + while( pExpr && ExprHasProperty(pExpr, EP_Skip) ){ + assert( pExpr->op==TK_COLLATE ); + pExpr = pExpr->pLeft; + } + return pExpr; +} + +/* +** Skip over any TK_COLLATE operators and/or any unlikely() +** or likelihood() or likely() functions at the root of an +** expression. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){ + while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){ + if( ExprHasProperty(pExpr, EP_Unlikely) ){ + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + assert( pExpr->x.pList->nExpr>0 ); + assert( pExpr->op==TK_FUNCTION ); + pExpr = pExpr->x.pList->a[0].pExpr; + }else{ + assert( pExpr->op==TK_COLLATE ); + pExpr = pExpr->pLeft; + } + } + return pExpr; +} + +/* +** Return the collation sequence for the expression pExpr. If +** there is no defined collating sequence, return NULL. +** +** See also: sqlite3ExprNNCollSeq() +** +** The sqlite3ExprNNCollSeq() works the same exact that it returns the +** default collation if pExpr has no defined collation. +** +** The collating sequence might be determined by a COLLATE operator +** or by the presence of a column with a defined collating sequence. +** COLLATE operators take first precedence. Left operands take +** precedence over right operands. +*/ +SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){ + sqlite3 *db = pParse->db; + CollSeq *pColl = 0; + const Expr *p = pExpr; + while( p ){ + int op = p->op; + if( op==TK_REGISTER ) op = p->op2; + if( (op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_TRIGGER) + && p->y.pTab!=0 + ){ + /* op==TK_REGISTER && p->y.pTab!=0 happens when pExpr was originally + ** a TK_COLUMN but was previously evaluated and cached in a register */ + int j = p->iColumn; + if( j>=0 ){ + const char *zColl = p->y.pTab->aCol[j].zColl; + pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0); + } + break; + } + if( op==TK_CAST || op==TK_UPLUS ){ + p = p->pLeft; + continue; + } + if( op==TK_VECTOR ){ + p = p->x.pList->a[0].pExpr; + continue; + } + if( op==TK_COLLATE ){ + pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken); + break; + } + if( p->flags & EP_Collate ){ + if( p->pLeft && (p->pLeft->flags & EP_Collate)!=0 ){ + p = p->pLeft; + }else{ + Expr *pNext = p->pRight; + /* The Expr.x union is never used at the same time as Expr.pRight */ + assert( p->x.pList==0 || p->pRight==0 ); + if( p->x.pList!=0 + && !db->mallocFailed + && ALWAYS(!ExprHasProperty(p, EP_xIsSelect)) + ){ + int i; + for(i=0; ALWAYS(ix.pList->nExpr); i++){ + if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){ + pNext = p->x.pList->a[i].pExpr; + break; + } + } + } + p = pNext; + } + }else{ + break; + } + } + if( sqlite3CheckCollSeq(pParse, pColl) ){ + pColl = 0; + } + return pColl; +} + +/* +** Return the collation sequence for the expression pExpr. If +** there is no defined collating sequence, return a pointer to the +** defautl collation sequence. +** +** See also: sqlite3ExprCollSeq() +** +** The sqlite3ExprCollSeq() routine works the same except that it +** returns NULL if there is no defined collation. +*/ +SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr){ + CollSeq *p = sqlite3ExprCollSeq(pParse, pExpr); + if( p==0 ) p = pParse->db->pDfltColl; + assert( p!=0 ); + return p; +} + +/* +** Return TRUE if the two expressions have equivalent collating sequences. +*/ +SQLITE_PRIVATE int sqlite3ExprCollSeqMatch(Parse *pParse, const Expr *pE1, const Expr *pE2){ + CollSeq *pColl1 = sqlite3ExprNNCollSeq(pParse, pE1); + CollSeq *pColl2 = sqlite3ExprNNCollSeq(pParse, pE2); + return sqlite3StrICmp(pColl1->zName, pColl2->zName)==0; +} + +/* +** pExpr is an operand of a comparison operator. aff2 is the +** type affinity of the other operand. This routine returns the +** type affinity that should be used for the comparison operator. +*/ +SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2){ + char aff1 = sqlite3ExprAffinity(pExpr); + if( aff1>SQLITE_AFF_NONE && aff2>SQLITE_AFF_NONE ){ + /* Both sides of the comparison are columns. If one has numeric + ** affinity, use that. Otherwise use no affinity. + */ + if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){ + return SQLITE_AFF_NUMERIC; + }else{ + return SQLITE_AFF_BLOB; + } + }else{ + /* One side is a column, the other is not. Use the columns affinity. */ + assert( aff1<=SQLITE_AFF_NONE || aff2<=SQLITE_AFF_NONE ); + return (aff1<=SQLITE_AFF_NONE ? aff2 : aff1) | SQLITE_AFF_NONE; + } +} + +/* +** pExpr is a comparison operator. Return the type affinity that should +** be applied to both operands prior to doing the comparison. +*/ +static char comparisonAffinity(const Expr *pExpr){ + char aff; + assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT || + pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE || + pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT ); + assert( pExpr->pLeft ); + aff = sqlite3ExprAffinity(pExpr->pLeft); + if( pExpr->pRight ){ + aff = sqlite3CompareAffinity(pExpr->pRight, aff); + }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff); + }else if( aff==0 ){ + aff = SQLITE_AFF_BLOB; + } + return aff; +} + +/* +** pExpr is a comparison expression, eg. '=', '<', IN(...) etc. +** idx_affinity is the affinity of an indexed column. Return true +** if the index with affinity idx_affinity may be used to implement +** the comparison in pExpr. +*/ +SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity){ + char aff = comparisonAffinity(pExpr); + if( affflags & EP_Collate ){ + pColl = sqlite3ExprCollSeq(pParse, pLeft); + }else if( pRight && (pRight->flags & EP_Collate)!=0 ){ + pColl = sqlite3ExprCollSeq(pParse, pRight); + }else{ + pColl = sqlite3ExprCollSeq(pParse, pLeft); + if( !pColl ){ + pColl = sqlite3ExprCollSeq(pParse, pRight); + } + } + return pColl; +} + +/* Expresssion p is a comparison operator. Return a collation sequence +** appropriate for the comparison operator. +** +** This is normally just a wrapper around sqlite3BinaryCompareCollSeq(). +** However, if the OP_Commuted flag is set, then the order of the operands +** is reversed in the sqlite3BinaryCompareCollSeq() call so that the +** correct collating sequence is found. +*/ +SQLITE_PRIVATE CollSeq *sqlite3ExprCompareCollSeq(Parse *pParse, const Expr *p){ + if( ExprHasProperty(p, EP_Commuted) ){ + return sqlite3BinaryCompareCollSeq(pParse, p->pRight, p->pLeft); + }else{ + return sqlite3BinaryCompareCollSeq(pParse, p->pLeft, p->pRight); + } +} + +/* +** Generate code for a comparison operator. +*/ +static int codeCompare( + Parse *pParse, /* The parsing (and code generating) context */ + Expr *pLeft, /* The left operand */ + Expr *pRight, /* The right operand */ + int opcode, /* The comparison opcode */ + int in1, int in2, /* Register holding operands */ + int dest, /* Jump here if true. */ + int jumpIfNull, /* If true, jump if either operand is NULL */ + int isCommuted /* The comparison has been commuted */ +){ + int p5; + int addr; + CollSeq *p4; + + if( pParse->nErr ) return 0; + if( isCommuted ){ + p4 = sqlite3BinaryCompareCollSeq(pParse, pRight, pLeft); + }else{ + p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight); + } + p5 = binaryCompareP5(pLeft, pRight, jumpIfNull); + addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1, + (void*)p4, P4_COLLSEQ); + sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5); + return addr; +} + +/* +** Return true if expression pExpr is a vector, or false otherwise. +** +** A vector is defined as any expression that results in two or more +** columns of result. Every TK_VECTOR node is an vector because the +** parser will not generate a TK_VECTOR with fewer than two entries. +** But a TK_SELECT might be either a vector or a scalar. It is only +** considered a vector if it has two or more result columns. +*/ +SQLITE_PRIVATE int sqlite3ExprIsVector(Expr *pExpr){ + return sqlite3ExprVectorSize(pExpr)>1; +} + +/* +** If the expression passed as the only argument is of type TK_VECTOR +** return the number of expressions in the vector. Or, if the expression +** is a sub-select, return the number of columns in the sub-select. For +** any other type of expression, return 1. +*/ +SQLITE_PRIVATE int sqlite3ExprVectorSize(Expr *pExpr){ + u8 op = pExpr->op; + if( op==TK_REGISTER ) op = pExpr->op2; + if( op==TK_VECTOR ){ + return pExpr->x.pList->nExpr; + }else if( op==TK_SELECT ){ + return pExpr->x.pSelect->pEList->nExpr; + }else{ + return 1; + } +} + +/* +** Return a pointer to a subexpression of pVector that is the i-th +** column of the vector (numbered starting with 0). The caller must +** ensure that i is within range. +** +** If pVector is really a scalar (and "scalar" here includes subqueries +** that return a single column!) then return pVector unmodified. +** +** pVector retains ownership of the returned subexpression. +** +** If the vector is a (SELECT ...) then the expression returned is +** just the expression for the i-th term of the result set, and may +** not be ready for evaluation because the table cursor has not yet +** been positioned. +*/ +SQLITE_PRIVATE Expr *sqlite3VectorFieldSubexpr(Expr *pVector, int i){ + assert( iop2==0 || pVector->op==TK_REGISTER ); + if( pVector->op==TK_SELECT || pVector->op2==TK_SELECT ){ + return pVector->x.pSelect->pEList->a[i].pExpr; + }else{ + return pVector->x.pList->a[i].pExpr; + } + } + return pVector; +} + +/* +** Compute and return a new Expr object which when passed to +** sqlite3ExprCode() will generate all necessary code to compute +** the iField-th column of the vector expression pVector. +** +** It is ok for pVector to be a scalar (as long as iField==0). +** In that case, this routine works like sqlite3ExprDup(). +** +** The caller owns the returned Expr object and is responsible for +** ensuring that the returned value eventually gets freed. +** +** The caller retains ownership of pVector. If pVector is a TK_SELECT, +** then the returned object will reference pVector and so pVector must remain +** valid for the life of the returned object. If pVector is a TK_VECTOR +** or a scalar expression, then it can be deleted as soon as this routine +** returns. +** +** A trick to cause a TK_SELECT pVector to be deleted together with +** the returned Expr object is to attach the pVector to the pRight field +** of the returned TK_SELECT_COLUMN Expr object. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprForVectorField( + Parse *pParse, /* Parsing context */ + Expr *pVector, /* The vector. List of expressions or a sub-SELECT */ + int iField /* Which column of the vector to return */ +){ + Expr *pRet; + if( pVector->op==TK_SELECT ){ + assert( pVector->flags & EP_xIsSelect ); + /* The TK_SELECT_COLUMN Expr node: + ** + ** pLeft: pVector containing TK_SELECT. Not deleted. + ** pRight: not used. But recursively deleted. + ** iColumn: Index of a column in pVector + ** iTable: 0 or the number of columns on the LHS of an assignment + ** pLeft->iTable: First in an array of register holding result, or 0 + ** if the result is not yet computed. + ** + ** sqlite3ExprDelete() specifically skips the recursive delete of + ** pLeft on TK_SELECT_COLUMN nodes. But pRight is followed, so pVector + ** can be attached to pRight to cause this node to take ownership of + ** pVector. Typically there will be multiple TK_SELECT_COLUMN nodes + ** with the same pLeft pointer to the pVector, but only one of them + ** will own the pVector. + */ + pRet = sqlite3PExpr(pParse, TK_SELECT_COLUMN, 0, 0); + if( pRet ){ + pRet->iColumn = iField; + pRet->pLeft = pVector; + } + assert( pRet==0 || pRet->iTable==0 ); + }else{ + if( pVector->op==TK_VECTOR ) pVector = pVector->x.pList->a[iField].pExpr; + pRet = sqlite3ExprDup(pParse->db, pVector, 0); + sqlite3RenameTokenRemap(pParse, pRet, pVector); + } + return pRet; +} + +/* +** If expression pExpr is of type TK_SELECT, generate code to evaluate +** it. Return the register in which the result is stored (or, if the +** sub-select returns more than one column, the first in an array +** of registers in which the result is stored). +** +** If pExpr is not a TK_SELECT expression, return 0. +*/ +static int exprCodeSubselect(Parse *pParse, Expr *pExpr){ + int reg = 0; +#ifndef SQLITE_OMIT_SUBQUERY + if( pExpr->op==TK_SELECT ){ + reg = sqlite3CodeSubselect(pParse, pExpr); + } +#endif + return reg; +} + +/* +** Argument pVector points to a vector expression - either a TK_VECTOR +** or TK_SELECT that returns more than one column. This function returns +** the register number of a register that contains the value of +** element iField of the vector. +** +** If pVector is a TK_SELECT expression, then code for it must have +** already been generated using the exprCodeSubselect() routine. In this +** case parameter regSelect should be the first in an array of registers +** containing the results of the sub-select. +** +** If pVector is of type TK_VECTOR, then code for the requested field +** is generated. In this case (*pRegFree) may be set to the number of +** a temporary register to be freed by the caller before returning. +** +** Before returning, output parameter (*ppExpr) is set to point to the +** Expr object corresponding to element iElem of the vector. +*/ +static int exprVectorRegister( + Parse *pParse, /* Parse context */ + Expr *pVector, /* Vector to extract element from */ + int iField, /* Field to extract from pVector */ + int regSelect, /* First in array of registers */ + Expr **ppExpr, /* OUT: Expression element */ + int *pRegFree /* OUT: Temp register to free */ +){ + u8 op = pVector->op; + assert( op==TK_VECTOR || op==TK_REGISTER || op==TK_SELECT ); + if( op==TK_REGISTER ){ + *ppExpr = sqlite3VectorFieldSubexpr(pVector, iField); + return pVector->iTable+iField; + } + if( op==TK_SELECT ){ + *ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr; + return regSelect+iField; + } + *ppExpr = pVector->x.pList->a[iField].pExpr; + return sqlite3ExprCodeTemp(pParse, *ppExpr, pRegFree); +} + +/* +** Expression pExpr is a comparison between two vector values. Compute +** the result of the comparison (1, 0, or NULL) and write that +** result into register dest. +** +** The caller must satisfy the following preconditions: +** +** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ +** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ +** otherwise: op==pExpr->op and p5==0 +*/ +static void codeVectorCompare( + Parse *pParse, /* Code generator context */ + Expr *pExpr, /* The comparison operation */ + int dest, /* Write results into this register */ + u8 op, /* Comparison operator */ + u8 p5 /* SQLITE_NULLEQ or zero */ +){ + Vdbe *v = pParse->pVdbe; + Expr *pLeft = pExpr->pLeft; + Expr *pRight = pExpr->pRight; + int nLeft = sqlite3ExprVectorSize(pLeft); + int i; + int regLeft = 0; + int regRight = 0; + u8 opx = op; + int addrDone = sqlite3VdbeMakeLabel(pParse); + int isCommuted = ExprHasProperty(pExpr,EP_Commuted); + + assert( !ExprHasVVAProperty(pExpr,EP_Immutable) ); + if( pParse->nErr ) return; + if( nLeft!=sqlite3ExprVectorSize(pRight) ){ + sqlite3ErrorMsg(pParse, "row value misused"); + return; + } + assert( pExpr->op==TK_EQ || pExpr->op==TK_NE + || pExpr->op==TK_IS || pExpr->op==TK_ISNOT + || pExpr->op==TK_LT || pExpr->op==TK_GT + || pExpr->op==TK_LE || pExpr->op==TK_GE + ); + assert( pExpr->op==op || (pExpr->op==TK_IS && op==TK_EQ) + || (pExpr->op==TK_ISNOT && op==TK_NE) ); + assert( p5==0 || pExpr->op!=op ); + assert( p5==SQLITE_NULLEQ || pExpr->op==op ); + + p5 |= SQLITE_STOREP2; + if( opx==TK_LE ) opx = TK_LT; + if( opx==TK_GE ) opx = TK_GT; + + regLeft = exprCodeSubselect(pParse, pLeft); + regRight = exprCodeSubselect(pParse, pRight); + + for(i=0; 1 /*Loop exits by "break"*/; i++){ + int regFree1 = 0, regFree2 = 0; + Expr *pL, *pR; + int r1, r2; + assert( i>=0 && i0 +/* +** Check that argument nHeight is less than or equal to the maximum +** expression depth allowed. If it is not, leave an error message in +** pParse. +*/ +SQLITE_PRIVATE int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){ + int rc = SQLITE_OK; + int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH]; + if( nHeight>mxHeight ){ + sqlite3ErrorMsg(pParse, + "Expression tree is too large (maximum depth %d)", mxHeight + ); + rc = SQLITE_ERROR; + } + return rc; +} + +/* The following three functions, heightOfExpr(), heightOfExprList() +** and heightOfSelect(), are used to determine the maximum height +** of any expression tree referenced by the structure passed as the +** first argument. +** +** If this maximum height is greater than the current value pointed +** to by pnHeight, the second parameter, then set *pnHeight to that +** value. +*/ +static void heightOfExpr(Expr *p, int *pnHeight){ + if( p ){ + if( p->nHeight>*pnHeight ){ + *pnHeight = p->nHeight; + } + } +} +static void heightOfExprList(ExprList *p, int *pnHeight){ + if( p ){ + int i; + for(i=0; inExpr; i++){ + heightOfExpr(p->a[i].pExpr, pnHeight); + } + } +} +static void heightOfSelect(Select *pSelect, int *pnHeight){ + Select *p; + for(p=pSelect; p; p=p->pPrior){ + heightOfExpr(p->pWhere, pnHeight); + heightOfExpr(p->pHaving, pnHeight); + heightOfExpr(p->pLimit, pnHeight); + heightOfExprList(p->pEList, pnHeight); + heightOfExprList(p->pGroupBy, pnHeight); + heightOfExprList(p->pOrderBy, pnHeight); + } +} + +/* +** Set the Expr.nHeight variable in the structure passed as an +** argument. An expression with no children, Expr.pList or +** Expr.pSelect member has a height of 1. Any other expression +** has a height equal to the maximum height of any other +** referenced Expr plus one. +** +** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags, +** if appropriate. +*/ +static void exprSetHeight(Expr *p){ + int nHeight = 0; + heightOfExpr(p->pLeft, &nHeight); + heightOfExpr(p->pRight, &nHeight); + if( ExprHasProperty(p, EP_xIsSelect) ){ + heightOfSelect(p->x.pSelect, &nHeight); + }else if( p->x.pList ){ + heightOfExprList(p->x.pList, &nHeight); + p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList); + } + p->nHeight = nHeight + 1; +} + +/* +** Set the Expr.nHeight variable using the exprSetHeight() function. If +** the height is greater than the maximum allowed expression depth, +** leave an error in pParse. +** +** Also propagate all EP_Propagate flags from the Expr.x.pList into +** Expr.flags. +*/ +SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){ + if( pParse->nErr ) return; + exprSetHeight(p); + sqlite3ExprCheckHeight(pParse, p->nHeight); +} + +/* +** Return the maximum height of any expression tree referenced +** by the select statement passed as an argument. +*/ +SQLITE_PRIVATE int sqlite3SelectExprHeight(Select *p){ + int nHeight = 0; + heightOfSelect(p, &nHeight); + return nHeight; +} +#else /* ABOVE: Height enforcement enabled. BELOW: Height enforcement off */ +/* +** Propagate all EP_Propagate flags from the Expr.x.pList into +** Expr.flags. +*/ +SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){ + if( pParse->nErr ) return; + if( p && p->x.pList && !ExprHasProperty(p, EP_xIsSelect) ){ + p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList); + } +} +#define exprSetHeight(y) +#endif /* SQLITE_MAX_EXPR_DEPTH>0 */ + +/* +** This routine is the core allocator for Expr nodes. +** +** Construct a new expression node and return a pointer to it. Memory +** for this node and for the pToken argument is a single allocation +** obtained from sqlite3DbMalloc(). The calling function +** is responsible for making sure the node eventually gets freed. +** +** If dequote is true, then the token (if it exists) is dequoted. +** If dequote is false, no dequoting is performed. The deQuote +** parameter is ignored if pToken is NULL or if the token does not +** appear to be quoted. If the quotes were of the form "..." (double-quotes) +** then the EP_DblQuoted flag is set on the expression node. +** +** Special case: If op==TK_INTEGER and pToken points to a string that +** can be translated into a 32-bit integer, then the token is not +** stored in u.zToken. Instead, the integer values is written +** into u.iValue and the EP_IntValue flag is set. No extra storage +** is allocated to hold the integer text and the dequote flag is ignored. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprAlloc( + sqlite3 *db, /* Handle for sqlite3DbMallocRawNN() */ + int op, /* Expression opcode */ + const Token *pToken, /* Token argument. Might be NULL */ + int dequote /* True to dequote */ +){ + Expr *pNew; + int nExtra = 0; + int iValue = 0; + + assert( db!=0 ); + if( pToken ){ + if( op!=TK_INTEGER || pToken->z==0 + || sqlite3GetInt32(pToken->z, &iValue)==0 ){ + nExtra = pToken->n+1; + assert( iValue>=0 ); + } + } + pNew = sqlite3DbMallocRawNN(db, sizeof(Expr)+nExtra); + if( pNew ){ + memset(pNew, 0, sizeof(Expr)); + pNew->op = (u8)op; + pNew->iAgg = -1; + if( pToken ){ + if( nExtra==0 ){ + pNew->flags |= EP_IntValue|EP_Leaf|(iValue?EP_IsTrue:EP_IsFalse); + pNew->u.iValue = iValue; + }else{ + pNew->u.zToken = (char*)&pNew[1]; + assert( pToken->z!=0 || pToken->n==0 ); + if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n); + pNew->u.zToken[pToken->n] = 0; + if( dequote && sqlite3Isquote(pNew->u.zToken[0]) ){ + sqlite3DequoteExpr(pNew); + } + } + } +#if SQLITE_MAX_EXPR_DEPTH>0 + pNew->nHeight = 1; +#endif + } + return pNew; +} + +/* +** Allocate a new expression node from a zero-terminated token that has +** already been dequoted. +*/ +SQLITE_PRIVATE Expr *sqlite3Expr( + sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */ + int op, /* Expression opcode */ + const char *zToken /* Token argument. Might be NULL */ +){ + Token x; + x.z = zToken; + x.n = sqlite3Strlen30(zToken); + return sqlite3ExprAlloc(db, op, &x, 0); +} + +/* +** Attach subtrees pLeft and pRight to the Expr node pRoot. +** +** If pRoot==NULL that means that a memory allocation error has occurred. +** In that case, delete the subtrees pLeft and pRight. +*/ +SQLITE_PRIVATE void sqlite3ExprAttachSubtrees( + sqlite3 *db, + Expr *pRoot, + Expr *pLeft, + Expr *pRight +){ + if( pRoot==0 ){ + assert( db->mallocFailed ); + sqlite3ExprDelete(db, pLeft); + sqlite3ExprDelete(db, pRight); + }else{ + if( pRight ){ + pRoot->pRight = pRight; + pRoot->flags |= EP_Propagate & pRight->flags; + } + if( pLeft ){ + pRoot->pLeft = pLeft; + pRoot->flags |= EP_Propagate & pLeft->flags; + } + exprSetHeight(pRoot); + } +} + +/* +** Allocate an Expr node which joins as many as two subtrees. +** +** One or both of the subtrees can be NULL. Return a pointer to the new +** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed, +** free the subtrees and return NULL. +*/ +SQLITE_PRIVATE Expr *sqlite3PExpr( + Parse *pParse, /* Parsing context */ + int op, /* Expression opcode */ + Expr *pLeft, /* Left operand */ + Expr *pRight /* Right operand */ +){ + Expr *p; + p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)); + if( p ){ + memset(p, 0, sizeof(Expr)); + p->op = op & 0xff; + p->iAgg = -1; + sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight); + sqlite3ExprCheckHeight(pParse, p->nHeight); + }else{ + sqlite3ExprDelete(pParse->db, pLeft); + sqlite3ExprDelete(pParse->db, pRight); + } + return p; +} + +/* +** Add pSelect to the Expr.x.pSelect field. Or, if pExpr is NULL (due +** do a memory allocation failure) then delete the pSelect object. +*/ +SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse *pParse, Expr *pExpr, Select *pSelect){ + if( pExpr ){ + pExpr->x.pSelect = pSelect; + ExprSetProperty(pExpr, EP_xIsSelect|EP_Subquery); + sqlite3ExprSetHeightAndFlags(pParse, pExpr); + }else{ + assert( pParse->db->mallocFailed ); + sqlite3SelectDelete(pParse->db, pSelect); + } +} + + +/* +** Join two expressions using an AND operator. If either expression is +** NULL, then just return the other expression. +** +** If one side or the other of the AND is known to be false, then instead +** of returning an AND expression, just return a constant expression with +** a value of false. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse *pParse, Expr *pLeft, Expr *pRight){ + sqlite3 *db = pParse->db; + if( pLeft==0 ){ + return pRight; + }else if( pRight==0 ){ + return pLeft; + }else if( (ExprAlwaysFalse(pLeft) || ExprAlwaysFalse(pRight)) + && !IN_RENAME_OBJECT + ){ + sqlite3ExprDelete(db, pLeft); + sqlite3ExprDelete(db, pRight); + return sqlite3Expr(db, TK_INTEGER, "0"); + }else{ + return sqlite3PExpr(pParse, TK_AND, pLeft, pRight); + } +} + +/* +** Construct a new expression node for a function with multiple +** arguments. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprFunction( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* Argument list */ + Token *pToken, /* Name of the function */ + int eDistinct /* SF_Distinct or SF_ALL or 0 */ +){ + Expr *pNew; + sqlite3 *db = pParse->db; + assert( pToken ); + pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1); + if( pNew==0 ){ + sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */ + return 0; + } + if( pList && pList->nExpr > pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){ + sqlite3ErrorMsg(pParse, "too many arguments on function %T", pToken); + } + pNew->x.pList = pList; + ExprSetProperty(pNew, EP_HasFunc); + assert( !ExprHasProperty(pNew, EP_xIsSelect) ); + sqlite3ExprSetHeightAndFlags(pParse, pNew); + if( eDistinct==SF_Distinct ) ExprSetProperty(pNew, EP_Distinct); + return pNew; +} + +/* +** Check to see if a function is usable according to current access +** rules: +** +** SQLITE_FUNC_DIRECT - Only usable from top-level SQL +** +** SQLITE_FUNC_UNSAFE - Usable if TRUSTED_SCHEMA or from +** top-level SQL +** +** If the function is not usable, create an error. +*/ +SQLITE_PRIVATE void sqlite3ExprFunctionUsable( + Parse *pParse, /* Parsing and code generating context */ + Expr *pExpr, /* The function invocation */ + FuncDef *pDef /* The function being invoked */ +){ + assert( !IN_RENAME_OBJECT ); + assert( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0 ); + if( ExprHasProperty(pExpr, EP_FromDDL) ){ + if( (pDef->funcFlags & SQLITE_FUNC_DIRECT)!=0 + || (pParse->db->flags & SQLITE_TrustedSchema)==0 + ){ + /* Functions prohibited in triggers and views if: + ** (1) tagged with SQLITE_DIRECTONLY + ** (2) not tagged with SQLITE_INNOCUOUS (which means it + ** is tagged with SQLITE_FUNC_UNSAFE) and + ** SQLITE_DBCONFIG_TRUSTED_SCHEMA is off (meaning + ** that the schema is possibly tainted). + */ + sqlite3ErrorMsg(pParse, "unsafe use of %s()", pDef->zName); + } + } +} + +/* +** Assign a variable number to an expression that encodes a wildcard +** in the original SQL statement. +** +** Wildcards consisting of a single "?" are assigned the next sequential +** variable number. +** +** Wildcards of the form "?nnn" are assigned the number "nnn". We make +** sure "nnn" is not too big to avoid a denial of service attack when +** the SQL statement comes from an external source. +** +** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number +** as the previous instance of the same wildcard. Or if this is the first +** instance of the wildcard, the next sequential variable number is +** assigned. +*/ +SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n){ + sqlite3 *db = pParse->db; + const char *z; + ynVar x; + + if( pExpr==0 ) return; + assert( !ExprHasProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) ); + z = pExpr->u.zToken; + assert( z!=0 ); + assert( z[0]!=0 ); + assert( n==(u32)sqlite3Strlen30(z) ); + if( z[1]==0 ){ + /* Wildcard of the form "?". Assign the next variable number */ + assert( z[0]=='?' ); + x = (ynVar)(++pParse->nVar); + }else{ + int doAdd = 0; + if( z[0]=='?' ){ + /* Wildcard of the form "?nnn". Convert "nnn" to an integer and + ** use it as the variable number */ + i64 i; + int bOk; + if( n==2 ){ /*OPTIMIZATION-IF-TRUE*/ + i = z[1]-'0'; /* The common case of ?N for a single digit N */ + bOk = 1; + }else{ + bOk = 0==sqlite3Atoi64(&z[1], &i, n-1, SQLITE_UTF8); + } + testcase( i==0 ); + testcase( i==1 ); + testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 ); + testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ); + if( bOk==0 || i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){ + sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d", + db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]); + return; + } + x = (ynVar)i; + if( x>pParse->nVar ){ + pParse->nVar = (int)x; + doAdd = 1; + }else if( sqlite3VListNumToName(pParse->pVList, x)==0 ){ + doAdd = 1; + } + }else{ + /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable + ** number as the prior appearance of the same name, or if the name + ** has never appeared before, reuse the same variable number + */ + x = (ynVar)sqlite3VListNameToNum(pParse->pVList, z, n); + if( x==0 ){ + x = (ynVar)(++pParse->nVar); + doAdd = 1; + } + } + if( doAdd ){ + pParse->pVList = sqlite3VListAdd(db, pParse->pVList, z, n, x); + } + } + pExpr->iColumn = x; + if( x>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){ + sqlite3ErrorMsg(pParse, "too many SQL variables"); + } +} + +/* +** Recursively delete an expression tree. +*/ +static SQLITE_NOINLINE void sqlite3ExprDeleteNN(sqlite3 *db, Expr *p){ + assert( p!=0 ); + /* Sanity check: Assert that the IntValue is non-negative if it exists */ + assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 ); + + assert( !ExprHasProperty(p, EP_WinFunc) || p->y.pWin!=0 || db->mallocFailed ); + assert( p->op!=TK_FUNCTION || ExprHasProperty(p, EP_TokenOnly|EP_Reduced) + || p->y.pWin==0 || ExprHasProperty(p, EP_WinFunc) ); +#ifdef SQLITE_DEBUG + if( ExprHasProperty(p, EP_Leaf) && !ExprHasProperty(p, EP_TokenOnly) ){ + assert( p->pLeft==0 ); + assert( p->pRight==0 ); + assert( p->x.pSelect==0 ); + } +#endif + if( !ExprHasProperty(p, (EP_TokenOnly|EP_Leaf)) ){ + /* The Expr.x union is never used at the same time as Expr.pRight */ + assert( p->x.pList==0 || p->pRight==0 ); + if( p->pLeft && p->op!=TK_SELECT_COLUMN ) sqlite3ExprDeleteNN(db, p->pLeft); + if( p->pRight ){ + assert( !ExprHasProperty(p, EP_WinFunc) ); + sqlite3ExprDeleteNN(db, p->pRight); + }else if( ExprHasProperty(p, EP_xIsSelect) ){ + assert( !ExprHasProperty(p, EP_WinFunc) ); + sqlite3SelectDelete(db, p->x.pSelect); + }else{ + sqlite3ExprListDelete(db, p->x.pList); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( ExprHasProperty(p, EP_WinFunc) ){ + sqlite3WindowDelete(db, p->y.pWin); + } +#endif + } + } + if( ExprHasProperty(p, EP_MemToken) ) sqlite3DbFree(db, p->u.zToken); + if( !ExprHasProperty(p, EP_Static) ){ + sqlite3DbFreeNN(db, p); + } +} +SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3 *db, Expr *p){ + if( p ) sqlite3ExprDeleteNN(db, p); +} + +/* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the +** expression. +*/ +SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete(Parse *pParse, Expr *p){ + if( p ){ + if( IN_RENAME_OBJECT ){ + sqlite3RenameExprUnmap(pParse, p); + } + sqlite3ExprDeleteNN(pParse->db, p); + } +} + +/* +** Return the number of bytes allocated for the expression structure +** passed as the first argument. This is always one of EXPR_FULLSIZE, +** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE. +*/ +static int exprStructSize(Expr *p){ + if( ExprHasProperty(p, EP_TokenOnly) ) return EXPR_TOKENONLYSIZE; + if( ExprHasProperty(p, EP_Reduced) ) return EXPR_REDUCEDSIZE; + return EXPR_FULLSIZE; +} + +/* +** The dupedExpr*Size() routines each return the number of bytes required +** to store a copy of an expression or expression tree. They differ in +** how much of the tree is measured. +** +** dupedExprStructSize() Size of only the Expr structure +** dupedExprNodeSize() Size of Expr + space for token +** dupedExprSize() Expr + token + subtree components +** +*************************************************************************** +** +** The dupedExprStructSize() function returns two values OR-ed together: +** (1) the space required for a copy of the Expr structure only and +** (2) the EP_xxx flags that indicate what the structure size should be. +** The return values is always one of: +** +** EXPR_FULLSIZE +** EXPR_REDUCEDSIZE | EP_Reduced +** EXPR_TOKENONLYSIZE | EP_TokenOnly +** +** The size of the structure can be found by masking the return value +** of this routine with 0xfff. The flags can be found by masking the +** return value with EP_Reduced|EP_TokenOnly. +** +** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size +** (unreduced) Expr objects as they or originally constructed by the parser. +** During expression analysis, extra information is computed and moved into +** later parts of the Expr object and that extra information might get chopped +** off if the expression is reduced. Note also that it does not work to +** make an EXPRDUP_REDUCE copy of a reduced expression. It is only legal +** to reduce a pristine expression tree from the parser. The implementation +** of dupedExprStructSize() contain multiple assert() statements that attempt +** to enforce this constraint. +*/ +static int dupedExprStructSize(Expr *p, int flags){ + int nSize; + assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */ + assert( EXPR_FULLSIZE<=0xfff ); + assert( (0xfff & (EP_Reduced|EP_TokenOnly))==0 ); + if( 0==flags || p->op==TK_SELECT_COLUMN +#ifndef SQLITE_OMIT_WINDOWFUNC + || ExprHasProperty(p, EP_WinFunc) +#endif + ){ + nSize = EXPR_FULLSIZE; + }else{ + assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) ); + assert( !ExprHasProperty(p, EP_FromJoin) ); + assert( !ExprHasProperty(p, EP_MemToken) ); + assert( !ExprHasVVAProperty(p, EP_NoReduce) ); + if( p->pLeft || p->x.pList ){ + nSize = EXPR_REDUCEDSIZE | EP_Reduced; + }else{ + assert( p->pRight==0 ); + nSize = EXPR_TOKENONLYSIZE | EP_TokenOnly; + } + } + return nSize; +} + +/* +** This function returns the space in bytes required to store the copy +** of the Expr structure and a copy of the Expr.u.zToken string (if that +** string is defined.) +*/ +static int dupedExprNodeSize(Expr *p, int flags){ + int nByte = dupedExprStructSize(p, flags) & 0xfff; + if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){ + nByte += sqlite3Strlen30NN(p->u.zToken)+1; + } + return ROUND8(nByte); +} + +/* +** Return the number of bytes required to create a duplicate of the +** expression passed as the first argument. The second argument is a +** mask containing EXPRDUP_XXX flags. +** +** The value returned includes space to create a copy of the Expr struct +** itself and the buffer referred to by Expr.u.zToken, if any. +** +** If the EXPRDUP_REDUCE flag is set, then the return value includes +** space to duplicate all Expr nodes in the tree formed by Expr.pLeft +** and Expr.pRight variables (but not for any structures pointed to or +** descended from the Expr.x.pList or Expr.x.pSelect variables). +*/ +static int dupedExprSize(Expr *p, int flags){ + int nByte = 0; + if( p ){ + nByte = dupedExprNodeSize(p, flags); + if( flags&EXPRDUP_REDUCE ){ + nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags); + } + } + return nByte; +} + +/* +** This function is similar to sqlite3ExprDup(), except that if pzBuffer +** is not NULL then *pzBuffer is assumed to point to a buffer large enough +** to store the copy of expression p, the copies of p->u.zToken +** (if applicable), and the copies of the p->pLeft and p->pRight expressions, +** if any. Before returning, *pzBuffer is set to the first byte past the +** portion of the buffer copied into by this function. +*/ +static Expr *exprDup(sqlite3 *db, Expr *p, int dupFlags, u8 **pzBuffer){ + Expr *pNew; /* Value to return */ + u8 *zAlloc; /* Memory space from which to build Expr object */ + u32 staticFlag; /* EP_Static if space not obtained from malloc */ + + assert( db!=0 ); + assert( p ); + assert( dupFlags==0 || dupFlags==EXPRDUP_REDUCE ); + assert( pzBuffer==0 || dupFlags==EXPRDUP_REDUCE ); + + /* Figure out where to write the new Expr structure. */ + if( pzBuffer ){ + zAlloc = *pzBuffer; + staticFlag = EP_Static; + }else{ + zAlloc = sqlite3DbMallocRawNN(db, dupedExprSize(p, dupFlags)); + staticFlag = 0; + } + pNew = (Expr *)zAlloc; + + if( pNew ){ + /* Set nNewSize to the size allocated for the structure pointed to + ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or + ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed + ** by the copy of the p->u.zToken string (if any). + */ + const unsigned nStructSize = dupedExprStructSize(p, dupFlags); + const int nNewSize = nStructSize & 0xfff; + int nToken; + if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){ + nToken = sqlite3Strlen30(p->u.zToken) + 1; + }else{ + nToken = 0; + } + if( dupFlags ){ + assert( ExprHasProperty(p, EP_Reduced)==0 ); + memcpy(zAlloc, p, nNewSize); + }else{ + u32 nSize = (u32)exprStructSize(p); + memcpy(zAlloc, p, nSize); + if( nSizeflags &= ~(EP_Reduced|EP_TokenOnly|EP_Static|EP_MemToken); + pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly); + pNew->flags |= staticFlag; + ExprClearVVAProperties(pNew); + if( dupFlags ){ + ExprSetVVAProperty(pNew, EP_Immutable); + } + + /* Copy the p->u.zToken string, if any. */ + if( nToken ){ + char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize]; + memcpy(zToken, p->u.zToken, nToken); + } + + if( 0==((p->flags|pNew->flags) & (EP_TokenOnly|EP_Leaf)) ){ + /* Fill in the pNew->x.pSelect or pNew->x.pList member. */ + if( ExprHasProperty(p, EP_xIsSelect) ){ + pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, dupFlags); + }else{ + pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, dupFlags); + } + } + + /* Fill in pNew->pLeft and pNew->pRight. */ + if( ExprHasProperty(pNew, EP_Reduced|EP_TokenOnly|EP_WinFunc) ){ + zAlloc += dupedExprNodeSize(p, dupFlags); + if( !ExprHasProperty(pNew, EP_TokenOnly|EP_Leaf) ){ + pNew->pLeft = p->pLeft ? + exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc) : 0; + pNew->pRight = p->pRight ? + exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc) : 0; + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( ExprHasProperty(p, EP_WinFunc) ){ + pNew->y.pWin = sqlite3WindowDup(db, pNew, p->y.pWin); + assert( ExprHasProperty(pNew, EP_WinFunc) ); + } +#endif /* SQLITE_OMIT_WINDOWFUNC */ + if( pzBuffer ){ + *pzBuffer = zAlloc; + } + }else{ + if( !ExprHasProperty(p, EP_TokenOnly|EP_Leaf) ){ + if( pNew->op==TK_SELECT_COLUMN ){ + pNew->pLeft = p->pLeft; + assert( p->iColumn==0 || p->pRight==0 ); + assert( p->pRight==0 || p->pRight==p->pLeft ); + }else{ + pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0); + } + pNew->pRight = sqlite3ExprDup(db, p->pRight, 0); + } + } + } + return pNew; +} + +/* +** Create and return a deep copy of the object passed as the second +** argument. If an OOM condition is encountered, NULL is returned +** and the db->mallocFailed flag set. +*/ +#ifndef SQLITE_OMIT_CTE +static With *withDup(sqlite3 *db, With *p){ + With *pRet = 0; + if( p ){ + sqlite3_int64 nByte = sizeof(*p) + sizeof(p->a[0]) * (p->nCte-1); + pRet = sqlite3DbMallocZero(db, nByte); + if( pRet ){ + int i; + pRet->nCte = p->nCte; + for(i=0; inCte; i++){ + pRet->a[i].pSelect = sqlite3SelectDup(db, p->a[i].pSelect, 0); + pRet->a[i].pCols = sqlite3ExprListDup(db, p->a[i].pCols, 0); + pRet->a[i].zName = sqlite3DbStrDup(db, p->a[i].zName); + } + } + } + return pRet; +} +#else +# define withDup(x,y) 0 +#endif + +#ifndef SQLITE_OMIT_WINDOWFUNC +/* +** The gatherSelectWindows() procedure and its helper routine +** gatherSelectWindowsCallback() are used to scan all the expressions +** an a newly duplicated SELECT statement and gather all of the Window +** objects found there, assembling them onto the linked list at Select->pWin. +*/ +static int gatherSelectWindowsCallback(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_WinFunc) ){ + Select *pSelect = pWalker->u.pSelect; + Window *pWin = pExpr->y.pWin; + assert( pWin ); + assert( IsWindowFunc(pExpr) ); + assert( pWin->ppThis==0 ); + sqlite3WindowLink(pSelect, pWin); + } + return WRC_Continue; +} +static int gatherSelectWindowsSelectCallback(Walker *pWalker, Select *p){ + return p==pWalker->u.pSelect ? WRC_Continue : WRC_Prune; +} +static void gatherSelectWindows(Select *p){ + Walker w; + w.xExprCallback = gatherSelectWindowsCallback; + w.xSelectCallback = gatherSelectWindowsSelectCallback; + w.xSelectCallback2 = 0; + w.pParse = 0; + w.u.pSelect = p; + sqlite3WalkSelect(&w, p); +} +#endif + + +/* +** The following group of routines make deep copies of expressions, +** expression lists, ID lists, and select statements. The copies can +** be deleted (by being passed to their respective ...Delete() routines) +** without effecting the originals. +** +** The expression list, ID, and source lists return by sqlite3ExprListDup(), +** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded +** by subsequent calls to sqlite*ListAppend() routines. +** +** Any tables that the SrcList might point to are not duplicated. +** +** The flags parameter contains a combination of the EXPRDUP_XXX flags. +** If the EXPRDUP_REDUCE flag is set, then the structure returned is a +** truncated version of the usual Expr structure that will be stored as +** part of the in-memory representation of the database schema. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3 *db, Expr *p, int flags){ + assert( flags==0 || flags==EXPRDUP_REDUCE ); + return p ? exprDup(db, p, flags, 0) : 0; +} +SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){ + ExprList *pNew; + struct ExprList_item *pItem, *pOldItem; + int i; + Expr *pPriorSelectCol = 0; + assert( db!=0 ); + if( p==0 ) return 0; + pNew = sqlite3DbMallocRawNN(db, sqlite3DbMallocSize(db, p)); + if( pNew==0 ) return 0; + pNew->nExpr = p->nExpr; + pItem = pNew->a; + pOldItem = p->a; + for(i=0; inExpr; i++, pItem++, pOldItem++){ + Expr *pOldExpr = pOldItem->pExpr; + Expr *pNewExpr; + pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags); + if( pOldExpr + && pOldExpr->op==TK_SELECT_COLUMN + && (pNewExpr = pItem->pExpr)!=0 + ){ + assert( pNewExpr->iColumn==0 || i>0 ); + if( pNewExpr->iColumn==0 ){ + assert( pOldExpr->pLeft==pOldExpr->pRight ); + pPriorSelectCol = pNewExpr->pLeft = pNewExpr->pRight; + }else{ + assert( i>0 ); + assert( pItem[-1].pExpr!=0 ); + assert( pNewExpr->iColumn==pItem[-1].pExpr->iColumn+1 ); + assert( pPriorSelectCol==pItem[-1].pExpr->pLeft ); + pNewExpr->pLeft = pPriorSelectCol; + } + } + pItem->zEName = sqlite3DbStrDup(db, pOldItem->zEName); + pItem->sortFlags = pOldItem->sortFlags; + pItem->eEName = pOldItem->eEName; + pItem->done = 0; + pItem->bNulls = pOldItem->bNulls; + pItem->bSorterRef = pOldItem->bSorterRef; + pItem->u = pOldItem->u; + } + return pNew; +} + +/* +** If cursors, triggers, views and subqueries are all omitted from +** the build, then none of the following routines, except for +** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes +** called with a NULL argument. +*/ +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \ + || !defined(SQLITE_OMIT_SUBQUERY) +SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){ + SrcList *pNew; + int i; + int nByte; + assert( db!=0 ); + if( p==0 ) return 0; + nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0); + pNew = sqlite3DbMallocRawNN(db, nByte ); + if( pNew==0 ) return 0; + pNew->nSrc = pNew->nAlloc = p->nSrc; + for(i=0; inSrc; i++){ + struct SrcList_item *pNewItem = &pNew->a[i]; + struct SrcList_item *pOldItem = &p->a[i]; + Table *pTab; + pNewItem->pSchema = pOldItem->pSchema; + pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase); + pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName); + pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias); + pNewItem->fg = pOldItem->fg; + pNewItem->iCursor = pOldItem->iCursor; + pNewItem->addrFillSub = pOldItem->addrFillSub; + pNewItem->regReturn = pOldItem->regReturn; + if( pNewItem->fg.isIndexedBy ){ + pNewItem->u1.zIndexedBy = sqlite3DbStrDup(db, pOldItem->u1.zIndexedBy); + } + pNewItem->pIBIndex = pOldItem->pIBIndex; + if( pNewItem->fg.isTabFunc ){ + pNewItem->u1.pFuncArg = + sqlite3ExprListDup(db, pOldItem->u1.pFuncArg, flags); + } + pTab = pNewItem->pTab = pOldItem->pTab; + if( pTab ){ + pTab->nTabRef++; + } + pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags); + pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn, flags); + pNewItem->pUsing = sqlite3IdListDup(db, pOldItem->pUsing); + pNewItem->colUsed = pOldItem->colUsed; + } + return pNew; +} +SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){ + IdList *pNew; + int i; + assert( db!=0 ); + if( p==0 ) return 0; + pNew = sqlite3DbMallocRawNN(db, sizeof(*pNew) ); + if( pNew==0 ) return 0; + pNew->nId = p->nId; + pNew->a = sqlite3DbMallocRawNN(db, p->nId*sizeof(p->a[0]) ); + if( pNew->a==0 ){ + sqlite3DbFreeNN(db, pNew); + return 0; + } + /* Note that because the size of the allocation for p->a[] is not + ** necessarily a power of two, sqlite3IdListAppend() may not be called + ** on the duplicate created by this function. */ + for(i=0; inId; i++){ + struct IdList_item *pNewItem = &pNew->a[i]; + struct IdList_item *pOldItem = &p->a[i]; + pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName); + pNewItem->idx = pOldItem->idx; + } + return pNew; +} +SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *pDup, int flags){ + Select *pRet = 0; + Select *pNext = 0; + Select **pp = &pRet; + Select *p; + + assert( db!=0 ); + for(p=pDup; p; p=p->pPrior){ + Select *pNew = sqlite3DbMallocRawNN(db, sizeof(*p) ); + if( pNew==0 ) break; + pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags); + pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags); + pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags); + pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags); + pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags); + pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags); + pNew->op = p->op; + pNew->pNext = pNext; + pNew->pPrior = 0; + pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags); + pNew->iLimit = 0; + pNew->iOffset = 0; + pNew->selFlags = p->selFlags & ~SF_UsesEphemeral; + pNew->addrOpenEphm[0] = -1; + pNew->addrOpenEphm[1] = -1; + pNew->nSelectRow = p->nSelectRow; + pNew->pWith = withDup(db, p->pWith); +#ifndef SQLITE_OMIT_WINDOWFUNC + pNew->pWin = 0; + pNew->pWinDefn = sqlite3WindowListDup(db, p->pWinDefn); + if( p->pWin && db->mallocFailed==0 ) gatherSelectWindows(pNew); +#endif + pNew->selId = p->selId; + *pp = pNew; + pp = &pNew->pPrior; + pNext = pNew; + } + + return pRet; +} +#else +SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){ + assert( p==0 ); + return 0; +} +#endif + + +/* +** Add a new element to the end of an expression list. If pList is +** initially NULL, then create a new expression list. +** +** The pList argument must be either NULL or a pointer to an ExprList +** obtained from a prior call to sqlite3ExprListAppend(). This routine +** may not be used with an ExprList obtained from sqlite3ExprListDup(). +** Reason: This routine assumes that the number of slots in pList->a[] +** is a power of two. That is true for sqlite3ExprListAppend() returns +** but is not necessarily true from the return value of sqlite3ExprListDup(). +** +** If a memory allocation error occurs, the entire list is freed and +** NULL is returned. If non-NULL is returned, then it is guaranteed +** that the new entry was successfully appended. +*/ +SQLITE_PRIVATE ExprList *sqlite3ExprListAppend( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List to which to append. Might be NULL */ + Expr *pExpr /* Expression to be appended. Might be NULL */ +){ + struct ExprList_item *pItem; + sqlite3 *db = pParse->db; + assert( db!=0 ); + if( pList==0 ){ + pList = sqlite3DbMallocRawNN(db, sizeof(ExprList) ); + if( pList==0 ){ + goto no_mem; + } + pList->nExpr = 0; + }else if( (pList->nExpr & (pList->nExpr-1))==0 ){ + ExprList *pNew; + pNew = sqlite3DbRealloc(db, pList, + sizeof(*pList)+(2*(sqlite3_int64)pList->nExpr-1)*sizeof(pList->a[0])); + if( pNew==0 ){ + goto no_mem; + } + pList = pNew; + } + pItem = &pList->a[pList->nExpr++]; + assert( offsetof(struct ExprList_item,zEName)==sizeof(pItem->pExpr) ); + assert( offsetof(struct ExprList_item,pExpr)==0 ); + memset(&pItem->zEName,0,sizeof(*pItem)-offsetof(struct ExprList_item,zEName)); + pItem->pExpr = pExpr; + return pList; + +no_mem: + /* Avoid leaking memory if malloc has failed. */ + sqlite3ExprDelete(db, pExpr); + sqlite3ExprListDelete(db, pList); + return 0; +} + +/* +** pColumns and pExpr form a vector assignment which is part of the SET +** clause of an UPDATE statement. Like this: +** +** (a,b,c) = (expr1,expr2,expr3) +** Or: (a,b,c) = (SELECT x,y,z FROM ....) +** +** For each term of the vector assignment, append new entries to the +** expression list pList. In the case of a subquery on the RHS, append +** TK_SELECT_COLUMN expressions. +*/ +SQLITE_PRIVATE ExprList *sqlite3ExprListAppendVector( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List to which to append. Might be NULL */ + IdList *pColumns, /* List of names of LHS of the assignment */ + Expr *pExpr /* Vector expression to be appended. Might be NULL */ +){ + sqlite3 *db = pParse->db; + int n; + int i; + int iFirst = pList ? pList->nExpr : 0; + /* pColumns can only be NULL due to an OOM but an OOM will cause an + ** exit prior to this routine being invoked */ + if( NEVER(pColumns==0) ) goto vector_append_error; + if( pExpr==0 ) goto vector_append_error; + + /* If the RHS is a vector, then we can immediately check to see that + ** the size of the RHS and LHS match. But if the RHS is a SELECT, + ** wildcards ("*") in the result set of the SELECT must be expanded before + ** we can do the size check, so defer the size check until code generation. + */ + if( pExpr->op!=TK_SELECT && pColumns->nId!=(n=sqlite3ExprVectorSize(pExpr)) ){ + sqlite3ErrorMsg(pParse, "%d columns assigned %d values", + pColumns->nId, n); + goto vector_append_error; + } + + for(i=0; inId; i++){ + Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i); + assert( pSubExpr!=0 || db->mallocFailed ); + assert( pSubExpr==0 || pSubExpr->iTable==0 ); + if( pSubExpr==0 ) continue; + pSubExpr->iTable = pColumns->nId; + pList = sqlite3ExprListAppend(pParse, pList, pSubExpr); + if( pList ){ + assert( pList->nExpr==iFirst+i+1 ); + pList->a[pList->nExpr-1].zEName = pColumns->a[i].zName; + pColumns->a[i].zName = 0; + } + } + + if( !db->mallocFailed && pExpr->op==TK_SELECT && ALWAYS(pList!=0) ){ + Expr *pFirst = pList->a[iFirst].pExpr; + assert( pFirst!=0 ); + assert( pFirst->op==TK_SELECT_COLUMN ); + + /* Store the SELECT statement in pRight so it will be deleted when + ** sqlite3ExprListDelete() is called */ + pFirst->pRight = pExpr; + pExpr = 0; + + /* Remember the size of the LHS in iTable so that we can check that + ** the RHS and LHS sizes match during code generation. */ + pFirst->iTable = pColumns->nId; + } + +vector_append_error: + sqlite3ExprUnmapAndDelete(pParse, pExpr); + sqlite3IdListDelete(db, pColumns); + return pList; +} + +/* +** Set the sort order for the last element on the given ExprList. +*/ +SQLITE_PRIVATE void sqlite3ExprListSetSortOrder(ExprList *p, int iSortOrder, int eNulls){ + struct ExprList_item *pItem; + if( p==0 ) return; + assert( p->nExpr>0 ); + + assert( SQLITE_SO_UNDEFINED<0 && SQLITE_SO_ASC==0 && SQLITE_SO_DESC>0 ); + assert( iSortOrder==SQLITE_SO_UNDEFINED + || iSortOrder==SQLITE_SO_ASC + || iSortOrder==SQLITE_SO_DESC + ); + assert( eNulls==SQLITE_SO_UNDEFINED + || eNulls==SQLITE_SO_ASC + || eNulls==SQLITE_SO_DESC + ); + + pItem = &p->a[p->nExpr-1]; + assert( pItem->bNulls==0 ); + if( iSortOrder==SQLITE_SO_UNDEFINED ){ + iSortOrder = SQLITE_SO_ASC; + } + pItem->sortFlags = (u8)iSortOrder; + + if( eNulls!=SQLITE_SO_UNDEFINED ){ + pItem->bNulls = 1; + if( iSortOrder!=eNulls ){ + pItem->sortFlags |= KEYINFO_ORDER_BIGNULL; + } + } +} + +/* +** Set the ExprList.a[].zEName element of the most recently added item +** on the expression list. +** +** pList might be NULL following an OOM error. But pName should never be +** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag +** is set. +*/ +SQLITE_PRIVATE void sqlite3ExprListSetName( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List to which to add the span. */ + Token *pName, /* Name to be added */ + int dequote /* True to cause the name to be dequoted */ +){ + assert( pList!=0 || pParse->db->mallocFailed!=0 ); + assert( pParse->eParseMode!=PARSE_MODE_UNMAP || dequote==0 ); + if( pList ){ + struct ExprList_item *pItem; + assert( pList->nExpr>0 ); + pItem = &pList->a[pList->nExpr-1]; + assert( pItem->zEName==0 ); + assert( pItem->eEName==ENAME_NAME ); + pItem->zEName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n); + if( dequote ){ + /* If dequote==0, then pName->z does not point to part of a DDL + ** statement handled by the parser. And so no token need be added + ** to the token-map. */ + sqlite3Dequote(pItem->zEName); + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenMap(pParse, (void*)pItem->zEName, pName); + } + } + } +} + +/* +** Set the ExprList.a[].zSpan element of the most recently added item +** on the expression list. +** +** pList might be NULL following an OOM error. But pSpan should never be +** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag +** is set. +*/ +SQLITE_PRIVATE void sqlite3ExprListSetSpan( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List to which to add the span. */ + const char *zStart, /* Start of the span */ + const char *zEnd /* End of the span */ +){ + sqlite3 *db = pParse->db; + assert( pList!=0 || db->mallocFailed!=0 ); + if( pList ){ + struct ExprList_item *pItem = &pList->a[pList->nExpr-1]; + assert( pList->nExpr>0 ); + if( pItem->zEName==0 ){ + pItem->zEName = sqlite3DbSpanDup(db, zStart, zEnd); + pItem->eEName = ENAME_SPAN; + } + } +} + +/* +** If the expression list pEList contains more than iLimit elements, +** leave an error message in pParse. +*/ +SQLITE_PRIVATE void sqlite3ExprListCheckLength( + Parse *pParse, + ExprList *pEList, + const char *zObject +){ + int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN]; + testcase( pEList && pEList->nExpr==mx ); + testcase( pEList && pEList->nExpr==mx+1 ); + if( pEList && pEList->nExpr>mx ){ + sqlite3ErrorMsg(pParse, "too many columns in %s", zObject); + } +} + +/* +** Delete an entire expression list. +*/ +static SQLITE_NOINLINE void exprListDeleteNN(sqlite3 *db, ExprList *pList){ + int i = pList->nExpr; + struct ExprList_item *pItem = pList->a; + assert( pList->nExpr>0 ); + do{ + sqlite3ExprDelete(db, pItem->pExpr); + sqlite3DbFree(db, pItem->zEName); + pItem++; + }while( --i>0 ); + sqlite3DbFreeNN(db, pList); +} +SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){ + if( pList ) exprListDeleteNN(db, pList); +} + +/* +** Return the bitwise-OR of all Expr.flags fields in the given +** ExprList. +*/ +SQLITE_PRIVATE u32 sqlite3ExprListFlags(const ExprList *pList){ + int i; + u32 m = 0; + assert( pList!=0 ); + for(i=0; inExpr; i++){ + Expr *pExpr = pList->a[i].pExpr; + assert( pExpr!=0 ); + m |= pExpr->flags; + } + return m; +} + +/* +** This is a SELECT-node callback for the expression walker that +** always "fails". By "fail" in this case, we mean set +** pWalker->eCode to zero and abort. +** +** This callback is used by multiple expression walkers. +*/ +SQLITE_PRIVATE int sqlite3SelectWalkFail(Walker *pWalker, Select *NotUsed){ + UNUSED_PARAMETER(NotUsed); + pWalker->eCode = 0; + return WRC_Abort; +} + +/* +** Check the input string to see if it is "true" or "false" (in any case). +** +** If the string is.... Return +** "true" EP_IsTrue +** "false" EP_IsFalse +** anything else 0 +*/ +SQLITE_PRIVATE u32 sqlite3IsTrueOrFalse(const char *zIn){ + if( sqlite3StrICmp(zIn, "true")==0 ) return EP_IsTrue; + if( sqlite3StrICmp(zIn, "false")==0 ) return EP_IsFalse; + return 0; +} + + +/* +** If the input expression is an ID with the name "true" or "false" +** then convert it into an TK_TRUEFALSE term. Return non-zero if +** the conversion happened, and zero if the expression is unaltered. +*/ +SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){ + u32 v; + assert( pExpr->op==TK_ID || pExpr->op==TK_STRING ); + if( !ExprHasProperty(pExpr, EP_Quoted) + && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0 + ){ + pExpr->op = TK_TRUEFALSE; + ExprSetProperty(pExpr, v); + return 1; + } + return 0; +} + +/* +** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE +** and 0 if it is FALSE. +*/ +SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr *pExpr){ + pExpr = sqlite3ExprSkipCollate((Expr*)pExpr); + assert( pExpr->op==TK_TRUEFALSE ); + assert( sqlite3StrICmp(pExpr->u.zToken,"true")==0 + || sqlite3StrICmp(pExpr->u.zToken,"false")==0 ); + return pExpr->u.zToken[4]==0; +} + +/* +** If pExpr is an AND or OR expression, try to simplify it by eliminating +** terms that are always true or false. Return the simplified expression. +** Or return the original expression if no simplification is possible. +** +** Examples: +** +** (x<10) AND true => (x<10) +** (x<10) AND false => false +** (x<10) AND (y=22 OR false) => (x<10) AND (y=22) +** (x<10) AND (y=22 OR true) => (x<10) +** (y=22) OR true => true +*/ +SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr *pExpr){ + assert( pExpr!=0 ); + if( pExpr->op==TK_AND || pExpr->op==TK_OR ){ + Expr *pRight = sqlite3ExprSimplifiedAndOr(pExpr->pRight); + Expr *pLeft = sqlite3ExprSimplifiedAndOr(pExpr->pLeft); + if( ExprAlwaysTrue(pLeft) || ExprAlwaysFalse(pRight) ){ + pExpr = pExpr->op==TK_AND ? pRight : pLeft; + }else if( ExprAlwaysTrue(pRight) || ExprAlwaysFalse(pLeft) ){ + pExpr = pExpr->op==TK_AND ? pLeft : pRight; + } + } + return pExpr; +} + + +/* +** These routines are Walker callbacks used to check expressions to +** see if they are "constant" for some definition of constant. The +** Walker.eCode value determines the type of "constant" we are looking +** for. +** +** These callback routines are used to implement the following: +** +** sqlite3ExprIsConstant() pWalker->eCode==1 +** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2 +** sqlite3ExprIsTableConstant() pWalker->eCode==3 +** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5 +** +** In all cases, the callbacks set Walker.eCode=0 and abort if the expression +** is found to not be a constant. +** +** The sqlite3ExprIsConstantOrFunction() is used for evaluating DEFAULT +** expressions in a CREATE TABLE statement. The Walker.eCode value is 5 +** when parsing an existing schema out of the sqlite_schema table and 4 +** when processing a new CREATE TABLE statement. A bound parameter raises +** an error for new statements, but is silently converted +** to NULL for existing schemas. This allows sqlite_schema tables that +** contain a bound parameter because they were generated by older versions +** of SQLite to be parsed by newer versions of SQLite without raising a +** malformed schema error. +*/ +static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){ + + /* If pWalker->eCode is 2 then any term of the expression that comes from + ** the ON or USING clauses of a left join disqualifies the expression + ** from being considered constant. */ + if( pWalker->eCode==2 && ExprHasProperty(pExpr, EP_FromJoin) ){ + pWalker->eCode = 0; + return WRC_Abort; + } + + switch( pExpr->op ){ + /* Consider functions to be constant if all their arguments are constant + ** and either pWalker->eCode==4 or 5 or the function has the + ** SQLITE_FUNC_CONST flag. */ + case TK_FUNCTION: + if( (pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc)) + && !ExprHasProperty(pExpr, EP_WinFunc) + ){ + if( pWalker->eCode==5 ) ExprSetProperty(pExpr, EP_FromDDL); + return WRC_Continue; + }else{ + pWalker->eCode = 0; + return WRC_Abort; + } + case TK_ID: + /* Convert "true" or "false" in a DEFAULT clause into the + ** appropriate TK_TRUEFALSE operator */ + if( sqlite3ExprIdToTrueFalse(pExpr) ){ + return WRC_Prune; + } + /* no break */ deliberate_fall_through + case TK_COLUMN: + case TK_AGG_FUNCTION: + case TK_AGG_COLUMN: + testcase( pExpr->op==TK_ID ); + testcase( pExpr->op==TK_COLUMN ); + testcase( pExpr->op==TK_AGG_FUNCTION ); + testcase( pExpr->op==TK_AGG_COLUMN ); + if( ExprHasProperty(pExpr, EP_FixedCol) && pWalker->eCode!=2 ){ + return WRC_Continue; + } + if( pWalker->eCode==3 && pExpr->iTable==pWalker->u.iCur ){ + return WRC_Continue; + } + /* no break */ deliberate_fall_through + case TK_IF_NULL_ROW: + case TK_REGISTER: + case TK_DOT: + testcase( pExpr->op==TK_REGISTER ); + testcase( pExpr->op==TK_IF_NULL_ROW ); + testcase( pExpr->op==TK_DOT ); + pWalker->eCode = 0; + return WRC_Abort; + case TK_VARIABLE: + if( pWalker->eCode==5 ){ + /* Silently convert bound parameters that appear inside of CREATE + ** statements into a NULL when parsing the CREATE statement text out + ** of the sqlite_schema table */ + pExpr->op = TK_NULL; + }else if( pWalker->eCode==4 ){ + /* A bound parameter in a CREATE statement that originates from + ** sqlite3_prepare() causes an error */ + pWalker->eCode = 0; + return WRC_Abort; + } + /* no break */ deliberate_fall_through + default: + testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */ + testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */ + return WRC_Continue; + } +} +static int exprIsConst(Expr *p, int initFlag, int iCur){ + Walker w; + w.eCode = initFlag; + w.xExprCallback = exprNodeIsConstant; + w.xSelectCallback = sqlite3SelectWalkFail; +#ifdef SQLITE_DEBUG + w.xSelectCallback2 = sqlite3SelectWalkAssert2; +#endif + w.u.iCur = iCur; + sqlite3WalkExpr(&w, p); + return w.eCode; +} + +/* +** Walk an expression tree. Return non-zero if the expression is constant +** and 0 if it involves variables or function calls. +** +** For the purposes of this function, a double-quoted string (ex: "abc") +** is considered a variable but a single-quoted string (ex: 'abc') is +** a constant. +*/ +SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr *p){ + return exprIsConst(p, 1, 0); +} + +/* +** Walk an expression tree. Return non-zero if +** +** (1) the expression is constant, and +** (2) the expression does originate in the ON or USING clause +** of a LEFT JOIN, and +** (3) the expression does not contain any EP_FixedCol TK_COLUMN +** operands created by the constant propagation optimization. +** +** When this routine returns true, it indicates that the expression +** can be added to the pParse->pConstExpr list and evaluated once when +** the prepared statement starts up. See sqlite3ExprCodeRunJustOnce(). +*/ +SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr *p){ + return exprIsConst(p, 2, 0); +} + +/* +** Walk an expression tree. Return non-zero if the expression is constant +** for any single row of the table with cursor iCur. In other words, the +** expression must not refer to any non-deterministic function nor any +** table other than iCur. +*/ +SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr *p, int iCur){ + return exprIsConst(p, 3, iCur); +} + + +/* +** sqlite3WalkExpr() callback used by sqlite3ExprIsConstantOrGroupBy(). +*/ +static int exprNodeIsConstantOrGroupBy(Walker *pWalker, Expr *pExpr){ + ExprList *pGroupBy = pWalker->u.pGroupBy; + int i; + + /* Check if pExpr is identical to any GROUP BY term. If so, consider + ** it constant. */ + for(i=0; inExpr; i++){ + Expr *p = pGroupBy->a[i].pExpr; + if( sqlite3ExprCompare(0, pExpr, p, -1)<2 ){ + CollSeq *pColl = sqlite3ExprNNCollSeq(pWalker->pParse, p); + if( sqlite3IsBinary(pColl) ){ + return WRC_Prune; + } + } + } + + /* Check if pExpr is a sub-select. If so, consider it variable. */ + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + pWalker->eCode = 0; + return WRC_Abort; + } + + return exprNodeIsConstant(pWalker, pExpr); +} + +/* +** Walk the expression tree passed as the first argument. Return non-zero +** if the expression consists entirely of constants or copies of terms +** in pGroupBy that sort with the BINARY collation sequence. +** +** This routine is used to determine if a term of the HAVING clause can +** be promoted into the WHERE clause. In order for such a promotion to work, +** the value of the HAVING clause term must be the same for all members of +** a "group". The requirement that the GROUP BY term must be BINARY +** assumes that no other collating sequence will have a finer-grained +** grouping than binary. In other words (A=B COLLATE binary) implies +** A=B in every other collating sequence. The requirement that the +** GROUP BY be BINARY is stricter than necessary. It would also work +** to promote HAVING clauses that use the same alternative collating +** sequence as the GROUP BY term, but that is much harder to check, +** alternative collating sequences are uncommon, and this is only an +** optimization, so we take the easy way out and simply require the +** GROUP BY to use the BINARY collating sequence. +*/ +SQLITE_PRIVATE int sqlite3ExprIsConstantOrGroupBy(Parse *pParse, Expr *p, ExprList *pGroupBy){ + Walker w; + w.eCode = 1; + w.xExprCallback = exprNodeIsConstantOrGroupBy; + w.xSelectCallback = 0; + w.u.pGroupBy = pGroupBy; + w.pParse = pParse; + sqlite3WalkExpr(&w, p); + return w.eCode; +} + +/* +** Walk an expression tree for the DEFAULT field of a column definition +** in a CREATE TABLE statement. Return non-zero if the expression is +** acceptable for use as a DEFAULT. That is to say, return non-zero if +** the expression is constant or a function call with constant arguments. +** Return and 0 if there are any variables. +** +** isInit is true when parsing from sqlite_schema. isInit is false when +** processing a new CREATE TABLE statement. When isInit is true, parameters +** (such as ? or $abc) in the expression are converted into NULL. When +** isInit is false, parameters raise an error. Parameters should not be +** allowed in a CREATE TABLE statement, but some legacy versions of SQLite +** allowed it, so we need to support it when reading sqlite_schema for +** backwards compatibility. +** +** If isInit is true, set EP_FromDDL on every TK_FUNCTION node. +** +** For the purposes of this function, a double-quoted string (ex: "abc") +** is considered a variable but a single-quoted string (ex: 'abc') is +** a constant. +*/ +SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr *p, u8 isInit){ + assert( isInit==0 || isInit==1 ); + return exprIsConst(p, 4+isInit, 0); +} + +#ifdef SQLITE_ENABLE_CURSOR_HINTS +/* +** Walk an expression tree. Return 1 if the expression contains a +** subquery of some kind. Return 0 if there are no subqueries. +*/ +SQLITE_PRIVATE int sqlite3ExprContainsSubquery(Expr *p){ + Walker w; + w.eCode = 1; + w.xExprCallback = sqlite3ExprWalkNoop; + w.xSelectCallback = sqlite3SelectWalkFail; +#ifdef SQLITE_DEBUG + w.xSelectCallback2 = sqlite3SelectWalkAssert2; +#endif + sqlite3WalkExpr(&w, p); + return w.eCode==0; +} +#endif + +/* +** If the expression p codes a constant integer that is small enough +** to fit in a 32-bit integer, return 1 and put the value of the integer +** in *pValue. If the expression is not an integer or if it is too big +** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged. +*/ +SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr *p, int *pValue){ + int rc = 0; + if( NEVER(p==0) ) return 0; /* Used to only happen following on OOM */ + + /* If an expression is an integer literal that fits in a signed 32-bit + ** integer, then the EP_IntValue flag will have already been set */ + assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0 + || sqlite3GetInt32(p->u.zToken, &rc)==0 ); + + if( p->flags & EP_IntValue ){ + *pValue = p->u.iValue; + return 1; + } + switch( p->op ){ + case TK_UPLUS: { + rc = sqlite3ExprIsInteger(p->pLeft, pValue); + break; + } + case TK_UMINUS: { + int v; + if( sqlite3ExprIsInteger(p->pLeft, &v) ){ + assert( v!=(-2147483647-1) ); + *pValue = -v; + rc = 1; + } + break; + } + default: break; + } + return rc; +} + +/* +** Return FALSE if there is no chance that the expression can be NULL. +** +** If the expression might be NULL or if the expression is too complex +** to tell return TRUE. +** +** This routine is used as an optimization, to skip OP_IsNull opcodes +** when we know that a value cannot be NULL. Hence, a false positive +** (returning TRUE when in fact the expression can never be NULL) might +** be a small performance hit but is otherwise harmless. On the other +** hand, a false negative (returning FALSE when the result could be NULL) +** will likely result in an incorrect answer. So when in doubt, return +** TRUE. +*/ +SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){ + u8 op; + while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ + p = p->pLeft; + } + op = p->op; + if( op==TK_REGISTER ) op = p->op2; + switch( op ){ + case TK_INTEGER: + case TK_STRING: + case TK_FLOAT: + case TK_BLOB: + return 0; + case TK_COLUMN: + return ExprHasProperty(p, EP_CanBeNull) || + p->y.pTab==0 || /* Reference to column of index on expression */ + (p->iColumn>=0 + && ALWAYS(p->y.pTab->aCol!=0) /* Defense against OOM problems */ + && p->y.pTab->aCol[p->iColumn].notNull==0); + default: + return 1; + } +} + +/* +** Return TRUE if the given expression is a constant which would be +** unchanged by OP_Affinity with the affinity given in the second +** argument. +** +** This routine is used to determine if the OP_Affinity operation +** can be omitted. When in doubt return FALSE. A false negative +** is harmless. A false positive, however, can result in the wrong +** answer. +*/ +SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff){ + u8 op; + int unaryMinus = 0; + if( aff==SQLITE_AFF_BLOB ) return 1; + while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ + if( p->op==TK_UMINUS ) unaryMinus = 1; + p = p->pLeft; + } + op = p->op; + if( op==TK_REGISTER ) op = p->op2; + switch( op ){ + case TK_INTEGER: { + return aff>=SQLITE_AFF_NUMERIC; + } + case TK_FLOAT: { + return aff>=SQLITE_AFF_NUMERIC; + } + case TK_STRING: { + return !unaryMinus && aff==SQLITE_AFF_TEXT; + } + case TK_BLOB: { + return !unaryMinus; + } + case TK_COLUMN: { + assert( p->iTable>=0 ); /* p cannot be part of a CHECK constraint */ + return aff>=SQLITE_AFF_NUMERIC && p->iColumn<0; + } + default: { + return 0; + } + } +} + +/* +** Return TRUE if the given string is a row-id column name. +*/ +SQLITE_PRIVATE int sqlite3IsRowid(const char *z){ + if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1; + if( sqlite3StrICmp(z, "ROWID")==0 ) return 1; + if( sqlite3StrICmp(z, "OID")==0 ) return 1; + return 0; +} + +/* +** pX is the RHS of an IN operator. If pX is a SELECT statement +** that can be simplified to a direct table access, then return +** a pointer to the SELECT statement. If pX is not a SELECT statement, +** or if the SELECT statement needs to be manifested into a transient +** table, then return NULL. +*/ +#ifndef SQLITE_OMIT_SUBQUERY +static Select *isCandidateForInOpt(Expr *pX){ + Select *p; + SrcList *pSrc; + ExprList *pEList; + Table *pTab; + int i; + if( !ExprHasProperty(pX, EP_xIsSelect) ) return 0; /* Not a subquery */ + if( ExprHasProperty(pX, EP_VarSelect) ) return 0; /* Correlated subq */ + p = pX->x.pSelect; + if( p->pPrior ) return 0; /* Not a compound SELECT */ + if( p->selFlags & (SF_Distinct|SF_Aggregate) ){ + testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct ); + testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate ); + return 0; /* No DISTINCT keyword and no aggregate functions */ + } + assert( p->pGroupBy==0 ); /* Has no GROUP BY clause */ + if( p->pLimit ) return 0; /* Has no LIMIT clause */ + if( p->pWhere ) return 0; /* Has no WHERE clause */ + pSrc = p->pSrc; + assert( pSrc!=0 ); + if( pSrc->nSrc!=1 ) return 0; /* Single term in FROM clause */ + if( pSrc->a[0].pSelect ) return 0; /* FROM is not a subquery or view */ + pTab = pSrc->a[0].pTab; + assert( pTab!=0 ); + assert( pTab->pSelect==0 ); /* FROM clause is not a view */ + if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */ + pEList = p->pEList; + assert( pEList!=0 ); + /* All SELECT results must be columns. */ + for(i=0; inExpr; i++){ + Expr *pRes = pEList->a[i].pExpr; + if( pRes->op!=TK_COLUMN ) return 0; + assert( pRes->iTable==pSrc->a[0].iCursor ); /* Not a correlated subquery */ + } + return p; +} +#endif /* SQLITE_OMIT_SUBQUERY */ + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** Generate code that checks the left-most column of index table iCur to see if +** it contains any NULL entries. Cause the register at regHasNull to be set +** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull +** to be set to NULL if iCur contains one or more NULL values. +*/ +static void sqlite3SetHasNullFlag(Vdbe *v, int iCur, int regHasNull){ + int addr1; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regHasNull); + addr1 = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_Column, iCur, 0, regHasNull); + sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG); + VdbeComment((v, "first_entry_in(%d)", iCur)); + sqlite3VdbeJumpHere(v, addr1); +} +#endif + + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** The argument is an IN operator with a list (not a subquery) on the +** right-hand side. Return TRUE if that list is constant. +*/ +static int sqlite3InRhsIsConstant(Expr *pIn){ + Expr *pLHS; + int res; + assert( !ExprHasProperty(pIn, EP_xIsSelect) ); + pLHS = pIn->pLeft; + pIn->pLeft = 0; + res = sqlite3ExprIsConstant(pIn); + pIn->pLeft = pLHS; + return res; +} +#endif + +/* +** This function is used by the implementation of the IN (...) operator. +** The pX parameter is the expression on the RHS of the IN operator, which +** might be either a list of expressions or a subquery. +** +** The job of this routine is to find or create a b-tree object that can +** be used either to test for membership in the RHS set or to iterate through +** all members of the RHS set, skipping duplicates. +** +** A cursor is opened on the b-tree object that is the RHS of the IN operator +** and pX->iTable is set to the index of that cursor. +** +** The returned value of this function indicates the b-tree type, as follows: +** +** IN_INDEX_ROWID - The cursor was opened on a database table. +** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index. +** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index. +** IN_INDEX_EPH - The cursor was opened on a specially created and +** populated epheremal table. +** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be +** implemented as a sequence of comparisons. +** +** An existing b-tree might be used if the RHS expression pX is a simple +** subquery such as: +** +** SELECT , ... FROM +** +** If the RHS of the IN operator is a list or a more complex subquery, then +** an ephemeral table might need to be generated from the RHS and then +** pX->iTable made to point to the ephemeral table instead of an +** existing table. +** +** The inFlags parameter must contain, at a minimum, one of the bits +** IN_INDEX_MEMBERSHIP or IN_INDEX_LOOP but not both. If inFlags contains +** IN_INDEX_MEMBERSHIP, then the generated table will be used for a fast +** membership test. When the IN_INDEX_LOOP bit is set, the IN index will +** be used to loop over all values of the RHS of the IN operator. +** +** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate +** through the set members) then the b-tree must not contain duplicates. +** An epheremal table will be created unless the selected columns are guaranteed +** to be unique - either because it is an INTEGER PRIMARY KEY or due to +** a UNIQUE constraint or index. +** +** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used +** for fast set membership tests) then an epheremal table must +** be used unless is a single INTEGER PRIMARY KEY column or an +** index can be found with the specified as its left-most. +** +** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and +** if the RHS of the IN operator is a list (not a subquery) then this +** routine might decide that creating an ephemeral b-tree for membership +** testing is too expensive and return IN_INDEX_NOOP. In that case, the +** calling routine should implement the IN operator using a sequence +** of Eq or Ne comparison operations. +** +** When the b-tree is being used for membership tests, the calling function +** might need to know whether or not the RHS side of the IN operator +** contains a NULL. If prRhsHasNull is not a NULL pointer and +** if there is any chance that the (...) might contain a NULL value at +** runtime, then a register is allocated and the register number written +** to *prRhsHasNull. If there is no chance that the (...) contains a +** NULL value, then *prRhsHasNull is left unchanged. +** +** If a register is allocated and its location stored in *prRhsHasNull, then +** the value in that register will be NULL if the b-tree contains one or more +** NULL values, and it will be some non-NULL value if the b-tree contains no +** NULL values. +** +** If the aiMap parameter is not NULL, it must point to an array containing +** one element for each column returned by the SELECT statement on the RHS +** of the IN(...) operator. The i'th entry of the array is populated with the +** offset of the index column that matches the i'th column returned by the +** SELECT. For example, if the expression and selected index are: +** +** (?,?,?) IN (SELECT a, b, c FROM t1) +** CREATE INDEX i1 ON t1(b, c, a); +** +** then aiMap[] is populated with {2, 0, 1}. +*/ +#ifndef SQLITE_OMIT_SUBQUERY +SQLITE_PRIVATE int sqlite3FindInIndex( + Parse *pParse, /* Parsing context */ + Expr *pX, /* The IN expression */ + u32 inFlags, /* IN_INDEX_LOOP, _MEMBERSHIP, and/or _NOOP_OK */ + int *prRhsHasNull, /* Register holding NULL status. See notes */ + int *aiMap, /* Mapping from Index fields to RHS fields */ + int *piTab /* OUT: index to use */ +){ + Select *p; /* SELECT to the right of IN operator */ + int eType = 0; /* Type of RHS table. IN_INDEX_* */ + int iTab = pParse->nTab++; /* Cursor of the RHS table */ + int mustBeUnique; /* True if RHS must be unique */ + Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */ + + assert( pX->op==TK_IN ); + mustBeUnique = (inFlags & IN_INDEX_LOOP)!=0; + + /* If the RHS of this IN(...) operator is a SELECT, and if it matters + ** whether or not the SELECT result contains NULL values, check whether + ** or not NULL is actually possible (it may not be, for example, due + ** to NOT NULL constraints in the schema). If no NULL values are possible, + ** set prRhsHasNull to 0 before continuing. */ + if( prRhsHasNull && (pX->flags & EP_xIsSelect) ){ + int i; + ExprList *pEList = pX->x.pSelect->pEList; + for(i=0; inExpr; i++){ + if( sqlite3ExprCanBeNull(pEList->a[i].pExpr) ) break; + } + if( i==pEList->nExpr ){ + prRhsHasNull = 0; + } + } + + /* Check to see if an existing table or index can be used to + ** satisfy the query. This is preferable to generating a new + ** ephemeral table. */ + if( pParse->nErr==0 && (p = isCandidateForInOpt(pX))!=0 ){ + sqlite3 *db = pParse->db; /* Database connection */ + Table *pTab; /* Table
    . */ + int iDb; /* Database idx for pTab */ + ExprList *pEList = p->pEList; + int nExpr = pEList->nExpr; + + assert( p->pEList!=0 ); /* Because of isCandidateForInOpt(p) */ + assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */ + assert( p->pSrc!=0 ); /* Because of isCandidateForInOpt(p) */ + pTab = p->pSrc->a[0].pTab; + + /* Code an OP_Transaction and OP_TableLock for
    . */ + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDb>=0 && iDbtnum, 0, pTab->zName); + + assert(v); /* sqlite3GetVdbe() has always been previously called */ + if( nExpr==1 && pEList->a[0].pExpr->iColumn<0 ){ + /* The "x IN (SELECT rowid FROM table)" case */ + int iAddr = sqlite3VdbeAddOp0(v, OP_Once); + VdbeCoverage(v); + + sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead); + eType = IN_INDEX_ROWID; + ExplainQueryPlan((pParse, 0, + "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR",pTab->zName)); + sqlite3VdbeJumpHere(v, iAddr); + }else{ + Index *pIdx; /* Iterator variable */ + int affinity_ok = 1; + int i; + + /* Check that the affinity that will be used to perform each + ** comparison is the same as the affinity of each column in table + ** on the RHS of the IN operator. If it not, it is not possible to + ** use any index of the RHS table. */ + for(i=0; ipLeft, i); + int iCol = pEList->a[i].pExpr->iColumn; + char idxaff = sqlite3TableColumnAffinity(pTab,iCol); /* RHS table */ + char cmpaff = sqlite3CompareAffinity(pLhs, idxaff); + testcase( cmpaff==SQLITE_AFF_BLOB ); + testcase( cmpaff==SQLITE_AFF_TEXT ); + switch( cmpaff ){ + case SQLITE_AFF_BLOB: + break; + case SQLITE_AFF_TEXT: + /* sqlite3CompareAffinity() only returns TEXT if one side or the + ** other has no affinity and the other side is TEXT. Hence, + ** the only way for cmpaff to be TEXT is for idxaff to be TEXT + ** and for the term on the LHS of the IN to have no affinity. */ + assert( idxaff==SQLITE_AFF_TEXT ); + break; + default: + affinity_ok = sqlite3IsNumericAffinity(idxaff); + } + } + + if( affinity_ok ){ + /* Search for an existing index that will work for this IN operator */ + for(pIdx=pTab->pIndex; pIdx && eType==0; pIdx=pIdx->pNext){ + Bitmask colUsed; /* Columns of the index used */ + Bitmask mCol; /* Mask for the current column */ + if( pIdx->nColumnpPartIdxWhere!=0 ) continue; + /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute + ** BITMASK(nExpr) without overflowing */ + testcase( pIdx->nColumn==BMS-2 ); + testcase( pIdx->nColumn==BMS-1 ); + if( pIdx->nColumn>=BMS-1 ) continue; + if( mustBeUnique ){ + if( pIdx->nKeyCol>nExpr + ||(pIdx->nColumn>nExpr && !IsUniqueIndex(pIdx)) + ){ + continue; /* This index is not unique over the IN RHS columns */ + } + } + + colUsed = 0; /* Columns of index used so far */ + for(i=0; ipLeft, i); + Expr *pRhs = pEList->a[i].pExpr; + CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pLhs, pRhs); + int j; + + assert( pReq!=0 || pRhs->iColumn==XN_ROWID || pParse->nErr ); + for(j=0; jaiColumn[j]!=pRhs->iColumn ) continue; + assert( pIdx->azColl[j] ); + if( pReq!=0 && sqlite3StrICmp(pReq->zName, pIdx->azColl[j])!=0 ){ + continue; + } + break; + } + if( j==nExpr ) break; + mCol = MASKBIT(j); + if( mCol & colUsed ) break; /* Each column used only once */ + colUsed |= mCol; + if( aiMap ) aiMap[i] = j; + } + + assert( i==nExpr || colUsed!=(MASKBIT(nExpr)-1) ); + if( colUsed==(MASKBIT(nExpr)-1) ){ + /* If we reach this point, that means the index pIdx is usable */ + int iAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + ExplainQueryPlan((pParse, 0, + "USING INDEX %s FOR IN-OPERATOR",pIdx->zName)); + sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + VdbeComment((v, "%s", pIdx->zName)); + assert( IN_INDEX_INDEX_DESC == IN_INDEX_INDEX_ASC+1 ); + eType = IN_INDEX_INDEX_ASC + pIdx->aSortOrder[0]; + + if( prRhsHasNull ){ +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK + i64 mask = (1<nMem; + if( nExpr==1 ){ + sqlite3SetHasNullFlag(v, iTab, *prRhsHasNull); + } + } + sqlite3VdbeJumpHere(v, iAddr); + } + } /* End loop over indexes */ + } /* End if( affinity_ok ) */ + } /* End if not an rowid index */ + } /* End attempt to optimize using an index */ + + /* If no preexisting index is available for the IN clause + ** and IN_INDEX_NOOP is an allowed reply + ** and the RHS of the IN operator is a list, not a subquery + ** and the RHS is not constant or has two or fewer terms, + ** then it is not worth creating an ephemeral table to evaluate + ** the IN operator so return IN_INDEX_NOOP. + */ + if( eType==0 + && (inFlags & IN_INDEX_NOOP_OK) + && !ExprHasProperty(pX, EP_xIsSelect) + && (!sqlite3InRhsIsConstant(pX) || pX->x.pList->nExpr<=2) + ){ + eType = IN_INDEX_NOOP; + } + + if( eType==0 ){ + /* Could not find an existing table or index to use as the RHS b-tree. + ** We will have to generate an ephemeral table to do the job. + */ + u32 savedNQueryLoop = pParse->nQueryLoop; + int rMayHaveNull = 0; + eType = IN_INDEX_EPH; + if( inFlags & IN_INDEX_LOOP ){ + pParse->nQueryLoop = 0; + }else if( prRhsHasNull ){ + *prRhsHasNull = rMayHaveNull = ++pParse->nMem; + } + assert( pX->op==TK_IN ); + sqlite3CodeRhsOfIN(pParse, pX, iTab); + if( rMayHaveNull ){ + sqlite3SetHasNullFlag(v, iTab, rMayHaveNull); + } + pParse->nQueryLoop = savedNQueryLoop; + } + + if( aiMap && eType!=IN_INDEX_INDEX_ASC && eType!=IN_INDEX_INDEX_DESC ){ + int i, n; + n = sqlite3ExprVectorSize(pX->pLeft); + for(i=0; ipLeft; + int nVal = sqlite3ExprVectorSize(pLeft); + Select *pSelect = (pExpr->flags & EP_xIsSelect) ? pExpr->x.pSelect : 0; + char *zRet; + + assert( pExpr->op==TK_IN ); + zRet = sqlite3DbMallocRaw(pParse->db, nVal+1); + if( zRet ){ + int i; + for(i=0; ipEList->a[i].pExpr, a); + }else{ + zRet[i] = a; + } + } + zRet[nVal] = '\0'; + } + return zRet; +} +#endif + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** Load the Parse object passed as the first argument with an error +** message of the form: +** +** "sub-select returns N columns - expected M" +*/ +SQLITE_PRIVATE void sqlite3SubselectError(Parse *pParse, int nActual, int nExpect){ + if( pParse->nErr==0 ){ + const char *zFmt = "sub-select returns %d columns - expected %d"; + sqlite3ErrorMsg(pParse, zFmt, nActual, nExpect); + } +} +#endif + +/* +** Expression pExpr is a vector that has been used in a context where +** it is not permitted. If pExpr is a sub-select vector, this routine +** loads the Parse object with a message of the form: +** +** "sub-select returns N columns - expected 1" +** +** Or, if it is a regular scalar vector: +** +** "row value misused" +*/ +SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){ +#ifndef SQLITE_OMIT_SUBQUERY + if( pExpr->flags & EP_xIsSelect ){ + sqlite3SubselectError(pParse, pExpr->x.pSelect->pEList->nExpr, 1); + }else +#endif + { + sqlite3ErrorMsg(pParse, "row value misused"); + } +} + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** Generate code that will construct an ephemeral table containing all terms +** in the RHS of an IN operator. The IN operator can be in either of two +** forms: +** +** x IN (4,5,11) -- IN operator with list on right-hand side +** x IN (SELECT a FROM b) -- IN operator with subquery on the right +** +** The pExpr parameter is the IN operator. The cursor number for the +** constructed ephermeral table is returned. The first time the ephemeral +** table is computed, the cursor number is also stored in pExpr->iTable, +** however the cursor number returned might not be the same, as it might +** have been duplicated using OP_OpenDup. +** +** If the LHS expression ("x" in the examples) is a column value, or +** the SELECT statement returns a column value, then the affinity of that +** column is used to build the index keys. If both 'x' and the +** SELECT... statement are columns, then numeric affinity is used +** if either column has NUMERIC or INTEGER affinity. If neither +** 'x' nor the SELECT... statement are columns, then numeric affinity +** is used. +*/ +SQLITE_PRIVATE void sqlite3CodeRhsOfIN( + Parse *pParse, /* Parsing context */ + Expr *pExpr, /* The IN operator */ + int iTab /* Use this cursor number */ +){ + int addrOnce = 0; /* Address of the OP_Once instruction at top */ + int addr; /* Address of OP_OpenEphemeral instruction */ + Expr *pLeft; /* the LHS of the IN operator */ + KeyInfo *pKeyInfo = 0; /* Key information */ + int nVal; /* Size of vector pLeft */ + Vdbe *v; /* The prepared statement under construction */ + + v = pParse->pVdbe; + assert( v!=0 ); + + /* The evaluation of the IN must be repeated every time it + ** is encountered if any of the following is true: + ** + ** * The right-hand side is a correlated subquery + ** * The right-hand side is an expression list containing variables + ** * We are inside a trigger + ** + ** If all of the above are false, then we can compute the RHS just once + ** and reuse it many names. + */ + if( !ExprHasProperty(pExpr, EP_VarSelect) && pParse->iSelfTab==0 ){ + /* Reuse of the RHS is allowed */ + /* If this routine has already been coded, but the previous code + ** might not have been invoked yet, so invoke it now as a subroutine. + */ + if( ExprHasProperty(pExpr, EP_Subrtn) ){ + addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + ExplainQueryPlan((pParse, 0, "REUSE LIST SUBQUERY %d", + pExpr->x.pSelect->selId)); + } + sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn, + pExpr->y.sub.iAddr); + sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable); + sqlite3VdbeJumpHere(v, addrOnce); + return; + } + + /* Begin coding the subroutine */ + ExprSetProperty(pExpr, EP_Subrtn); + assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); + pExpr->y.sub.regReturn = ++pParse->nMem; + pExpr->y.sub.iAddr = + sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1; + VdbeComment((v, "return address")); + + addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + } + + /* Check to see if this is a vector IN operator */ + pLeft = pExpr->pLeft; + nVal = sqlite3ExprVectorSize(pLeft); + + /* Construct the ephemeral table that will contain the content of + ** RHS of the IN operator. + */ + pExpr->iTable = iTab; + addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal); +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId)); + }else{ + VdbeComment((v, "RHS of IN operator")); + } +#endif + pKeyInfo = sqlite3KeyInfoAlloc(pParse->db, nVal, 1); + + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + /* Case 1: expr IN (SELECT ...) + ** + ** Generate code to write the results of the select into the temporary + ** table allocated and opened above. + */ + Select *pSelect = pExpr->x.pSelect; + ExprList *pEList = pSelect->pEList; + + ExplainQueryPlan((pParse, 1, "%sLIST SUBQUERY %d", + addrOnce?"":"CORRELATED ", pSelect->selId + )); + /* If the LHS and RHS of the IN operator do not match, that + ** error will have been caught long before we reach this point. */ + if( ALWAYS(pEList->nExpr==nVal) ){ + SelectDest dest; + int i; + sqlite3SelectDestInit(&dest, SRT_Set, iTab); + dest.zAffSdst = exprINAffinity(pParse, pExpr); + pSelect->iLimit = 0; + testcase( pSelect->selFlags & SF_Distinct ); + testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */ + if( sqlite3Select(pParse, pSelect, &dest) ){ + sqlite3DbFree(pParse->db, dest.zAffSdst); + sqlite3KeyInfoUnref(pKeyInfo); + return; + } + sqlite3DbFree(pParse->db, dest.zAffSdst); + assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */ + assert( pEList!=0 ); + assert( pEList->nExpr>0 ); + assert( sqlite3KeyInfoIsWriteable(pKeyInfo) ); + for(i=0; iaColl[i] = sqlite3BinaryCompareCollSeq( + pParse, p, pEList->a[i].pExpr + ); + } + } + }else if( ALWAYS(pExpr->x.pList!=0) ){ + /* Case 2: expr IN (exprlist) + ** + ** For each expression, build an index key from the evaluation and + ** store it in the temporary table. If is a column, then use + ** that columns affinity when building index keys. If is not + ** a column, use numeric affinity. + */ + char affinity; /* Affinity of the LHS of the IN */ + int i; + ExprList *pList = pExpr->x.pList; + struct ExprList_item *pItem; + int r1, r2; + affinity = sqlite3ExprAffinity(pLeft); + if( affinity<=SQLITE_AFF_NONE ){ + affinity = SQLITE_AFF_BLOB; + }else if( affinity==SQLITE_AFF_REAL ){ + affinity = SQLITE_AFF_NUMERIC; + } + if( pKeyInfo ){ + assert( sqlite3KeyInfoIsWriteable(pKeyInfo) ); + pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft); + } + + /* Loop through each expression in . */ + r1 = sqlite3GetTempReg(pParse); + r2 = sqlite3GetTempReg(pParse); + for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){ + Expr *pE2 = pItem->pExpr; + + /* If the expression is not constant then we will need to + ** disable the test that was generated above that makes sure + ** this code only executes once. Because for a non-constant + ** expression we need to rerun this code each time. + */ + if( addrOnce && !sqlite3ExprIsConstant(pE2) ){ + sqlite3VdbeChangeToNoop(v, addrOnce); + ExprClearProperty(pExpr, EP_Subrtn); + addrOnce = 0; + } + + /* Evaluate the expression and insert it into the temp table */ + sqlite3ExprCode(pParse, pE2, r1); + sqlite3VdbeAddOp4(v, OP_MakeRecord, r1, 1, r2, &affinity, 1); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r2, r1, 1); + } + sqlite3ReleaseTempReg(pParse, r1); + sqlite3ReleaseTempReg(pParse, r2); + } + if( pKeyInfo ){ + sqlite3VdbeChangeP4(v, addr, (void *)pKeyInfo, P4_KEYINFO); + } + if( addrOnce ){ + sqlite3VdbeJumpHere(v, addrOnce); + /* Subroutine return */ + sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn); + sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1); + sqlite3ClearTempRegCache(pParse); + } +} +#endif /* SQLITE_OMIT_SUBQUERY */ + +/* +** Generate code for scalar subqueries used as a subquery expression +** or EXISTS operator: +** +** (SELECT a FROM b) -- subquery +** EXISTS (SELECT a FROM b) -- EXISTS subquery +** +** The pExpr parameter is the SELECT or EXISTS operator to be coded. +** +** Return the register that holds the result. For a multi-column SELECT, +** the result is stored in a contiguous array of registers and the +** return value is the register of the left-most result column. +** Return 0 if an error occurs. +*/ +#ifndef SQLITE_OMIT_SUBQUERY +SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){ + int addrOnce = 0; /* Address of OP_Once at top of subroutine */ + int rReg = 0; /* Register storing resulting */ + Select *pSel; /* SELECT statement to encode */ + SelectDest dest; /* How to deal with SELECT result */ + int nReg; /* Registers to allocate */ + Expr *pLimit; /* New limit expression */ + + Vdbe *v = pParse->pVdbe; + assert( v!=0 ); + testcase( pExpr->op==TK_EXISTS ); + testcase( pExpr->op==TK_SELECT ); + assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT ); + assert( ExprHasProperty(pExpr, EP_xIsSelect) ); + pSel = pExpr->x.pSelect; + + /* The evaluation of the EXISTS/SELECT must be repeated every time it + ** is encountered if any of the following is true: + ** + ** * The right-hand side is a correlated subquery + ** * The right-hand side is an expression list containing variables + ** * We are inside a trigger + ** + ** If all of the above are false, then we can run this code just once + ** save the results, and reuse the same result on subsequent invocations. + */ + if( !ExprHasProperty(pExpr, EP_VarSelect) ){ + /* If this routine has already been coded, then invoke it as a + ** subroutine. */ + if( ExprHasProperty(pExpr, EP_Subrtn) ){ + ExplainQueryPlan((pParse, 0, "REUSE SUBQUERY %d", pSel->selId)); + sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn, + pExpr->y.sub.iAddr); + return pExpr->iTable; + } + + /* Begin coding the subroutine */ + ExprSetProperty(pExpr, EP_Subrtn); + pExpr->y.sub.regReturn = ++pParse->nMem; + pExpr->y.sub.iAddr = + sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1; + VdbeComment((v, "return address")); + + addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + } + + /* For a SELECT, generate code to put the values for all columns of + ** the first row into an array of registers and return the index of + ** the first register. + ** + ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists) + ** into a register and return that register number. + ** + ** 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", + addrOnce?"":"CORRELATED ", pSel->selId)); + nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1; + sqlite3SelectDestInit(&dest, 0, pParse->nMem+1); + pParse->nMem += nReg; + if( pExpr->op==TK_SELECT ){ + dest.eDest = SRT_Mem; + dest.iSdst = dest.iSDParm; + dest.nSdst = nReg; + sqlite3VdbeAddOp3(v, OP_Null, 0, dest.iSDParm, dest.iSDParm+nReg-1); + VdbeComment((v, "Init subquery result")); + }else{ + dest.eDest = SRT_Exists; + sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iSDParm); + VdbeComment((v, "Init EXISTS result")); + } + if( pSel->pLimit ){ + /* The subquery already has a limit. If the pre-existing limit is X + ** then make the new limit X<>0 so that the new limit is either 1 or 0 */ + sqlite3 *db = pParse->db; + pLimit = sqlite3Expr(db, TK_INTEGER, "0"); + if( pLimit ){ + pLimit->affExpr = SQLITE_AFF_NUMERIC; + pLimit = sqlite3PExpr(pParse, TK_NE, + sqlite3ExprDup(db, pSel->pLimit->pLeft, 0), pLimit); + } + sqlite3ExprDelete(db, pSel->pLimit->pLeft); + pSel->pLimit->pLeft = pLimit; + }else{ + /* If there is no pre-existing limit add a limit of 1 */ + pLimit = sqlite3Expr(pParse->db, TK_INTEGER, "1"); + pSel->pLimit = sqlite3PExpr(pParse, TK_LIMIT, pLimit, 0); + } + pSel->iLimit = 0; + if( sqlite3Select(pParse, pSel, &dest) ){ + return 0; + } + pExpr->iTable = rReg = dest.iSDParm; + ExprSetVVAProperty(pExpr, EP_NoReduce); + if( addrOnce ){ + sqlite3VdbeJumpHere(v, addrOnce); + + /* Subroutine return */ + sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn); + sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1); + sqlite3ClearTempRegCache(pParse); + } + + return rReg; +} +#endif /* SQLITE_OMIT_SUBQUERY */ + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** Expr pIn is an IN(...) expression. This function checks that the +** sub-select on the RHS of the IN() operator has the same number of +** columns as the vector on the LHS. Or, if the RHS of the IN() is not +** a sub-query, that the LHS is a vector of size 1. +*/ +SQLITE_PRIVATE int sqlite3ExprCheckIN(Parse *pParse, Expr *pIn){ + int nVector = sqlite3ExprVectorSize(pIn->pLeft); + if( (pIn->flags & EP_xIsSelect) ){ + if( nVector!=pIn->x.pSelect->pEList->nExpr ){ + sqlite3SubselectError(pParse, pIn->x.pSelect->pEList->nExpr, nVector); + return 1; + } + }else if( nVector!=1 ){ + sqlite3VectorErrorMsg(pParse, pIn->pLeft); + return 1; + } + return 0; +} +#endif + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** Generate code for an IN expression. +** +** x IN (SELECT ...) +** x IN (value, value, ...) +** +** The left-hand side (LHS) is a scalar or vector expression. The +** right-hand side (RHS) is an array of zero or more scalar values, or a +** subquery. If the RHS is a subquery, the number of result columns must +** match the number of columns in the vector on the LHS. If the RHS is +** a list of values, the LHS must be a scalar. +** +** The IN operator is true if the LHS value is contained within the RHS. +** The result is false if the LHS is definitely not in the RHS. The +** result is NULL if the presence of the LHS in the RHS cannot be +** determined due to NULLs. +** +** This routine generates code that jumps to destIfFalse if the LHS is not +** contained within the RHS. If due to NULLs we cannot determine if the LHS +** is contained in the RHS then jump to destIfNull. If the LHS is contained +** within the RHS then fall through. +** +** See the separate in-operator.md documentation file in the canonical +** SQLite source tree for additional information. +*/ +static void sqlite3ExprCodeIN( + Parse *pParse, /* Parsing and code generating context */ + Expr *pExpr, /* The IN expression */ + int destIfFalse, /* Jump here if LHS is not contained in the RHS */ + int destIfNull /* Jump here if the results are unknown due to NULLs */ +){ + int rRhsHasNull = 0; /* Register that is true if RHS contains NULL values */ + int eType; /* Type of the RHS */ + int rLhs; /* Register(s) holding the LHS values */ + int rLhsOrig; /* LHS values prior to reordering by aiMap[] */ + Vdbe *v; /* Statement under construction */ + int *aiMap = 0; /* Map from vector field to index column */ + char *zAff = 0; /* Affinity string for comparisons */ + int nVector; /* Size of vectors for this IN operator */ + int iDummy; /* Dummy parameter to exprCodeVector() */ + Expr *pLeft; /* The LHS of the IN operator */ + int i; /* loop counter */ + int destStep2; /* Where to jump when NULLs seen in step 2 */ + int destStep6 = 0; /* Start of code for Step 6 */ + int addrTruthOp; /* Address of opcode that determines the IN is true */ + int destNotNull; /* Jump here if a comparison is not true in step 6 */ + int addrTop; /* Top of the step-6 loop */ + int iTab = 0; /* Index to use */ + u8 okConstFactor = pParse->okConstFactor; + + assert( !ExprHasVVAProperty(pExpr,EP_Immutable) ); + pLeft = pExpr->pLeft; + if( sqlite3ExprCheckIN(pParse, pExpr) ) return; + zAff = exprINAffinity(pParse, pExpr); + nVector = sqlite3ExprVectorSize(pExpr->pLeft); + aiMap = (int*)sqlite3DbMallocZero( + pParse->db, nVector*(sizeof(int) + sizeof(char)) + 1 + ); + if( pParse->db->mallocFailed ) goto sqlite3ExprCodeIN_oom_error; + + /* Attempt to compute the RHS. After this step, if anything other than + ** IN_INDEX_NOOP is returned, the table opened with cursor iTab + ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned, + ** the RHS has not yet been coded. */ + v = pParse->pVdbe; + assert( v!=0 ); /* OOM detected prior to this routine */ + VdbeNoopComment((v, "begin IN expr")); + eType = sqlite3FindInIndex(pParse, pExpr, + IN_INDEX_MEMBERSHIP | IN_INDEX_NOOP_OK, + destIfFalse==destIfNull ? 0 : &rRhsHasNull, + aiMap, &iTab); + + assert( pParse->nErr || nVector==1 || eType==IN_INDEX_EPH + || eType==IN_INDEX_INDEX_ASC || eType==IN_INDEX_INDEX_DESC + ); +#ifdef SQLITE_DEBUG + /* Confirm that aiMap[] contains nVector integer values between 0 and + ** nVector-1. */ + for(i=0; i from " IN (...)". If the LHS is a + ** vector, then it is stored in an array of nVector registers starting + ** at r1. + ** + ** sqlite3FindInIndex() might have reordered the fields of the LHS vector + ** so that the fields are in the same order as an existing index. The + ** aiMap[] array contains a mapping from the original LHS field order to + ** the field order that matches the RHS index. + ** + ** Avoid factoring the LHS of the IN(...) expression out of the loop, + ** even if it is constant, as OP_Affinity may be used on the register + ** by code generated below. */ + assert( pParse->okConstFactor==okConstFactor ); + pParse->okConstFactor = 0; + rLhsOrig = exprCodeVector(pParse, pLeft, &iDummy); + pParse->okConstFactor = okConstFactor; + for(i=0; ix.pList; + CollSeq *pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft); + int labelOk = sqlite3VdbeMakeLabel(pParse); + int r2, regToFree; + int regCkNull = 0; + int ii; + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + if( destIfNull!=destIfFalse ){ + regCkNull = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_BitAnd, rLhs, rLhs, regCkNull); + } + for(ii=0; iinExpr; ii++){ + r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, ®ToFree); + if( regCkNull && sqlite3ExprCanBeNull(pList->a[ii].pExpr) ){ + sqlite3VdbeAddOp3(v, OP_BitAnd, regCkNull, r2, regCkNull); + } + sqlite3ReleaseTempReg(pParse, regToFree); + if( iinExpr-1 || destIfNull!=destIfFalse ){ + int op = rLhs!=r2 ? OP_Eq : OP_NotNull; + sqlite3VdbeAddOp4(v, op, rLhs, labelOk, r2, + (void*)pColl, P4_COLLSEQ); + VdbeCoverageIf(v, iinExpr-1 && op==OP_Eq); + VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_Eq); + VdbeCoverageIf(v, iinExpr-1 && op==OP_NotNull); + VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_NotNull); + sqlite3VdbeChangeP5(v, zAff[0]); + }else{ + int op = rLhs!=r2 ? OP_Ne : OP_IsNull; + assert( destIfNull==destIfFalse ); + sqlite3VdbeAddOp4(v, op, rLhs, destIfFalse, r2, + (void*)pColl, P4_COLLSEQ); + VdbeCoverageIf(v, op==OP_Ne); + VdbeCoverageIf(v, op==OP_IsNull); + sqlite3VdbeChangeP5(v, zAff[0] | SQLITE_JUMPIFNULL); + } + } + if( regCkNull ){ + sqlite3VdbeAddOp2(v, OP_IsNull, regCkNull, destIfNull); VdbeCoverage(v); + sqlite3VdbeGoto(v, destIfFalse); + } + sqlite3VdbeResolveLabel(v, labelOk); + sqlite3ReleaseTempReg(pParse, regCkNull); + goto sqlite3ExprCodeIN_finished; + } + + /* Step 2: Check to see if the LHS contains any NULL columns. If the + ** LHS does contain NULLs then the result must be either FALSE or NULL. + ** We will then skip the binary search of the RHS. + */ + if( destIfNull==destIfFalse ){ + destStep2 = destIfFalse; + }else{ + destStep2 = destStep6 = sqlite3VdbeMakeLabel(pParse); + } + if( pParse->nErr ) goto sqlite3ExprCodeIN_finished; + for(i=0; ipLeft, i); + if( sqlite3ExprCanBeNull(p) ){ + sqlite3VdbeAddOp2(v, OP_IsNull, rLhs+i, destStep2); + VdbeCoverage(v); + } + } + + /* Step 3. The LHS is now known to be non-NULL. Do the binary search + ** of the RHS using the LHS as a probe. If found, the result is + ** true. + */ + if( eType==IN_INDEX_ROWID ){ + /* In this case, the RHS is the ROWID of table b-tree and so we also + ** know that the RHS is non-NULL. Hence, we combine steps 3 and 4 + ** into a single opcode. */ + sqlite3VdbeAddOp3(v, OP_SeekRowid, iTab, destIfFalse, rLhs); + VdbeCoverage(v); + addrTruthOp = sqlite3VdbeAddOp0(v, OP_Goto); /* Return True */ + }else{ + sqlite3VdbeAddOp4(v, OP_Affinity, rLhs, nVector, 0, zAff, nVector); + if( destIfFalse==destIfNull ){ + /* Combine Step 3 and Step 5 into a single opcode */ + sqlite3VdbeAddOp4Int(v, OP_NotFound, iTab, destIfFalse, + rLhs, nVector); VdbeCoverage(v); + goto sqlite3ExprCodeIN_finished; + } + /* Ordinary Step 3, for the case where FALSE and NULL are distinct */ + addrTruthOp = sqlite3VdbeAddOp4Int(v, OP_Found, iTab, 0, + rLhs, nVector); VdbeCoverage(v); + } + + /* Step 4. If the RHS is known to be non-NULL and we did not find + ** an match on the search above, then the result must be FALSE. + */ + if( rRhsHasNull && nVector==1 ){ + sqlite3VdbeAddOp2(v, OP_NotNull, rRhsHasNull, destIfFalse); + VdbeCoverage(v); + } + + /* Step 5. If we do not care about the difference between NULL and + ** FALSE, then just return false. + */ + if( destIfFalse==destIfNull ) sqlite3VdbeGoto(v, destIfFalse); + + /* Step 6: Loop through rows of the RHS. Compare each row to the LHS. + ** If any comparison is NULL, then the result is NULL. If all + ** comparisons are FALSE then the final result is FALSE. + ** + ** For a scalar LHS, it is sufficient to check just the first row + ** of the RHS. + */ + if( destStep6 ) sqlite3VdbeResolveLabel(v, destStep6); + addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, destIfFalse); + VdbeCoverage(v); + if( nVector>1 ){ + destNotNull = sqlite3VdbeMakeLabel(pParse); + }else{ + /* For nVector==1, combine steps 6 and 7 by immediately returning + ** FALSE if the first comparison is not NULL */ + destNotNull = destIfFalse; + } + for(i=0; i1 ){ + sqlite3VdbeResolveLabel(v, destNotNull); + sqlite3VdbeAddOp2(v, OP_Next, iTab, addrTop+1); + VdbeCoverage(v); + + /* Step 7: If we reach this point, we know that the result must + ** be false. */ + sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfFalse); + } + + /* Jumps here in order to return true. */ + sqlite3VdbeJumpHere(v, addrTruthOp); + +sqlite3ExprCodeIN_finished: + if( rLhs!=rLhsOrig ) sqlite3ReleaseTempReg(pParse, rLhs); + VdbeComment((v, "end IN expr")); +sqlite3ExprCodeIN_oom_error: + sqlite3DbFree(pParse->db, aiMap); + sqlite3DbFree(pParse->db, zAff); +} +#endif /* SQLITE_OMIT_SUBQUERY */ + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* +** Generate an instruction that will put the floating point +** value described by z[0..n-1] into register iMem. +** +** The z[] string will probably not be zero-terminated. But the +** z[n] character is guaranteed to be something that does not look +** like the continuation of the number. +*/ +static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){ + if( ALWAYS(z!=0) ){ + double value; + sqlite3AtoF(z, &value, sqlite3Strlen30(z), SQLITE_UTF8); + assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */ + if( negateFlag ) value = -value; + sqlite3VdbeAddOp4Dup8(v, OP_Real, 0, iMem, 0, (u8*)&value, P4_REAL); + } +} +#endif + + +/* +** Generate an instruction that will put the integer describe by +** text z[0..n-1] into register iMem. +** +** Expr.u.zToken is always UTF8 and zero-terminated. +*/ +static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){ + Vdbe *v = pParse->pVdbe; + if( pExpr->flags & EP_IntValue ){ + int i = pExpr->u.iValue; + assert( i>=0 ); + if( negFlag ) i = -i; + sqlite3VdbeAddOp2(v, OP_Integer, i, iMem); + }else{ + int c; + i64 value; + const char *z = pExpr->u.zToken; + assert( z!=0 ); + c = sqlite3DecOrHexToI64(z, &value); + if( (c==3 && !negFlag) || (c==2) || (negFlag && value==SMALLEST_INT64)){ +#ifdef SQLITE_OMIT_FLOATING_POINT + sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z); +#else +#ifndef SQLITE_OMIT_HEX_INTEGER + if( sqlite3_strnicmp(z,"0x",2)==0 ){ + sqlite3ErrorMsg(pParse, "hex literal too big: %s%s", negFlag?"-":"",z); + }else +#endif + { + codeReal(v, z, negFlag, iMem); + } +#endif + }else{ + if( negFlag ){ value = c==3 ? SMALLEST_INT64 : -value; } + sqlite3VdbeAddOp4Dup8(v, OP_Int64, 0, iMem, 0, (u8*)&value, P4_INT64); + } + } +} + + +/* Generate code that will load into register regOut a value that is +** appropriate for the iIdxCol-th column of index pIdx. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeLoadIndexColumn( + Parse *pParse, /* The parsing context */ + Index *pIdx, /* The index whose column is to be loaded */ + int iTabCur, /* Cursor pointing to a table row */ + int iIdxCol, /* The column of the index to be loaded */ + int regOut /* Store the index column value in this register */ +){ + i16 iTabCol = pIdx->aiColumn[iIdxCol]; + if( iTabCol==XN_EXPR ){ + assert( pIdx->aColExpr ); + assert( pIdx->aColExpr->nExpr>iIdxCol ); + pParse->iSelfTab = iTabCur + 1; + sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[iIdxCol].pExpr, regOut); + pParse->iSelfTab = 0; + }else{ + sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pIdx->pTable, iTabCur, + iTabCol, regOut); + } +} + +#ifndef SQLITE_OMIT_GENERATED_COLUMNS +/* +** Generate code that will compute the value of generated column pCol +** and store the result in register regOut +*/ +SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn( + Parse *pParse, + Column *pCol, + int regOut +){ + int iAddr; + Vdbe *v = pParse->pVdbe; + assert( v!=0 ); + assert( pParse->iSelfTab!=0 ); + if( pParse->iSelfTab>0 ){ + iAddr = sqlite3VdbeAddOp3(v, OP_IfNullRow, pParse->iSelfTab-1, 0, regOut); + }else{ + iAddr = 0; + } + sqlite3ExprCodeCopy(pParse, pCol->pDflt, regOut); + if( pCol->affinity>=SQLITE_AFF_TEXT ){ + sqlite3VdbeAddOp4(v, OP_Affinity, regOut, 1, 0, &pCol->affinity, 1); + } + if( iAddr ) sqlite3VdbeJumpHere(v, iAddr); +} +#endif /* SQLITE_OMIT_GENERATED_COLUMNS */ + +/* +** Generate code to extract the value of the iCol-th column of a table. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable( + Vdbe *v, /* Parsing context */ + Table *pTab, /* The table containing the value */ + int iTabCur, /* The table cursor. Or the PK cursor for WITHOUT ROWID */ + int iCol, /* Index of the column to extract */ + int regOut /* Extract the value into this register */ +){ + Column *pCol; + assert( v!=0 ); + if( pTab==0 ){ + sqlite3VdbeAddOp3(v, OP_Column, iTabCur, iCol, regOut); + return; + } + if( iCol<0 || iCol==pTab->iPKey ){ + sqlite3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut); + }else{ + int op; + int x; + if( IsVirtual(pTab) ){ + op = OP_VColumn; + x = iCol; +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + }else if( (pCol = &pTab->aCol[iCol])->colFlags & COLFLAG_VIRTUAL ){ + Parse *pParse = sqlite3VdbeParser(v); + if( pCol->colFlags & COLFLAG_BUSY ){ + sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pCol->zName); + }else{ + int savedSelfTab = pParse->iSelfTab; + pCol->colFlags |= COLFLAG_BUSY; + pParse->iSelfTab = iTabCur+1; + sqlite3ExprCodeGeneratedColumn(pParse, pCol, regOut); + pParse->iSelfTab = savedSelfTab; + pCol->colFlags &= ~COLFLAG_BUSY; + } + return; +#endif + }else if( !HasRowid(pTab) ){ + testcase( iCol!=sqlite3TableColumnToStorage(pTab, iCol) ); + x = sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab), iCol); + op = OP_Column; + }else{ + x = sqlite3TableColumnToStorage(pTab,iCol); + testcase( x!=iCol ); + op = OP_Column; + } + sqlite3VdbeAddOp3(v, op, iTabCur, x, regOut); + sqlite3ColumnDefault(v, pTab, iCol, regOut); + } +} + +/* +** Generate code that will extract the iColumn-th column from +** table pTab and store the column value in register iReg. +** +** There must be an open cursor to pTab in iTable when this routine +** is called. If iColumn<0 then code is generated that extracts the rowid. +*/ +SQLITE_PRIVATE int sqlite3ExprCodeGetColumn( + Parse *pParse, /* Parsing and code generating context */ + Table *pTab, /* Description of the table we are reading from */ + int iColumn, /* Index of the table column */ + int iTable, /* The cursor pointing to the table */ + int iReg, /* Store results here */ + u8 p5 /* P5 value for OP_Column + FLAGS */ +){ + assert( pParse->pVdbe!=0 ); + sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pTab, iTable, iColumn, iReg); + if( p5 ){ + VdbeOp *pOp = sqlite3VdbeGetOp(pParse->pVdbe,-1); + if( pOp->opcode==OP_Column ) pOp->p5 = p5; + } + return iReg; +} + +/* +** Generate code to move content from registers iFrom...iFrom+nReg-1 +** over to iTo..iTo+nReg-1. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){ + sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg); +} + +/* +** Convert a scalar expression node to a TK_REGISTER referencing +** register iReg. The caller must ensure that iReg already contains +** the correct value for the expression. +*/ +static void exprToRegister(Expr *pExpr, int iReg){ + Expr *p = sqlite3ExprSkipCollateAndLikely(pExpr); + if( NEVER(p==0) ) return; + p->op2 = p->op; + p->op = TK_REGISTER; + p->iTable = iReg; + ExprClearProperty(p, EP_Skip); +} + +/* +** Evaluate an expression (either a vector or a scalar expression) and store +** the result in continguous temporary registers. Return the index of +** the first register used to store the result. +** +** If the returned result register is a temporary scalar, then also write +** that register number into *piFreeable. If the returned result register +** is not a temporary or if the expression is a vector set *piFreeable +** to 0. +*/ +static int exprCodeVector(Parse *pParse, Expr *p, int *piFreeable){ + int iResult; + int nResult = sqlite3ExprVectorSize(p); + if( nResult==1 ){ + iResult = sqlite3ExprCodeTemp(pParse, p, piFreeable); + }else{ + *piFreeable = 0; + if( p->op==TK_SELECT ){ +#if SQLITE_OMIT_SUBQUERY + iResult = 0; +#else + iResult = sqlite3CodeSubselect(pParse, p); +#endif + }else{ + int i; + iResult = pParse->nMem+1; + pParse->nMem += nResult; + for(i=0; ix.pList->a[i].pExpr, i+iResult); + } + } + } + return iResult; +} + +/* +** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5) +** so that a subsequent copy will not be merged into this one. +*/ +static void setDoNotMergeFlagOnCopy(Vdbe *v){ + if( sqlite3VdbeGetOp(v, -1)->opcode==OP_Copy ){ + sqlite3VdbeChangeP5(v, 1); /* Tag trailing OP_Copy as not mergable */ + } +} + +/* +** Generate code to implement special SQL functions that are implemented +** in-line rather than by using the usual callbacks. +*/ +static int exprCodeInlineFunction( + Parse *pParse, /* Parsing context */ + ExprList *pFarg, /* List of function arguments */ + int iFuncId, /* Function ID. One of the INTFUNC_... values */ + int target /* Store function result in this register */ +){ + int nFarg; + Vdbe *v = pParse->pVdbe; + assert( v!=0 ); + assert( pFarg!=0 ); + nFarg = pFarg->nExpr; + assert( nFarg>0 ); /* All in-line functions have at least one argument */ + switch( iFuncId ){ + case INLINEFUNC_coalesce: { + /* Attempt a direct implementation of the built-in COALESCE() and + ** IFNULL() functions. This avoids unnecessary evaluation of + ** arguments past the first non-NULL argument. + */ + int endCoalesce = sqlite3VdbeMakeLabel(pParse); + int i; + assert( nFarg>=2 ); + sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target); + for(i=1; ia[i].pExpr, target); + } + setDoNotMergeFlagOnCopy(v); + sqlite3VdbeResolveLabel(v, endCoalesce); + break; + } + case INLINEFUNC_iif: { + Expr caseExpr; + memset(&caseExpr, 0, sizeof(caseExpr)); + caseExpr.op = TK_CASE; + caseExpr.x.pList = pFarg; + return sqlite3ExprCodeTarget(pParse, &caseExpr, target); + } + + default: { + /* The UNLIKELY() function is a no-op. The result is the value + ** of the first argument. + */ + assert( nFarg==1 || nFarg==2 ); + target = sqlite3ExprCodeTarget(pParse, pFarg->a[0].pExpr, target); + break; + } + + /*********************************************************************** + ** Test-only SQL functions that are only usable if enabled + ** via SQLITE_TESTCTRL_INTERNAL_FUNCTIONS + */ + case INLINEFUNC_expr_compare: { + /* Compare two expressions using sqlite3ExprCompare() */ + assert( nFarg==2 ); + sqlite3VdbeAddOp2(v, OP_Integer, + sqlite3ExprCompare(0,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1), + target); + break; + } + + case INLINEFUNC_expr_implies_expr: { + /* Compare two expressions using sqlite3ExprImpliesExpr() */ + assert( nFarg==2 ); + sqlite3VdbeAddOp2(v, OP_Integer, + sqlite3ExprImpliesExpr(pParse,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1), + target); + break; + } + + case INLINEFUNC_implies_nonnull_row: { + /* REsult of sqlite3ExprImpliesNonNullRow() */ + Expr *pA1; + assert( nFarg==2 ); + pA1 = pFarg->a[1].pExpr; + if( pA1->op==TK_COLUMN ){ + sqlite3VdbeAddOp2(v, OP_Integer, + sqlite3ExprImpliesNonNullRow(pFarg->a[0].pExpr,pA1->iTable), + target); + }else{ + sqlite3VdbeAddOp2(v, OP_Null, 0, target); + } + break; + } + +#ifdef SQLITE_DEBUG + case INLINEFUNC_affinity: { + /* The AFFINITY() function evaluates to a string that describes + ** the type affinity of the argument. This is used for testing of + ** the SQLite type logic. + */ + const char *azAff[] = { "blob", "text", "numeric", "integer", "real" }; + char aff; + assert( nFarg==1 ); + aff = sqlite3ExprAffinity(pFarg->a[0].pExpr); + sqlite3VdbeLoadString(v, target, + (aff<=SQLITE_AFF_NONE) ? "none" : azAff[aff-SQLITE_AFF_BLOB]); + break; + } +#endif + } + return target; +} + + +/* +** Generate code into the current Vdbe to evaluate the given +** expression. Attempt to store the results in register "target". +** Return the register where results are stored. +** +** With this routine, there is no guarantee that results will +** be stored in target. The result might be stored in some other +** register if it is convenient to do so. The calling function +** must check the return code and move the results to the desired +** register. +*/ +SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){ + Vdbe *v = pParse->pVdbe; /* The VM under construction */ + int op; /* The opcode being coded */ + int inReg = target; /* Results stored in register inReg */ + int regFree1 = 0; /* If non-zero free this temporary register */ + int regFree2 = 0; /* If non-zero free this temporary register */ + int r1, r2; /* Various register numbers */ + Expr tempX; /* Temporary expression node */ + int p5 = 0; + + assert( target>0 && target<=pParse->nMem ); + assert( v!=0 ); + +expr_code_doover: + if( pExpr==0 ){ + op = TK_NULL; + }else{ + assert( !ExprHasVVAProperty(pExpr,EP_Immutable) ); + op = pExpr->op; + } + switch( op ){ + case TK_AGG_COLUMN: { + AggInfo *pAggInfo = pExpr->pAggInfo; + struct AggInfo_col *pCol; + assert( pAggInfo!=0 ); + assert( pExpr->iAgg>=0 && pExpr->iAggnColumn ); + pCol = &pAggInfo->aCol[pExpr->iAgg]; + if( !pAggInfo->directMode ){ + assert( pCol->iMem>0 ); + return pCol->iMem; + }else if( pAggInfo->useSortingIdx ){ + Table *pTab = pCol->pTab; + sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab, + pCol->iSorterColumn, target); + if( pCol->iColumn<0 ){ + VdbeComment((v,"%s.rowid",pTab->zName)); + }else{ + VdbeComment((v,"%s.%s",pTab->zName,pTab->aCol[pCol->iColumn].zName)); + if( pTab->aCol[pCol->iColumn].affinity==SQLITE_AFF_REAL ){ + sqlite3VdbeAddOp1(v, OP_RealAffinity, target); + } + } + return target; + } + /* Otherwise, fall thru into the TK_COLUMN case */ + /* no break */ deliberate_fall_through + } + case TK_COLUMN: { + int iTab = pExpr->iTable; + int iReg; + if( ExprHasProperty(pExpr, EP_FixedCol) ){ + /* This COLUMN expression is really a constant due to WHERE clause + ** constraints, and that constant is coded by the pExpr->pLeft + ** expresssion. However, make sure the constant has the correct + ** datatype by applying the Affinity of the table column to the + ** constant. + */ + int aff; + iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target); + if( pExpr->y.pTab ){ + aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn); + }else{ + aff = pExpr->affExpr; + } + if( aff>SQLITE_AFF_BLOB ){ + static const char zAff[] = "B\000C\000D\000E"; + assert( SQLITE_AFF_BLOB=='A' ); + assert( SQLITE_AFF_TEXT=='B' ); + sqlite3VdbeAddOp4(v, OP_Affinity, iReg, 1, 0, + &zAff[(aff-'B')*2], P4_STATIC); + } + return iReg; + } + if( iTab<0 ){ + if( pParse->iSelfTab<0 ){ + /* Other columns in the same row for CHECK constraints or + ** generated columns or for inserting into partial index. + ** The row is unpacked into registers beginning at + ** 0-(pParse->iSelfTab). The rowid (if any) is in a register + ** immediately prior to the first column. + */ + Column *pCol; + Table *pTab = pExpr->y.pTab; + int iSrc; + int iCol = pExpr->iColumn; + assert( pTab!=0 ); + assert( iCol>=XN_ROWID ); + assert( iColnCol ); + if( iCol<0 ){ + return -1-pParse->iSelfTab; + } + pCol = pTab->aCol + iCol; + testcase( iCol!=sqlite3TableColumnToStorage(pTab,iCol) ); + iSrc = sqlite3TableColumnToStorage(pTab, iCol) - pParse->iSelfTab; +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( pCol->colFlags & COLFLAG_GENERATED ){ + if( pCol->colFlags & COLFLAG_BUSY ){ + sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", + pCol->zName); + return 0; + } + pCol->colFlags |= COLFLAG_BUSY; + if( pCol->colFlags & COLFLAG_NOTAVAIL ){ + sqlite3ExprCodeGeneratedColumn(pParse, pCol, iSrc); + } + pCol->colFlags &= ~(COLFLAG_BUSY|COLFLAG_NOTAVAIL); + return iSrc; + }else +#endif /* SQLITE_OMIT_GENERATED_COLUMNS */ + if( pCol->affinity==SQLITE_AFF_REAL ){ + sqlite3VdbeAddOp2(v, OP_SCopy, iSrc, target); + sqlite3VdbeAddOp1(v, OP_RealAffinity, target); + return target; + }else{ + return iSrc; + } + }else{ + /* Coding an expression that is part of an index where column names + ** in the index refer to the table to which the index belongs */ + iTab = pParse->iSelfTab - 1; + } + } + iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab, + pExpr->iColumn, iTab, target, + pExpr->op2); + if( pExpr->y.pTab==0 && pExpr->affExpr==SQLITE_AFF_REAL ){ + sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg); + } + return iReg; + } + case TK_INTEGER: { + codeInteger(pParse, pExpr, 0, target); + return target; + } + case TK_TRUEFALSE: { + sqlite3VdbeAddOp2(v, OP_Integer, sqlite3ExprTruthValue(pExpr), target); + return target; + } +#ifndef SQLITE_OMIT_FLOATING_POINT + case TK_FLOAT: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + codeReal(v, pExpr->u.zToken, 0, target); + return target; + } +#endif + case TK_STRING: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3VdbeLoadString(v, target, pExpr->u.zToken); + return target; + } + default: { + /* Make NULL the default case so that if a bug causes an illegal + ** Expr node to be passed into this function, it will be handled + ** sanely and not crash. But keep the assert() to bring the problem + ** to the attention of the developers. */ + assert( op==TK_NULL ); + sqlite3VdbeAddOp2(v, OP_Null, 0, target); + return target; + } +#ifndef SQLITE_OMIT_BLOB_LITERAL + case TK_BLOB: { + int n; + const char *z; + char *zBlob; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' ); + assert( pExpr->u.zToken[1]=='\'' ); + z = &pExpr->u.zToken[2]; + n = sqlite3Strlen30(z) - 1; + assert( z[n]=='\'' ); + zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n); + sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC); + return target; + } +#endif + case TK_VARIABLE: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + assert( pExpr->u.zToken!=0 ); + assert( pExpr->u.zToken[0]!=0 ); + sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target); + if( pExpr->u.zToken[1]!=0 ){ + const char *z = sqlite3VListNumToName(pParse->pVList, pExpr->iColumn); + assert( pExpr->u.zToken[0]=='?' || (z && !strcmp(pExpr->u.zToken, z)) ); + pParse->pVList[0] = 0; /* Indicate VList may no longer be enlarged */ + sqlite3VdbeAppendP4(v, (char*)z, P4_STATIC); + } + return target; + } + case TK_REGISTER: { + return pExpr->iTable; + } +#ifndef SQLITE_OMIT_CAST + case TK_CAST: { + /* Expressions of the form: CAST(pLeft AS token) */ + inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target); + if( inReg!=target ){ + sqlite3VdbeAddOp2(v, OP_SCopy, inReg, target); + inReg = target; + } + sqlite3VdbeAddOp2(v, OP_Cast, target, + sqlite3AffinityType(pExpr->u.zToken, 0)); + return inReg; + } +#endif /* SQLITE_OMIT_CAST */ + case TK_IS: + case TK_ISNOT: + op = (op==TK_IS) ? TK_EQ : TK_NE; + p5 = SQLITE_NULLEQ; + /* fall-through */ + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: { + Expr *pLeft = pExpr->pLeft; + if( sqlite3ExprIsVector(pLeft) ){ + codeVectorCompare(pParse, pExpr, target, op, p5); + }else{ + r1 = sqlite3ExprCodeTemp(pParse, pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); + codeCompare(pParse, pLeft, pExpr->pRight, op, + r1, r2, inReg, SQLITE_STOREP2 | p5, + ExprHasProperty(pExpr,EP_Commuted)); + assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt); + assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le); + assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt); + assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge); + assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq); + assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne); + testcase( regFree1==0 ); + testcase( regFree2==0 ); + } + break; + } + case TK_AND: + case TK_OR: + case TK_PLUS: + case TK_STAR: + case TK_MINUS: + case TK_REM: + case TK_BITAND: + case TK_BITOR: + case TK_SLASH: + case TK_LSHIFT: + case TK_RSHIFT: + case TK_CONCAT: { + assert( TK_AND==OP_And ); testcase( op==TK_AND ); + assert( TK_OR==OP_Or ); testcase( op==TK_OR ); + assert( TK_PLUS==OP_Add ); testcase( op==TK_PLUS ); + assert( TK_MINUS==OP_Subtract ); testcase( op==TK_MINUS ); + assert( TK_REM==OP_Remainder ); testcase( op==TK_REM ); + assert( TK_BITAND==OP_BitAnd ); testcase( op==TK_BITAND ); + assert( TK_BITOR==OP_BitOr ); testcase( op==TK_BITOR ); + assert( TK_SLASH==OP_Divide ); testcase( op==TK_SLASH ); + assert( TK_LSHIFT==OP_ShiftLeft ); testcase( op==TK_LSHIFT ); + assert( TK_RSHIFT==OP_ShiftRight ); testcase( op==TK_RSHIFT ); + assert( TK_CONCAT==OP_Concat ); testcase( op==TK_CONCAT ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); + sqlite3VdbeAddOp3(v, op, r2, r1, target); + testcase( regFree1==0 ); + testcase( regFree2==0 ); + break; + } + case TK_UMINUS: { + Expr *pLeft = pExpr->pLeft; + assert( pLeft ); + if( pLeft->op==TK_INTEGER ){ + codeInteger(pParse, pLeft, 1, target); + return target; +#ifndef SQLITE_OMIT_FLOATING_POINT + }else if( pLeft->op==TK_FLOAT ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + codeReal(v, pLeft->u.zToken, 1, target); + return target; +#endif + }else{ + tempX.op = TK_INTEGER; + tempX.flags = EP_IntValue|EP_TokenOnly; + tempX.u.iValue = 0; + ExprClearVVAProperties(&tempX); + r1 = sqlite3ExprCodeTemp(pParse, &tempX, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2); + sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target); + testcase( regFree2==0 ); + } + break; + } + case TK_BITNOT: + case TK_NOT: { + assert( TK_BITNOT==OP_BitNot ); testcase( op==TK_BITNOT ); + assert( TK_NOT==OP_Not ); testcase( op==TK_NOT ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + testcase( regFree1==0 ); + sqlite3VdbeAddOp2(v, op, r1, inReg); + break; + } + case TK_TRUTH: { + int isTrue; /* IS TRUE or IS NOT TRUE */ + int bNormal; /* IS TRUE or IS FALSE */ + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + testcase( regFree1==0 ); + isTrue = sqlite3ExprTruthValue(pExpr->pRight); + bNormal = pExpr->op2==TK_IS; + testcase( isTrue && bNormal); + testcase( !isTrue && bNormal); + sqlite3VdbeAddOp4Int(v, OP_IsTrue, r1, inReg, !isTrue, isTrue ^ bNormal); + break; + } + case TK_ISNULL: + case TK_NOTNULL: { + int addr; + assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL ); + assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL ); + sqlite3VdbeAddOp2(v, OP_Integer, 1, target); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + testcase( regFree1==0 ); + addr = sqlite3VdbeAddOp1(v, op, r1); + VdbeCoverageIf(v, op==TK_ISNULL); + VdbeCoverageIf(v, op==TK_NOTNULL); + sqlite3VdbeAddOp2(v, OP_Integer, 0, target); + sqlite3VdbeJumpHere(v, addr); + break; + } + case TK_AGG_FUNCTION: { + AggInfo *pInfo = pExpr->pAggInfo; + if( pInfo==0 + || NEVER(pExpr->iAgg<0) + || NEVER(pExpr->iAgg>=pInfo->nFunc) + ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken); + }else{ + return pInfo->aFunc[pExpr->iAgg].iMem; + } + break; + } + case TK_FUNCTION: { + ExprList *pFarg; /* List of function arguments */ + int nFarg; /* Number of function arguments */ + FuncDef *pDef; /* The function definition object */ + const char *zId; /* The function name */ + u32 constMask = 0; /* Mask of function arguments that are constant */ + int i; /* Loop counter */ + sqlite3 *db = pParse->db; /* The database connection */ + u8 enc = ENC(db); /* The text encoding used by this database */ + CollSeq *pColl = 0; /* A collating sequence */ + +#ifndef SQLITE_OMIT_WINDOWFUNC + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + return pExpr->y.pWin->regResult; + } +#endif + + if( ConstFactorOk(pParse) && sqlite3ExprIsConstantNotJoin(pExpr) ){ + /* SQL functions can be expensive. So try to avoid running them + ** multiple times if we know they always give the same result */ + return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1); + } + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + assert( !ExprHasProperty(pExpr, EP_TokenOnly) ); + pFarg = pExpr->x.pList; + nFarg = pFarg ? pFarg->nExpr : 0; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + zId = pExpr->u.zToken; + pDef = sqlite3FindFunction(db, zId, nFarg, enc, 0); +#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION + if( pDef==0 && pParse->explain ){ + pDef = sqlite3FindFunction(db, "unknown", nFarg, enc, 0); + } +#endif + if( pDef==0 || pDef->xFinalize!=0 ){ + sqlite3ErrorMsg(pParse, "unknown function: %s()", zId); + break; + } + if( pDef->funcFlags & SQLITE_FUNC_INLINE ){ + assert( (pDef->funcFlags & SQLITE_FUNC_UNSAFE)==0 ); + assert( (pDef->funcFlags & SQLITE_FUNC_DIRECT)==0 ); + return exprCodeInlineFunction(pParse, pFarg, + SQLITE_PTR_TO_INT(pDef->pUserData), target); + }else if( pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE) ){ + sqlite3ExprFunctionUsable(pParse, pExpr, pDef); + } + + for(i=0; ia[i].pExpr) ){ + testcase( i==31 ); + constMask |= MASKBIT32(i); + } + if( (pDef->funcFlags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){ + pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr); + } + } + if( pFarg ){ + if( constMask ){ + r1 = pParse->nMem+1; + pParse->nMem += nFarg; + }else{ + r1 = sqlite3GetTempRange(pParse, nFarg); + } + + /* For length() and typeof() functions with a column argument, + ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG + ** or OPFLAG_TYPEOFARG respectively, to avoid unnecessary data + ** loading. + */ + if( (pDef->funcFlags & (SQLITE_FUNC_LENGTH|SQLITE_FUNC_TYPEOF))!=0 ){ + u8 exprOp; + assert( nFarg==1 ); + assert( pFarg->a[0].pExpr!=0 ); + exprOp = pFarg->a[0].pExpr->op; + if( exprOp==TK_COLUMN || exprOp==TK_AGG_COLUMN ){ + assert( SQLITE_FUNC_LENGTH==OPFLAG_LENGTHARG ); + assert( SQLITE_FUNC_TYPEOF==OPFLAG_TYPEOFARG ); + testcase( pDef->funcFlags & OPFLAG_LENGTHARG ); + pFarg->a[0].pExpr->op2 = + pDef->funcFlags & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG); + } + } + + sqlite3ExprCodeExprList(pParse, pFarg, r1, 0, + SQLITE_ECEL_DUP|SQLITE_ECEL_FACTOR); + }else{ + r1 = 0; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* Possibly overload the function if the first argument is + ** a virtual table column. + ** + ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the + ** second argument, not the first, as the argument to test to + ** see if it is a column in a virtual table. This is done because + ** the left operand of infix functions (the operand we want to + ** control overloading) ends up as the second argument to the + ** function. The expression "A glob B" is equivalent to + ** "glob(B,A). We want to use the A in "A glob B" to test + ** for function overloading. But we use the B term in "glob(B,A)". + */ + if( nFarg>=2 && ExprHasProperty(pExpr, EP_InfixFunc) ){ + pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr); + }else if( nFarg>0 ){ + pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr); + } +#endif + if( pDef->funcFlags & SQLITE_FUNC_NEEDCOLL ){ + if( !pColl ) pColl = db->pDfltColl; + sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ); + } +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC + if( pDef->funcFlags & SQLITE_FUNC_OFFSET ){ + Expr *pArg = pFarg->a[0].pExpr; + if( pArg->op==TK_COLUMN ){ + sqlite3VdbeAddOp3(v, OP_Offset, pArg->iTable, pArg->iColumn, target); + }else{ + sqlite3VdbeAddOp2(v, OP_Null, 0, target); + } + }else +#endif + { + sqlite3VdbeAddFunctionCall(pParse, constMask, r1, target, nFarg, + pDef, pExpr->op2); + } + if( nFarg ){ + if( constMask==0 ){ + sqlite3ReleaseTempRange(pParse, r1, nFarg); + }else{ + sqlite3VdbeReleaseRegisters(pParse, r1, nFarg, constMask, 1); + } + } + return target; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_EXISTS: + case TK_SELECT: { + int nCol; + testcase( op==TK_EXISTS ); + testcase( op==TK_SELECT ); + if( pParse->db->mallocFailed ){ + return 0; + }else if( op==TK_SELECT && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1 ){ + sqlite3SubselectError(pParse, nCol, 1); + }else{ + return sqlite3CodeSubselect(pParse, pExpr); + } + break; + } + case TK_SELECT_COLUMN: { + int n; + if( pExpr->pLeft->iTable==0 ){ + pExpr->pLeft->iTable = sqlite3CodeSubselect(pParse, pExpr->pLeft); + } + assert( pExpr->iTable==0 || pExpr->pLeft->op==TK_SELECT ); + if( pExpr->iTable!=0 + && pExpr->iTable!=(n = sqlite3ExprVectorSize(pExpr->pLeft)) + ){ + sqlite3ErrorMsg(pParse, "%d columns assigned %d values", + pExpr->iTable, n); + } + return pExpr->pLeft->iTable + pExpr->iColumn; + } + case TK_IN: { + int destIfFalse = sqlite3VdbeMakeLabel(pParse); + int destIfNull = sqlite3VdbeMakeLabel(pParse); + sqlite3VdbeAddOp2(v, OP_Null, 0, target); + sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull); + sqlite3VdbeAddOp2(v, OP_Integer, 1, target); + sqlite3VdbeResolveLabel(v, destIfFalse); + sqlite3VdbeAddOp2(v, OP_AddImm, target, 0); + sqlite3VdbeResolveLabel(v, destIfNull); + return target; + } +#endif /* SQLITE_OMIT_SUBQUERY */ + + + /* + ** x BETWEEN y AND z + ** + ** This is equivalent to + ** + ** x>=y AND x<=z + ** + ** X is stored in pExpr->pLeft. + ** Y is stored in pExpr->pList->a[0].pExpr. + ** Z is stored in pExpr->pList->a[1].pExpr. + */ + case TK_BETWEEN: { + exprCodeBetween(pParse, pExpr, target, 0, 0); + return target; + } + case TK_SPAN: + case TK_COLLATE: + case TK_UPLUS: { + pExpr = pExpr->pLeft; + goto expr_code_doover; /* 2018-04-28: Prevent deep recursion. OSSFuzz. */ + } + + case TK_TRIGGER: { + /* If the opcode is TK_TRIGGER, then the expression is a reference + ** to a column in the new.* or old.* pseudo-tables available to + ** trigger programs. In this case Expr.iTable is set to 1 for the + ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn + ** is set to the column of the pseudo-table to read, or to -1 to + ** read the rowid field. + ** + ** The expression is implemented using an OP_Param opcode. The p1 + ** parameter is set to 0 for an old.rowid reference, or to (i+1) + ** to reference another column of the old.* pseudo-table, where + ** i is the index of the column. For a new.rowid reference, p1 is + ** set to (n+1), where n is the number of columns in each pseudo-table. + ** For a reference to any other column in the new.* pseudo-table, p1 + ** is set to (n+2+i), where n and i are as defined previously. For + ** example, if the table on which triggers are being fired is + ** declared as: + ** + ** CREATE TABLE t1(a, b); + ** + ** Then p1 is interpreted as follows: + ** + ** p1==0 -> old.rowid p1==3 -> new.rowid + ** p1==1 -> old.a p1==4 -> new.a + ** p1==2 -> old.b p1==5 -> new.b + */ + Table *pTab = pExpr->y.pTab; + int iCol = pExpr->iColumn; + int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + + sqlite3TableColumnToStorage(pTab, iCol); + + assert( pExpr->iTable==0 || pExpr->iTable==1 ); + assert( iCol>=-1 && iColnCol ); + assert( pTab->iPKey<0 || iCol!=pTab->iPKey ); + assert( p1>=0 && p1<(pTab->nCol*2+2) ); + + sqlite3VdbeAddOp2(v, OP_Param, p1, target); + VdbeComment((v, "r[%d]=%s.%s", target, + (pExpr->iTable ? "new" : "old"), + (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zName) + )); + +#ifndef SQLITE_OMIT_FLOATING_POINT + /* If the column has REAL affinity, it may currently be stored as an + ** integer. Use OP_RealAffinity to make sure it is really real. + ** + ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to + ** floating point when extracting it from the record. */ + if( iCol>=0 && pTab->aCol[iCol].affinity==SQLITE_AFF_REAL ){ + sqlite3VdbeAddOp1(v, OP_RealAffinity, target); + } +#endif + break; + } + + case TK_VECTOR: { + sqlite3ErrorMsg(pParse, "row value misused"); + break; + } + + /* TK_IF_NULL_ROW Expr nodes are inserted ahead of expressions + ** that derive from the right-hand table of a LEFT JOIN. The + ** Expr.iTable value is the table number for the right-hand table. + ** The expression is only evaluated if that table is not currently + ** on a LEFT JOIN NULL row. + */ + case TK_IF_NULL_ROW: { + int addrINR; + u8 okConstFactor = pParse->okConstFactor; + addrINR = sqlite3VdbeAddOp1(v, OP_IfNullRow, pExpr->iTable); + /* Temporarily disable factoring of constant expressions, since + ** even though expressions may appear to be constant, they are not + ** really constant because they originate from the right-hand side + ** of a LEFT JOIN. */ + pParse->okConstFactor = 0; + inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target); + pParse->okConstFactor = okConstFactor; + sqlite3VdbeJumpHere(v, addrINR); + sqlite3VdbeChangeP3(v, addrINR, inReg); + break; + } + + /* + ** Form A: + ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END + ** + ** Form B: + ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END + ** + ** Form A is can be transformed into the equivalent form B as follows: + ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ... + ** WHEN x=eN THEN rN ELSE y END + ** + ** X (if it exists) is in pExpr->pLeft. + ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is + ** odd. The Y is also optional. If the number of elements in x.pList + ** is even, then Y is omitted and the "otherwise" result is NULL. + ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1]. + ** + ** The result of the expression is the Ri for the first matching Ei, + ** or if there is no matching Ei, the ELSE term Y, or if there is + ** no ELSE term, NULL. + */ + case TK_CASE: { + int endLabel; /* GOTO label for end of CASE stmt */ + int nextCase; /* GOTO label for next WHEN clause */ + int nExpr; /* 2x number of WHEN terms */ + int i; /* Loop counter */ + ExprList *pEList; /* List of WHEN terms */ + struct ExprList_item *aListelem; /* Array of WHEN terms */ + Expr opCompare; /* The X==Ei expression */ + Expr *pX; /* The X expression */ + Expr *pTest = 0; /* X==Ei (form A) or just Ei (form B) */ + Expr *pDel = 0; + sqlite3 *db = pParse->db; + + assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList ); + assert(pExpr->x.pList->nExpr > 0); + pEList = pExpr->x.pList; + aListelem = pEList->a; + nExpr = pEList->nExpr; + endLabel = sqlite3VdbeMakeLabel(pParse); + if( (pX = pExpr->pLeft)!=0 ){ + pDel = sqlite3ExprDup(db, pX, 0); + if( db->mallocFailed ){ + sqlite3ExprDelete(db, pDel); + break; + } + testcase( pX->op==TK_COLUMN ); + exprToRegister(pDel, exprCodeVector(pParse, pDel, ®Free1)); + testcase( regFree1==0 ); + memset(&opCompare, 0, sizeof(opCompare)); + opCompare.op = TK_EQ; + opCompare.pLeft = pDel; + pTest = &opCompare; + /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001: + ** The value in regFree1 might get SCopy-ed into the file result. + ** So make sure that the regFree1 register is not reused for other + ** purposes and possibly overwritten. */ + regFree1 = 0; + } + for(i=0; iop==TK_COLUMN ); + sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL); + testcase( aListelem[i+1].pExpr->op==TK_COLUMN ); + sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target); + sqlite3VdbeGoto(v, endLabel); + sqlite3VdbeResolveLabel(v, nextCase); + } + if( (nExpr&1)!=0 ){ + sqlite3ExprCode(pParse, pEList->a[nExpr-1].pExpr, target); + }else{ + sqlite3VdbeAddOp2(v, OP_Null, 0, target); + } + sqlite3ExprDelete(db, pDel); + setDoNotMergeFlagOnCopy(v); + sqlite3VdbeResolveLabel(v, endLabel); + break; + } +#ifndef SQLITE_OMIT_TRIGGER + case TK_RAISE: { + assert( pExpr->affExpr==OE_Rollback + || pExpr->affExpr==OE_Abort + || pExpr->affExpr==OE_Fail + || pExpr->affExpr==OE_Ignore + ); + if( !pParse->pTriggerTab && !pParse->nested ){ + sqlite3ErrorMsg(pParse, + "RAISE() may only be used within a trigger-program"); + return 0; + } + if( pExpr->affExpr==OE_Abort ){ + sqlite3MayAbort(pParse); + } + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + if( pExpr->affExpr==OE_Ignore ){ + sqlite3VdbeAddOp4( + v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0); + VdbeCoverage(v); + }else{ + sqlite3HaltConstraint(pParse, + pParse->pTriggerTab ? SQLITE_CONSTRAINT_TRIGGER : SQLITE_ERROR, + pExpr->affExpr, pExpr->u.zToken, 0, 0); + } + + break; + } +#endif + } + sqlite3ReleaseTempReg(pParse, regFree1); + sqlite3ReleaseTempReg(pParse, regFree2); + return inReg; +} + +/* +** Generate code that will evaluate expression pExpr just one time +** per prepared statement execution. +** +** If the expression uses functions (that might throw an exception) then +** guard them with an OP_Once opcode to ensure that the code is only executed +** once. If no functions are involved, then factor the code out and put it at +** the end of the prepared statement in the initialization section. +** +** If regDest>=0 then the result is always stored in that register and the +** result is not reusable. If regDest<0 then this routine is free to +** store the value whereever it wants. The register where the expression +** is stored is returned. When regDest<0, two identical expressions might +** code to the same register, if they do not contain function calls and hence +** are factored out into the initialization section at the end of the +** prepared statement. +*/ +SQLITE_PRIVATE int sqlite3ExprCodeRunJustOnce( + Parse *pParse, /* Parsing context */ + Expr *pExpr, /* The expression to code when the VDBE initializes */ + int regDest /* Store the value in this register */ +){ + ExprList *p; + assert( ConstFactorOk(pParse) ); + p = pParse->pConstExpr; + if( regDest<0 && p ){ + struct ExprList_item *pItem; + int i; + for(pItem=p->a, i=p->nExpr; i>0; pItem++, i--){ + if( pItem->reusable && sqlite3ExprCompare(0,pItem->pExpr,pExpr,-1)==0 ){ + return pItem->u.iConstExprReg; + } + } + } + pExpr = sqlite3ExprDup(pParse->db, pExpr, 0); + if( pExpr!=0 && ExprHasProperty(pExpr, EP_HasFunc) ){ + Vdbe *v = pParse->pVdbe; + int addr; + assert( v ); + addr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + pParse->okConstFactor = 0; + if( !pParse->db->mallocFailed ){ + if( regDest<0 ) regDest = ++pParse->nMem; + sqlite3ExprCode(pParse, pExpr, regDest); + } + pParse->okConstFactor = 1; + sqlite3ExprDelete(pParse->db, pExpr); + sqlite3VdbeJumpHere(v, addr); + }else{ + p = sqlite3ExprListAppend(pParse, p, pExpr); + if( p ){ + struct ExprList_item *pItem = &p->a[p->nExpr-1]; + pItem->reusable = regDest<0; + if( regDest<0 ) regDest = ++pParse->nMem; + pItem->u.iConstExprReg = regDest; + } + pParse->pConstExpr = p; + } + return regDest; +} + +/* +** Generate code to evaluate an expression and store the results +** into a register. Return the register number where the results +** are stored. +** +** If the register is a temporary register that can be deallocated, +** then write its number into *pReg. If the result register is not +** a temporary, then set *pReg to zero. +** +** If pExpr is a constant, then this routine might generate this +** code to fill the register in the initialization section of the +** VDBE program, in order to factor it out of the evaluation loop. +*/ +SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){ + int r2; + pExpr = sqlite3ExprSkipCollateAndLikely(pExpr); + if( ConstFactorOk(pParse) + && ALWAYS(pExpr!=0) + && pExpr->op!=TK_REGISTER + && sqlite3ExprIsConstantNotJoin(pExpr) + ){ + *pReg = 0; + r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1); + }else{ + int r1 = sqlite3GetTempReg(pParse); + r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1); + if( r2==r1 ){ + *pReg = r1; + }else{ + sqlite3ReleaseTempReg(pParse, r1); + *pReg = 0; + } + } + return r2; +} + +/* +** Generate code that will evaluate expression pExpr and store the +** results in register target. The results are guaranteed to appear +** in register target. +*/ +SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){ + int inReg; + + assert( pExpr==0 || !ExprHasVVAProperty(pExpr,EP_Immutable) ); + assert( target>0 && target<=pParse->nMem ); + assert( pParse->pVdbe!=0 || pParse->db->mallocFailed ); + if( pParse->pVdbe==0 ) return; + inReg = sqlite3ExprCodeTarget(pParse, pExpr, target); + if( inReg!=target ){ + u8 op; + if( ExprHasProperty(pExpr,EP_Subquery) ){ + op = OP_Copy; + }else{ + op = OP_SCopy; + } + sqlite3VdbeAddOp2(pParse->pVdbe, op, inReg, target); + } +} + +/* +** Make a transient copy of expression pExpr and then code it using +** sqlite3ExprCode(). This routine works just like sqlite3ExprCode() +** except that the input expression is guaranteed to be unchanged. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){ + sqlite3 *db = pParse->db; + pExpr = sqlite3ExprDup(db, pExpr, 0); + if( !db->mallocFailed ) sqlite3ExprCode(pParse, pExpr, target); + sqlite3ExprDelete(db, pExpr); +} + +/* +** Generate code that will evaluate expression pExpr and store the +** results in register target. The results are guaranteed to appear +** in register target. If the expression is constant, then this routine +** might choose to code the expression at initialization time. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){ + if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pExpr) ){ + sqlite3ExprCodeRunJustOnce(pParse, pExpr, target); + }else{ + sqlite3ExprCodeCopy(pParse, pExpr, target); + } +} + +/* +** Generate code that pushes the value of every element of the given +** expression list into a sequence of registers beginning at target. +** +** Return the number of elements evaluated. The number returned will +** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF +** is defined. +** +** The SQLITE_ECEL_DUP flag prevents the arguments from being +** filled using OP_SCopy. OP_Copy must be used instead. +** +** The SQLITE_ECEL_FACTOR argument allows constant arguments to be +** factored out into initialization code. +** +** The SQLITE_ECEL_REF flag means that expressions in the list with +** ExprList.a[].u.x.iOrderByCol>0 have already been evaluated and stored +** in registers at srcReg, and so the value can be copied from there. +** If SQLITE_ECEL_OMITREF is also set, then the values with u.x.iOrderByCol>0 +** are simply omitted rather than being copied from srcReg. +*/ +SQLITE_PRIVATE int sqlite3ExprCodeExprList( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* The expression list to be coded */ + int target, /* Where to write results */ + int srcReg, /* Source registers if SQLITE_ECEL_REF */ + u8 flags /* SQLITE_ECEL_* flags */ +){ + struct ExprList_item *pItem; + int i, j, n; + u8 copyOp = (flags & SQLITE_ECEL_DUP) ? OP_Copy : OP_SCopy; + Vdbe *v = pParse->pVdbe; + assert( pList!=0 ); + assert( target>0 ); + assert( pParse->pVdbe!=0 ); /* Never gets this far otherwise */ + n = pList->nExpr; + if( !ConstFactorOk(pParse) ) flags &= ~SQLITE_ECEL_FACTOR; + for(pItem=pList->a, i=0; ipExpr; +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + if( pItem->bSorterRef ){ + i--; + n--; + }else +#endif + if( (flags & SQLITE_ECEL_REF)!=0 && (j = pItem->u.x.iOrderByCol)>0 ){ + if( flags & SQLITE_ECEL_OMITREF ){ + i--; + n--; + }else{ + sqlite3VdbeAddOp2(v, copyOp, j+srcReg-1, target+i); + } + }else if( (flags & SQLITE_ECEL_FACTOR)!=0 + && sqlite3ExprIsConstantNotJoin(pExpr) + ){ + sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i); + }else{ + int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i); + if( inReg!=target+i ){ + VdbeOp *pOp; + if( copyOp==OP_Copy + && (pOp=sqlite3VdbeGetOp(v, -1))->opcode==OP_Copy + && pOp->p1+pOp->p3+1==inReg + && pOp->p2+pOp->p3+1==target+i + && pOp->p5==0 /* The do-not-merge flag must be clear */ + ){ + pOp->p3++; + }else{ + sqlite3VdbeAddOp2(v, copyOp, inReg, target+i); + } + } + } + } + return n; +} + +/* +** Generate code for a BETWEEN operator. +** +** x BETWEEN y AND z +** +** The above is equivalent to +** +** x>=y AND x<=z +** +** Code it as such, taking care to do the common subexpression +** elimination of x. +** +** The xJumpIf parameter determines details: +** +** NULL: Store the boolean result in reg[dest] +** sqlite3ExprIfTrue: Jump to dest if true +** sqlite3ExprIfFalse: Jump to dest if false +** +** The jumpIfNull parameter is ignored if xJumpIf is NULL. +*/ +static void exprCodeBetween( + Parse *pParse, /* Parsing and code generating context */ + Expr *pExpr, /* The BETWEEN expression */ + int dest, /* Jump destination or storage location */ + void (*xJump)(Parse*,Expr*,int,int), /* Action to take */ + int jumpIfNull /* Take the jump if the BETWEEN is NULL */ +){ + Expr exprAnd; /* The AND operator in x>=y AND x<=z */ + Expr compLeft; /* The x>=y term */ + Expr compRight; /* The x<=z term */ + int regFree1 = 0; /* Temporary use register */ + Expr *pDel = 0; + sqlite3 *db = pParse->db; + + memset(&compLeft, 0, sizeof(Expr)); + memset(&compRight, 0, sizeof(Expr)); + memset(&exprAnd, 0, sizeof(Expr)); + + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + pDel = sqlite3ExprDup(db, pExpr->pLeft, 0); + if( db->mallocFailed==0 ){ + exprAnd.op = TK_AND; + exprAnd.pLeft = &compLeft; + exprAnd.pRight = &compRight; + compLeft.op = TK_GE; + compLeft.pLeft = pDel; + compLeft.pRight = pExpr->x.pList->a[0].pExpr; + compRight.op = TK_LE; + compRight.pLeft = pDel; + compRight.pRight = pExpr->x.pList->a[1].pExpr; + exprToRegister(pDel, exprCodeVector(pParse, pDel, ®Free1)); + if( xJump ){ + xJump(pParse, &exprAnd, dest, jumpIfNull); + }else{ + /* Mark the expression is being from the ON or USING clause of a join + ** so that the sqlite3ExprCodeTarget() routine will not attempt to move + ** it into the Parse.pConstExpr list. We should use a new bit for this, + ** for clarity, but we are out of bits in the Expr.flags field so we + ** have to reuse the EP_FromJoin bit. Bummer. */ + pDel->flags |= EP_FromJoin; + sqlite3ExprCodeTarget(pParse, &exprAnd, dest); + } + sqlite3ReleaseTempReg(pParse, regFree1); + } + sqlite3ExprDelete(db, pDel); + + /* Ensure adequate test coverage */ + testcase( xJump==sqlite3ExprIfTrue && jumpIfNull==0 && regFree1==0 ); + testcase( xJump==sqlite3ExprIfTrue && jumpIfNull==0 && regFree1!=0 ); + testcase( xJump==sqlite3ExprIfTrue && jumpIfNull!=0 && regFree1==0 ); + testcase( xJump==sqlite3ExprIfTrue && jumpIfNull!=0 && regFree1!=0 ); + testcase( xJump==sqlite3ExprIfFalse && jumpIfNull==0 && regFree1==0 ); + testcase( xJump==sqlite3ExprIfFalse && jumpIfNull==0 && regFree1!=0 ); + testcase( xJump==sqlite3ExprIfFalse && jumpIfNull!=0 && regFree1==0 ); + testcase( xJump==sqlite3ExprIfFalse && jumpIfNull!=0 && regFree1!=0 ); + testcase( xJump==0 ); +} + +/* +** Generate code for a boolean expression such that a jump is made +** to the label "dest" if the expression is true but execution +** continues straight thru if the expression is false. +** +** If the expression evaluates to NULL (neither true nor false), then +** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL. +** +** This code depends on the fact that certain token values (ex: TK_EQ) +** are the same as opcode values (ex: OP_Eq) that implement the corresponding +** operation. Special comments in vdbe.c and the mkopcodeh.awk script in +** the make process cause these values to align. Assert()s in the code +** below verify that the numbers are aligned correctly. +*/ +SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ + Vdbe *v = pParse->pVdbe; + int op = 0; + int regFree1 = 0; + int regFree2 = 0; + int r1, r2; + + assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 ); + if( NEVER(v==0) ) return; /* Existence of VDBE checked by caller */ + if( NEVER(pExpr==0) ) return; /* No way this can happen */ + assert( !ExprHasVVAProperty(pExpr, EP_Immutable) ); + op = pExpr->op; + switch( op ){ + case TK_AND: + case TK_OR: { + Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr); + if( pAlt!=pExpr ){ + sqlite3ExprIfTrue(pParse, pAlt, dest, jumpIfNull); + }else if( op==TK_AND ){ + int d2 = sqlite3VdbeMakeLabel(pParse); + testcase( jumpIfNull==0 ); + sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2, + jumpIfNull^SQLITE_JUMPIFNULL); + sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); + sqlite3VdbeResolveLabel(v, d2); + }else{ + testcase( jumpIfNull==0 ); + sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); + sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); + } + break; + } + case TK_NOT: { + testcase( jumpIfNull==0 ); + sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); + break; + } + case TK_TRUTH: { + int isNot; /* IS NOT TRUE or IS NOT FALSE */ + int isTrue; /* IS TRUE or IS NOT TRUE */ + testcase( jumpIfNull==0 ); + isNot = pExpr->op2==TK_ISNOT; + isTrue = sqlite3ExprTruthValue(pExpr->pRight); + testcase( isTrue && isNot ); + testcase( !isTrue && isNot ); + if( isTrue ^ isNot ){ + sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, + isNot ? SQLITE_JUMPIFNULL : 0); + }else{ + sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, + isNot ? SQLITE_JUMPIFNULL : 0); + } + break; + } + case TK_IS: + case TK_ISNOT: + testcase( op==TK_IS ); + testcase( op==TK_ISNOT ); + op = (op==TK_IS) ? TK_EQ : TK_NE; + jumpIfNull = SQLITE_NULLEQ; + /* no break */ deliberate_fall_through + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: { + if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr; + testcase( jumpIfNull==0 ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, + r1, r2, dest, jumpIfNull, ExprHasProperty(pExpr,EP_Commuted)); + assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt); + assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le); + assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt); + assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge); + assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); + VdbeCoverageIf(v, op==OP_Eq && jumpIfNull==SQLITE_NULLEQ); + VdbeCoverageIf(v, op==OP_Eq && jumpIfNull!=SQLITE_NULLEQ); + assert(TK_NE==OP_Ne); testcase(op==OP_Ne); + VdbeCoverageIf(v, op==OP_Ne && jumpIfNull==SQLITE_NULLEQ); + VdbeCoverageIf(v, op==OP_Ne && jumpIfNull!=SQLITE_NULLEQ); + testcase( regFree1==0 ); + testcase( regFree2==0 ); + break; + } + case TK_ISNULL: + case TK_NOTNULL: { + assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL ); + assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + sqlite3VdbeAddOp2(v, op, r1, dest); + VdbeCoverageIf(v, op==TK_ISNULL); + VdbeCoverageIf(v, op==TK_NOTNULL); + testcase( regFree1==0 ); + break; + } + case TK_BETWEEN: { + testcase( jumpIfNull==0 ); + exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfTrue, jumpIfNull); + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_IN: { + int destIfFalse = sqlite3VdbeMakeLabel(pParse); + int destIfNull = jumpIfNull ? dest : destIfFalse; + sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull); + sqlite3VdbeGoto(v, dest); + sqlite3VdbeResolveLabel(v, destIfFalse); + break; + } +#endif + default: { + default_expr: + if( ExprAlwaysTrue(pExpr) ){ + sqlite3VdbeGoto(v, dest); + }else if( ExprAlwaysFalse(pExpr) ){ + /* No-op */ + }else{ + r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1); + sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0); + VdbeCoverage(v); + testcase( regFree1==0 ); + testcase( jumpIfNull==0 ); + } + break; + } + } + sqlite3ReleaseTempReg(pParse, regFree1); + sqlite3ReleaseTempReg(pParse, regFree2); +} + +/* +** Generate code for a boolean expression such that a jump is made +** to the label "dest" if the expression is false but execution +** continues straight thru if the expression is true. +** +** If the expression evaluates to NULL (neither true nor false) then +** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull +** is 0. +*/ +SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ + Vdbe *v = pParse->pVdbe; + int op = 0; + int regFree1 = 0; + int regFree2 = 0; + int r1, r2; + + assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 ); + if( NEVER(v==0) ) return; /* Existence of VDBE checked by caller */ + if( pExpr==0 ) return; + assert( !ExprHasVVAProperty(pExpr,EP_Immutable) ); + + /* The value of pExpr->op and op are related as follows: + ** + ** pExpr->op op + ** --------- ---------- + ** TK_ISNULL OP_NotNull + ** TK_NOTNULL OP_IsNull + ** TK_NE OP_Eq + ** TK_EQ OP_Ne + ** TK_GT OP_Le + ** TK_LE OP_Gt + ** TK_GE OP_Lt + ** TK_LT OP_Ge + ** + ** For other values of pExpr->op, op is undefined and unused. + ** The value of TK_ and OP_ constants are arranged such that we + ** can compute the mapping above using the following expression. + ** Assert()s verify that the computation is correct. + */ + op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1); + + /* Verify correct alignment of TK_ and OP_ constants + */ + assert( pExpr->op!=TK_ISNULL || op==OP_NotNull ); + assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull ); + assert( pExpr->op!=TK_NE || op==OP_Eq ); + assert( pExpr->op!=TK_EQ || op==OP_Ne ); + assert( pExpr->op!=TK_LT || op==OP_Ge ); + assert( pExpr->op!=TK_LE || op==OP_Gt ); + assert( pExpr->op!=TK_GT || op==OP_Le ); + assert( pExpr->op!=TK_GE || op==OP_Lt ); + + switch( pExpr->op ){ + case TK_AND: + case TK_OR: { + Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr); + if( pAlt!=pExpr ){ + sqlite3ExprIfFalse(pParse, pAlt, dest, jumpIfNull); + }else if( pExpr->op==TK_AND ){ + testcase( jumpIfNull==0 ); + sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); + sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); + }else{ + int d2 = sqlite3VdbeMakeLabel(pParse); + testcase( jumpIfNull==0 ); + sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, + jumpIfNull^SQLITE_JUMPIFNULL); + sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); + sqlite3VdbeResolveLabel(v, d2); + } + break; + } + case TK_NOT: { + testcase( jumpIfNull==0 ); + sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); + break; + } + case TK_TRUTH: { + int isNot; /* IS NOT TRUE or IS NOT FALSE */ + int isTrue; /* IS TRUE or IS NOT TRUE */ + testcase( jumpIfNull==0 ); + isNot = pExpr->op2==TK_ISNOT; + isTrue = sqlite3ExprTruthValue(pExpr->pRight); + testcase( isTrue && isNot ); + testcase( !isTrue && isNot ); + if( isTrue ^ isNot ){ + /* IS TRUE and IS NOT FALSE */ + sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, + isNot ? 0 : SQLITE_JUMPIFNULL); + + }else{ + /* IS FALSE and IS NOT TRUE */ + sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, + isNot ? 0 : SQLITE_JUMPIFNULL); + } + break; + } + case TK_IS: + case TK_ISNOT: + testcase( pExpr->op==TK_IS ); + testcase( pExpr->op==TK_ISNOT ); + op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ; + jumpIfNull = SQLITE_NULLEQ; + /* no break */ deliberate_fall_through + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: { + if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr; + testcase( jumpIfNull==0 ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, + r1, r2, dest, jumpIfNull,ExprHasProperty(pExpr,EP_Commuted)); + assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt); + assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le); + assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt); + assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge); + assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); + VdbeCoverageIf(v, op==OP_Eq && jumpIfNull!=SQLITE_NULLEQ); + VdbeCoverageIf(v, op==OP_Eq && jumpIfNull==SQLITE_NULLEQ); + assert(TK_NE==OP_Ne); testcase(op==OP_Ne); + VdbeCoverageIf(v, op==OP_Ne && jumpIfNull!=SQLITE_NULLEQ); + VdbeCoverageIf(v, op==OP_Ne && jumpIfNull==SQLITE_NULLEQ); + testcase( regFree1==0 ); + testcase( regFree2==0 ); + break; + } + case TK_ISNULL: + case TK_NOTNULL: { + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + sqlite3VdbeAddOp2(v, op, r1, dest); + testcase( op==TK_ISNULL ); VdbeCoverageIf(v, op==TK_ISNULL); + testcase( op==TK_NOTNULL ); VdbeCoverageIf(v, op==TK_NOTNULL); + testcase( regFree1==0 ); + break; + } + case TK_BETWEEN: { + testcase( jumpIfNull==0 ); + exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfFalse, jumpIfNull); + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_IN: { + if( jumpIfNull ){ + sqlite3ExprCodeIN(pParse, pExpr, dest, dest); + }else{ + int destIfNull = sqlite3VdbeMakeLabel(pParse); + sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull); + sqlite3VdbeResolveLabel(v, destIfNull); + } + break; + } +#endif + default: { + default_expr: + if( ExprAlwaysFalse(pExpr) ){ + sqlite3VdbeGoto(v, dest); + }else if( ExprAlwaysTrue(pExpr) ){ + /* no-op */ + }else{ + r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1); + sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0); + VdbeCoverage(v); + testcase( regFree1==0 ); + testcase( jumpIfNull==0 ); + } + break; + } + } + sqlite3ReleaseTempReg(pParse, regFree1); + sqlite3ReleaseTempReg(pParse, regFree2); +} + +/* +** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before +** code generation, and that copy is deleted after code generation. This +** ensures that the original pExpr is unchanged. +*/ +SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse *pParse, Expr *pExpr, int dest,int jumpIfNull){ + sqlite3 *db = pParse->db; + Expr *pCopy = sqlite3ExprDup(db, pExpr, 0); + if( db->mallocFailed==0 ){ + sqlite3ExprIfFalse(pParse, pCopy, dest, jumpIfNull); + } + sqlite3ExprDelete(db, pCopy); +} + +/* +** Expression pVar is guaranteed to be an SQL variable. pExpr may be any +** type of expression. +** +** If pExpr is a simple SQL value - an integer, real, string, blob +** or NULL value - then the VDBE currently being prepared is configured +** to re-prepare each time a new value is bound to variable pVar. +** +** Additionally, if pExpr is a simple SQL value and the value is the +** same as that currently bound to variable pVar, non-zero is returned. +** Otherwise, if the values are not the same or if pExpr is not a simple +** SQL value, zero is returned. +*/ +static int exprCompareVariable(Parse *pParse, Expr *pVar, Expr *pExpr){ + int res = 0; + int iVar; + sqlite3_value *pL, *pR = 0; + + sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, SQLITE_AFF_BLOB, &pR); + if( pR ){ + iVar = pVar->iColumn; + sqlite3VdbeSetVarmask(pParse->pVdbe, iVar); + pL = sqlite3VdbeGetBoundValue(pParse->pReprepare, iVar, SQLITE_AFF_BLOB); + if( pL ){ + if( sqlite3_value_type(pL)==SQLITE_TEXT ){ + sqlite3_value_text(pL); /* Make sure the encoding is UTF-8 */ + } + res = 0==sqlite3MemCompare(pL, pR, 0); + } + sqlite3ValueFree(pR); + sqlite3ValueFree(pL); + } + + return res; +} + +/* +** Do a deep comparison of two expression trees. Return 0 if the two +** expressions are completely identical. Return 1 if they differ only +** by a COLLATE operator at the top level. Return 2 if there are differences +** other than the top-level COLLATE operator. +** +** If any subelement of pB has Expr.iTable==(-1) then it is allowed +** to compare equal to an equivalent element in pA with Expr.iTable==iTab. +** +** The pA side might be using TK_REGISTER. If that is the case and pB is +** not using TK_REGISTER but is otherwise equivalent, then still return 0. +** +** Sometimes this routine will return 2 even if the two expressions +** really are equivalent. If we cannot prove that the expressions are +** identical, we return 2 just to be safe. So if this routine +** returns 2, then you do not really know for certain if the two +** expressions are the same. But if you get a 0 or 1 return, then you +** can be sure the expressions are the same. In the places where +** this routine is used, it does not hurt to get an extra 2 - that +** just might result in some slightly slower code. But returning +** an incorrect 0 or 1 could lead to a malfunction. +** +** If pParse is not NULL then TK_VARIABLE terms in pA with bindings in +** pParse->pReprepare can be matched against literals in pB. The +** pParse->pVdbe->expmask bitmask is updated for each variable referenced. +** If pParse is NULL (the normal case) then any TK_VARIABLE term in +** Argument pParse should normally be NULL. If it is not NULL and pA or +** pB causes a return value of 2. +*/ +SQLITE_PRIVATE int sqlite3ExprCompare(Parse *pParse, Expr *pA, Expr *pB, int iTab){ + u32 combinedFlags; + if( pA==0 || pB==0 ){ + return pB==pA ? 0 : 2; + } + if( pParse && pA->op==TK_VARIABLE && exprCompareVariable(pParse, pA, pB) ){ + return 0; + } + combinedFlags = pA->flags | pB->flags; + if( combinedFlags & EP_IntValue ){ + if( (pA->flags&pB->flags&EP_IntValue)!=0 && pA->u.iValue==pB->u.iValue ){ + return 0; + } + return 2; + } + if( pA->op!=pB->op || pA->op==TK_RAISE ){ + if( pA->op==TK_COLLATE && sqlite3ExprCompare(pParse, pA->pLeft,pB,iTab)<2 ){ + return 1; + } + if( pB->op==TK_COLLATE && sqlite3ExprCompare(pParse, pA,pB->pLeft,iTab)<2 ){ + return 1; + } + return 2; + } + if( pA->op!=TK_COLUMN && pA->op!=TK_AGG_COLUMN && pA->u.zToken ){ + if( pA->op==TK_FUNCTION || pA->op==TK_AGG_FUNCTION ){ + if( sqlite3StrICmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2; +#ifndef SQLITE_OMIT_WINDOWFUNC + assert( pA->op==pB->op ); + if( ExprHasProperty(pA,EP_WinFunc)!=ExprHasProperty(pB,EP_WinFunc) ){ + return 2; + } + if( ExprHasProperty(pA,EP_WinFunc) ){ + if( sqlite3WindowCompare(pParse, pA->y.pWin, pB->y.pWin, 1)!=0 ){ + return 2; + } + } +#endif + }else if( pA->op==TK_NULL ){ + return 0; + }else if( pA->op==TK_COLLATE ){ + if( sqlite3_stricmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2; + }else if( ALWAYS(pB->u.zToken!=0) && strcmp(pA->u.zToken,pB->u.zToken)!=0 ){ + return 2; + } + } + if( (pA->flags & (EP_Distinct|EP_Commuted)) + != (pB->flags & (EP_Distinct|EP_Commuted)) ) return 2; + if( ALWAYS((combinedFlags & EP_TokenOnly)==0) ){ + if( combinedFlags & EP_xIsSelect ) return 2; + if( (combinedFlags & EP_FixedCol)==0 + && sqlite3ExprCompare(pParse, pA->pLeft, pB->pLeft, iTab) ) return 2; + if( sqlite3ExprCompare(pParse, pA->pRight, pB->pRight, iTab) ) return 2; + if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList, iTab) ) return 2; + if( pA->op!=TK_STRING + && pA->op!=TK_TRUEFALSE + && ALWAYS((combinedFlags & EP_Reduced)==0) + ){ + if( pA->iColumn!=pB->iColumn ) return 2; + if( pA->op2!=pB->op2 && pA->op==TK_TRUTH ) return 2; + if( pA->op!=TK_IN && pA->iTable!=pB->iTable && pA->iTable!=iTab ){ + return 2; + } + } + } + return 0; +} + +/* +** Compare two ExprList objects. Return 0 if they are identical, 1 +** if they are certainly different, or 2 if it is not possible to +** determine if they are identical or not. +** +** If any subelement of pB has Expr.iTable==(-1) then it is allowed +** to compare equal to an equivalent element in pA with Expr.iTable==iTab. +** +** This routine might return non-zero for equivalent ExprLists. The +** only consequence will be disabled optimizations. But this routine +** must never return 0 if the two ExprList objects are different, or +** a malfunction will result. +** +** Two NULL pointers are considered to be the same. But a NULL pointer +** always differs from a non-NULL pointer. +*/ +SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList *pA, ExprList *pB, int iTab){ + int i; + if( pA==0 && pB==0 ) return 0; + if( pA==0 || pB==0 ) return 1; + if( pA->nExpr!=pB->nExpr ) return 1; + for(i=0; inExpr; i++){ + int res; + Expr *pExprA = pA->a[i].pExpr; + Expr *pExprB = pB->a[i].pExpr; + if( pA->a[i].sortFlags!=pB->a[i].sortFlags ) return 1; + if( (res = sqlite3ExprCompare(0, pExprA, pExprB, iTab)) ) return res; + } + return 0; +} + +/* +** Like sqlite3ExprCompare() except COLLATE operators at the top-level +** are ignored. +*/ +SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr *pA, Expr *pB, int iTab){ + return sqlite3ExprCompare(0, + sqlite3ExprSkipCollateAndLikely(pA), + sqlite3ExprSkipCollateAndLikely(pB), + iTab); +} + +/* +** Return non-zero if Expr p can only be true if pNN is not NULL. +** +** Or if seenNot is true, return non-zero if Expr p can only be +** non-NULL if pNN is not NULL +*/ +static int exprImpliesNotNull( + Parse *pParse, /* Parsing context */ + Expr *p, /* The expression to be checked */ + Expr *pNN, /* The expression that is NOT NULL */ + int iTab, /* Table being evaluated */ + int seenNot /* Return true only if p can be any non-NULL value */ +){ + assert( p ); + assert( pNN ); + if( sqlite3ExprCompare(pParse, p, pNN, iTab)==0 ){ + return pNN->op!=TK_NULL; + } + switch( p->op ){ + case TK_IN: { + if( seenNot && ExprHasProperty(p, EP_xIsSelect) ) return 0; + assert( ExprHasProperty(p,EP_xIsSelect) + || (p->x.pList!=0 && p->x.pList->nExpr>0) ); + return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1); + } + case TK_BETWEEN: { + ExprList *pList = p->x.pList; + assert( pList!=0 ); + assert( pList->nExpr==2 ); + if( seenNot ) return 0; + if( exprImpliesNotNull(pParse, pList->a[0].pExpr, pNN, iTab, 1) + || exprImpliesNotNull(pParse, pList->a[1].pExpr, pNN, iTab, 1) + ){ + return 1; + } + return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1); + } + case TK_EQ: + case TK_NE: + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_PLUS: + case TK_MINUS: + case TK_BITOR: + case TK_LSHIFT: + case TK_RSHIFT: + case TK_CONCAT: + seenNot = 1; + /* no break */ deliberate_fall_through + case TK_STAR: + case TK_REM: + case TK_BITAND: + case TK_SLASH: { + if( exprImpliesNotNull(pParse, p->pRight, pNN, iTab, seenNot) ) return 1; + /* no break */ deliberate_fall_through + } + case TK_SPAN: + case TK_COLLATE: + case TK_UPLUS: + case TK_UMINUS: { + return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, seenNot); + } + case TK_TRUTH: { + if( seenNot ) return 0; + if( p->op2!=TK_IS ) return 0; + return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1); + } + case TK_BITNOT: + case TK_NOT: { + return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1); + } + } + return 0; +} + +/* +** Return true if we can prove the pE2 will always be true if pE1 is +** true. Return false if we cannot complete the proof or if pE2 might +** be false. Examples: +** +** pE1: x==5 pE2: x==5 Result: true +** pE1: x>0 pE2: x==5 Result: false +** pE1: x=21 pE2: x=21 OR y=43 Result: true +** pE1: x!=123 pE2: x IS NOT NULL Result: true +** pE1: x!=?1 pE2: x IS NOT NULL Result: true +** pE1: x IS NULL pE2: x IS NOT NULL Result: false +** pE1: x IS ?2 pE2: x IS NOT NULL Reuslt: false +** +** When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has +** Expr.iTable<0 then assume a table number given by iTab. +** +** If pParse is not NULL, then the values of bound variables in pE1 are +** compared against literal values in pE2 and pParse->pVdbe->expmask is +** modified to record which bound variables are referenced. If pParse +** is NULL, then false will be returned if pE1 contains any bound variables. +** +** When in doubt, return false. Returning true might give a performance +** improvement. Returning false might cause a performance reduction, but +** it will always give the correct answer and is hence always safe. +*/ +SQLITE_PRIVATE int sqlite3ExprImpliesExpr(Parse *pParse, Expr *pE1, Expr *pE2, int iTab){ + if( sqlite3ExprCompare(pParse, pE1, pE2, iTab)==0 ){ + return 1; + } + if( pE2->op==TK_OR + && (sqlite3ExprImpliesExpr(pParse, pE1, pE2->pLeft, iTab) + || sqlite3ExprImpliesExpr(pParse, pE1, pE2->pRight, iTab) ) + ){ + return 1; + } + if( pE2->op==TK_NOTNULL + && exprImpliesNotNull(pParse, pE1, pE2->pLeft, iTab, 0) + ){ + return 1; + } + return 0; +} + +/* +** This is the Expr node callback for sqlite3ExprImpliesNonNullRow(). +** If the expression node requires that the table at pWalker->iCur +** have one or more non-NULL column, then set pWalker->eCode to 1 and abort. +** +** This routine controls an optimization. False positives (setting +** pWalker->eCode to 1 when it should not be) are deadly, but false-negatives +** (never setting pWalker->eCode) is a harmless missed optimization. +*/ +static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){ + testcase( pExpr->op==TK_AGG_COLUMN ); + testcase( pExpr->op==TK_AGG_FUNCTION ); + if( ExprHasProperty(pExpr, EP_FromJoin) ) return WRC_Prune; + switch( pExpr->op ){ + case TK_ISNOT: + case TK_ISNULL: + case TK_NOTNULL: + case TK_IS: + case TK_OR: + case TK_VECTOR: + case TK_CASE: + case TK_IN: + case TK_FUNCTION: + case TK_TRUTH: + testcase( pExpr->op==TK_ISNOT ); + testcase( pExpr->op==TK_ISNULL ); + testcase( pExpr->op==TK_NOTNULL ); + testcase( pExpr->op==TK_IS ); + testcase( pExpr->op==TK_OR ); + testcase( pExpr->op==TK_VECTOR ); + testcase( pExpr->op==TK_CASE ); + testcase( pExpr->op==TK_IN ); + testcase( pExpr->op==TK_FUNCTION ); + testcase( pExpr->op==TK_TRUTH ); + return WRC_Prune; + case TK_COLUMN: + if( pWalker->u.iCur==pExpr->iTable ){ + pWalker->eCode = 1; + return WRC_Abort; + } + return WRC_Prune; + + case TK_AND: + if( pWalker->eCode==0 ){ + sqlite3WalkExpr(pWalker, pExpr->pLeft); + if( pWalker->eCode ){ + pWalker->eCode = 0; + sqlite3WalkExpr(pWalker, pExpr->pRight); + } + } + return WRC_Prune; + + case TK_BETWEEN: + if( sqlite3WalkExpr(pWalker, pExpr->pLeft)==WRC_Abort ){ + assert( pWalker->eCode ); + return WRC_Abort; + } + return WRC_Prune; + + /* Virtual tables are allowed to use constraints like x=NULL. So + ** a term of the form x=y does not prove that y is not null if x + ** is the column of a virtual table */ + case TK_EQ: + case TK_NE: + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: { + Expr *pLeft = pExpr->pLeft; + Expr *pRight = pExpr->pRight; + testcase( pExpr->op==TK_EQ ); + testcase( pExpr->op==TK_NE ); + testcase( pExpr->op==TK_LT ); + testcase( pExpr->op==TK_LE ); + testcase( pExpr->op==TK_GT ); + testcase( pExpr->op==TK_GE ); + /* The y.pTab=0 assignment in wherecode.c always happens after the + ** impliesNotNullRow() test */ + if( (pLeft->op==TK_COLUMN && ALWAYS(pLeft->y.pTab!=0) + && IsVirtual(pLeft->y.pTab)) + || (pRight->op==TK_COLUMN && ALWAYS(pRight->y.pTab!=0) + && IsVirtual(pRight->y.pTab)) + ){ + return WRC_Prune; + } + /* no break */ deliberate_fall_through + } + default: + return WRC_Continue; + } +} + +/* +** Return true (non-zero) if expression p can only be true if at least +** one column of table iTab is non-null. In other words, return true +** if expression p will always be NULL or false if every column of iTab +** is NULL. +** +** False negatives are acceptable. In other words, it is ok to return +** zero even if expression p will never be true of every column of iTab +** is NULL. A false negative is merely a missed optimization opportunity. +** +** False positives are not allowed, however. A false positive may result +** in an incorrect answer. +** +** Terms of p that are marked with EP_FromJoin (and hence that come from +** the ON or USING clauses of LEFT JOINS) are excluded from the analysis. +** +** This routine is used to check if a LEFT JOIN can be converted into +** an ordinary JOIN. The p argument is the WHERE clause. If the WHERE +** clause requires that some column of the right table of the LEFT JOIN +** be non-NULL, then the LEFT JOIN can be safely converted into an +** ordinary join. +*/ +SQLITE_PRIVATE int sqlite3ExprImpliesNonNullRow(Expr *p, int iTab){ + Walker w; + p = sqlite3ExprSkipCollateAndLikely(p); + if( p==0 ) return 0; + if( p->op==TK_NOTNULL ){ + p = p->pLeft; + }else{ + while( p->op==TK_AND ){ + if( sqlite3ExprImpliesNonNullRow(p->pLeft, iTab) ) return 1; + p = p->pRight; + } + } + w.xExprCallback = impliesNotNullRow; + w.xSelectCallback = 0; + w.xSelectCallback2 = 0; + w.eCode = 0; + w.u.iCur = iTab; + sqlite3WalkExpr(&w, p); + return w.eCode; +} + +/* +** An instance of the following structure is used by the tree walker +** to determine if an expression can be evaluated by reference to the +** index only, without having to do a search for the corresponding +** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur +** is the cursor for the table. +*/ +struct IdxCover { + Index *pIdx; /* The index to be tested for coverage */ + int iCur; /* Cursor number for the table corresponding to the index */ +}; + +/* +** Check to see if there are references to columns in table +** pWalker->u.pIdxCover->iCur can be satisfied using the index +** pWalker->u.pIdxCover->pIdx. +*/ +static int exprIdxCover(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_COLUMN + && pExpr->iTable==pWalker->u.pIdxCover->iCur + && sqlite3TableColumnToIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0 + ){ + pWalker->eCode = 1; + return WRC_Abort; + } + return WRC_Continue; +} + +/* +** Determine if an index pIdx on table with cursor iCur contains will +** the expression pExpr. Return true if the index does cover the +** expression and false if the pExpr expression references table columns +** that are not found in the index pIdx. +** +** An index covering an expression means that the expression can be +** evaluated using only the index and without having to lookup the +** corresponding table entry. +*/ +SQLITE_PRIVATE int sqlite3ExprCoveredByIndex( + Expr *pExpr, /* The index to be tested */ + int iCur, /* The cursor number for the corresponding table */ + Index *pIdx /* The index that might be used for coverage */ +){ + Walker w; + struct IdxCover xcov; + memset(&w, 0, sizeof(w)); + xcov.iCur = iCur; + xcov.pIdx = pIdx; + w.xExprCallback = exprIdxCover; + w.u.pIdxCover = &xcov; + sqlite3WalkExpr(&w, pExpr); + return !w.eCode; +} + + +/* +** An instance of the following structure is used by the tree walker +** to count references to table columns in the arguments of an +** aggregate function, in order to implement the +** sqlite3FunctionThisSrc() routine. +*/ +struct SrcCount { + SrcList *pSrc; /* One particular FROM clause in a nested query */ + int iSrcInner; /* Smallest cursor number in this context */ + int nThis; /* Number of references to columns in pSrcList */ + int nOther; /* Number of references to columns in other FROM clauses */ +}; + +/* +** xSelect callback for sqlite3FunctionUsesThisSrc(). If this is the first +** SELECT with a FROM clause encountered during this iteration, set +** SrcCount.iSrcInner to the cursor number of the leftmost object in +** the FROM cause. +*/ +static int selectSrcCount(Walker *pWalker, Select *pSel){ + struct SrcCount *p = pWalker->u.pSrcCount; + if( p->iSrcInner==0x7FFFFFFF && ALWAYS(pSel->pSrc) && pSel->pSrc->nSrc ){ + pWalker->u.pSrcCount->iSrcInner = pSel->pSrc->a[0].iCursor; + } + return WRC_Continue; +} + +/* +** Count the number of references to columns. +*/ +static int exprSrcCount(Walker *pWalker, Expr *pExpr){ + /* There was once a NEVER() on the second term on the grounds that + ** sqlite3FunctionUsesThisSrc() was always called before + ** sqlite3ExprAnalyzeAggregates() and so the TK_COLUMNs have not yet + ** been converted into TK_AGG_COLUMN. But this is no longer true due + ** to window functions - sqlite3WindowRewrite() may now indirectly call + ** FunctionUsesThisSrc() when creating a new sub-select. */ + if( pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN ){ + int i; + struct SrcCount *p = pWalker->u.pSrcCount; + SrcList *pSrc = p->pSrc; + int nSrc = pSrc ? pSrc->nSrc : 0; + for(i=0; iiTable==pSrc->a[i].iCursor ) break; + } + if( inThis++; + }else if( pExpr->iTableiSrcInner ){ + /* In a well-formed parse tree (no name resolution errors), + ** TK_COLUMN nodes with smaller Expr.iTable values are in an + ** outer context. Those are the only ones to count as "other" */ + p->nOther++; + } + } + return WRC_Continue; +} + +/* +** Determine if any of the arguments to the pExpr Function reference +** pSrcList. Return true if they do. Also return true if the function +** has no arguments or has only constant arguments. Return false if pExpr +** references columns but not columns of tables found in pSrcList. +*/ +SQLITE_PRIVATE int sqlite3FunctionUsesThisSrc(Expr *pExpr, SrcList *pSrcList){ + Walker w; + struct SrcCount cnt; + assert( pExpr->op==TK_AGG_FUNCTION ); + memset(&w, 0, sizeof(w)); + w.xExprCallback = exprSrcCount; + w.xSelectCallback = selectSrcCount; + w.u.pSrcCount = &cnt; + cnt.pSrc = pSrcList; + cnt.iSrcInner = (pSrcList&&pSrcList->nSrc)?pSrcList->a[0].iCursor:0x7FFFFFFF; + cnt.nThis = 0; + cnt.nOther = 0; + sqlite3WalkExprList(&w, pExpr->x.pList); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + sqlite3WalkExpr(&w, pExpr->y.pWin->pFilter); + } +#endif + return cnt.nThis>0 || cnt.nOther==0; +} + +/* +** This is a Walker expression node callback. +** +** For Expr nodes that contain pAggInfo pointers, make sure the AggInfo +** object that is referenced does not refer directly to the Expr. If +** it does, make a copy. This is done because the pExpr argument is +** subject to change. +** +** The copy is stored on pParse->pConstExpr with a register number of 0. +** This will cause the expression to be deleted automatically when the +** Parse object is destroyed, but the zero register number means that it +** will not generate any code in the preamble. +*/ +static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){ + if( ALWAYS(!ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced)) + && pExpr->pAggInfo!=0 + ){ + AggInfo *pAggInfo = pExpr->pAggInfo; + int iAgg = pExpr->iAgg; + Parse *pParse = pWalker->pParse; + sqlite3 *db = pParse->db; + assert( pExpr->op==TK_AGG_COLUMN || pExpr->op==TK_AGG_FUNCTION ); + if( pExpr->op==TK_AGG_COLUMN ){ + assert( iAgg>=0 && iAggnColumn ); + if( pAggInfo->aCol[iAgg].pCExpr==pExpr ){ + pExpr = sqlite3ExprDup(db, pExpr, 0); + if( pExpr ){ + pAggInfo->aCol[iAgg].pCExpr = pExpr; + pParse->pConstExpr = + sqlite3ExprListAppend(pParse, pParse->pConstExpr, pExpr); + } + } + }else{ + assert( iAgg>=0 && iAggnFunc ); + if( pAggInfo->aFunc[iAgg].pFExpr==pExpr ){ + pExpr = sqlite3ExprDup(db, pExpr, 0); + if( pExpr ){ + pAggInfo->aFunc[iAgg].pFExpr = pExpr; + pParse->pConstExpr = + sqlite3ExprListAppend(pParse, pParse->pConstExpr, pExpr); + } + } + } + } + return WRC_Continue; +} + +/* +** Initialize a Walker object so that will persist AggInfo entries referenced +** by the tree that is walked. +*/ +SQLITE_PRIVATE void sqlite3AggInfoPersistWalkerInit(Walker *pWalker, Parse *pParse){ + memset(pWalker, 0, sizeof(*pWalker)); + pWalker->pParse = pParse; + pWalker->xExprCallback = agginfoPersistExprCb; + pWalker->xSelectCallback = sqlite3SelectWalkNoop; +} + +/* +** Add a new element to the pAggInfo->aCol[] array. Return the index of +** the new element. Return a negative number if malloc fails. +*/ +static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){ + int i; + pInfo->aCol = sqlite3ArrayAllocate( + db, + pInfo->aCol, + sizeof(pInfo->aCol[0]), + &pInfo->nColumn, + &i + ); + return i; +} + +/* +** Add a new element to the pAggInfo->aFunc[] array. Return the index of +** the new element. Return a negative number if malloc fails. +*/ +static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){ + int i; + pInfo->aFunc = sqlite3ArrayAllocate( + db, + pInfo->aFunc, + sizeof(pInfo->aFunc[0]), + &pInfo->nFunc, + &i + ); + return i; +} + +/* +** This is the xExprCallback for a tree walker. It is used to +** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates +** for additional information. +*/ +static int analyzeAggregate(Walker *pWalker, Expr *pExpr){ + int i; + NameContext *pNC = pWalker->u.pNC; + Parse *pParse = pNC->pParse; + SrcList *pSrcList = pNC->pSrcList; + AggInfo *pAggInfo = pNC->uNC.pAggInfo; + + assert( pNC->ncFlags & NC_UAggInfo ); + switch( pExpr->op ){ + case TK_AGG_COLUMN: + case TK_COLUMN: { + testcase( pExpr->op==TK_AGG_COLUMN ); + testcase( pExpr->op==TK_COLUMN ); + /* Check to see if the column is in one of the tables in the FROM + ** clause of the aggregate query */ + if( ALWAYS(pSrcList!=0) ){ + struct SrcList_item *pItem = pSrcList->a; + for(i=0; inSrc; i++, pItem++){ + struct AggInfo_col *pCol; + assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); + if( pExpr->iTable==pItem->iCursor ){ + /* If we reach this point, it means that pExpr refers to a table + ** that is in the FROM clause of the aggregate query. + ** + ** Make an entry for the column in pAggInfo->aCol[] if there + ** is not an entry there already. + */ + int k; + pCol = pAggInfo->aCol; + for(k=0; knColumn; k++, pCol++){ + if( pCol->iTable==pExpr->iTable && + pCol->iColumn==pExpr->iColumn ){ + break; + } + } + if( (k>=pAggInfo->nColumn) + && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0 + ){ + pCol = &pAggInfo->aCol[k]; + pCol->pTab = pExpr->y.pTab; + pCol->iTable = pExpr->iTable; + pCol->iColumn = pExpr->iColumn; + pCol->iMem = ++pParse->nMem; + pCol->iSorterColumn = -1; + pCol->pCExpr = pExpr; + if( pAggInfo->pGroupBy ){ + int j, n; + ExprList *pGB = pAggInfo->pGroupBy; + struct ExprList_item *pTerm = pGB->a; + n = pGB->nExpr; + for(j=0; jpExpr; + if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable && + pE->iColumn==pExpr->iColumn ){ + pCol->iSorterColumn = j; + break; + } + } + } + if( pCol->iSorterColumn<0 ){ + pCol->iSorterColumn = pAggInfo->nSortingColumn++; + } + } + /* There is now an entry for pExpr in pAggInfo->aCol[] (either + ** because it was there before or because we just created it). + ** Convert the pExpr to be a TK_AGG_COLUMN referring to that + ** pAggInfo->aCol[] entry. + */ + ExprSetVVAProperty(pExpr, EP_NoReduce); + pExpr->pAggInfo = pAggInfo; + pExpr->op = TK_AGG_COLUMN; + pExpr->iAgg = (i16)k; + break; + } /* endif pExpr->iTable==pItem->iCursor */ + } /* end loop over pSrcList */ + } + return WRC_Prune; + } + case TK_AGG_FUNCTION: { + if( (pNC->ncFlags & NC_InAggFunc)==0 + && pWalker->walkerDepth==pExpr->op2 + ){ + /* Check to see if pExpr is a duplicate of another aggregate + ** function that is already in the pAggInfo structure + */ + struct AggInfo_func *pItem = pAggInfo->aFunc; + for(i=0; inFunc; i++, pItem++){ + if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){ + break; + } + } + if( i>=pAggInfo->nFunc ){ + /* pExpr is original. Make a new entry in pAggInfo->aFunc[] + */ + u8 enc = ENC(pParse->db); + i = addAggInfoFunc(pParse->db, pAggInfo); + if( i>=0 ){ + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + pItem = &pAggInfo->aFunc[i]; + pItem->pFExpr = pExpr; + pItem->iMem = ++pParse->nMem; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + pItem->pFunc = sqlite3FindFunction(pParse->db, + pExpr->u.zToken, + pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0); + if( pExpr->flags & EP_Distinct ){ + pItem->iDistinct = pParse->nTab++; + }else{ + pItem->iDistinct = -1; + } + } + } + /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry + */ + assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); + ExprSetVVAProperty(pExpr, EP_NoReduce); + pExpr->iAgg = (i16)i; + pExpr->pAggInfo = pAggInfo; + return WRC_Prune; + }else{ + return WRC_Continue; + } + } + } + return WRC_Continue; +} + +/* +** Analyze the pExpr expression looking for aggregate functions and +** for variables that need to be added to AggInfo object that pNC->pAggInfo +** points to. Additional entries are made on the AggInfo object as +** necessary. +** +** This routine should only be called after the expression has been +** analyzed by sqlite3ResolveExprNames(). +*/ +SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){ + Walker w; + w.xExprCallback = analyzeAggregate; + w.xSelectCallback = sqlite3WalkerDepthIncrease; + w.xSelectCallback2 = sqlite3WalkerDepthDecrease; + w.walkerDepth = 0; + w.u.pNC = pNC; + w.pParse = 0; + assert( pNC->pSrcList!=0 ); + sqlite3WalkExpr(&w, pExpr); +} + +/* +** Call sqlite3ExprAnalyzeAggregates() for every expression in an +** expression list. Return the number of errors. +** +** If an error is found, the analysis is cut short. +*/ +SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){ + struct ExprList_item *pItem; + int i; + if( pList ){ + for(pItem=pList->a, i=0; inExpr; i++, pItem++){ + sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr); + } + } +} + +/* +** Allocate a single new register for use to hold some intermediate result. +*/ +SQLITE_PRIVATE int sqlite3GetTempReg(Parse *pParse){ + if( pParse->nTempReg==0 ){ + return ++pParse->nMem; + } + return pParse->aTempReg[--pParse->nTempReg]; +} + +/* +** Deallocate a register, making available for reuse for some other +** purpose. +*/ +SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse *pParse, int iReg){ + if( iReg ){ + sqlite3VdbeReleaseRegisters(pParse, iReg, 1, 0, 0); + if( pParse->nTempRegaTempReg) ){ + pParse->aTempReg[pParse->nTempReg++] = iReg; + } + } +} + +/* +** Allocate or deallocate a block of nReg consecutive registers. +*/ +SQLITE_PRIVATE int sqlite3GetTempRange(Parse *pParse, int nReg){ + int i, n; + if( nReg==1 ) return sqlite3GetTempReg(pParse); + i = pParse->iRangeReg; + n = pParse->nRangeReg; + if( nReg<=n ){ + pParse->iRangeReg += nReg; + pParse->nRangeReg -= nReg; + }else{ + i = pParse->nMem+1; + pParse->nMem += nReg; + } + return i; +} +SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){ + if( nReg==1 ){ + sqlite3ReleaseTempReg(pParse, iReg); + return; + } + sqlite3VdbeReleaseRegisters(pParse, iReg, nReg, 0, 0); + if( nReg>pParse->nRangeReg ){ + pParse->nRangeReg = nReg; + pParse->iRangeReg = iReg; + } +} + +/* +** Mark all temporary registers as being unavailable for reuse. +** +** Always invoke this procedure after coding a subroutine or co-routine +** that might be invoked from other parts of the code, to ensure that +** the sub/co-routine does not use registers in common with the code that +** invokes the sub/co-routine. +*/ +SQLITE_PRIVATE void sqlite3ClearTempRegCache(Parse *pParse){ + pParse->nTempReg = 0; + pParse->nRangeReg = 0; +} + +/* +** Validate that no temporary register falls within the range of +** iFirst..iLast, inclusive. This routine is only call from within assert() +** statements. +*/ +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3NoTempsInRange(Parse *pParse, int iFirst, int iLast){ + int i; + if( pParse->nRangeReg>0 + && pParse->iRangeReg+pParse->nRangeReg > iFirst + && pParse->iRangeReg <= iLast + ){ + return 0; + } + for(i=0; inTempReg; i++){ + if( pParse->aTempReg[i]>=iFirst && pParse->aTempReg[i]<=iLast ){ + return 0; + } + } + return 1; +} +#endif /* SQLITE_DEBUG */ + +/************** End of expr.c ************************************************/ +/************** Begin file alter.c *******************************************/ +/* +** 2005 February 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that used to generate VDBE code +** that implements the ALTER TABLE command. +*/ +/* #include "sqliteInt.h" */ + +/* +** The code in this file only exists if we are not omitting the +** ALTER TABLE logic from the build. +*/ +#ifndef SQLITE_OMIT_ALTERTABLE + +/* +** Parameter zName is the name of a table that is about to be altered +** (either with ALTER TABLE ... RENAME TO or ALTER TABLE ... ADD COLUMN). +** If the table is a system table, this function leaves an error message +** in pParse->zErr (system tables may not be altered) and returns non-zero. +** +** Or, if zName is not a system table, zero is returned. +*/ +static int isAlterableTable(Parse *pParse, Table *pTab){ + if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7) +#ifndef SQLITE_OMIT_VIRTUALTABLE + || ( (pTab->tabFlags & TF_Shadow)!=0 + && sqlite3ReadOnlyShadowTables(pParse->db) + ) +#endif + ){ + sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName); + return 1; + } + return 0; +} + +/* +** Generate code to verify that the schemas of database zDb and, if +** bTemp is not true, database "temp", can still be parsed. This is +** called at the end of the generation of an ALTER TABLE ... RENAME ... +** statement to ensure that the operation has not rendered any schema +** objects unusable. +*/ +static void renameTestSchema(Parse *pParse, const char *zDb, int bTemp){ + sqlite3NestedParse(pParse, + "SELECT 1 " + "FROM \"%w\"." DFLT_SCHEMA_TABLE " " + "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" + " AND sql NOT LIKE 'create virtual%%'" + " AND sqlite_rename_test(%Q, sql, type, name, %d)=NULL ", + zDb, + zDb, bTemp + ); + + if( bTemp==0 ){ + sqlite3NestedParse(pParse, + "SELECT 1 " + "FROM temp." DFLT_SCHEMA_TABLE " " + "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" + " AND sql NOT LIKE 'create virtual%%'" + " AND sqlite_rename_test(%Q, sql, type, name, 1)=NULL ", + zDb + ); + } +} + +/* +** Generate code to reload the schema for database iDb. And, if iDb!=1, for +** the temp database as well. +*/ +static void renameReloadSchema(Parse *pParse, int iDb){ + Vdbe *v = pParse->pVdbe; + if( v ){ + sqlite3ChangeCookie(pParse, iDb); + sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0); + if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0); + } +} + +/* +** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy" +** command. +*/ +SQLITE_PRIVATE void sqlite3AlterRenameTable( + Parse *pParse, /* Parser context. */ + SrcList *pSrc, /* The table to rename. */ + Token *pName /* The new table name. */ +){ + int iDb; /* Database that contains the table */ + char *zDb; /* Name of database iDb */ + Table *pTab; /* Table being renamed */ + char *zName = 0; /* NULL-terminated version of pName */ + sqlite3 *db = pParse->db; /* Database connection */ + int nTabName; /* Number of UTF-8 characters in zTabName */ + const char *zTabName; /* Original name of the table */ + Vdbe *v; + VTable *pVTab = 0; /* Non-zero if this is a v-tab with an xRename() */ + u32 savedDbFlags; /* Saved value of db->mDbFlags */ + + savedDbFlags = db->mDbFlags; + if( NEVER(db->mallocFailed) ) goto exit_rename_table; + assert( pSrc->nSrc==1 ); + assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); + + pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]); + if( !pTab ) goto exit_rename_table; + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + zDb = db->aDb[iDb].zDbSName; + db->mDbFlags |= DBFLAG_PreferBuiltin; + + /* Get a NULL terminated version of the new table name. */ + zName = sqlite3NameFromToken(db, pName); + if( !zName ) goto exit_rename_table; + + /* Check that a table or index named 'zName' does not already exist + ** in database iDb. If so, this is an error. + */ + if( sqlite3FindTable(db, zName, zDb) + || sqlite3FindIndex(db, zName, zDb) + || sqlite3IsShadowTableOf(db, pTab, zName) + ){ + sqlite3ErrorMsg(pParse, + "there is already another table or index with this name: %s", zName); + goto exit_rename_table; + } + + /* Make sure it is not a system table being altered, or a reserved name + ** that the table is being renamed to. + */ + if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){ + goto exit_rename_table; + } + if( SQLITE_OK!=sqlite3CheckObjectName(pParse,zName,"table",zName) ){ + goto exit_rename_table; + } + +#ifndef SQLITE_OMIT_VIEW + if( pTab->pSelect ){ + sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName); + goto exit_rename_table; + } +#endif + +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Invoke the authorization callback. */ + if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){ + goto exit_rename_table; + } +#endif + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto exit_rename_table; + } + if( IsVirtual(pTab) ){ + pVTab = sqlite3GetVTable(db, pTab); + if( pVTab->pVtab->pModule->xRename==0 ){ + pVTab = 0; + } + } +#endif + + /* Begin a transaction for database iDb. Then modify the schema cookie + ** (since the ALTER TABLE modifies the schema). Call sqlite3MayAbort(), + ** as the scalar functions (e.g. sqlite_rename_table()) invoked by the + ** nested SQL may raise an exception. */ + v = sqlite3GetVdbe(pParse); + if( v==0 ){ + goto exit_rename_table; + } + sqlite3MayAbort(pParse); + + /* figure out how many UTF-8 characters are in zName */ + zTabName = pTab->zName; + nTabName = sqlite3Utf8CharLen(zTabName, -1); + + /* Rewrite all CREATE TABLE, INDEX, TRIGGER or VIEW statements in + ** the schema to use the new table name. */ + sqlite3NestedParse(pParse, + "UPDATE \"%w\"." DFLT_SCHEMA_TABLE " SET " + "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, %d) " + "WHERE (type!='index' OR tbl_name=%Q COLLATE nocase)" + "AND name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" + , zDb, zDb, zTabName, zName, (iDb==1), zTabName + ); + + /* Update the tbl_name and name columns of the sqlite_schema table + ** as required. */ + sqlite3NestedParse(pParse, + "UPDATE %Q." DFLT_SCHEMA_TABLE " SET " + "tbl_name = %Q, " + "name = CASE " + "WHEN type='table' THEN %Q " + "WHEN name LIKE 'sqliteX_autoindex%%' ESCAPE 'X' " + " AND type='index' THEN " + "'sqlite_autoindex_' || %Q || substr(name,%d+18) " + "ELSE name END " + "WHERE tbl_name=%Q COLLATE nocase AND " + "(type='table' OR type='index' OR type='trigger');", + zDb, + zName, zName, zName, + nTabName, zTabName + ); + +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* If the sqlite_sequence table exists in this database, then update + ** it with the new table name. + */ + if( sqlite3FindTable(db, "sqlite_sequence", zDb) ){ + sqlite3NestedParse(pParse, + "UPDATE \"%w\".sqlite_sequence set name = %Q WHERE name = %Q", + zDb, zName, pTab->zName); + } +#endif + + /* If the table being renamed is not itself part of the temp database, + ** edit view and trigger definitions within the temp database + ** as required. */ + if( iDb!=1 ){ + sqlite3NestedParse(pParse, + "UPDATE sqlite_temp_schema SET " + "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, 1), " + "tbl_name = " + "CASE WHEN tbl_name=%Q COLLATE nocase AND " + " sqlite_rename_test(%Q, sql, type, name, 1) " + "THEN %Q ELSE tbl_name END " + "WHERE type IN ('view', 'trigger')" + , zDb, zTabName, zName, zTabName, zDb, zName); + } + + /* If this is a virtual table, invoke the xRename() function if + ** one is defined. The xRename() callback will modify the names + ** of any resources used by the v-table implementation (including other + ** SQLite tables) that are identified by the name of the virtual table. + */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( pVTab ){ + int i = ++pParse->nMem; + sqlite3VdbeLoadString(v, i, zName); + sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pVTab, P4_VTAB); + } +#endif + + renameReloadSchema(pParse, iDb); + renameTestSchema(pParse, zDb, iDb==1); + +exit_rename_table: + sqlite3SrcListDelete(db, pSrc); + sqlite3DbFree(db, zName); + db->mDbFlags = savedDbFlags; +} + +/* +** Write code that will raise an error if the table described by +** zDb and zTab is not empty. +*/ +static void sqlite3ErrorIfNotEmpty( + Parse *pParse, /* Parsing context */ + const char *zDb, /* Schema holding the table */ + const char *zTab, /* Table to check for empty */ + const char *zErr /* Error message text */ +){ + sqlite3NestedParse(pParse, + "SELECT raise(ABORT,%Q) FROM \"%w\".\"%w\"", + zErr, zDb, zTab + ); +} + +/* +** This function is called after an "ALTER TABLE ... ADD" statement +** has been parsed. Argument pColDef contains the text of the new +** column definition. +** +** The Table structure pParse->pNewTable was extended to include +** the new column during parsing. +*/ +SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){ + Table *pNew; /* Copy of pParse->pNewTable */ + Table *pTab; /* Table being altered */ + int iDb; /* Database number */ + const char *zDb; /* Database name */ + const char *zTab; /* Table name */ + char *zCol; /* Null-terminated column definition */ + Column *pCol; /* The new column */ + Expr *pDflt; /* Default value for the new column */ + sqlite3 *db; /* The database connection; */ + Vdbe *v; /* The prepared statement under construction */ + int r1; /* Temporary registers */ + + db = pParse->db; + if( pParse->nErr || db->mallocFailed ) return; + pNew = pParse->pNewTable; + assert( pNew ); + + assert( sqlite3BtreeHoldsAllMutexes(db) ); + iDb = sqlite3SchemaToIndex(db, pNew->pSchema); + zDb = db->aDb[iDb].zDbSName; + zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */ + pCol = &pNew->aCol[pNew->nCol-1]; + pDflt = pCol->pDflt; + pTab = sqlite3FindTable(db, zTab, zDb); + assert( pTab ); + +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Invoke the authorization callback. */ + if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){ + return; + } +#endif + + + /* Check that the new column is not specified as PRIMARY KEY or UNIQUE. + ** If there is a NOT NULL constraint, then the default value for the + ** column must not be NULL. + */ + if( pCol->colFlags & COLFLAG_PRIMKEY ){ + sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column"); + return; + } + if( pNew->pIndex ){ + sqlite3ErrorMsg(pParse, + "Cannot add a UNIQUE column"); + return; + } + if( (pCol->colFlags & COLFLAG_GENERATED)==0 ){ + /* If the default value for the new column was specified with a + ** literal NULL, then set pDflt to 0. This simplifies checking + ** for an SQL NULL default below. + */ + assert( pDflt==0 || pDflt->op==TK_SPAN ); + if( pDflt && pDflt->pLeft->op==TK_NULL ){ + pDflt = 0; + } + if( (db->flags&SQLITE_ForeignKeys) && pNew->pFKey && pDflt ){ + sqlite3ErrorIfNotEmpty(pParse, zDb, zTab, + "Cannot add a REFERENCES column with non-NULL default value"); + } + if( pCol->notNull && !pDflt ){ + sqlite3ErrorIfNotEmpty(pParse, zDb, zTab, + "Cannot add a NOT NULL column with default value NULL"); + } + + + /* Ensure the default expression is something that sqlite3ValueFromExpr() + ** can handle (i.e. not CURRENT_TIME etc.) + */ + if( pDflt ){ + sqlite3_value *pVal = 0; + int rc; + rc = sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_BLOB, &pVal); + assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); + if( rc!=SQLITE_OK ){ + assert( db->mallocFailed == 1 ); + return; + } + if( !pVal ){ + sqlite3ErrorIfNotEmpty(pParse, zDb, zTab, + "Cannot add a column with non-constant default"); + } + sqlite3ValueFree(pVal); + } + }else if( pCol->colFlags & COLFLAG_STORED ){ + sqlite3ErrorIfNotEmpty(pParse, zDb, zTab, "cannot add a STORED column"); + } + + + /* Modify the CREATE TABLE statement. */ + zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n); + if( zCol ){ + char *zEnd = &zCol[pColDef->n-1]; + u32 savedDbFlags = db->mDbFlags; + while( zEnd>zCol && (*zEnd==';' || sqlite3Isspace(*zEnd)) ){ + *zEnd-- = '\0'; + } + db->mDbFlags |= DBFLAG_PreferBuiltin; + sqlite3NestedParse(pParse, + "UPDATE \"%w\"." DFLT_SCHEMA_TABLE " SET " + "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d) " + "WHERE type = 'table' AND name = %Q", + zDb, pNew->addColOffset, zCol, pNew->addColOffset+1, + zTab + ); + sqlite3DbFree(db, zCol); + db->mDbFlags = savedDbFlags; + } + + /* Make sure the schema version is at least 3. But do not upgrade + ** from less than 3 to 4, as that will corrupt any preexisting DESC + ** index. + */ + v = sqlite3GetVdbe(pParse); + if( v ){ + r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT); + sqlite3VdbeUsesBtree(v, iDb); + sqlite3VdbeAddOp2(v, OP_AddImm, r1, -2); + sqlite3VdbeAddOp2(v, OP_IfPos, r1, sqlite3VdbeCurrentAddr(v)+2); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3); + sqlite3ReleaseTempReg(pParse, r1); + } + + /* Reload the table definition */ + renameReloadSchema(pParse, iDb); +} + +/* +** This function is called by the parser after the table-name in +** an "ALTER TABLE ADD" statement is parsed. Argument +** pSrc is the full-name of the table being altered. +** +** This routine makes a (partial) copy of the Table structure +** for the table being altered and sets Parse.pNewTable to point +** to it. Routines called by the parser as the column definition +** is parsed (i.e. sqlite3AddColumn()) add the new Column data to +** the copy. The copy of the Table structure is deleted by tokenize.c +** after parsing is finished. +** +** Routine sqlite3AlterFinishAddColumn() will be called to complete +** coding the "ALTER TABLE ... ADD" statement. +*/ +SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){ + Table *pNew; + Table *pTab; + int iDb; + int i; + int nAlloc; + sqlite3 *db = pParse->db; + + /* Look up the table being altered. */ + assert( pParse->pNewTable==0 ); + assert( sqlite3BtreeHoldsAllMutexes(db) ); + if( db->mallocFailed ) goto exit_begin_add_column; + pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]); + if( !pTab ) goto exit_begin_add_column; + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + sqlite3ErrorMsg(pParse, "virtual tables may not be altered"); + goto exit_begin_add_column; + } +#endif + + /* Make sure this is not an attempt to ALTER a view. */ + if( pTab->pSelect ){ + sqlite3ErrorMsg(pParse, "Cannot add a column to a view"); + goto exit_begin_add_column; + } + if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){ + goto exit_begin_add_column; + } + + sqlite3MayAbort(pParse); + assert( pTab->addColOffset>0 ); + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + + /* Put a copy of the Table struct in Parse.pNewTable for the + ** sqlite3AddColumn() function and friends to modify. But modify + ** the name by adding an "sqlite_altertab_" prefix. By adding this + ** prefix, we insure that the name will not collide with an existing + ** table because user table are not allowed to have the "sqlite_" + ** prefix on their name. + */ + pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table)); + if( !pNew ) goto exit_begin_add_column; + pParse->pNewTable = pNew; + pNew->nTabRef = 1; + pNew->nCol = pTab->nCol; + assert( pNew->nCol>0 ); + nAlloc = (((pNew->nCol-1)/8)*8)+8; + assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 ); + pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc); + pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName); + if( !pNew->aCol || !pNew->zName ){ + assert( db->mallocFailed ); + goto exit_begin_add_column; + } + memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol); + for(i=0; inCol; i++){ + Column *pCol = &pNew->aCol[i]; + pCol->zName = sqlite3DbStrDup(db, pCol->zName); + pCol->hName = sqlite3StrIHash(pCol->zName); + pCol->zColl = 0; + pCol->pDflt = 0; + } + pNew->pSchema = db->aDb[iDb].pSchema; + pNew->addColOffset = pTab->addColOffset; + pNew->nTabRef = 1; + +exit_begin_add_column: + sqlite3SrcListDelete(db, pSrc); + return; +} + +/* +** Parameter pTab is the subject of an ALTER TABLE ... RENAME COLUMN +** command. This function checks if the table is a view or virtual +** table (columns of views or virtual tables may not be renamed). If so, +** it loads an error message into pParse and returns non-zero. +** +** Or, if pTab is not a view or virtual table, zero is returned. +*/ +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) +static int isRealTable(Parse *pParse, Table *pTab){ + const char *zType = 0; +#ifndef SQLITE_OMIT_VIEW + if( pTab->pSelect ){ + zType = "view"; + } +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + zType = "virtual table"; + } +#endif + if( zType ){ + sqlite3ErrorMsg( + pParse, "cannot rename columns of %s \"%s\"", zType, pTab->zName + ); + return 1; + } + return 0; +} +#else /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */ +# define isRealTable(x,y) (0) +#endif + +/* +** Handles the following parser reduction: +** +** cmd ::= ALTER TABLE pSrc RENAME COLUMN pOld TO pNew +*/ +SQLITE_PRIVATE void sqlite3AlterRenameColumn( + Parse *pParse, /* Parsing context */ + SrcList *pSrc, /* Table being altered. pSrc->nSrc==1 */ + Token *pOld, /* Name of column being changed */ + Token *pNew /* New column name */ +){ + sqlite3 *db = pParse->db; /* Database connection */ + Table *pTab; /* Table being updated */ + int iCol; /* Index of column being renamed */ + char *zOld = 0; /* Old column name */ + char *zNew = 0; /* New column name */ + const char *zDb; /* Name of schema containing the table */ + int iSchema; /* Index of the schema */ + int bQuote; /* True to quote the new name */ + + /* Locate the table to be altered */ + pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]); + if( !pTab ) goto exit_rename_column; + + /* Cannot alter a system table */ + if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_rename_column; + if( SQLITE_OK!=isRealTable(pParse, pTab) ) goto exit_rename_column; + + /* Which schema holds the table to be altered */ + iSchema = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iSchema>=0 ); + zDb = db->aDb[iSchema].zDbSName; + +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Invoke the authorization callback. */ + if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){ + goto exit_rename_column; + } +#endif + + /* Make sure the old name really is a column name in the table to be + ** altered. Set iCol to be the index of the column being renamed */ + zOld = sqlite3NameFromToken(db, pOld); + if( !zOld ) goto exit_rename_column; + for(iCol=0; iColnCol; iCol++){ + if( 0==sqlite3StrICmp(pTab->aCol[iCol].zName, zOld) ) break; + } + if( iCol==pTab->nCol ){ + sqlite3ErrorMsg(pParse, "no such column: \"%s\"", zOld); + goto exit_rename_column; + } + + /* Do the rename operation using a recursive UPDATE statement that + ** uses the sqlite_rename_column() SQL function to compute the new + ** CREATE statement text for the sqlite_schema table. + */ + sqlite3MayAbort(pParse); + zNew = sqlite3NameFromToken(db, pNew); + if( !zNew ) goto exit_rename_column; + assert( pNew->n>0 ); + bQuote = sqlite3Isquote(pNew->z[0]); + sqlite3NestedParse(pParse, + "UPDATE \"%w\"." DFLT_SCHEMA_TABLE " SET " + "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, %d) " + "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X' " + " AND (type != 'index' OR tbl_name = %Q)" + " AND sql NOT LIKE 'create virtual%%'", + zDb, + zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1, + pTab->zName + ); + + sqlite3NestedParse(pParse, + "UPDATE temp." DFLT_SCHEMA_TABLE " SET " + "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, 1) " + "WHERE type IN ('trigger', 'view')", + zDb, pTab->zName, iCol, zNew, bQuote + ); + + /* Drop and reload the database schema. */ + renameReloadSchema(pParse, iSchema); + renameTestSchema(pParse, zDb, iSchema==1); + + exit_rename_column: + sqlite3SrcListDelete(db, pSrc); + sqlite3DbFree(db, zOld); + sqlite3DbFree(db, zNew); + return; +} + +/* +** Each RenameToken object maps an element of the parse tree into +** the token that generated that element. The parse tree element +** might be one of: +** +** * A pointer to an Expr that represents an ID +** * The name of a table column in Column.zName +** +** A list of RenameToken objects can be constructed during parsing. +** Each new object is created by sqlite3RenameTokenMap(). +** As the parse tree is transformed, the sqlite3RenameTokenRemap() +** routine is used to keep the mapping current. +** +** After the parse finishes, renameTokenFind() routine can be used +** to look up the actual token value that created some element in +** the parse tree. +*/ +struct RenameToken { + void *p; /* Parse tree element created by token t */ + Token t; /* The token that created parse tree element p */ + RenameToken *pNext; /* Next is a list of all RenameToken objects */ +}; + +/* +** The context of an ALTER TABLE RENAME COLUMN operation that gets passed +** down into the Walker. +*/ +typedef struct RenameCtx RenameCtx; +struct RenameCtx { + RenameToken *pList; /* List of tokens to overwrite */ + int nList; /* Number of tokens in pList */ + int iCol; /* Index of column being renamed */ + Table *pTab; /* Table being ALTERed */ + const char *zOld; /* Old column name */ +}; + +#ifdef SQLITE_DEBUG +/* +** This function is only for debugging. It performs two tasks: +** +** 1. Checks that pointer pPtr does not already appear in the +** rename-token list. +** +** 2. Dereferences each pointer in the rename-token list. +** +** The second is most effective when debugging under valgrind or +** address-sanitizer or similar. If any of these pointers no longer +** point to valid objects, an exception is raised by the memory-checking +** tool. +** +** The point of this is to prevent comparisons of invalid pointer values. +** Even though this always seems to work, it is undefined according to the +** C standard. Example of undefined comparison: +** +** sqlite3_free(x); +** if( x==y ) ... +** +** Technically, as x no longer points into a valid object or to the byte +** following a valid object, it may not be used in comparison operations. +*/ +static void renameTokenCheckAll(Parse *pParse, void *pPtr){ + if( pParse->nErr==0 && pParse->db->mallocFailed==0 ){ + RenameToken *p; + u8 i = 0; + for(p=pParse->pRename; p; p=p->pNext){ + if( p->p ){ + assert( p->p!=pPtr ); + i += *(u8*)(p->p); + } + } + } +} +#else +# define renameTokenCheckAll(x,y) +#endif + +/* +** Remember that the parser tree element pPtr was created using +** the token pToken. +** +** In other words, construct a new RenameToken object and add it +** to the list of RenameToken objects currently being built up +** in pParse->pRename. +** +** The pPtr argument is returned so that this routine can be used +** with tail recursion in tokenExpr() routine, for a small performance +** improvement. +*/ +SQLITE_PRIVATE void *sqlite3RenameTokenMap(Parse *pParse, void *pPtr, Token *pToken){ + RenameToken *pNew; + assert( pPtr || pParse->db->mallocFailed ); + renameTokenCheckAll(pParse, pPtr); + if( ALWAYS(pParse->eParseMode!=PARSE_MODE_UNMAP) ){ + pNew = sqlite3DbMallocZero(pParse->db, sizeof(RenameToken)); + if( pNew ){ + pNew->p = pPtr; + pNew->t = *pToken; + pNew->pNext = pParse->pRename; + pParse->pRename = pNew; + } + } + + return pPtr; +} + +/* +** It is assumed that there is already a RenameToken object associated +** with parse tree element pFrom. This function remaps the associated token +** to parse tree element pTo. +*/ +SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse *pParse, void *pTo, void *pFrom){ + RenameToken *p; + renameTokenCheckAll(pParse, pTo); + for(p=pParse->pRename; p; p=p->pNext){ + if( p->p==pFrom ){ + p->p = pTo; + break; + } + } +} + +/* +** Walker callback used by sqlite3RenameExprUnmap(). +*/ +static int renameUnmapExprCb(Walker *pWalker, Expr *pExpr){ + Parse *pParse = pWalker->pParse; + sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr); + return WRC_Continue; +} + +/* +** Iterate through the Select objects that are part of WITH clauses attached +** to select statement pSelect. +*/ +static void renameWalkWith(Walker *pWalker, Select *pSelect){ + With *pWith = pSelect->pWith; + if( pWith ){ + int i; + for(i=0; inCte; i++){ + Select *p = pWith->a[i].pSelect; + NameContext sNC; + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pWalker->pParse; + sqlite3SelectPrep(sNC.pParse, p, &sNC); + sqlite3WalkSelect(pWalker, p); + sqlite3RenameExprlistUnmap(pWalker->pParse, pWith->a[i].pCols); + } + } +} + +/* +** Unmap all tokens in the IdList object passed as the second argument. +*/ +static void unmapColumnIdlistNames( + Parse *pParse, + IdList *pIdList +){ + if( pIdList ){ + int ii; + for(ii=0; iinId; ii++){ + sqlite3RenameTokenRemap(pParse, 0, (void*)pIdList->a[ii].zName); + } + } +} + +/* +** Walker callback used by sqlite3RenameExprUnmap(). +*/ +static int renameUnmapSelectCb(Walker *pWalker, Select *p){ + Parse *pParse = pWalker->pParse; + int i; + if( pParse->nErr ) return WRC_Abort; + if( NEVER(p->selFlags & SF_View) ) return WRC_Prune; + if( ALWAYS(p->pEList) ){ + ExprList *pList = p->pEList; + for(i=0; inExpr; i++){ + if( pList->a[i].zEName && pList->a[i].eEName==ENAME_NAME ){ + sqlite3RenameTokenRemap(pParse, 0, (void*)pList->a[i].zEName); + } + } + } + if( ALWAYS(p->pSrc) ){ /* Every Select as a SrcList, even if it is empty */ + SrcList *pSrc = p->pSrc; + for(i=0; inSrc; i++){ + sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName); + if( sqlite3WalkExpr(pWalker, pSrc->a[i].pOn) ) return WRC_Abort; + unmapColumnIdlistNames(pParse, pSrc->a[i].pUsing); + } + } + + renameWalkWith(pWalker, p); + return WRC_Continue; +} + +/* +** Remove all nodes that are part of expression pExpr from the rename list. +*/ +SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse *pParse, Expr *pExpr){ + u8 eMode = pParse->eParseMode; + Walker sWalker; + memset(&sWalker, 0, sizeof(Walker)); + sWalker.pParse = pParse; + sWalker.xExprCallback = renameUnmapExprCb; + sWalker.xSelectCallback = renameUnmapSelectCb; + pParse->eParseMode = PARSE_MODE_UNMAP; + sqlite3WalkExpr(&sWalker, pExpr); + pParse->eParseMode = eMode; +} + +/* +** Remove all nodes that are part of expression-list pEList from the +** rename list. +*/ +SQLITE_PRIVATE void sqlite3RenameExprlistUnmap(Parse *pParse, ExprList *pEList){ + if( pEList ){ + int i; + Walker sWalker; + memset(&sWalker, 0, sizeof(Walker)); + sWalker.pParse = pParse; + sWalker.xExprCallback = renameUnmapExprCb; + sqlite3WalkExprList(&sWalker, pEList); + for(i=0; inExpr; i++){ + if( ALWAYS(pEList->a[i].eEName==ENAME_NAME) ){ + sqlite3RenameTokenRemap(pParse, 0, (void*)pEList->a[i].zEName); + } + } + } +} + +/* +** Free the list of RenameToken objects given in the second argument +*/ +static void renameTokenFree(sqlite3 *db, RenameToken *pToken){ + RenameToken *pNext; + RenameToken *p; + for(p=pToken; p; p=pNext){ + pNext = p->pNext; + sqlite3DbFree(db, p); + } +} + +/* +** Search the Parse object passed as the first argument for a RenameToken +** object associated with parse tree element pPtr. If found, remove it +** from the Parse object and add it to the list maintained by the +** RenameCtx object passed as the second argument. +*/ +static void renameTokenFind(Parse *pParse, struct RenameCtx *pCtx, void *pPtr){ + RenameToken **pp; + assert( pPtr!=0 ); + for(pp=&pParse->pRename; (*pp); pp=&(*pp)->pNext){ + if( (*pp)->p==pPtr ){ + RenameToken *pToken = *pp; + *pp = pToken->pNext; + pToken->pNext = pCtx->pList; + pCtx->pList = pToken; + pCtx->nList++; + break; + } + } +} + +/* +** This is a Walker select callback. It does nothing. It is only required +** because without a dummy callback, sqlite3WalkExpr() and similar do not +** descend into sub-select statements. +*/ +static int renameColumnSelectCb(Walker *pWalker, Select *p){ + if( p->selFlags & SF_View ) return WRC_Prune; + renameWalkWith(pWalker, p); + return WRC_Continue; +} + +/* +** This is a Walker expression callback. +** +** For every TK_COLUMN node in the expression tree, search to see +** if the column being references is the column being renamed by an +** ALTER TABLE statement. If it is, then attach its associated +** RenameToken object to the list of RenameToken objects being +** constructed in RenameCtx object at pWalker->u.pRename. +*/ +static int renameColumnExprCb(Walker *pWalker, Expr *pExpr){ + RenameCtx *p = pWalker->u.pRename; + if( pExpr->op==TK_TRIGGER + && pExpr->iColumn==p->iCol + && pWalker->pParse->pTriggerTab==p->pTab + ){ + renameTokenFind(pWalker->pParse, p, (void*)pExpr); + }else if( pExpr->op==TK_COLUMN + && pExpr->iColumn==p->iCol + && p->pTab==pExpr->y.pTab + ){ + renameTokenFind(pWalker->pParse, p, (void*)pExpr); + } + return WRC_Continue; +} + +/* +** The RenameCtx contains a list of tokens that reference a column that +** is being renamed by an ALTER TABLE statement. Return the "last" +** RenameToken in the RenameCtx and remove that RenameToken from the +** RenameContext. "Last" means the last RenameToken encountered when +** the input SQL is parsed from left to right. Repeated calls to this routine +** return all column name tokens in the order that they are encountered +** in the SQL statement. +*/ +static RenameToken *renameColumnTokenNext(RenameCtx *pCtx){ + RenameToken *pBest = pCtx->pList; + RenameToken *pToken; + RenameToken **pp; + + for(pToken=pBest->pNext; pToken; pToken=pToken->pNext){ + if( pToken->t.z>pBest->t.z ) pBest = pToken; + } + for(pp=&pCtx->pList; *pp!=pBest; pp=&(*pp)->pNext); + *pp = pBest->pNext; + + return pBest; +} + +/* +** An error occured while parsing or otherwise processing a database +** object (either pParse->pNewTable, pNewIndex or pNewTrigger) as part of an +** ALTER TABLE RENAME COLUMN program. The error message emitted by the +** sub-routine is currently stored in pParse->zErrMsg. This function +** adds context to the error message and then stores it in pCtx. +*/ +static void renameColumnParseError( + sqlite3_context *pCtx, + int bPost, + sqlite3_value *pType, + sqlite3_value *pObject, + Parse *pParse +){ + const char *zT = (const char*)sqlite3_value_text(pType); + const char *zN = (const char*)sqlite3_value_text(pObject); + char *zErr; + + zErr = sqlite3_mprintf("error in %s %s%s: %s", + zT, zN, (bPost ? " after rename" : ""), + pParse->zErrMsg + ); + sqlite3_result_error(pCtx, zErr, -1); + sqlite3_free(zErr); +} + +/* +** For each name in the the expression-list pEList (i.e. each +** pEList->a[i].zName) that matches the string in zOld, extract the +** corresponding rename-token from Parse object pParse and add it +** to the RenameCtx pCtx. +*/ +static void renameColumnElistNames( + Parse *pParse, + RenameCtx *pCtx, + ExprList *pEList, + const char *zOld +){ + if( pEList ){ + int i; + for(i=0; inExpr; i++){ + char *zName = pEList->a[i].zEName; + if( ALWAYS(pEList->a[i].eEName==ENAME_NAME) + && ALWAYS(zName!=0) + && 0==sqlite3_stricmp(zName, zOld) + ){ + renameTokenFind(pParse, pCtx, (void*)zName); + } + } + } +} + +/* +** For each name in the the id-list pIdList (i.e. each pIdList->a[i].zName) +** that matches the string in zOld, extract the corresponding rename-token +** from Parse object pParse and add it to the RenameCtx pCtx. +*/ +static void renameColumnIdlistNames( + Parse *pParse, + RenameCtx *pCtx, + IdList *pIdList, + const char *zOld +){ + if( pIdList ){ + int i; + for(i=0; inId; i++){ + char *zName = pIdList->a[i].zName; + if( 0==sqlite3_stricmp(zName, zOld) ){ + renameTokenFind(pParse, pCtx, (void*)zName); + } + } + } +} + + +/* +** Parse the SQL statement zSql using Parse object (*p). The Parse object +** is initialized by this function before it is used. +*/ +static int renameParseSql( + Parse *p, /* Memory to use for Parse object */ + const char *zDb, /* Name of schema SQL belongs to */ + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL to parse */ + int bTemp /* True if SQL is from temp schema */ +){ + int rc; + char *zErr = 0; + + db->init.iDb = bTemp ? 1 : sqlite3FindDbName(db, zDb); + + /* Parse the SQL statement passed as the first argument. If no error + ** occurs and the parse does not result in a new table, index or + ** trigger object, the database must be corrupt. */ + memset(p, 0, sizeof(Parse)); + p->eParseMode = PARSE_MODE_RENAME; + p->db = db; + p->nQueryLoop = 1; + rc = sqlite3RunParser(p, zSql, &zErr); + assert( p->zErrMsg==0 ); + assert( rc!=SQLITE_OK || zErr==0 ); + p->zErrMsg = zErr; + if( db->mallocFailed ) rc = SQLITE_NOMEM; + if( rc==SQLITE_OK + && p->pNewTable==0 && p->pNewIndex==0 && p->pNewTrigger==0 + ){ + rc = SQLITE_CORRUPT_BKPT; + } + +#ifdef SQLITE_DEBUG + /* Ensure that all mappings in the Parse.pRename list really do map to + ** a part of the input string. */ + if( rc==SQLITE_OK ){ + int nSql = sqlite3Strlen30(zSql); + RenameToken *pToken; + for(pToken=p->pRename; pToken; pToken=pToken->pNext){ + assert( pToken->t.z>=zSql && &pToken->t.z[pToken->t.n]<=&zSql[nSql] ); + } + } +#endif + + db->init.iDb = 0; + return rc; +} + +/* +** This function edits SQL statement zSql, replacing each token identified +** by the linked list pRename with the text of zNew. If argument bQuote is +** true, then zNew is always quoted first. If no error occurs, the result +** is loaded into context object pCtx as the result. +** +** Or, if an error occurs (i.e. an OOM condition), an error is left in +** pCtx and an SQLite error code returned. +*/ +static int renameEditSql( + sqlite3_context *pCtx, /* Return result here */ + RenameCtx *pRename, /* Rename context */ + const char *zSql, /* SQL statement to edit */ + const char *zNew, /* New token text */ + int bQuote /* True to always quote token */ +){ + int nNew = sqlite3Strlen30(zNew); + int nSql = sqlite3Strlen30(zSql); + sqlite3 *db = sqlite3_context_db_handle(pCtx); + int rc = SQLITE_OK; + char *zQuot; + char *zOut; + int nQuot; + + /* Set zQuot to point to a buffer containing a quoted copy of the + ** identifier zNew. If the corresponding identifier in the original + ** ALTER TABLE statement was quoted (bQuote==1), then set zNew to + ** point to zQuot so that all substitutions are made using the + ** quoted version of the new column name. */ + zQuot = sqlite3MPrintf(db, "\"%w\"", zNew); + if( zQuot==0 ){ + return SQLITE_NOMEM; + }else{ + nQuot = sqlite3Strlen30(zQuot); + } + if( bQuote ){ + zNew = zQuot; + nNew = nQuot; + } + + /* At this point pRename->pList contains a list of RenameToken objects + ** corresponding to all tokens in the input SQL that must be replaced + ** with the new column name. All that remains is to construct and + ** return the edited SQL string. */ + assert( nQuot>=nNew ); + zOut = sqlite3DbMallocZero(db, nSql + pRename->nList*nQuot + 1); + if( zOut ){ + int nOut = nSql; + memcpy(zOut, zSql, nSql); + while( pRename->pList ){ + int iOff; /* Offset of token to replace in zOut */ + RenameToken *pBest = renameColumnTokenNext(pRename); + + u32 nReplace; + const char *zReplace; + if( sqlite3IsIdChar(*pBest->t.z) ){ + nReplace = nNew; + zReplace = zNew; + }else{ + nReplace = nQuot; + zReplace = zQuot; + } + + iOff = pBest->t.z - zSql; + if( pBest->t.n!=nReplace ){ + memmove(&zOut[iOff + nReplace], &zOut[iOff + pBest->t.n], + nOut - (iOff + pBest->t.n) + ); + nOut += nReplace - pBest->t.n; + zOut[nOut] = '\0'; + } + memcpy(&zOut[iOff], zReplace, nReplace); + sqlite3DbFree(db, pBest); + } + + sqlite3_result_text(pCtx, zOut, -1, SQLITE_TRANSIENT); + sqlite3DbFree(db, zOut); + }else{ + rc = SQLITE_NOMEM; + } + + sqlite3_free(zQuot); + return rc; +} + +/* +** Resolve all symbols in the trigger at pParse->pNewTrigger, assuming +** it was read from the schema of database zDb. Return SQLITE_OK if +** successful. Otherwise, return an SQLite error code and leave an error +** message in the Parse object. +*/ +static int renameResolveTrigger(Parse *pParse){ + sqlite3 *db = pParse->db; + Trigger *pNew = pParse->pNewTrigger; + TriggerStep *pStep; + NameContext sNC; + int rc = SQLITE_OK; + + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + assert( pNew->pTabSchema ); + pParse->pTriggerTab = sqlite3FindTable(db, pNew->table, + db->aDb[sqlite3SchemaToIndex(db, pNew->pTabSchema)].zDbSName + ); + pParse->eTriggerOp = pNew->op; + /* ALWAYS() because if the table of the trigger does not exist, the + ** error would have been hit before this point */ + if( ALWAYS(pParse->pTriggerTab) ){ + rc = sqlite3ViewGetColumnNames(pParse, pParse->pTriggerTab); + } + + /* Resolve symbols in WHEN clause */ + if( rc==SQLITE_OK && pNew->pWhen ){ + rc = sqlite3ResolveExprNames(&sNC, pNew->pWhen); + } + + for(pStep=pNew->step_list; rc==SQLITE_OK && pStep; pStep=pStep->pNext){ + if( pStep->pSelect ){ + sqlite3SelectPrep(pParse, pStep->pSelect, &sNC); + if( pParse->nErr ) rc = pParse->rc; + } + if( rc==SQLITE_OK && pStep->zTarget ){ + SrcList *pSrc = sqlite3TriggerStepSrc(pParse, pStep); + if( pSrc ){ + int i; + for(i=0; inSrc && rc==SQLITE_OK; i++){ + struct SrcList_item *p = &pSrc->a[i]; + p->iCursor = pParse->nTab++; + if( p->pSelect ){ + sqlite3SelectPrep(pParse, p->pSelect, 0); + sqlite3ExpandSubquery(pParse, p); + assert( i>0 ); + assert( pStep->pFrom->a[i-1].pSelect ); + sqlite3SelectPrep(pParse, pStep->pFrom->a[i-1].pSelect, 0); + }else{ + p->pTab = sqlite3LocateTableItem(pParse, 0, p); + if( p->pTab==0 ){ + rc = SQLITE_ERROR; + }else{ + p->pTab->nTabRef++; + rc = sqlite3ViewGetColumnNames(pParse, p->pTab); + } + } + } + sNC.pSrcList = pSrc; + if( rc==SQLITE_OK && pStep->pWhere ){ + rc = sqlite3ResolveExprNames(&sNC, pStep->pWhere); + } + if( rc==SQLITE_OK ){ + rc = sqlite3ResolveExprListNames(&sNC, pStep->pExprList); + } + assert( !pStep->pUpsert || (!pStep->pWhere && !pStep->pExprList) ); + if( pStep->pUpsert ){ + Upsert *pUpsert = pStep->pUpsert; + assert( rc==SQLITE_OK ); + pUpsert->pUpsertSrc = pSrc; + sNC.uNC.pUpsert = pUpsert; + sNC.ncFlags = NC_UUpsert; + rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget); + if( rc==SQLITE_OK ){ + ExprList *pUpsertSet = pUpsert->pUpsertSet; + rc = sqlite3ResolveExprListNames(&sNC, pUpsertSet); + } + if( rc==SQLITE_OK ){ + rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertWhere); + } + if( rc==SQLITE_OK ){ + rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere); + } + sNC.ncFlags = 0; + } + sNC.pSrcList = 0; + sqlite3SrcListDelete(db, pSrc); + }else{ + rc = SQLITE_NOMEM; + } + } + } + return rc; +} + +/* +** Invoke sqlite3WalkExpr() or sqlite3WalkSelect() on all Select or Expr +** objects that are part of the trigger passed as the second argument. +*/ +static void renameWalkTrigger(Walker *pWalker, Trigger *pTrigger){ + TriggerStep *pStep; + + /* Find tokens to edit in WHEN clause */ + sqlite3WalkExpr(pWalker, pTrigger->pWhen); + + /* Find tokens to edit in trigger steps */ + for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){ + sqlite3WalkSelect(pWalker, pStep->pSelect); + sqlite3WalkExpr(pWalker, pStep->pWhere); + sqlite3WalkExprList(pWalker, pStep->pExprList); + if( pStep->pUpsert ){ + Upsert *pUpsert = pStep->pUpsert; + sqlite3WalkExprList(pWalker, pUpsert->pUpsertTarget); + sqlite3WalkExprList(pWalker, pUpsert->pUpsertSet); + sqlite3WalkExpr(pWalker, pUpsert->pUpsertWhere); + sqlite3WalkExpr(pWalker, pUpsert->pUpsertTargetWhere); + } + if( pStep->pFrom ){ + int i; + for(i=0; ipFrom->nSrc; i++){ + sqlite3WalkSelect(pWalker, pStep->pFrom->a[i].pSelect); + } + } + } +} + +/* +** Free the contents of Parse object (*pParse). Do not free the memory +** occupied by the Parse object itself. +*/ +static void renameParseCleanup(Parse *pParse){ + sqlite3 *db = pParse->db; + Index *pIdx; + if( pParse->pVdbe ){ + sqlite3VdbeFinalize(pParse->pVdbe); + } + sqlite3DeleteTable(db, pParse->pNewTable); + while( (pIdx = pParse->pNewIndex)!=0 ){ + pParse->pNewIndex = pIdx->pNext; + sqlite3FreeIndex(db, pIdx); + } + sqlite3DeleteTrigger(db, pParse->pNewTrigger); + sqlite3DbFree(db, pParse->zErrMsg); + renameTokenFree(db, pParse->pRename); + sqlite3ParserReset(pParse); +} + +/* +** SQL function: +** +** sqlite_rename_column(zSql, iCol, bQuote, zNew, zTable, zOld) +** +** 0. zSql: SQL statement to rewrite +** 1. type: Type of object ("table", "view" etc.) +** 2. object: Name of object +** 3. Database: Database name (e.g. "main") +** 4. Table: Table name +** 5. iCol: Index of column to rename +** 6. zNew: New column name +** 7. bQuote: Non-zero if the new column name should be quoted. +** 8. bTemp: True if zSql comes from temp schema +** +** Do a column rename operation on the CREATE statement given in zSql. +** The iCol-th column (left-most is 0) of table zTable is renamed from zCol +** into zNew. The name should be quoted if bQuote is true. +** +** This function is used internally by the ALTER TABLE RENAME COLUMN command. +** It is only accessible to SQL created using sqlite3NestedParse(). It is +** not reachable from ordinary SQL passed into sqlite3_prepare(). +*/ +static void renameColumnFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + sqlite3 *db = sqlite3_context_db_handle(context); + RenameCtx sCtx; + const char *zSql = (const char*)sqlite3_value_text(argv[0]); + const char *zDb = (const char*)sqlite3_value_text(argv[3]); + const char *zTable = (const char*)sqlite3_value_text(argv[4]); + int iCol = sqlite3_value_int(argv[5]); + const char *zNew = (const char*)sqlite3_value_text(argv[6]); + int bQuote = sqlite3_value_int(argv[7]); + int bTemp = sqlite3_value_int(argv[8]); + const char *zOld; + int rc; + Parse sParse; + Walker sWalker; + Index *pIdx; + int i; + Table *pTab; +#ifndef SQLITE_OMIT_AUTHORIZATION + sqlite3_xauth xAuth = db->xAuth; +#endif + + UNUSED_PARAMETER(NotUsed); + if( zSql==0 ) return; + if( zTable==0 ) return; + if( zNew==0 ) return; + if( iCol<0 ) return; + sqlite3BtreeEnterAll(db); + pTab = sqlite3FindTable(db, zTable, zDb); + if( pTab==0 || iCol>=pTab->nCol ){ + sqlite3BtreeLeaveAll(db); + return; + } + zOld = pTab->aCol[iCol].zName; + memset(&sCtx, 0, sizeof(sCtx)); + sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol); + +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = 0; +#endif + rc = renameParseSql(&sParse, zDb, db, zSql, bTemp); + + /* Find tokens that need to be replaced. */ + memset(&sWalker, 0, sizeof(Walker)); + sWalker.pParse = &sParse; + sWalker.xExprCallback = renameColumnExprCb; + sWalker.xSelectCallback = renameColumnSelectCb; + sWalker.u.pRename = &sCtx; + + sCtx.pTab = pTab; + if( rc!=SQLITE_OK ) goto renameColumnFunc_done; + if( sParse.pNewTable ){ + Select *pSelect = sParse.pNewTable->pSelect; + if( pSelect ){ + pSelect->selFlags &= ~SF_View; + sParse.rc = SQLITE_OK; + sqlite3SelectPrep(&sParse, pSelect, 0); + rc = (db->mallocFailed ? SQLITE_NOMEM : sParse.rc); + if( rc==SQLITE_OK ){ + sqlite3WalkSelect(&sWalker, pSelect); + } + if( rc!=SQLITE_OK ) goto renameColumnFunc_done; + }else{ + /* A regular table */ + int bFKOnly = sqlite3_stricmp(zTable, sParse.pNewTable->zName); + FKey *pFKey; + assert( sParse.pNewTable->pSelect==0 ); + sCtx.pTab = sParse.pNewTable; + if( bFKOnly==0 ){ + renameTokenFind( + &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zName + ); + if( sCtx.iCol<0 ){ + renameTokenFind(&sParse, &sCtx, (void*)&sParse.pNewTable->iPKey); + } + sqlite3WalkExprList(&sWalker, sParse.pNewTable->pCheck); + for(pIdx=sParse.pNewTable->pIndex; pIdx; pIdx=pIdx->pNext){ + sqlite3WalkExprList(&sWalker, pIdx->aColExpr); + } + for(pIdx=sParse.pNewIndex; pIdx; pIdx=pIdx->pNext){ + sqlite3WalkExprList(&sWalker, pIdx->aColExpr); + } + } +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + for(i=0; inCol; i++){ + sqlite3WalkExpr(&sWalker, sParse.pNewTable->aCol[i].pDflt); + } +#endif + + for(pFKey=sParse.pNewTable->pFKey; pFKey; pFKey=pFKey->pNextFrom){ + for(i=0; inCol; i++){ + if( bFKOnly==0 && pFKey->aCol[i].iFrom==iCol ){ + renameTokenFind(&sParse, &sCtx, (void*)&pFKey->aCol[i]); + } + if( 0==sqlite3_stricmp(pFKey->zTo, zTable) + && 0==sqlite3_stricmp(pFKey->aCol[i].zCol, zOld) + ){ + renameTokenFind(&sParse, &sCtx, (void*)pFKey->aCol[i].zCol); + } + } + } + } + }else if( sParse.pNewIndex ){ + sqlite3WalkExprList(&sWalker, sParse.pNewIndex->aColExpr); + sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere); + }else{ + /* A trigger */ + TriggerStep *pStep; + rc = renameResolveTrigger(&sParse); + if( rc!=SQLITE_OK ) goto renameColumnFunc_done; + + for(pStep=sParse.pNewTrigger->step_list; pStep; pStep=pStep->pNext){ + if( pStep->zTarget ){ + Table *pTarget = sqlite3LocateTable(&sParse, 0, pStep->zTarget, zDb); + if( pTarget==pTab ){ + if( pStep->pUpsert ){ + ExprList *pUpsertSet = pStep->pUpsert->pUpsertSet; + renameColumnElistNames(&sParse, &sCtx, pUpsertSet, zOld); + } + renameColumnIdlistNames(&sParse, &sCtx, pStep->pIdList, zOld); + renameColumnElistNames(&sParse, &sCtx, pStep->pExprList, zOld); + } + } + } + + + /* Find tokens to edit in UPDATE OF clause */ + if( sParse.pTriggerTab==pTab ){ + renameColumnIdlistNames(&sParse, &sCtx,sParse.pNewTrigger->pColumns,zOld); + } + + /* Find tokens to edit in various expressions and selects */ + renameWalkTrigger(&sWalker, sParse.pNewTrigger); + } + + assert( rc==SQLITE_OK ); + rc = renameEditSql(context, &sCtx, zSql, zNew, bQuote); + +renameColumnFunc_done: + if( rc!=SQLITE_OK ){ + if( sParse.zErrMsg ){ + renameColumnParseError(context, 0, argv[1], argv[2], &sParse); + }else{ + sqlite3_result_error_code(context, rc); + } + } + + renameParseCleanup(&sParse); + renameTokenFree(db, sCtx.pList); +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = xAuth; +#endif + sqlite3BtreeLeaveAll(db); +} + +/* +** Walker expression callback used by "RENAME TABLE". +*/ +static int renameTableExprCb(Walker *pWalker, Expr *pExpr){ + RenameCtx *p = pWalker->u.pRename; + if( pExpr->op==TK_COLUMN && p->pTab==pExpr->y.pTab ){ + renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab); + } + return WRC_Continue; +} + +/* +** Walker select callback used by "RENAME TABLE". +*/ +static int renameTableSelectCb(Walker *pWalker, Select *pSelect){ + int i; + RenameCtx *p = pWalker->u.pRename; + SrcList *pSrc = pSelect->pSrc; + if( pSelect->selFlags & SF_View ) return WRC_Prune; + if( pSrc==0 ){ + assert( pWalker->pParse->db->mallocFailed ); + return WRC_Abort; + } + for(i=0; inSrc; i++){ + struct SrcList_item *pItem = &pSrc->a[i]; + if( pItem->pTab==p->pTab ){ + renameTokenFind(pWalker->pParse, p, pItem->zName); + } + } + renameWalkWith(pWalker, pSelect); + + return WRC_Continue; +} + + +/* +** This C function implements an SQL user function that is used by SQL code +** generated by the ALTER TABLE ... RENAME command to modify the definition +** of any foreign key constraints that use the table being renamed as the +** parent table. It is passed three arguments: +** +** 0: The database containing the table being renamed. +** 1. type: Type of object ("table", "view" etc.) +** 2. object: Name of object +** 3: The complete text of the schema statement being modified, +** 4: The old name of the table being renamed, and +** 5: The new name of the table being renamed. +** 6: True if the schema statement comes from the temp db. +** +** It returns the new schema statement. For example: +** +** sqlite_rename_table('main', 'CREATE TABLE t1(a REFERENCES t2)','t2','t3',0) +** -> 'CREATE TABLE t1(a REFERENCES t3)' +*/ +static void renameTableFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + sqlite3 *db = sqlite3_context_db_handle(context); + const char *zDb = (const char*)sqlite3_value_text(argv[0]); + const char *zInput = (const char*)sqlite3_value_text(argv[3]); + const char *zOld = (const char*)sqlite3_value_text(argv[4]); + const char *zNew = (const char*)sqlite3_value_text(argv[5]); + int bTemp = sqlite3_value_int(argv[6]); + UNUSED_PARAMETER(NotUsed); + + if( zInput && zOld && zNew ){ + Parse sParse; + int rc; + int bQuote = 1; + RenameCtx sCtx; + Walker sWalker; + +#ifndef SQLITE_OMIT_AUTHORIZATION + sqlite3_xauth xAuth = db->xAuth; + db->xAuth = 0; +#endif + + sqlite3BtreeEnterAll(db); + + memset(&sCtx, 0, sizeof(RenameCtx)); + sCtx.pTab = sqlite3FindTable(db, zOld, zDb); + memset(&sWalker, 0, sizeof(Walker)); + sWalker.pParse = &sParse; + sWalker.xExprCallback = renameTableExprCb; + sWalker.xSelectCallback = renameTableSelectCb; + sWalker.u.pRename = &sCtx; + + rc = renameParseSql(&sParse, zDb, db, zInput, bTemp); + + if( rc==SQLITE_OK ){ + int isLegacy = (db->flags & SQLITE_LegacyAlter); + if( sParse.pNewTable ){ + Table *pTab = sParse.pNewTable; + + if( pTab->pSelect ){ + if( isLegacy==0 ){ + Select *pSelect = pTab->pSelect; + NameContext sNC; + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = &sParse; + + assert( pSelect->selFlags & SF_View ); + pSelect->selFlags &= ~SF_View; + sqlite3SelectPrep(&sParse, pTab->pSelect, &sNC); + if( sParse.nErr ){ + rc = sParse.rc; + }else{ + sqlite3WalkSelect(&sWalker, pTab->pSelect); + } + } + }else{ + /* Modify any FK definitions to point to the new table. */ +#ifndef SQLITE_OMIT_FOREIGN_KEY + if( isLegacy==0 || (db->flags & SQLITE_ForeignKeys) ){ + FKey *pFKey; + for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){ + if( sqlite3_stricmp(pFKey->zTo, zOld)==0 ){ + renameTokenFind(&sParse, &sCtx, (void*)pFKey->zTo); + } + } + } +#endif + + /* If this is the table being altered, fix any table refs in CHECK + ** expressions. Also update the name that appears right after the + ** "CREATE [VIRTUAL] TABLE" bit. */ + if( sqlite3_stricmp(zOld, pTab->zName)==0 ){ + sCtx.pTab = pTab; + if( isLegacy==0 ){ + sqlite3WalkExprList(&sWalker, pTab->pCheck); + } + renameTokenFind(&sParse, &sCtx, pTab->zName); + } + } + } + + else if( sParse.pNewIndex ){ + renameTokenFind(&sParse, &sCtx, sParse.pNewIndex->zName); + if( isLegacy==0 ){ + sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere); + } + } + +#ifndef SQLITE_OMIT_TRIGGER + else{ + Trigger *pTrigger = sParse.pNewTrigger; + TriggerStep *pStep; + if( 0==sqlite3_stricmp(sParse.pNewTrigger->table, zOld) + && sCtx.pTab->pSchema==pTrigger->pTabSchema + ){ + renameTokenFind(&sParse, &sCtx, sParse.pNewTrigger->table); + } + + if( isLegacy==0 ){ + rc = renameResolveTrigger(&sParse); + if( rc==SQLITE_OK ){ + renameWalkTrigger(&sWalker, pTrigger); + for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){ + if( pStep->zTarget && 0==sqlite3_stricmp(pStep->zTarget, zOld) ){ + renameTokenFind(&sParse, &sCtx, pStep->zTarget); + } + } + } + } + } +#endif + } + + if( rc==SQLITE_OK ){ + rc = renameEditSql(context, &sCtx, zInput, zNew, bQuote); + } + if( rc!=SQLITE_OK ){ + if( sParse.zErrMsg ){ + renameColumnParseError(context, 0, argv[1], argv[2], &sParse); + }else{ + sqlite3_result_error_code(context, rc); + } + } + + renameParseCleanup(&sParse); + renameTokenFree(db, sCtx.pList); + sqlite3BtreeLeaveAll(db); +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = xAuth; +#endif + } + + return; +} + +/* +** An SQL user function that checks that there are no parse or symbol +** resolution problems in a CREATE TRIGGER|TABLE|VIEW|INDEX statement. +** After an ALTER TABLE .. RENAME operation is performed and the schema +** reloaded, this function is called on each SQL statement in the schema +** to ensure that it is still usable. +** +** 0: Database name ("main", "temp" etc.). +** 1: SQL statement. +** 2: Object type ("view", "table", "trigger" or "index"). +** 3: Object name. +** 4: True if object is from temp schema. +** +** Unless it finds an error, this function normally returns NULL. However, it +** returns integer value 1 if: +** +** * the SQL argument creates a trigger, and +** * the table that the trigger is attached to is in database zDb. +*/ +static void renameTableTest( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + sqlite3 *db = sqlite3_context_db_handle(context); + char const *zDb = (const char*)sqlite3_value_text(argv[0]); + char const *zInput = (const char*)sqlite3_value_text(argv[1]); + int bTemp = sqlite3_value_int(argv[4]); + int isLegacy = (db->flags & SQLITE_LegacyAlter); + +#ifndef SQLITE_OMIT_AUTHORIZATION + sqlite3_xauth xAuth = db->xAuth; + db->xAuth = 0; +#endif + + UNUSED_PARAMETER(NotUsed); + if( zDb && zInput ){ + int rc; + Parse sParse; + rc = renameParseSql(&sParse, zDb, db, zInput, bTemp); + if( rc==SQLITE_OK ){ + if( isLegacy==0 && sParse.pNewTable && sParse.pNewTable->pSelect ){ + NameContext sNC; + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = &sParse; + sqlite3SelectPrep(&sParse, sParse.pNewTable->pSelect, &sNC); + if( sParse.nErr ) rc = sParse.rc; + } + + else if( sParse.pNewTrigger ){ + if( isLegacy==0 ){ + rc = renameResolveTrigger(&sParse); + } + if( rc==SQLITE_OK ){ + int i1 = sqlite3SchemaToIndex(db, sParse.pNewTrigger->pTabSchema); + int i2 = sqlite3FindDbName(db, zDb); + if( i1==i2 ) sqlite3_result_int(context, 1); + } + } + } + + if( rc!=SQLITE_OK ){ + renameColumnParseError(context, 1, argv[2], argv[3], &sParse); + } + renameParseCleanup(&sParse); + } + +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = xAuth; +#endif +} + +/* +** Register built-in functions used to help implement ALTER TABLE +*/ +SQLITE_PRIVATE void sqlite3AlterFunctions(void){ + static FuncDef aAlterTableFuncs[] = { + INTERNAL_FUNCTION(sqlite_rename_column, 9, renameColumnFunc), + INTERNAL_FUNCTION(sqlite_rename_table, 7, renameTableFunc), + INTERNAL_FUNCTION(sqlite_rename_test, 5, renameTableTest), + }; + sqlite3InsertBuiltinFuncs(aAlterTableFuncs, ArraySize(aAlterTableFuncs)); +} +#endif /* SQLITE_ALTER_TABLE */ + +/************** End of alter.c ***********************************************/ +/************** Begin file analyze.c *****************************************/ +/* +** 2005-07-08 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code associated with the ANALYZE command. +** +** The ANALYZE command gather statistics about the content of tables +** and indices. These statistics are made available to the query planner +** to help it make better decisions about how to perform queries. +** +** The following system tables are or have been supported: +** +** CREATE TABLE sqlite_stat1(tbl, idx, stat); +** CREATE TABLE sqlite_stat2(tbl, idx, sampleno, sample); +** CREATE TABLE sqlite_stat3(tbl, idx, nEq, nLt, nDLt, sample); +** CREATE TABLE sqlite_stat4(tbl, idx, nEq, nLt, nDLt, sample); +** +** Additional tables might be added in future releases of SQLite. +** The sqlite_stat2 table is not created or used unless the SQLite version +** is between 3.6.18 and 3.7.8, inclusive, and unless SQLite is compiled +** with SQLITE_ENABLE_STAT2. The sqlite_stat2 table is deprecated. +** The sqlite_stat2 table is superseded by sqlite_stat3, which is only +** created and used by SQLite versions 3.7.9 through 3.29.0 when +** SQLITE_ENABLE_STAT3 defined. The functionality of sqlite_stat3 +** is a superset of sqlite_stat2 and is also now deprecated. The +** sqlite_stat4 is an enhanced version of sqlite_stat3 and is only +** available when compiled with SQLITE_ENABLE_STAT4 and in SQLite +** versions 3.8.1 and later. STAT4 is the only variant that is still +** supported. +** +** For most applications, sqlite_stat1 provides all the statistics required +** for the query planner to make good choices. +** +** Format of sqlite_stat1: +** +** There is normally one row per index, with the index identified by the +** name in the idx column. The tbl column is the name of the table to +** which the index belongs. In each such row, the stat column will be +** a string consisting of a list of integers. The first integer in this +** list is the number of rows in the index. (This is the same as the +** number of rows in the table, except for partial indices.) The second +** integer is the average number of rows in the index that have the same +** value in the first column of the index. The third integer is the average +** number of rows in the index that have the same value for the first two +** columns. The N-th integer (for N>1) is the average number of rows in +** the index which have the same value for the first N-1 columns. For +** a K-column index, there will be K+1 integers in the stat column. If +** the index is unique, then the last integer will be 1. +** +** The list of integers in the stat column can optionally be followed +** by the keyword "unordered". The "unordered" keyword, if it is present, +** must be separated from the last integer by a single space. If the +** "unordered" keyword is present, then the query planner assumes that +** the index is unordered and will not use the index for a range query. +** +** If the sqlite_stat1.idx column is NULL, then the sqlite_stat1.stat +** column contains a single integer which is the (estimated) number of +** rows in the table identified by sqlite_stat1.tbl. +** +** Format of sqlite_stat2: +** +** The sqlite_stat2 is only created and is only used if SQLite is compiled +** with SQLITE_ENABLE_STAT2 and if the SQLite version number is between +** 3.6.18 and 3.7.8. The "stat2" table contains additional information +** about the distribution of keys within an index. The index is identified by +** the "idx" column and the "tbl" column is the name of the table to which +** the index belongs. There are usually 10 rows in the sqlite_stat2 +** table for each index. +** +** The sqlite_stat2 entries for an index that have sampleno between 0 and 9 +** inclusive are samples of the left-most key value in the index taken at +** evenly spaced points along the index. Let the number of samples be S +** (10 in the standard build) and let C be the number of rows in the index. +** Then the sampled rows are given by: +** +** rownumber = (i*C*2 + C)/(S*2) +** +** For i between 0 and S-1. Conceptually, the index space is divided into +** S uniform buckets and the samples are the middle row from each bucket. +** +** The format for sqlite_stat2 is recorded here for legacy reference. This +** version of SQLite does not support sqlite_stat2. It neither reads nor +** writes the sqlite_stat2 table. This version of SQLite only supports +** sqlite_stat3. +** +** Format for sqlite_stat3: +** +** The sqlite_stat3 format is a subset of sqlite_stat4. Hence, the +** sqlite_stat4 format will be described first. Further information +** about sqlite_stat3 follows the sqlite_stat4 description. +** +** Format for sqlite_stat4: +** +** As with sqlite_stat2, the sqlite_stat4 table contains histogram data +** to aid the query planner in choosing good indices based on the values +** that indexed columns are compared against in the WHERE clauses of +** queries. +** +** The sqlite_stat4 table contains multiple entries for each index. +** The idx column names the index and the tbl column is the table of the +** index. If the idx and tbl columns are the same, then the sample is +** of the INTEGER PRIMARY KEY. The sample column is a blob which is the +** binary encoding of a key from the index. The nEq column is a +** list of integers. The first integer is the approximate number +** of entries in the index whose left-most column exactly matches +** the left-most column of the sample. The second integer in nEq +** is the approximate number of entries in the index where the +** first two columns match the first two columns of the sample. +** And so forth. nLt is another list of integers that show the approximate +** number of entries that are strictly less than the sample. The first +** integer in nLt contains the number of entries in the index where the +** left-most column is less than the left-most column of the sample. +** The K-th integer in the nLt entry is the number of index entries +** where the first K columns are less than the first K columns of the +** sample. The nDLt column is like nLt except that it contains the +** number of distinct entries in the index that are less than the +** sample. +** +** There can be an arbitrary number of sqlite_stat4 entries per index. +** The ANALYZE command will typically generate sqlite_stat4 tables +** that contain between 10 and 40 samples which are distributed across +** the key space, though not uniformly, and which include samples with +** large nEq values. +** +** Format for sqlite_stat3 redux: +** +** The sqlite_stat3 table is like sqlite_stat4 except that it only +** looks at the left-most column of the index. The sqlite_stat3.sample +** column contains the actual value of the left-most column instead +** of a blob encoding of the complete index key as is found in +** sqlite_stat4.sample. The nEq, nLt, and nDLt entries of sqlite_stat3 +** all contain just a single integer which is the same as the first +** integer in the equivalent columns in sqlite_stat4. +*/ +#ifndef SQLITE_OMIT_ANALYZE +/* #include "sqliteInt.h" */ + +#if defined(SQLITE_ENABLE_STAT4) +# define IsStat4 1 +#else +# define IsStat4 0 +# undef SQLITE_STAT4_SAMPLES +# define SQLITE_STAT4_SAMPLES 1 +#endif + +/* +** This routine generates code that opens the sqlite_statN tables. +** The sqlite_stat1 table is always relevant. sqlite_stat2 is now +** obsolete. sqlite_stat3 and sqlite_stat4 are only opened when +** appropriate compile-time options are provided. +** +** If the sqlite_statN tables do not previously exist, it is created. +** +** Argument zWhere may be a pointer to a buffer containing a table name, +** or it may be a NULL pointer. If it is not NULL, then all entries in +** the sqlite_statN tables associated with the named table are deleted. +** If zWhere==0, then code is generated to delete all stat table entries. +*/ +static void openStatTable( + Parse *pParse, /* Parsing context */ + int iDb, /* The database we are looking in */ + int iStatCur, /* Open the sqlite_stat1 table on this cursor */ + const char *zWhere, /* Delete entries for this table or index */ + const char *zWhereType /* Either "tbl" or "idx" */ +){ + static const struct { + const char *zName; + const char *zCols; + } aTable[] = { + { "sqlite_stat1", "tbl,idx,stat" }, +#if defined(SQLITE_ENABLE_STAT4) + { "sqlite_stat4", "tbl,idx,neq,nlt,ndlt,sample" }, +#else + { "sqlite_stat4", 0 }, +#endif + { "sqlite_stat3", 0 }, + }; + int i; + sqlite3 *db = pParse->db; + Db *pDb; + Vdbe *v = sqlite3GetVdbe(pParse); + u32 aRoot[ArraySize(aTable)]; + u8 aCreateTbl[ArraySize(aTable)]; +#ifdef SQLITE_ENABLE_STAT4 + const int nToOpen = OptimizationEnabled(db,SQLITE_Stat4) ? 2 : 1; +#else + const int nToOpen = 1; +#endif + + if( v==0 ) return; + assert( sqlite3BtreeHoldsAllMutexes(db) ); + assert( sqlite3VdbeDb(v)==db ); + pDb = &db->aDb[iDb]; + + /* Create new statistic tables if they do not exist, or clear them + ** if they do already exist. + */ + for(i=0; izDbSName))==0 ){ + if( iregRoot. This is important + ** because the OpenWrite opcode below will be needing it. */ + sqlite3NestedParse(pParse, + "CREATE TABLE %Q.%s(%s)", pDb->zDbSName, zTab, aTable[i].zCols + ); + aRoot[i] = (u32)pParse->regRoot; + aCreateTbl[i] = OPFLAG_P2ISREG; + } + }else{ + /* The table already exists. If zWhere is not NULL, delete all entries + ** associated with the table zWhere. If zWhere is NULL, delete the + ** entire contents of the table. */ + aRoot[i] = pStat->tnum; + sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab); + if( zWhere ){ + sqlite3NestedParse(pParse, + "DELETE FROM %Q.%s WHERE %s=%Q", + pDb->zDbSName, zTab, zWhereType, zWhere + ); +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + }else if( db->xPreUpdateCallback ){ + sqlite3NestedParse(pParse, "DELETE FROM %Q.%s", pDb->zDbSName, zTab); +#endif + }else{ + /* The sqlite_stat[134] table already exists. Delete all rows. */ + sqlite3VdbeAddOp2(v, OP_Clear, (int)aRoot[i], iDb); + } + } + } + + /* Open the sqlite_stat[134] tables for writing. */ + for(i=0; inRowid ){ + sqlite3DbFree(db, p->u.aRowid); + p->nRowid = 0; + } +} +#endif + +/* Initialize the BLOB value of a ROWID +*/ +#ifdef SQLITE_ENABLE_STAT4 +static void sampleSetRowid(sqlite3 *db, StatSample *p, int n, const u8 *pData){ + assert( db!=0 ); + if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid); + p->u.aRowid = sqlite3DbMallocRawNN(db, n); + if( p->u.aRowid ){ + p->nRowid = n; + memcpy(p->u.aRowid, pData, n); + }else{ + p->nRowid = 0; + } +} +#endif + +/* Initialize the INTEGER value of a ROWID. +*/ +#ifdef SQLITE_ENABLE_STAT4 +static void sampleSetRowidInt64(sqlite3 *db, StatSample *p, i64 iRowid){ + assert( db!=0 ); + if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid); + p->nRowid = 0; + p->u.iRowid = iRowid; +} +#endif + + +/* +** Copy the contents of object (*pFrom) into (*pTo). +*/ +#ifdef SQLITE_ENABLE_STAT4 +static void sampleCopy(StatAccum *p, StatSample *pTo, StatSample *pFrom){ + pTo->isPSample = pFrom->isPSample; + pTo->iCol = pFrom->iCol; + pTo->iHash = pFrom->iHash; + memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol); + memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol); + memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol); + if( pFrom->nRowid ){ + sampleSetRowid(p->db, pTo, pFrom->nRowid, pFrom->u.aRowid); + }else{ + sampleSetRowidInt64(p->db, pTo, pFrom->u.iRowid); + } +} +#endif + +/* +** Reclaim all memory of a StatAccum structure. +*/ +static void statAccumDestructor(void *pOld){ + StatAccum *p = (StatAccum*)pOld; +#ifdef SQLITE_ENABLE_STAT4 + if( p->mxSample ){ + int i; + for(i=0; inCol; i++) sampleClear(p->db, p->aBest+i); + for(i=0; imxSample; i++) sampleClear(p->db, p->a+i); + sampleClear(p->db, &p->current); + } +#endif + sqlite3DbFree(p->db, p); +} + +/* +** Implementation of the stat_init(N,K,C,L) SQL function. The four parameters +** are: +** N: The number of columns in the index including the rowid/pk (note 1) +** K: The number of columns in the index excluding the rowid/pk. +** C: Estimated number of rows in the index +** L: A limit on the number of rows to scan, or 0 for no-limit +** +** Note 1: In the special case of the covering index that implements a +** WITHOUT ROWID table, N is the number of PRIMARY KEY columns, not the +** total number of columns in the table. +** +** For indexes on ordinary rowid tables, N==K+1. But for indexes on +** WITHOUT ROWID tables, N=K+P where P is the number of columns in the +** PRIMARY KEY of the table. The covering index that implements the +** original WITHOUT ROWID table as N==K as a special case. +** +** This routine allocates the StatAccum object in heap memory. The return +** value is a pointer to the StatAccum object. The datatype of the +** return value is BLOB, but it is really just a pointer to the StatAccum +** object. +*/ +static void statInit( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + StatAccum *p; + int nCol; /* Number of columns in index being sampled */ + int nKeyCol; /* Number of key columns */ + int nColUp; /* nCol rounded up for alignment */ + int n; /* Bytes of space to allocate */ + sqlite3 *db = sqlite3_context_db_handle(context); /* Database connection */ +#ifdef SQLITE_ENABLE_STAT4 + /* Maximum number of samples. 0 if STAT4 data is not collected */ + int mxSample = OptimizationEnabled(db,SQLITE_Stat4) ?SQLITE_STAT4_SAMPLES :0; +#endif + + /* Decode the three function arguments */ + UNUSED_PARAMETER(argc); + nCol = sqlite3_value_int(argv[0]); + assert( nCol>0 ); + nColUp = sizeof(tRowcnt)<8 ? (nCol+1)&~1 : nCol; + nKeyCol = sqlite3_value_int(argv[1]); + assert( nKeyCol<=nCol ); + assert( nKeyCol>0 ); + + /* Allocate the space required for the StatAccum object */ + n = sizeof(*p) + + sizeof(tRowcnt)*nColUp /* StatAccum.anEq */ + + sizeof(tRowcnt)*nColUp; /* StatAccum.anDLt */ +#ifdef SQLITE_ENABLE_STAT4 + if( mxSample ){ + n += sizeof(tRowcnt)*nColUp /* StatAccum.anLt */ + + sizeof(StatSample)*(nCol+mxSample) /* StatAccum.aBest[], a[] */ + + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample); + } +#endif + db = sqlite3_context_db_handle(context); + p = sqlite3DbMallocZero(db, n); + if( p==0 ){ + sqlite3_result_error_nomem(context); + return; + } + + p->db = db; + p->nEst = sqlite3_value_int64(argv[2]); + p->nRow = 0; + p->nLimit = sqlite3_value_int64(argv[3]); + p->nCol = nCol; + p->nKeyCol = nKeyCol; + p->nSkipAhead = 0; + p->current.anDLt = (tRowcnt*)&p[1]; + p->current.anEq = &p->current.anDLt[nColUp]; + +#ifdef SQLITE_ENABLE_STAT4 + p->mxSample = p->nLimit==0 ? mxSample : 0; + if( mxSample ){ + u8 *pSpace; /* Allocated space not yet assigned */ + int i; /* Used to iterate through p->aSample[] */ + + p->iGet = -1; + p->nPSample = (tRowcnt)(p->nEst/(mxSample/3+1) + 1); + p->current.anLt = &p->current.anEq[nColUp]; + p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]); + + /* Set up the StatAccum.a[] and aBest[] arrays */ + p->a = (struct StatSample*)&p->current.anLt[nColUp]; + p->aBest = &p->a[mxSample]; + pSpace = (u8*)(&p->a[mxSample+nCol]); + for(i=0; i<(mxSample+nCol); i++){ + p->a[i].anEq = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp); + p->a[i].anLt = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp); + p->a[i].anDLt = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp); + } + assert( (pSpace - (u8*)p)==n ); + + for(i=0; iaBest[i].iCol = i; + } + } +#endif + + /* Return a pointer to the allocated object to the caller. Note that + ** only the pointer (the 2nd parameter) matters. The size of the object + ** (given by the 3rd parameter) is never used and can be any positive + ** value. */ + sqlite3_result_blob(context, p, sizeof(*p), statAccumDestructor); +} +static const FuncDef statInitFuncdef = { + 4, /* nArg */ + SQLITE_UTF8, /* funcFlags */ + 0, /* pUserData */ + 0, /* pNext */ + statInit, /* xSFunc */ + 0, /* xFinalize */ + 0, 0, /* xValue, xInverse */ + "stat_init", /* zName */ + {0} +}; + +#ifdef SQLITE_ENABLE_STAT4 +/* +** pNew and pOld are both candidate non-periodic samples selected for +** the same column (pNew->iCol==pOld->iCol). Ignoring this column and +** considering only any trailing columns and the sample hash value, this +** function returns true if sample pNew is to be preferred over pOld. +** In other words, if we assume that the cardinalities of the selected +** column for pNew and pOld are equal, is pNew to be preferred over pOld. +** +** This function assumes that for each argument sample, the contents of +** the anEq[] array from pSample->anEq[pSample->iCol+1] onwards are valid. +*/ +static int sampleIsBetterPost( + StatAccum *pAccum, + StatSample *pNew, + StatSample *pOld +){ + int nCol = pAccum->nCol; + int i; + assert( pNew->iCol==pOld->iCol ); + for(i=pNew->iCol+1; ianEq[i]>pOld->anEq[i] ) return 1; + if( pNew->anEq[i]anEq[i] ) return 0; + } + if( pNew->iHash>pOld->iHash ) return 1; + return 0; +} +#endif + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Return true if pNew is to be preferred over pOld. +** +** This function assumes that for each argument sample, the contents of +** the anEq[] array from pSample->anEq[pSample->iCol] onwards are valid. +*/ +static int sampleIsBetter( + StatAccum *pAccum, + StatSample *pNew, + StatSample *pOld +){ + tRowcnt nEqNew = pNew->anEq[pNew->iCol]; + tRowcnt nEqOld = pOld->anEq[pOld->iCol]; + + assert( pOld->isPSample==0 && pNew->isPSample==0 ); + assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) ); + + if( (nEqNew>nEqOld) ) return 1; + if( nEqNew==nEqOld ){ + if( pNew->iColiCol ) return 1; + return (pNew->iCol==pOld->iCol && sampleIsBetterPost(pAccum, pNew, pOld)); + } + return 0; +} + +/* +** Copy the contents of sample *pNew into the p->a[] array. If necessary, +** remove the least desirable sample from p->a[] to make room. +*/ +static void sampleInsert(StatAccum *p, StatSample *pNew, int nEqZero){ + StatSample *pSample = 0; + int i; + + assert( IsStat4 || nEqZero==0 ); + + /* StatAccum.nMaxEqZero is set to the maximum number of leading 0 + ** values in the anEq[] array of any sample in StatAccum.a[]. In + ** other words, if nMaxEqZero is n, then it is guaranteed that there + ** are no samples with StatSample.anEq[m]==0 for (m>=n). */ + if( nEqZero>p->nMaxEqZero ){ + p->nMaxEqZero = nEqZero; + } + if( pNew->isPSample==0 ){ + StatSample *pUpgrade = 0; + assert( pNew->anEq[pNew->iCol]>0 ); + + /* This sample is being added because the prefix that ends in column + ** iCol occurs many times in the table. However, if we have already + ** added a sample that shares this prefix, there is no need to add + ** this one. Instead, upgrade the priority of the highest priority + ** existing sample that shares this prefix. */ + for(i=p->nSample-1; i>=0; i--){ + StatSample *pOld = &p->a[i]; + if( pOld->anEq[pNew->iCol]==0 ){ + if( pOld->isPSample ) return; + assert( pOld->iCol>pNew->iCol ); + assert( sampleIsBetter(p, pNew, pOld) ); + if( pUpgrade==0 || sampleIsBetter(p, pOld, pUpgrade) ){ + pUpgrade = pOld; + } + } + } + if( pUpgrade ){ + pUpgrade->iCol = pNew->iCol; + pUpgrade->anEq[pUpgrade->iCol] = pNew->anEq[pUpgrade->iCol]; + goto find_new_min; + } + } + + /* If necessary, remove sample iMin to make room for the new sample. */ + if( p->nSample>=p->mxSample ){ + StatSample *pMin = &p->a[p->iMin]; + tRowcnt *anEq = pMin->anEq; + tRowcnt *anLt = pMin->anLt; + tRowcnt *anDLt = pMin->anDLt; + sampleClear(p->db, pMin); + memmove(pMin, &pMin[1], sizeof(p->a[0])*(p->nSample-p->iMin-1)); + pSample = &p->a[p->nSample-1]; + pSample->nRowid = 0; + pSample->anEq = anEq; + pSample->anDLt = anDLt; + pSample->anLt = anLt; + p->nSample = p->mxSample-1; + } + + /* The "rows less-than" for the rowid column must be greater than that + ** for the last sample in the p->a[] array. Otherwise, the samples would + ** be out of order. */ + assert( p->nSample==0 + || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] ); + + /* Insert the new sample */ + pSample = &p->a[p->nSample]; + sampleCopy(p, pSample, pNew); + p->nSample++; + + /* Zero the first nEqZero entries in the anEq[] array. */ + memset(pSample->anEq, 0, sizeof(tRowcnt)*nEqZero); + +find_new_min: + if( p->nSample>=p->mxSample ){ + int iMin = -1; + for(i=0; imxSample; i++){ + if( p->a[i].isPSample ) continue; + if( iMin<0 || sampleIsBetter(p, &p->a[iMin], &p->a[i]) ){ + iMin = i; + } + } + assert( iMin>=0 ); + p->iMin = iMin; + } +} +#endif /* SQLITE_ENABLE_STAT4 */ + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Field iChng of the index being scanned has changed. So at this point +** p->current contains a sample that reflects the previous row of the +** index. The value of anEq[iChng] and subsequent anEq[] elements are +** correct at this point. +*/ +static void samplePushPrevious(StatAccum *p, int iChng){ + int i; + + /* Check if any samples from the aBest[] array should be pushed + ** into IndexSample.a[] at this point. */ + for(i=(p->nCol-2); i>=iChng; i--){ + StatSample *pBest = &p->aBest[i]; + pBest->anEq[i] = p->current.anEq[i]; + if( p->nSamplemxSample || sampleIsBetter(p, pBest, &p->a[p->iMin]) ){ + sampleInsert(p, pBest, i); + } + } + + /* Check that no sample contains an anEq[] entry with an index of + ** p->nMaxEqZero or greater set to zero. */ + for(i=p->nSample-1; i>=0; i--){ + int j; + for(j=p->nMaxEqZero; jnCol; j++) assert( p->a[i].anEq[j]>0 ); + } + + /* Update the anEq[] fields of any samples already collected. */ + if( iChngnMaxEqZero ){ + for(i=p->nSample-1; i>=0; i--){ + int j; + for(j=iChng; jnCol; j++){ + if( p->a[i].anEq[j]==0 ) p->a[i].anEq[j] = p->current.anEq[j]; + } + } + p->nMaxEqZero = iChng; + } +} +#endif /* SQLITE_ENABLE_STAT4 */ + +/* +** Implementation of the stat_push SQL function: stat_push(P,C,R) +** Arguments: +** +** P Pointer to the StatAccum object created by stat_init() +** C Index of left-most column to differ from previous row +** R Rowid for the current row. Might be a key record for +** WITHOUT ROWID tables. +** +** The purpose of this routine is to collect statistical data and/or +** samples from the index being analyzed into the StatAccum object. +** The stat_get() SQL function will be used afterwards to +** retrieve the information gathered. +** +** This SQL function usually returns NULL, but might return an integer +** if it wants the byte-code to do special processing. +** +** The R parameter is only used for STAT4 +*/ +static void statPush( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int i; + + /* The three function arguments */ + StatAccum *p = (StatAccum*)sqlite3_value_blob(argv[0]); + int iChng = sqlite3_value_int(argv[1]); + + UNUSED_PARAMETER( argc ); + UNUSED_PARAMETER( context ); + assert( p->nCol>0 ); + assert( iChngnCol ); + + if( p->nRow==0 ){ + /* This is the first call to this function. Do initialization. */ + for(i=0; inCol; i++) p->current.anEq[i] = 1; + }else{ + /* Second and subsequent calls get processed here */ +#ifdef SQLITE_ENABLE_STAT4 + if( p->mxSample ) samplePushPrevious(p, iChng); +#endif + + /* Update anDLt[], anLt[] and anEq[] to reflect the values that apply + ** to the current row of the index. */ + for(i=0; icurrent.anEq[i]++; + } + for(i=iChng; inCol; i++){ + p->current.anDLt[i]++; +#ifdef SQLITE_ENABLE_STAT4 + if( p->mxSample ) p->current.anLt[i] += p->current.anEq[i]; +#endif + p->current.anEq[i] = 1; + } + } + + p->nRow++; +#ifdef SQLITE_ENABLE_STAT4 + if( p->mxSample ){ + tRowcnt nLt; + if( sqlite3_value_type(argv[2])==SQLITE_INTEGER ){ + sampleSetRowidInt64(p->db, &p->current, sqlite3_value_int64(argv[2])); + }else{ + sampleSetRowid(p->db, &p->current, sqlite3_value_bytes(argv[2]), + sqlite3_value_blob(argv[2])); + } + p->current.iHash = p->iPrn = p->iPrn*1103515245 + 12345; + + nLt = p->current.anLt[p->nCol-1]; + /* Check if this is to be a periodic sample. If so, add it. */ + if( (nLt/p->nPSample)!=(nLt+1)/p->nPSample ){ + p->current.isPSample = 1; + p->current.iCol = 0; + sampleInsert(p, &p->current, p->nCol-1); + p->current.isPSample = 0; + } + + /* Update the aBest[] array. */ + for(i=0; i<(p->nCol-1); i++){ + p->current.iCol = i; + if( i>=iChng || sampleIsBetterPost(p, &p->current, &p->aBest[i]) ){ + sampleCopy(p, &p->aBest[i], &p->current); + } + } + }else +#endif + if( p->nLimit && p->nRow>(tRowcnt)p->nLimit*(p->nSkipAhead+1) ){ + p->nSkipAhead++; + sqlite3_result_int(context, p->current.anDLt[0]>0); + } +} + +static const FuncDef statPushFuncdef = { + 2+IsStat4, /* nArg */ + SQLITE_UTF8, /* funcFlags */ + 0, /* pUserData */ + 0, /* pNext */ + statPush, /* xSFunc */ + 0, /* xFinalize */ + 0, 0, /* xValue, xInverse */ + "stat_push", /* zName */ + {0} +}; + +#define STAT_GET_STAT1 0 /* "stat" column of stat1 table */ +#define STAT_GET_ROWID 1 /* "rowid" column of stat[34] entry */ +#define STAT_GET_NEQ 2 /* "neq" column of stat[34] entry */ +#define STAT_GET_NLT 3 /* "nlt" column of stat[34] entry */ +#define STAT_GET_NDLT 4 /* "ndlt" column of stat[34] entry */ + +/* +** Implementation of the stat_get(P,J) SQL function. This routine is +** used to query statistical information that has been gathered into +** the StatAccum object by prior calls to stat_push(). The P parameter +** has type BLOB but it is really just a pointer to the StatAccum object. +** The content to returned is determined by the parameter J +** which is one of the STAT_GET_xxxx values defined above. +** +** The stat_get(P,J) function is not available to generic SQL. It is +** inserted as part of a manually constructed bytecode program. (See +** the callStatGet() routine below.) It is guaranteed that the P +** parameter will always be a pointer to a StatAccum object, never a +** NULL. +** +** If STAT4 is not enabled, then J is always +** STAT_GET_STAT1 and is hence omitted and this routine becomes +** a one-parameter function, stat_get(P), that always returns the +** stat1 table entry information. +*/ +static void statGet( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + StatAccum *p = (StatAccum*)sqlite3_value_blob(argv[0]); +#ifdef SQLITE_ENABLE_STAT4 + /* STAT4 has a parameter on this routine. */ + int eCall = sqlite3_value_int(argv[1]); + assert( argc==2 ); + assert( eCall==STAT_GET_STAT1 || eCall==STAT_GET_NEQ + || eCall==STAT_GET_ROWID || eCall==STAT_GET_NLT + || eCall==STAT_GET_NDLT + ); + assert( eCall==STAT_GET_STAT1 || p->mxSample ); + if( eCall==STAT_GET_STAT1 ) +#else + assert( argc==1 ); +#endif + { + /* Return the value to store in the "stat" column of the sqlite_stat1 + ** table for this index. + ** + ** The value is a string composed of a list of integers describing + ** the index. The first integer in the list is the total number of + ** entries in the index. There is one additional integer in the list + ** for each indexed column. This additional integer is an estimate of + ** the number of rows matched by a equality query on the index using + ** a key with the corresponding number of fields. In other words, + ** if the index is on columns (a,b) and the sqlite_stat1 value is + ** "100 10 2", then SQLite estimates that: + ** + ** * the index contains 100 rows, + ** * "WHERE a=?" matches 10 rows, and + ** * "WHERE a=? AND b=?" matches 2 rows. + ** + ** If D is the count of distinct values and K is the total number of + ** rows, then each estimate is computed as: + ** + ** I = (K+D-1)/D + */ + char *z; + int i; + + char *zRet = sqlite3MallocZero( (p->nKeyCol+1)*25 ); + if( zRet==0 ){ + sqlite3_result_error_nomem(context); + return; + } + + sqlite3_snprintf(24, zRet, "%llu", + p->nSkipAhead ? (u64)p->nEst : (u64)p->nRow); + z = zRet + sqlite3Strlen30(zRet); + for(i=0; inKeyCol; i++){ + u64 nDistinct = p->current.anDLt[i] + 1; + u64 iVal = (p->nRow + nDistinct - 1) / nDistinct; + sqlite3_snprintf(24, z, " %llu", iVal); + z += sqlite3Strlen30(z); + assert( p->current.anEq[i] ); + } + assert( z[0]=='\0' && z>zRet ); + + sqlite3_result_text(context, zRet, -1, sqlite3_free); + } +#ifdef SQLITE_ENABLE_STAT4 + else if( eCall==STAT_GET_ROWID ){ + if( p->iGet<0 ){ + samplePushPrevious(p, 0); + p->iGet = 0; + } + if( p->iGetnSample ){ + StatSample *pS = p->a + p->iGet; + if( pS->nRowid==0 ){ + sqlite3_result_int64(context, pS->u.iRowid); + }else{ + sqlite3_result_blob(context, pS->u.aRowid, pS->nRowid, + SQLITE_TRANSIENT); + } + } + }else{ + tRowcnt *aCnt = 0; + + assert( p->iGetnSample ); + switch( eCall ){ + case STAT_GET_NEQ: aCnt = p->a[p->iGet].anEq; break; + case STAT_GET_NLT: aCnt = p->a[p->iGet].anLt; break; + default: { + aCnt = p->a[p->iGet].anDLt; + p->iGet++; + break; + } + } + + { + char *zRet = sqlite3MallocZero(p->nCol * 25); + if( zRet==0 ){ + sqlite3_result_error_nomem(context); + }else{ + int i; + char *z = zRet; + for(i=0; inCol; i++){ + sqlite3_snprintf(24, z, "%llu ", (u64)aCnt[i]); + z += sqlite3Strlen30(z); + } + assert( z[0]=='\0' && z>zRet ); + z[-1] = '\0'; + sqlite3_result_text(context, zRet, -1, sqlite3_free); + } + } + } +#endif /* SQLITE_ENABLE_STAT4 */ +#ifndef SQLITE_DEBUG + UNUSED_PARAMETER( argc ); +#endif +} +static const FuncDef statGetFuncdef = { + 1+IsStat4, /* nArg */ + SQLITE_UTF8, /* funcFlags */ + 0, /* pUserData */ + 0, /* pNext */ + statGet, /* xSFunc */ + 0, /* xFinalize */ + 0, 0, /* xValue, xInverse */ + "stat_get", /* zName */ + {0} +}; + +static void callStatGet(Parse *pParse, int regStat, int iParam, int regOut){ +#ifdef SQLITE_ENABLE_STAT4 + sqlite3VdbeAddOp2(pParse->pVdbe, OP_Integer, iParam, regStat+1); +#elif SQLITE_DEBUG + assert( iParam==STAT_GET_STAT1 ); +#else + UNUSED_PARAMETER( iParam ); +#endif + assert( regOut!=regStat && regOut!=regStat+1 ); + sqlite3VdbeAddFunctionCall(pParse, 0, regStat, regOut, 1+IsStat4, + &statGetFuncdef, 0); +} + +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS +/* Add a comment to the most recent VDBE opcode that is the name +** of the k-th column of the pIdx index. +*/ +static void analyzeVdbeCommentIndexWithColumnName( + Vdbe *v, /* Prepared statement under construction */ + Index *pIdx, /* Index whose column is being loaded */ + int k /* Which column index */ +){ + int i; /* Index of column in the table */ + assert( k>=0 && knColumn ); + i = pIdx->aiColumn[k]; + if( NEVER(i==XN_ROWID) ){ + VdbeComment((v,"%s.rowid",pIdx->zName)); + }else if( i==XN_EXPR ){ + VdbeComment((v,"%s.expr(%d)",pIdx->zName, k)); + }else{ + VdbeComment((v,"%s.%s", pIdx->zName, pIdx->pTable->aCol[i].zName)); + } +} +#else +# define analyzeVdbeCommentIndexWithColumnName(a,b,c) +#endif /* SQLITE_DEBUG */ + +/* +** Generate code to do an analysis of all indices associated with +** a single table. +*/ +static void analyzeOneTable( + Parse *pParse, /* Parser context */ + Table *pTab, /* Table whose indices are to be analyzed */ + Index *pOnlyIdx, /* If not NULL, only analyze this one index */ + int iStatCur, /* Index of VdbeCursor that writes the sqlite_stat1 table */ + int iMem, /* Available memory locations begin here */ + int iTab /* Next available cursor */ +){ + sqlite3 *db = pParse->db; /* Database handle */ + Index *pIdx; /* An index to being analyzed */ + int iIdxCur; /* Cursor open on index being analyzed */ + int iTabCur; /* Table cursor */ + Vdbe *v; /* The virtual machine being built up */ + int i; /* Loop counter */ + int jZeroRows = -1; /* Jump from here if number of rows is zero */ + int iDb; /* Index of database containing pTab */ + u8 needTableCnt = 1; /* True to count the table */ + int regNewRowid = iMem++; /* Rowid for the inserted record */ + int regStat = iMem++; /* Register to hold StatAccum object */ + int regChng = iMem++; /* Index of changed index field */ + int regRowid = iMem++; /* Rowid argument passed to stat_push() */ + int regTemp = iMem++; /* Temporary use register */ + int regTemp2 = iMem++; /* Second temporary use register */ + int regTabname = iMem++; /* Register containing table name */ + int regIdxname = iMem++; /* Register containing index name */ + int regStat1 = iMem++; /* Value for the stat column of sqlite_stat1 */ + int regPrev = iMem; /* MUST BE LAST (see below) */ +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + Table *pStat1 = 0; +#endif + + pParse->nMem = MAX(pParse->nMem, iMem); + v = sqlite3GetVdbe(pParse); + if( v==0 || NEVER(pTab==0) ){ + return; + } + if( pTab->tnum==0 ){ + /* Do not gather statistics on views or virtual tables */ + return; + } + if( sqlite3_strlike("sqlite\\_%", pTab->zName, '\\')==0 ){ + /* Do not gather statistics on system tables */ + return; + } + assert( sqlite3BtreeHoldsAllMutexes(db) ); + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDb>=0 ); + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); +#ifndef SQLITE_OMIT_AUTHORIZATION + if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0, + db->aDb[iDb].zDbSName ) ){ + return; + } +#endif + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + if( db->xPreUpdateCallback ){ + pStat1 = (Table*)sqlite3DbMallocZero(db, sizeof(Table) + 13); + if( pStat1==0 ) return; + pStat1->zName = (char*)&pStat1[1]; + memcpy(pStat1->zName, "sqlite_stat1", 13); + pStat1->nCol = 3; + pStat1->iPKey = -1; + sqlite3VdbeAddOp4(pParse->pVdbe, OP_Noop, 0, 0, 0,(char*)pStat1,P4_DYNBLOB); + } +#endif + + /* Establish a read-lock on the table at the shared-cache level. + ** Open a read-only cursor on the table. Also allocate a cursor number + ** to use for scanning indexes (iIdxCur). No index cursor is opened at + ** this time though. */ + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + iTabCur = iTab++; + iIdxCur = iTab++; + pParse->nTab = MAX(pParse->nTab, iTab); + sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead); + sqlite3VdbeLoadString(v, regTabname, pTab->zName); + + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int nCol; /* Number of columns in pIdx. "N" */ + int addrRewind; /* Address of "OP_Rewind iIdxCur" */ + int addrNextRow; /* Address of "next_row:" */ + const char *zIdxName; /* Name of the index */ + int nColTest; /* Number of columns to test for changes */ + + if( pOnlyIdx && pOnlyIdx!=pIdx ) continue; + if( pIdx->pPartIdxWhere==0 ) needTableCnt = 0; + if( !HasRowid(pTab) && IsPrimaryKeyIndex(pIdx) ){ + nCol = pIdx->nKeyCol; + zIdxName = pTab->zName; + nColTest = nCol - 1; + }else{ + nCol = pIdx->nColumn; + zIdxName = pIdx->zName; + nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1; + } + + /* Populate the register containing the index name. */ + sqlite3VdbeLoadString(v, regIdxname, zIdxName); + VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName)); + + /* + ** Pseudo-code for loop that calls stat_push(): + ** + ** Rewind csr + ** if eof(csr) goto end_of_scan; + ** regChng = 0 + ** goto chng_addr_0; + ** + ** next_row: + ** regChng = 0 + ** if( idx(0) != regPrev(0) ) goto chng_addr_0 + ** regChng = 1 + ** if( idx(1) != regPrev(1) ) goto chng_addr_1 + ** ... + ** regChng = N + ** goto chng_addr_N + ** + ** chng_addr_0: + ** regPrev(0) = idx(0) + ** chng_addr_1: + ** regPrev(1) = idx(1) + ** ... + ** + ** endDistinctTest: + ** regRowid = idx(rowid) + ** stat_push(P, regChng, regRowid) + ** Next csr + ** if !eof(csr) goto next_row; + ** + ** end_of_scan: + */ + + /* Make sure there are enough memory cells allocated to accommodate + ** the regPrev array and a trailing rowid (the rowid slot is required + ** when building a record to insert into the sample column of + ** the sqlite_stat4 table. */ + pParse->nMem = MAX(pParse->nMem, regPrev+nColTest); + + /* Open a read-only cursor on the index being analyzed. */ + assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) ); + sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + VdbeComment((v, "%s", pIdx->zName)); + + /* Invoke the stat_init() function. The arguments are: + ** + ** (1) the number of columns in the index including the rowid + ** (or for a WITHOUT ROWID table, the number of PK columns), + ** (2) the number of columns in the key without the rowid/pk + ** (3) estimated number of rows in the index, + */ + sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat+1); + assert( regRowid==regStat+2 ); + sqlite3VdbeAddOp2(v, OP_Integer, pIdx->nKeyCol, regRowid); +#ifdef SQLITE_ENABLE_STAT4 + if( OptimizationEnabled(db, SQLITE_Stat4) ){ + sqlite3VdbeAddOp2(v, OP_Count, iIdxCur, regTemp); + addrRewind = sqlite3VdbeAddOp1(v, OP_Rewind, iIdxCur); + VdbeCoverage(v); + }else +#endif + { + addrRewind = sqlite3VdbeAddOp1(v, OP_Rewind, iIdxCur); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_Count, iIdxCur, regTemp, 1); + } + assert( regTemp2==regStat+4 ); + sqlite3VdbeAddOp2(v, OP_Integer, db->nAnalysisLimit, regTemp2); + sqlite3VdbeAddFunctionCall(pParse, 0, regStat+1, regStat, 4, + &statInitFuncdef, 0); + + /* Implementation of the following: + ** + ** Rewind csr + ** if eof(csr) goto end_of_scan; + ** regChng = 0 + ** goto next_push_0; + ** + */ + sqlite3VdbeAddOp2(v, OP_Integer, 0, regChng); + addrNextRow = sqlite3VdbeCurrentAddr(v); + + if( nColTest>0 ){ + int endDistinctTest = sqlite3VdbeMakeLabel(pParse); + int *aGotoChng; /* Array of jump instruction addresses */ + aGotoChng = sqlite3DbMallocRawNN(db, sizeof(int)*nColTest); + if( aGotoChng==0 ) continue; + + /* + ** next_row: + ** regChng = 0 + ** if( idx(0) != regPrev(0) ) goto chng_addr_0 + ** regChng = 1 + ** if( idx(1) != regPrev(1) ) goto chng_addr_1 + ** ... + ** regChng = N + ** goto endDistinctTest + */ + sqlite3VdbeAddOp0(v, OP_Goto); + addrNextRow = sqlite3VdbeCurrentAddr(v); + if( nColTest==1 && pIdx->nKeyCol==1 && IsUniqueIndex(pIdx) ){ + /* For a single-column UNIQUE index, once we have found a non-NULL + ** row, we know that all the rest will be distinct, so skip + ** subsequent distinctness tests. */ + sqlite3VdbeAddOp2(v, OP_NotNull, regPrev, endDistinctTest); + VdbeCoverage(v); + } + for(i=0; iazColl[i]); + sqlite3VdbeAddOp2(v, OP_Integer, i, regChng); + sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, regTemp); + analyzeVdbeCommentIndexWithColumnName(v,pIdx,i); + aGotoChng[i] = + sqlite3VdbeAddOp4(v, OP_Ne, regTemp, 0, regPrev+i, pColl, P4_COLLSEQ); + sqlite3VdbeChangeP5(v, SQLITE_NULLEQ); + VdbeCoverage(v); + } + sqlite3VdbeAddOp2(v, OP_Integer, nColTest, regChng); + sqlite3VdbeGoto(v, endDistinctTest); + + + /* + ** chng_addr_0: + ** regPrev(0) = idx(0) + ** chng_addr_1: + ** regPrev(1) = idx(1) + ** ... + */ + sqlite3VdbeJumpHere(v, addrNextRow-1); + for(i=0; ipTable); + int j, k, regKey; + regKey = sqlite3GetTempRange(pParse, pPk->nKeyCol); + for(j=0; jnKeyCol; j++){ + k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[j]); + assert( k>=0 && knColumn ); + sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, regKey+j); + analyzeVdbeCommentIndexWithColumnName(v,pIdx,k); + } + sqlite3VdbeAddOp3(v, OP_MakeRecord, regKey, pPk->nKeyCol, regRowid); + sqlite3ReleaseTempRange(pParse, regKey, pPk->nKeyCol); + } + } +#endif + assert( regChng==(regStat+1) ); + { + sqlite3VdbeAddFunctionCall(pParse, 1, regStat, regTemp, 2+IsStat4, + &statPushFuncdef, 0); + if( db->nAnalysisLimit ){ + int j1, j2, j3; + j1 = sqlite3VdbeAddOp1(v, OP_IsNull, regTemp); VdbeCoverage(v); + j2 = sqlite3VdbeAddOp1(v, OP_If, regTemp); VdbeCoverage(v); + j3 = sqlite3VdbeAddOp4Int(v, OP_SeekGT, iIdxCur, 0, regPrev, 1); + VdbeCoverage(v); + sqlite3VdbeJumpHere(v, j1); + sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, addrNextRow); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, j2); + sqlite3VdbeJumpHere(v, j3); + }else{ + sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, addrNextRow); VdbeCoverage(v); + } + } + + /* Add the entry to the stat1 table. */ + callStatGet(pParse, regStat, STAT_GET_STAT1, regStat1); + assert( "BBB"[0]==SQLITE_AFF_TEXT ); + sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regTemp, "BBB", 0); + sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid); + sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regTemp, regNewRowid); +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + sqlite3VdbeChangeP4(v, -1, (char*)pStat1, P4_TABLE); +#endif + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + + /* Add the entries to the stat4 table. */ +#ifdef SQLITE_ENABLE_STAT4 + if( OptimizationEnabled(db, SQLITE_Stat4) && db->nAnalysisLimit==0 ){ + int regEq = regStat1; + int regLt = regStat1+1; + int regDLt = regStat1+2; + int regSample = regStat1+3; + int regCol = regStat1+4; + int regSampleRowid = regCol + nCol; + int addrNext; + int addrIsNull; + u8 seekOp = HasRowid(pTab) ? OP_NotExists : OP_NotFound; + + pParse->nMem = MAX(pParse->nMem, regCol+nCol); + + addrNext = sqlite3VdbeCurrentAddr(v); + callStatGet(pParse, regStat, STAT_GET_ROWID, regSampleRowid); + addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, regSampleRowid); + VdbeCoverage(v); + callStatGet(pParse, regStat, STAT_GET_NEQ, regEq); + callStatGet(pParse, regStat, STAT_GET_NLT, regLt); + callStatGet(pParse, regStat, STAT_GET_NDLT, regDLt); + sqlite3VdbeAddOp4Int(v, seekOp, iTabCur, addrNext, regSampleRowid, 0); + VdbeCoverage(v); + for(i=0; izName)); + sqlite3VdbeAddOp2(v, OP_Count, iTabCur, regStat1); + jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, regStat1); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Null, 0, regIdxname); + assert( "BBB"[0]==SQLITE_AFF_TEXT ); + sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regTemp, "BBB", 0); + sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid); + sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regTemp, regNewRowid); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + sqlite3VdbeChangeP4(v, -1, (char*)pStat1, P4_TABLE); +#endif + sqlite3VdbeJumpHere(v, jZeroRows); + } +} + + +/* +** Generate code that will cause the most recent index analysis to +** be loaded into internal hash tables where is can be used. +*/ +static void loadAnalysis(Parse *pParse, int iDb){ + Vdbe *v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb); + } +} + +/* +** Generate code that will do an analysis of an entire database +*/ +static void analyzeDatabase(Parse *pParse, int iDb){ + sqlite3 *db = pParse->db; + Schema *pSchema = db->aDb[iDb].pSchema; /* Schema of database iDb */ + HashElem *k; + int iStatCur; + int iMem; + int iTab; + + sqlite3BeginWriteOperation(pParse, 0, iDb); + iStatCur = pParse->nTab; + pParse->nTab += 3; + openStatTable(pParse, iDb, iStatCur, 0, 0); + iMem = pParse->nMem+1; + iTab = pParse->nTab; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){ + Table *pTab = (Table*)sqliteHashData(k); + analyzeOneTable(pParse, pTab, 0, iStatCur, iMem, iTab); + } + loadAnalysis(pParse, iDb); +} + +/* +** Generate code that will do an analysis of a single table in +** a database. If pOnlyIdx is not NULL then it is a single index +** in pTab that should be analyzed. +*/ +static void analyzeTable(Parse *pParse, Table *pTab, Index *pOnlyIdx){ + int iDb; + int iStatCur; + + assert( pTab!=0 ); + assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + sqlite3BeginWriteOperation(pParse, 0, iDb); + iStatCur = pParse->nTab; + pParse->nTab += 3; + if( pOnlyIdx ){ + openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx"); + }else{ + openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl"); + } + analyzeOneTable(pParse, pTab, pOnlyIdx, iStatCur,pParse->nMem+1,pParse->nTab); + loadAnalysis(pParse, iDb); +} + +/* +** Generate code for the ANALYZE command. The parser calls this routine +** when it recognizes an ANALYZE command. +** +** ANALYZE -- 1 +** ANALYZE -- 2 +** ANALYZE ?.? -- 3 +** +** Form 1 causes all indices in all attached databases to be analyzed. +** Form 2 analyzes all indices the single database named. +** Form 3 analyzes all indices associated with the named table. +*/ +SQLITE_PRIVATE void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){ + sqlite3 *db = pParse->db; + int iDb; + int i; + char *z, *zDb; + Table *pTab; + Index *pIdx; + Token *pTableName; + Vdbe *v; + + /* Read the database schema. If an error occurs, leave an error message + ** and code in pParse and return NULL. */ + assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + return; + } + + assert( pName2!=0 || pName1==0 ); + if( pName1==0 ){ + /* Form 1: Analyze everything */ + for(i=0; inDb; i++){ + if( i==1 ) continue; /* Do not analyze the TEMP database */ + analyzeDatabase(pParse, i); + } + }else if( pName2->n==0 && (iDb = sqlite3FindDb(db, pName1))>=0 ){ + /* Analyze the schema named as the argument */ + analyzeDatabase(pParse, iDb); + }else{ + /* Form 3: Analyze the table or index named as an argument */ + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName); + if( iDb>=0 ){ + zDb = pName2->n ? db->aDb[iDb].zDbSName : 0; + z = sqlite3NameFromToken(db, pTableName); + if( z ){ + if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){ + analyzeTable(pParse, pIdx->pTable, pIdx); + }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){ + analyzeTable(pParse, pTab, 0); + } + sqlite3DbFree(db, z); + } + } + } + if( db->nSqlExec==0 && (v = sqlite3GetVdbe(pParse))!=0 ){ + sqlite3VdbeAddOp0(v, OP_Expire); + } +} + +/* +** Used to pass information from the analyzer reader through to the +** callback routine. +*/ +typedef struct analysisInfo analysisInfo; +struct analysisInfo { + sqlite3 *db; + const char *zDatabase; +}; + +/* +** The first argument points to a nul-terminated string containing a +** list of space separated integers. Read the first nOut of these into +** the array aOut[]. +*/ +static void decodeIntArray( + char *zIntArray, /* String containing int array to decode */ + int nOut, /* Number of slots in aOut[] */ + tRowcnt *aOut, /* Store integers here */ + LogEst *aLog, /* Or, if aOut==0, here */ + Index *pIndex /* Handle extra flags for this index, if not NULL */ +){ + char *z = zIntArray; + int c; + int i; + tRowcnt v; + +#ifdef SQLITE_ENABLE_STAT4 + if( z==0 ) z = ""; +#else + assert( z!=0 ); +#endif + for(i=0; *z && i='0' && c<='9' ){ + v = v*10 + c - '0'; + z++; + } +#ifdef SQLITE_ENABLE_STAT4 + if( aOut ) aOut[i] = v; + if( aLog ) aLog[i] = sqlite3LogEst(v); +#else + assert( aOut==0 ); + UNUSED_PARAMETER(aOut); + assert( aLog!=0 ); + aLog[i] = sqlite3LogEst(v); +#endif + if( *z==' ' ) z++; + } +#ifndef SQLITE_ENABLE_STAT4 + assert( pIndex!=0 ); { +#else + if( pIndex ){ +#endif + pIndex->bUnordered = 0; + pIndex->noSkipScan = 0; + while( z[0] ){ + if( sqlite3_strglob("unordered*", z)==0 ){ + pIndex->bUnordered = 1; + }else if( sqlite3_strglob("sz=[0-9]*", z)==0 ){ + int sz = sqlite3Atoi(z+3); + if( sz<2 ) sz = 2; + pIndex->szIdxRow = sqlite3LogEst(sz); + }else if( sqlite3_strglob("noskipscan*", z)==0 ){ + pIndex->noSkipScan = 1; + } +#ifdef SQLITE_ENABLE_COSTMULT + else if( sqlite3_strglob("costmult=[0-9]*",z)==0 ){ + pIndex->pTable->costMult = sqlite3LogEst(sqlite3Atoi(z+9)); + } +#endif + while( z[0]!=0 && z[0]!=' ' ) z++; + while( z[0]==' ' ) z++; + } + } +} + +/* +** This callback is invoked once for each index when reading the +** sqlite_stat1 table. +** +** argv[0] = name of the table +** argv[1] = name of the index (might be NULL) +** argv[2] = results of analysis - on integer for each column +** +** Entries for which argv[1]==NULL simply record the number of rows in +** the table. +*/ +static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){ + analysisInfo *pInfo = (analysisInfo*)pData; + Index *pIndex; + Table *pTable; + const char *z; + + assert( argc==3 ); + UNUSED_PARAMETER2(NotUsed, argc); + + if( argv==0 || argv[0]==0 || argv[2]==0 ){ + return 0; + } + pTable = sqlite3FindTable(pInfo->db, argv[0], pInfo->zDatabase); + if( pTable==0 ){ + return 0; + } + if( argv[1]==0 ){ + pIndex = 0; + }else if( sqlite3_stricmp(argv[0],argv[1])==0 ){ + pIndex = sqlite3PrimaryKeyIndex(pTable); + }else{ + pIndex = sqlite3FindIndex(pInfo->db, argv[1], pInfo->zDatabase); + } + z = argv[2]; + + if( pIndex ){ + tRowcnt *aiRowEst = 0; + int nCol = pIndex->nKeyCol+1; +#ifdef SQLITE_ENABLE_STAT4 + /* Index.aiRowEst may already be set here if there are duplicate + ** sqlite_stat1 entries for this index. In that case just clobber + ** the old data with the new instead of allocating a new array. */ + if( pIndex->aiRowEst==0 ){ + pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol); + if( pIndex->aiRowEst==0 ) sqlite3OomFault(pInfo->db); + } + aiRowEst = pIndex->aiRowEst; +#endif + pIndex->bUnordered = 0; + decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex); + pIndex->hasStat1 = 1; + if( pIndex->pPartIdxWhere==0 ){ + pTable->nRowLogEst = pIndex->aiRowLogEst[0]; + pTable->tabFlags |= TF_HasStat1; + } + }else{ + Index fakeIdx; + fakeIdx.szIdxRow = pTable->szTabRow; +#ifdef SQLITE_ENABLE_COSTMULT + fakeIdx.pTable = pTable; +#endif + decodeIntArray((char*)z, 1, 0, &pTable->nRowLogEst, &fakeIdx); + pTable->szTabRow = fakeIdx.szIdxRow; + pTable->tabFlags |= TF_HasStat1; + } + + return 0; +} + +/* +** If the Index.aSample variable is not NULL, delete the aSample[] array +** and its contents. +*/ +SQLITE_PRIVATE void sqlite3DeleteIndexSamples(sqlite3 *db, Index *pIdx){ +#ifdef SQLITE_ENABLE_STAT4 + if( pIdx->aSample ){ + int j; + for(j=0; jnSample; j++){ + IndexSample *p = &pIdx->aSample[j]; + sqlite3DbFree(db, p->p); + } + sqlite3DbFree(db, pIdx->aSample); + } + if( db && db->pnBytesFreed==0 ){ + pIdx->nSample = 0; + pIdx->aSample = 0; + } +#else + UNUSED_PARAMETER(db); + UNUSED_PARAMETER(pIdx); +#endif /* SQLITE_ENABLE_STAT4 */ +} + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Populate the pIdx->aAvgEq[] array based on the samples currently +** stored in pIdx->aSample[]. +*/ +static void initAvgEq(Index *pIdx){ + if( pIdx ){ + IndexSample *aSample = pIdx->aSample; + IndexSample *pFinal = &aSample[pIdx->nSample-1]; + int iCol; + int nCol = 1; + if( pIdx->nSampleCol>1 ){ + /* If this is stat4 data, then calculate aAvgEq[] values for all + ** sample columns except the last. The last is always set to 1, as + ** once the trailing PK fields are considered all index keys are + ** unique. */ + nCol = pIdx->nSampleCol-1; + pIdx->aAvgEq[nCol] = 1; + } + for(iCol=0; iColnSample; + int i; /* Used to iterate through samples */ + tRowcnt sumEq = 0; /* Sum of the nEq values */ + tRowcnt avgEq = 0; + tRowcnt nRow; /* Number of rows in index */ + i64 nSum100 = 0; /* Number of terms contributing to sumEq */ + i64 nDist100; /* Number of distinct values in index */ + + if( !pIdx->aiRowEst || iCol>=pIdx->nKeyCol || pIdx->aiRowEst[iCol+1]==0 ){ + nRow = pFinal->anLt[iCol]; + nDist100 = (i64)100 * pFinal->anDLt[iCol]; + nSample--; + }else{ + nRow = pIdx->aiRowEst[0]; + nDist100 = ((i64)100 * pIdx->aiRowEst[0]) / pIdx->aiRowEst[iCol+1]; + } + pIdx->nRowEst0 = nRow; + + /* Set nSum to the number of distinct (iCol+1) field prefixes that + ** occur in the stat4 table for this index. Set sumEq to the sum of + ** the nEq values for column iCol for the same set (adding the value + ** only once where there exist duplicate prefixes). */ + for(i=0; inSample-1) + || aSample[i].anDLt[iCol]!=aSample[i+1].anDLt[iCol] + ){ + sumEq += aSample[i].anEq[iCol]; + nSum100 += 100; + } + } + + if( nDist100>nSum100 && sumEqaAvgEq[iCol] = avgEq; + } + } +} + +/* +** Look up an index by name. Or, if the name of a WITHOUT ROWID table +** is supplied instead, find the PRIMARY KEY index for that table. +*/ +static Index *findIndexOrPrimaryKey( + sqlite3 *db, + const char *zName, + const char *zDb +){ + Index *pIdx = sqlite3FindIndex(db, zName, zDb); + if( pIdx==0 ){ + Table *pTab = sqlite3FindTable(db, zName, zDb); + if( pTab && !HasRowid(pTab) ) pIdx = sqlite3PrimaryKeyIndex(pTab); + } + return pIdx; +} + +/* +** Load the content from either the sqlite_stat4 +** into the relevant Index.aSample[] arrays. +** +** Arguments zSql1 and zSql2 must point to SQL statements that return +** data equivalent to the following: +** +** zSql1: SELECT idx,count(*) FROM %Q.sqlite_stat4 GROUP BY idx +** zSql2: SELECT idx,neq,nlt,ndlt,sample FROM %Q.sqlite_stat4 +** +** where %Q is replaced with the database name before the SQL is executed. +*/ +static int loadStatTbl( + sqlite3 *db, /* Database handle */ + const char *zSql1, /* SQL statement 1 (see above) */ + const char *zSql2, /* SQL statement 2 (see above) */ + const char *zDb /* Database name (e.g. "main") */ +){ + int rc; /* Result codes from subroutines */ + sqlite3_stmt *pStmt = 0; /* An SQL statement being run */ + char *zSql; /* Text of the SQL statement */ + Index *pPrevIdx = 0; /* Previous index in the loop */ + IndexSample *pSample; /* A slot in pIdx->aSample[] */ + + assert( db->lookaside.bDisable ); + zSql = sqlite3MPrintf(db, zSql1, zDb); + if( !zSql ){ + return SQLITE_NOMEM_BKPT; + } + rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0); + sqlite3DbFree(db, zSql); + if( rc ) return rc; + + while( sqlite3_step(pStmt)==SQLITE_ROW ){ + int nIdxCol = 1; /* Number of columns in stat4 records */ + + char *zIndex; /* Index name */ + Index *pIdx; /* Pointer to the index object */ + int nSample; /* Number of samples */ + int nByte; /* Bytes of space required */ + int i; /* Bytes of space required */ + tRowcnt *pSpace; + + zIndex = (char *)sqlite3_column_text(pStmt, 0); + if( zIndex==0 ) continue; + nSample = sqlite3_column_int(pStmt, 1); + pIdx = findIndexOrPrimaryKey(db, zIndex, zDb); + assert( pIdx==0 || pIdx->nSample==0 ); + if( pIdx==0 ) continue; + assert( !HasRowid(pIdx->pTable) || pIdx->nColumn==pIdx->nKeyCol+1 ); + if( !HasRowid(pIdx->pTable) && IsPrimaryKeyIndex(pIdx) ){ + nIdxCol = pIdx->nKeyCol; + }else{ + nIdxCol = pIdx->nColumn; + } + pIdx->nSampleCol = nIdxCol; + nByte = sizeof(IndexSample) * nSample; + nByte += sizeof(tRowcnt) * nIdxCol * 3 * nSample; + nByte += nIdxCol * sizeof(tRowcnt); /* Space for Index.aAvgEq[] */ + + pIdx->aSample = sqlite3DbMallocZero(db, nByte); + if( pIdx->aSample==0 ){ + sqlite3_finalize(pStmt); + return SQLITE_NOMEM_BKPT; + } + pSpace = (tRowcnt*)&pIdx->aSample[nSample]; + pIdx->aAvgEq = pSpace; pSpace += nIdxCol; + pIdx->pTable->tabFlags |= TF_HasStat4; + for(i=0; iaSample[i].anEq = pSpace; pSpace += nIdxCol; + pIdx->aSample[i].anLt = pSpace; pSpace += nIdxCol; + pIdx->aSample[i].anDLt = pSpace; pSpace += nIdxCol; + } + assert( ((u8*)pSpace)-nByte==(u8*)(pIdx->aSample) ); + } + rc = sqlite3_finalize(pStmt); + if( rc ) return rc; + + zSql = sqlite3MPrintf(db, zSql2, zDb); + if( !zSql ){ + return SQLITE_NOMEM_BKPT; + } + rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0); + sqlite3DbFree(db, zSql); + if( rc ) return rc; + + while( sqlite3_step(pStmt)==SQLITE_ROW ){ + char *zIndex; /* Index name */ + Index *pIdx; /* Pointer to the index object */ + int nCol = 1; /* Number of columns in index */ + + zIndex = (char *)sqlite3_column_text(pStmt, 0); + if( zIndex==0 ) continue; + pIdx = findIndexOrPrimaryKey(db, zIndex, zDb); + if( pIdx==0 ) continue; + /* This next condition is true if data has already been loaded from + ** the sqlite_stat4 table. */ + nCol = pIdx->nSampleCol; + if( pIdx!=pPrevIdx ){ + initAvgEq(pPrevIdx); + pPrevIdx = pIdx; + } + pSample = &pIdx->aSample[pIdx->nSample]; + decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0); + decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0); + decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0); + + /* Take a copy of the sample. Add two 0x00 bytes the end of the buffer. + ** This is in case the sample record is corrupted. In that case, the + ** sqlite3VdbeRecordCompare() may read up to two varints past the + ** end of the allocated buffer before it realizes it is dealing with + ** a corrupt record. Adding the two 0x00 bytes prevents this from causing + ** a buffer overread. */ + pSample->n = sqlite3_column_bytes(pStmt, 4); + pSample->p = sqlite3DbMallocZero(db, pSample->n + 2); + if( pSample->p==0 ){ + sqlite3_finalize(pStmt); + return SQLITE_NOMEM_BKPT; + } + if( pSample->n ){ + memcpy(pSample->p, sqlite3_column_blob(pStmt, 4), pSample->n); + } + pIdx->nSample++; + } + rc = sqlite3_finalize(pStmt); + if( rc==SQLITE_OK ) initAvgEq(pPrevIdx); + return rc; +} + +/* +** Load content from the sqlite_stat4 table into +** the Index.aSample[] arrays of all indices. +*/ +static int loadStat4(sqlite3 *db, const char *zDb){ + int rc = SQLITE_OK; /* Result codes from subroutines */ + + assert( db->lookaside.bDisable ); + if( sqlite3FindTable(db, "sqlite_stat4", zDb) ){ + rc = loadStatTbl(db, + "SELECT idx,count(*) FROM %Q.sqlite_stat4 GROUP BY idx", + "SELECT idx,neq,nlt,ndlt,sample FROM %Q.sqlite_stat4", + zDb + ); + } + return rc; +} +#endif /* SQLITE_ENABLE_STAT4 */ + +/* +** Load the content of the sqlite_stat1 and sqlite_stat4 tables. The +** contents of sqlite_stat1 are used to populate the Index.aiRowEst[] +** arrays. The contents of sqlite_stat4 are used to populate the +** Index.aSample[] arrays. +** +** If the sqlite_stat1 table is not present in the database, SQLITE_ERROR +** is returned. In this case, even if SQLITE_ENABLE_STAT4 was defined +** during compilation and the sqlite_stat4 table is present, no data is +** read from it. +** +** If SQLITE_ENABLE_STAT4 was defined during compilation and the +** sqlite_stat4 table is not present in the database, SQLITE_ERROR is +** returned. However, in this case, data is read from the sqlite_stat1 +** table (if it is present) before returning. +** +** If an OOM error occurs, this function always sets db->mallocFailed. +** This means if the caller does not care about other errors, the return +** code may be ignored. +*/ +SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){ + analysisInfo sInfo; + HashElem *i; + char *zSql; + int rc = SQLITE_OK; + Schema *pSchema = db->aDb[iDb].pSchema; + + assert( iDb>=0 && iDbnDb ); + assert( db->aDb[iDb].pBt!=0 ); + + /* Clear any prior statistics */ + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + for(i=sqliteHashFirst(&pSchema->tblHash); i; i=sqliteHashNext(i)){ + Table *pTab = sqliteHashData(i); + pTab->tabFlags &= ~TF_HasStat1; + } + for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){ + Index *pIdx = sqliteHashData(i); + pIdx->hasStat1 = 0; +#ifdef SQLITE_ENABLE_STAT4 + sqlite3DeleteIndexSamples(db, pIdx); + pIdx->aSample = 0; +#endif + } + + /* Load new statistics out of the sqlite_stat1 table */ + sInfo.db = db; + sInfo.zDatabase = db->aDb[iDb].zDbSName; + if( sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)!=0 ){ + zSql = sqlite3MPrintf(db, + "SELECT tbl,idx,stat FROM %Q.sqlite_stat1", sInfo.zDatabase); + if( zSql==0 ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0); + sqlite3DbFree(db, zSql); + } + } + + /* Set appropriate defaults on all indexes not in the sqlite_stat1 table */ + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){ + Index *pIdx = sqliteHashData(i); + if( !pIdx->hasStat1 ) sqlite3DefaultRowEst(pIdx); + } + + /* Load the statistics from the sqlite_stat4 table. */ +#ifdef SQLITE_ENABLE_STAT4 + if( rc==SQLITE_OK ){ + DisableLookaside; + rc = loadStat4(db, sInfo.zDatabase); + EnableLookaside; + } + for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){ + Index *pIdx = sqliteHashData(i); + sqlite3_free(pIdx->aiRowEst); + pIdx->aiRowEst = 0; + } +#endif + + if( rc==SQLITE_NOMEM ){ + sqlite3OomFault(db); + } + return rc; +} + + +#endif /* SQLITE_OMIT_ANALYZE */ + +/************** End of analyze.c *********************************************/ +/************** Begin file attach.c ******************************************/ +/* +** 2003 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the ATTACH and DETACH commands. +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_ATTACH +/* +** Resolve an expression that was part of an ATTACH or DETACH statement. This +** is slightly different from resolving a normal SQL expression, because simple +** identifiers are treated as strings, not possible column names or aliases. +** +** i.e. if the parser sees: +** +** ATTACH DATABASE abc AS def +** +** it treats the two expressions as literal strings 'abc' and 'def' instead of +** looking for columns of the same name. +** +** This only applies to the root node of pExpr, so the statement: +** +** ATTACH DATABASE abc||def AS 'db2' +** +** will fail because neither abc or def can be resolved. +*/ +static int resolveAttachExpr(NameContext *pName, Expr *pExpr) +{ + int rc = SQLITE_OK; + if( pExpr ){ + if( pExpr->op!=TK_ID ){ + rc = sqlite3ResolveExprNames(pName, pExpr); + }else{ + pExpr->op = TK_STRING; + } + } + return rc; +} + +/* +** Return true if zName points to a name that may be used to refer to +** database iDb attached to handle db. +*/ +SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName){ + return ( + sqlite3StrICmp(db->aDb[iDb].zDbSName, zName)==0 + || (iDb==0 && sqlite3StrICmp("main", zName)==0) + ); +} + +/* +** An SQL user-function registered to do the work of an ATTACH statement. The +** three arguments to the function come directly from an attach statement: +** +** ATTACH DATABASE x AS y KEY z +** +** SELECT sqlite_attach(x, y, z) +** +** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the +** third argument. +** +** If the db->init.reopenMemdb flags is set, then instead of attaching a +** new database, close the database on db->init.iDb and reopen it as an +** empty MemDB. +*/ +static void attachFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + int i; + int rc = 0; + sqlite3 *db = sqlite3_context_db_handle(context); + const char *zName; + const char *zFile; + char *zPath = 0; + char *zErr = 0; + unsigned int flags; + Db *aNew; /* New array of Db pointers */ + Db *pNew; /* Db object for the newly attached database */ + char *zErrDyn = 0; + sqlite3_vfs *pVfs; + + UNUSED_PARAMETER(NotUsed); + zFile = (const char *)sqlite3_value_text(argv[0]); + zName = (const char *)sqlite3_value_text(argv[1]); + if( zFile==0 ) zFile = ""; + if( zName==0 ) zName = ""; + +#ifdef SQLITE_ENABLE_DESERIALIZE +# define REOPEN_AS_MEMDB(db) (db->init.reopenMemdb) +#else +# define REOPEN_AS_MEMDB(db) (0) +#endif + + if( REOPEN_AS_MEMDB(db) ){ + /* This is not a real ATTACH. Instead, this routine is being called + ** from sqlite3_deserialize() to close database db->init.iDb and + ** reopen it as a MemDB */ + pVfs = sqlite3_vfs_find("memdb"); + if( pVfs==0 ) return; + pNew = &db->aDb[db->init.iDb]; + if( pNew->pBt ) sqlite3BtreeClose(pNew->pBt); + pNew->pBt = 0; + pNew->pSchema = 0; + rc = sqlite3BtreeOpen(pVfs, "x\0", db, &pNew->pBt, 0, SQLITE_OPEN_MAIN_DB); + }else{ + /* This is a real ATTACH + ** + ** Check for the following errors: + ** + ** * Too many attached databases, + ** * Transaction currently open + ** * Specified database name already being used. + */ + if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){ + zErrDyn = sqlite3MPrintf(db, "too many attached databases - max %d", + db->aLimit[SQLITE_LIMIT_ATTACHED] + ); + goto attach_error; + } + for(i=0; inDb; i++){ + assert( zName ); + if( sqlite3DbIsNamed(db, i, zName) ){ + zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName); + goto attach_error; + } + } + + /* Allocate the new entry in the db->aDb[] array and initialize the schema + ** hash tables. + */ + if( db->aDb==db->aDbStatic ){ + aNew = sqlite3DbMallocRawNN(db, sizeof(db->aDb[0])*3 ); + if( aNew==0 ) return; + memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2); + }else{ + aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) ); + if( aNew==0 ) return; + } + db->aDb = aNew; + pNew = &db->aDb[db->nDb]; + memset(pNew, 0, sizeof(*pNew)); + + /* Open the database file. If the btree is successfully opened, use + ** it to obtain the database schema. At this point the schema may + ** or may not be initialized. + */ + flags = db->openFlags; + rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_NOMEM ) sqlite3OomFault(db); + sqlite3_result_error(context, zErr, -1); + sqlite3_free(zErr); + return; + } + assert( pVfs ); + flags |= SQLITE_OPEN_MAIN_DB; + rc = sqlite3BtreeOpen(pVfs, zPath, db, &pNew->pBt, 0, flags); + db->nDb++; + pNew->zDbSName = sqlite3DbStrDup(db, zName); + } + db->noSharedCache = 0; + if( rc==SQLITE_CONSTRAINT ){ + rc = SQLITE_ERROR; + zErrDyn = sqlite3MPrintf(db, "database is already attached"); + }else if( rc==SQLITE_OK ){ + Pager *pPager; + pNew->pSchema = sqlite3SchemaGet(db, pNew->pBt); + if( !pNew->pSchema ){ + rc = SQLITE_NOMEM_BKPT; + }else if( pNew->pSchema->file_format && pNew->pSchema->enc!=ENC(db) ){ + zErrDyn = sqlite3MPrintf(db, + "attached databases must use the same text encoding as main database"); + rc = SQLITE_ERROR; + } + sqlite3BtreeEnter(pNew->pBt); + pPager = sqlite3BtreePager(pNew->pBt); + sqlite3PagerLockingMode(pPager, db->dfltLockMode); + sqlite3BtreeSecureDelete(pNew->pBt, + sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) ); +#ifndef SQLITE_OMIT_PAGER_PRAGMAS + sqlite3BtreeSetPagerFlags(pNew->pBt, + PAGER_SYNCHRONOUS_FULL | (db->flags & PAGER_FLAGS_MASK)); +#endif + sqlite3BtreeLeave(pNew->pBt); + } + pNew->safety_level = SQLITE_DEFAULT_SYNCHRONOUS+1; + if( rc==SQLITE_OK && pNew->zDbSName==0 ){ + rc = SQLITE_NOMEM_BKPT; + } + sqlite3_free_filename( zPath ); + + /* If the file was opened successfully, read the schema for the new database. + ** If this fails, or if opening the file failed, then close the file and + ** remove the entry from the db->aDb[] array. i.e. put everything back the + ** way we found it. + */ + if( rc==SQLITE_OK ){ + sqlite3BtreeEnterAll(db); + db->init.iDb = 0; + db->mDbFlags &= ~(DBFLAG_SchemaKnownOk); + if( !REOPEN_AS_MEMDB(db) ){ + rc = sqlite3Init(db, &zErrDyn); + } + sqlite3BtreeLeaveAll(db); + assert( zErrDyn==0 || rc!=SQLITE_OK ); + } +#ifdef SQLITE_USER_AUTHENTICATION + if( rc==SQLITE_OK && !REOPEN_AS_MEMDB(db) ){ + u8 newAuth = 0; + rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth); + if( newAuthauth.authLevel ){ + rc = SQLITE_AUTH_USER; + } + } +#endif + if( rc ){ + if( !REOPEN_AS_MEMDB(db) ){ + int iDb = db->nDb - 1; + assert( iDb>=2 ); + if( db->aDb[iDb].pBt ){ + sqlite3BtreeClose(db->aDb[iDb].pBt); + db->aDb[iDb].pBt = 0; + db->aDb[iDb].pSchema = 0; + } + sqlite3ResetAllSchemasOfConnection(db); + db->nDb = iDb; + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ + sqlite3OomFault(db); + sqlite3DbFree(db, zErrDyn); + zErrDyn = sqlite3MPrintf(db, "out of memory"); + }else if( zErrDyn==0 ){ + zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile); + } + } + goto attach_error; + } + + return; + +attach_error: + /* Return an error if we get here */ + if( zErrDyn ){ + sqlite3_result_error(context, zErrDyn, -1); + sqlite3DbFree(db, zErrDyn); + } + if( rc ) sqlite3_result_error_code(context, rc); +} + +/* +** An SQL user-function registered to do the work of an DETACH statement. The +** three arguments to the function come directly from a detach statement: +** +** DETACH DATABASE x +** +** SELECT sqlite_detach(x) +*/ +static void detachFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + const char *zName = (const char *)sqlite3_value_text(argv[0]); + sqlite3 *db = sqlite3_context_db_handle(context); + int i; + Db *pDb = 0; + HashElem *pEntry; + char zErr[128]; + + UNUSED_PARAMETER(NotUsed); + + if( zName==0 ) zName = ""; + for(i=0; inDb; i++){ + pDb = &db->aDb[i]; + if( pDb->pBt==0 ) continue; + if( sqlite3DbIsNamed(db, i, zName) ) break; + } + + if( i>=db->nDb ){ + sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName); + goto detach_error; + } + if( i<2 ){ + sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName); + goto detach_error; + } + if( sqlite3BtreeTxnState(pDb->pBt)!=SQLITE_TXN_NONE + || sqlite3BtreeIsInBackup(pDb->pBt) + ){ + sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName); + goto detach_error; + } + + /* If any TEMP triggers reference the schema being detached, move those + ** triggers to reference the TEMP schema itself. */ + assert( db->aDb[1].pSchema ); + pEntry = sqliteHashFirst(&db->aDb[1].pSchema->trigHash); + while( pEntry ){ + Trigger *pTrig = (Trigger*)sqliteHashData(pEntry); + if( pTrig->pTabSchema==pDb->pSchema ){ + pTrig->pTabSchema = pTrig->pSchema; + } + pEntry = sqliteHashNext(pEntry); + } + + sqlite3BtreeClose(pDb->pBt); + pDb->pBt = 0; + pDb->pSchema = 0; + sqlite3CollapseDatabaseArray(db); + return; + +detach_error: + sqlite3_result_error(context, zErr, -1); +} + +/* +** This procedure generates VDBE code for a single invocation of either the +** sqlite_detach() or sqlite_attach() SQL user functions. +*/ +static void codeAttach( + Parse *pParse, /* The parser context */ + int type, /* Either SQLITE_ATTACH or SQLITE_DETACH */ + FuncDef const *pFunc,/* FuncDef wrapper for detachFunc() or attachFunc() */ + Expr *pAuthArg, /* Expression to pass to authorization callback */ + Expr *pFilename, /* Name of database file */ + Expr *pDbname, /* Name of the database to use internally */ + Expr *pKey /* Database key for encryption extension */ +){ + int rc; + NameContext sName; + Vdbe *v; + sqlite3* db = pParse->db; + int regArgs; + + if( pParse->nErr ) goto attach_end; + memset(&sName, 0, sizeof(NameContext)); + sName.pParse = pParse; + + if( + SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) || + SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) || + SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey)) + ){ + goto attach_end; + } + +#ifndef SQLITE_OMIT_AUTHORIZATION + if( pAuthArg ){ + char *zAuthArg; + if( pAuthArg->op==TK_STRING ){ + zAuthArg = pAuthArg->u.zToken; + }else{ + zAuthArg = 0; + } + rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0); + if(rc!=SQLITE_OK ){ + goto attach_end; + } + } +#endif /* SQLITE_OMIT_AUTHORIZATION */ + + + v = sqlite3GetVdbe(pParse); + regArgs = sqlite3GetTempRange(pParse, 4); + sqlite3ExprCode(pParse, pFilename, regArgs); + sqlite3ExprCode(pParse, pDbname, regArgs+1); + sqlite3ExprCode(pParse, pKey, regArgs+2); + + assert( v || db->mallocFailed ); + if( v ){ + sqlite3VdbeAddFunctionCall(pParse, 0, regArgs+3-pFunc->nArg, regArgs+3, + pFunc->nArg, pFunc, 0); + /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this + ** statement only). For DETACH, set it to false (expire all existing + ** statements). + */ + sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH)); + } + +attach_end: + sqlite3ExprDelete(db, pFilename); + sqlite3ExprDelete(db, pDbname); + sqlite3ExprDelete(db, pKey); +} + +/* +** Called by the parser to compile a DETACH statement. +** +** DETACH pDbname +*/ +SQLITE_PRIVATE void sqlite3Detach(Parse *pParse, Expr *pDbname){ + static const FuncDef detach_func = { + 1, /* nArg */ + SQLITE_UTF8, /* funcFlags */ + 0, /* pUserData */ + 0, /* pNext */ + detachFunc, /* xSFunc */ + 0, /* xFinalize */ + 0, 0, /* xValue, xInverse */ + "sqlite_detach", /* zName */ + {0} + }; + codeAttach(pParse, SQLITE_DETACH, &detach_func, pDbname, 0, 0, pDbname); +} + +/* +** Called by the parser to compile an ATTACH statement. +** +** ATTACH p AS pDbname KEY pKey +*/ +SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){ + static const FuncDef attach_func = { + 3, /* nArg */ + SQLITE_UTF8, /* funcFlags */ + 0, /* pUserData */ + 0, /* pNext */ + attachFunc, /* xSFunc */ + 0, /* xFinalize */ + 0, 0, /* xValue, xInverse */ + "sqlite_attach", /* zName */ + {0} + }; + codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey); +} +#endif /* SQLITE_OMIT_ATTACH */ + +/* +** Initialize a DbFixer structure. This routine must be called prior +** to passing the structure to one of the sqliteFixAAAA() routines below. +*/ +SQLITE_PRIVATE void sqlite3FixInit( + DbFixer *pFix, /* The fixer to be initialized */ + Parse *pParse, /* Error messages will be written here */ + int iDb, /* This is the database that must be used */ + const char *zType, /* "view", "trigger", or "index" */ + const Token *pName /* Name of the view, trigger, or index */ +){ + sqlite3 *db; + + db = pParse->db; + assert( db->nDb>iDb ); + pFix->pParse = pParse; + pFix->zDb = db->aDb[iDb].zDbSName; + pFix->pSchema = db->aDb[iDb].pSchema; + pFix->zType = zType; + pFix->pName = pName; + pFix->bTemp = (iDb==1); +} + +/* +** The following set of routines walk through the parse tree and assign +** a specific database to all table references where the database name +** was left unspecified in the original SQL statement. The pFix structure +** must have been initialized by a prior call to sqlite3FixInit(). +** +** These routines are used to make sure that an index, trigger, or +** view in one database does not refer to objects in a different database. +** (Exception: indices, triggers, and views in the TEMP database are +** allowed to refer to anything.) If a reference is explicitly made +** to an object in a different database, an error message is added to +** pParse->zErrMsg and these routines return non-zero. If everything +** checks out, these routines return 0. +*/ +SQLITE_PRIVATE int sqlite3FixSrcList( + DbFixer *pFix, /* Context of the fixation */ + SrcList *pList /* The Source list to check and modify */ +){ + int i; + struct SrcList_item *pItem; + sqlite3 *db = pFix->pParse->db; + int iDb = sqlite3FindDbName(db, pFix->zDb); + + if( NEVER(pList==0) ) return 0; + + for(i=0, pItem=pList->a; inSrc; i++, pItem++){ + if( pFix->bTemp==0 ){ + if( pItem->zDatabase && iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){ + sqlite3ErrorMsg(pFix->pParse, + "%s %T cannot reference objects in database %s", + pFix->zType, pFix->pName, pItem->zDatabase); + return 1; + } + sqlite3DbFree(db, pItem->zDatabase); + pItem->zDatabase = 0; + pItem->pSchema = pFix->pSchema; + pItem->fg.fromDDL = 1; + } +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) + if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1; + if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1; +#endif + if( pItem->fg.isTabFunc && sqlite3FixExprList(pFix, pItem->u1.pFuncArg) ){ + return 1; + } + } + return 0; +} +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) +SQLITE_PRIVATE int sqlite3FixSelect( + DbFixer *pFix, /* Context of the fixation */ + Select *pSelect /* The SELECT statement to be fixed to one database */ +){ + while( pSelect ){ + if( sqlite3FixExprList(pFix, pSelect->pEList) ){ + return 1; + } + if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){ + return 1; + } + if( sqlite3FixExpr(pFix, pSelect->pWhere) ){ + return 1; + } + if( sqlite3FixExprList(pFix, pSelect->pGroupBy) ){ + return 1; + } + if( sqlite3FixExpr(pFix, pSelect->pHaving) ){ + return 1; + } + if( sqlite3FixExprList(pFix, pSelect->pOrderBy) ){ + return 1; + } + if( sqlite3FixExpr(pFix, pSelect->pLimit) ){ + return 1; + } + if( pSelect->pWith ){ + int i; + for(i=0; ipWith->nCte; i++){ + if( sqlite3FixSelect(pFix, pSelect->pWith->a[i].pSelect) ){ + return 1; + } + } + } + pSelect = pSelect->pPrior; + } + return 0; +} +SQLITE_PRIVATE int sqlite3FixExpr( + DbFixer *pFix, /* Context of the fixation */ + Expr *pExpr /* The expression to be fixed to one database */ +){ + while( pExpr ){ + if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL); + if( pExpr->op==TK_VARIABLE ){ + if( pFix->pParse->db->init.busy ){ + pExpr->op = TK_NULL; + }else{ + sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType); + return 1; + } + } + if( ExprHasProperty(pExpr, EP_TokenOnly|EP_Leaf) ) break; + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1; + }else{ + if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1; + } + if( sqlite3FixExpr(pFix, pExpr->pRight) ){ + return 1; + } + pExpr = pExpr->pLeft; + } + return 0; +} +SQLITE_PRIVATE int sqlite3FixExprList( + DbFixer *pFix, /* Context of the fixation */ + ExprList *pList /* The expression to be fixed to one database */ +){ + int i; + struct ExprList_item *pItem; + if( pList==0 ) return 0; + for(i=0, pItem=pList->a; inExpr; i++, pItem++){ + if( sqlite3FixExpr(pFix, pItem->pExpr) ){ + return 1; + } + } + return 0; +} +#endif + +#ifndef SQLITE_OMIT_TRIGGER +SQLITE_PRIVATE int sqlite3FixTriggerStep( + DbFixer *pFix, /* Context of the fixation */ + TriggerStep *pStep /* The trigger step be fixed to one database */ +){ + while( pStep ){ + if( sqlite3FixSelect(pFix, pStep->pSelect) ){ + return 1; + } + if( sqlite3FixExpr(pFix, pStep->pWhere) ){ + return 1; + } + if( sqlite3FixExprList(pFix, pStep->pExprList) ){ + return 1; + } + if( pStep->pFrom && sqlite3FixSrcList(pFix, pStep->pFrom) ){ + return 1; + } +#ifndef SQLITE_OMIT_UPSERT + if( pStep->pUpsert ){ + Upsert *pUp = pStep->pUpsert; + if( sqlite3FixExprList(pFix, pUp->pUpsertTarget) + || sqlite3FixExpr(pFix, pUp->pUpsertTargetWhere) + || sqlite3FixExprList(pFix, pUp->pUpsertSet) + || sqlite3FixExpr(pFix, pUp->pUpsertWhere) + ){ + return 1; + } + } +#endif + pStep = pStep->pNext; + } + return 0; +} +#endif + +/************** End of attach.c **********************************************/ +/************** Begin file auth.c ********************************************/ +/* +** 2003 January 11 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the sqlite3_set_authorizer() +** API. This facility is an optional feature of the library. Embedded +** systems that do not need this facility may omit it by recompiling +** the library with -DSQLITE_OMIT_AUTHORIZATION=1 +*/ +/* #include "sqliteInt.h" */ + +/* +** All of the code in this file may be omitted by defining a single +** macro. +*/ +#ifndef SQLITE_OMIT_AUTHORIZATION + +/* +** Set or clear the access authorization function. +** +** The access authorization function is be called during the compilation +** phase to verify that the user has read and/or write access permission on +** various fields of the database. The first argument to the auth function +** is a copy of the 3rd argument to this routine. The second argument +** to the auth function is one of these constants: +** +** SQLITE_CREATE_INDEX +** SQLITE_CREATE_TABLE +** SQLITE_CREATE_TEMP_INDEX +** SQLITE_CREATE_TEMP_TABLE +** SQLITE_CREATE_TEMP_TRIGGER +** SQLITE_CREATE_TEMP_VIEW +** SQLITE_CREATE_TRIGGER +** SQLITE_CREATE_VIEW +** SQLITE_DELETE +** SQLITE_DROP_INDEX +** SQLITE_DROP_TABLE +** SQLITE_DROP_TEMP_INDEX +** SQLITE_DROP_TEMP_TABLE +** SQLITE_DROP_TEMP_TRIGGER +** SQLITE_DROP_TEMP_VIEW +** SQLITE_DROP_TRIGGER +** SQLITE_DROP_VIEW +** SQLITE_INSERT +** SQLITE_PRAGMA +** SQLITE_READ +** SQLITE_SELECT +** SQLITE_TRANSACTION +** SQLITE_UPDATE +** +** The third and fourth arguments to the auth function are the name of +** the table and the column that are being accessed. The auth function +** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE. If +** SQLITE_OK is returned, it means that access is allowed. SQLITE_DENY +** means that the SQL statement will never-run - the sqlite3_exec() call +** will return with an error. SQLITE_IGNORE means that the SQL statement +** should run but attempts to read the specified column will return NULL +** and attempts to write the column will be ignored. +** +** Setting the auth function to NULL disables this hook. The default +** setting of the auth function is NULL. +*/ +SQLITE_API int sqlite3_set_authorizer( + sqlite3 *db, + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), + void *pArg +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + db->xAuth = (sqlite3_xauth)xAuth; + db->pAuthArg = pArg; + if( db->xAuth ) sqlite3ExpirePreparedStatements(db, 1); + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +/* +** Write an error message into pParse->zErrMsg that explains that the +** user-supplied authorization function returned an illegal value. +*/ +static void sqliteAuthBadReturnCode(Parse *pParse){ + sqlite3ErrorMsg(pParse, "authorizer malfunction"); + pParse->rc = SQLITE_ERROR; +} + +/* +** Invoke the authorization callback for permission to read column zCol from +** table zTab in database zDb. This function assumes that an authorization +** callback has been registered (i.e. that sqlite3.xAuth is not NULL). +** +** If SQLITE_IGNORE is returned and pExpr is not NULL, then pExpr is changed +** to an SQL NULL expression. Otherwise, if pExpr is NULL, then SQLITE_IGNORE +** is treated as SQLITE_DENY. In this case an error is left in pParse. +*/ +SQLITE_PRIVATE int sqlite3AuthReadCol( + Parse *pParse, /* The parser context */ + const char *zTab, /* Table name */ + const char *zCol, /* Column name */ + int iDb /* Index of containing database. */ +){ + sqlite3 *db = pParse->db; /* Database handle */ + char *zDb = db->aDb[iDb].zDbSName; /* Schema name of attached database */ + int rc; /* Auth callback return code */ + + if( db->init.busy ) return SQLITE_OK; + rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext +#ifdef SQLITE_USER_AUTHENTICATION + ,db->auth.zAuthUser +#endif + ); + if( rc==SQLITE_DENY ){ + char *z = sqlite3_mprintf("%s.%s", zTab, zCol); + if( db->nDb>2 || iDb!=0 ) z = sqlite3_mprintf("%s.%z", zDb, z); + sqlite3ErrorMsg(pParse, "access to %z is prohibited", z); + pParse->rc = SQLITE_AUTH; + }else if( rc!=SQLITE_IGNORE && rc!=SQLITE_OK ){ + sqliteAuthBadReturnCode(pParse); + } + return rc; +} + +/* +** The pExpr should be a TK_COLUMN expression. The table referred to +** is in pTabList or else it is the NEW or OLD table of a trigger. +** Check to see if it is OK to read this particular column. +** +** If the auth function returns SQLITE_IGNORE, change the TK_COLUMN +** instruction into a TK_NULL. If the auth function returns SQLITE_DENY, +** then generate an error. +*/ +SQLITE_PRIVATE void sqlite3AuthRead( + Parse *pParse, /* The parser context */ + Expr *pExpr, /* The expression to check authorization on */ + Schema *pSchema, /* The schema of the expression */ + SrcList *pTabList /* All table that pExpr might refer to */ +){ + sqlite3 *db = pParse->db; + Table *pTab = 0; /* The table being read */ + const char *zCol; /* Name of the column of the table */ + int iSrc; /* Index in pTabList->a[] of table being read */ + int iDb; /* The index of the database the expression refers to */ + int iCol; /* Index of column in table */ + + assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER ); + assert( !IN_RENAME_OBJECT || db->xAuth==0 ); + if( db->xAuth==0 ) return; + iDb = sqlite3SchemaToIndex(pParse->db, pSchema); + if( iDb<0 ){ + /* An attempt to read a column out of a subquery or other + ** temporary table. */ + return; + } + + if( pExpr->op==TK_TRIGGER ){ + pTab = pParse->pTriggerTab; + }else{ + assert( pTabList ); + for(iSrc=0; ALWAYS(iSrcnSrc); iSrc++){ + if( pExpr->iTable==pTabList->a[iSrc].iCursor ){ + pTab = pTabList->a[iSrc].pTab; + break; + } + } + } + iCol = pExpr->iColumn; + if( NEVER(pTab==0) ) return; + + if( iCol>=0 ){ + assert( iColnCol ); + zCol = pTab->aCol[iCol].zName; + }else if( pTab->iPKey>=0 ){ + assert( pTab->iPKeynCol ); + zCol = pTab->aCol[pTab->iPKey].zName; + }else{ + zCol = "ROWID"; + } + assert( iDb>=0 && iDbnDb ); + if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){ + pExpr->op = TK_NULL; + } +} + +/* +** Do an authorization check using the code and arguments given. Return +** either SQLITE_OK (zero) or SQLITE_IGNORE or SQLITE_DENY. If SQLITE_DENY +** is returned, then the error count and error message in pParse are +** modified appropriately. +*/ +SQLITE_PRIVATE int sqlite3AuthCheck( + Parse *pParse, + int code, + const char *zArg1, + const char *zArg2, + const char *zArg3 +){ + sqlite3 *db = pParse->db; + int rc; + + /* Don't do any authorization checks if the database is initialising + ** or if the parser is being invoked from within sqlite3_declare_vtab. + */ + assert( !IN_RENAME_OBJECT || db->xAuth==0 ); + if( db->init.busy || IN_SPECIAL_PARSE ){ + return SQLITE_OK; + } + + if( db->xAuth==0 ){ + return SQLITE_OK; + } + + /* EVIDENCE-OF: R-43249-19882 The third through sixth parameters to the + ** callback are either NULL pointers or zero-terminated strings that + ** contain additional details about the action to be authorized. + ** + ** The following testcase() macros show that any of the 3rd through 6th + ** parameters can be either NULL or a string. */ + testcase( zArg1==0 ); + testcase( zArg2==0 ); + testcase( zArg3==0 ); + testcase( pParse->zAuthContext==0 ); + + rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext +#ifdef SQLITE_USER_AUTHENTICATION + ,db->auth.zAuthUser +#endif + ); + if( rc==SQLITE_DENY ){ + sqlite3ErrorMsg(pParse, "not authorized"); + pParse->rc = SQLITE_AUTH; + }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){ + rc = SQLITE_DENY; + sqliteAuthBadReturnCode(pParse); + } + return rc; +} + +/* +** Push an authorization context. After this routine is called, the +** zArg3 argument to authorization callbacks will be zContext until +** popped. Or if pParse==0, this routine is a no-op. +*/ +SQLITE_PRIVATE void sqlite3AuthContextPush( + Parse *pParse, + AuthContext *pContext, + const char *zContext +){ + assert( pParse ); + pContext->pParse = pParse; + pContext->zAuthContext = pParse->zAuthContext; + pParse->zAuthContext = zContext; +} + +/* +** Pop an authorization context that was previously pushed +** by sqlite3AuthContextPush +*/ +SQLITE_PRIVATE void sqlite3AuthContextPop(AuthContext *pContext){ + if( pContext->pParse ){ + pContext->pParse->zAuthContext = pContext->zAuthContext; + pContext->pParse = 0; + } +} + +#endif /* SQLITE_OMIT_AUTHORIZATION */ + +/************** End of auth.c ************************************************/ +/************** Begin file build.c *******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the SQLite parser +** when syntax rules are reduced. The routines in this file handle the +** following kinds of SQL syntax: +** +** CREATE TABLE +** DROP TABLE +** CREATE INDEX +** DROP INDEX +** creating ID lists +** BEGIN TRANSACTION +** COMMIT +** ROLLBACK +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** The TableLock structure is only used by the sqlite3TableLock() and +** codeTableLocks() functions. +*/ +struct TableLock { + int iDb; /* The database containing the table to be locked */ + Pgno iTab; /* The root page of the table to be locked */ + u8 isWriteLock; /* True for write lock. False for a read lock */ + const char *zLockName; /* Name of the table */ +}; + +/* +** Record the fact that we want to lock a table at run-time. +** +** The table to be locked has root page iTab and is found in database iDb. +** A read or a write lock can be taken depending on isWritelock. +** +** This routine just records the fact that the lock is desired. The +** code to make the lock occur is generated by a later call to +** codeTableLocks() which occurs during sqlite3FinishCoding(). +*/ +SQLITE_PRIVATE void sqlite3TableLock( + Parse *pParse, /* Parsing context */ + int iDb, /* Index of the database containing the table to lock */ + Pgno iTab, /* Root page number of the table to be locked */ + u8 isWriteLock, /* True for a write lock */ + const char *zName /* Name of the table to be locked */ +){ + Parse *pToplevel; + int i; + int nBytes; + TableLock *p; + assert( iDb>=0 ); + + if( iDb==1 ) return; + if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return; + pToplevel = sqlite3ParseToplevel(pParse); + for(i=0; inTableLock; i++){ + p = &pToplevel->aTableLock[i]; + if( p->iDb==iDb && p->iTab==iTab ){ + p->isWriteLock = (p->isWriteLock || isWriteLock); + return; + } + } + + nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1); + pToplevel->aTableLock = + sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes); + if( pToplevel->aTableLock ){ + p = &pToplevel->aTableLock[pToplevel->nTableLock++]; + p->iDb = iDb; + p->iTab = iTab; + p->isWriteLock = isWriteLock; + p->zLockName = zName; + }else{ + pToplevel->nTableLock = 0; + sqlite3OomFault(pToplevel->db); + } +} + +/* +** Code an OP_TableLock instruction for each table locked by the +** statement (configured by calls to sqlite3TableLock()). +*/ +static void codeTableLocks(Parse *pParse){ + int i; + Vdbe *pVdbe = pParse->pVdbe; + assert( pVdbe!=0 ); + + for(i=0; inTableLock; i++){ + TableLock *p = &pParse->aTableLock[i]; + int p1 = p->iDb; + sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock, + p->zLockName, P4_STATIC); + } +} +#else + #define codeTableLocks(x) +#endif + +/* +** Return TRUE if the given yDbMask object is empty - if it contains no +** 1 bits. This routine is used by the DbMaskAllZero() and DbMaskNotZero() +** macros when SQLITE_MAX_ATTACHED is greater than 30. +*/ +#if SQLITE_MAX_ATTACHED>30 +SQLITE_PRIVATE int sqlite3DbMaskAllZero(yDbMask m){ + int i; + for(i=0; ipToplevel==0 ); + db = pParse->db; + if( pParse->nested ) return; + if( db->mallocFailed || pParse->nErr ){ + if( pParse->rc==SQLITE_OK ) pParse->rc = SQLITE_ERROR; + return; + } + + /* Begin by generating some termination code at the end of the + ** vdbe program + */ + v = sqlite3GetVdbe(pParse); + assert( !pParse->isMultiWrite + || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort)); + if( v ){ + sqlite3VdbeAddOp0(v, OP_Halt); + +#if SQLITE_USER_AUTHENTICATION + if( pParse->nTableLock>0 && db->init.busy==0 ){ + sqlite3UserAuthInit(db); + if( db->auth.authLevelrc = SQLITE_AUTH_USER; + return; + } + } +#endif + + /* The cookie mask contains one bit for each database file open. + ** (Bit 0 is for main, bit 1 is for temp, and so forth.) Bits are + ** set for each database that is used. Generate code to start a + ** transaction on each used database and to verify the schema cookie + ** on each used database. + */ + if( db->mallocFailed==0 + && (DbMaskNonZero(pParse->cookieMask) || pParse->pConstExpr) + ){ + int iDb, i; + assert( sqlite3VdbeGetOp(v, 0)->opcode==OP_Init ); + sqlite3VdbeJumpHere(v, 0); + for(iDb=0; iDbnDb; iDb++){ + Schema *pSchema; + if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue; + sqlite3VdbeUsesBtree(v, iDb); + pSchema = db->aDb[iDb].pSchema; + sqlite3VdbeAddOp4Int(v, + OP_Transaction, /* Opcode */ + iDb, /* P1 */ + DbMaskTest(pParse->writeMask,iDb), /* P2 */ + pSchema->schema_cookie, /* P3 */ + pSchema->iGeneration /* P4 */ + ); + if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1); + VdbeComment((v, + "usesStmtJournal=%d", pParse->mayAbort && pParse->isMultiWrite)); + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + for(i=0; inVtabLock; i++){ + char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]); + sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB); + } + pParse->nVtabLock = 0; +#endif + + /* Once all the cookies have been verified and transactions opened, + ** obtain the required table-locks. This is a no-op unless the + ** shared-cache feature is enabled. + */ + codeTableLocks(pParse); + + /* Initialize any AUTOINCREMENT data structures required. + */ + sqlite3AutoincrementBegin(pParse); + + /* Code constant expressions that where factored out of inner loops. + ** + ** The pConstExpr list might also contain expressions that we simply + ** want to keep around until the Parse object is deleted. Such + ** expressions have iConstExprReg==0. Do not generate code for + ** those expressions, of course. + */ + if( pParse->pConstExpr ){ + ExprList *pEL = pParse->pConstExpr; + pParse->okConstFactor = 0; + for(i=0; inExpr; i++){ + int iReg = pEL->a[i].u.iConstExprReg; + if( iReg>0 ){ + sqlite3ExprCode(pParse, pEL->a[i].pExpr, iReg); + } + } + } + + /* Finally, jump back to the beginning of the executable code. */ + sqlite3VdbeGoto(v, 1); + } + } + + + /* Get the VDBE program ready for execution + */ + if( v && pParse->nErr==0 && !db->mallocFailed ){ + /* A minimum of one cursor is required if autoincrement is used + * See ticket [a696379c1f08866] */ + assert( pParse->pAinc==0 || pParse->nTab>0 ); + sqlite3VdbeMakeReady(v, pParse); + pParse->rc = SQLITE_DONE; + }else{ + pParse->rc = SQLITE_ERROR; + } +} + +/* +** Run the parser and code generator recursively in order to generate +** code for the SQL statement given onto the end of the pParse context +** currently under construction. When the parser is run recursively +** this way, the final OP_Halt is not appended and other initialization +** and finalization steps are omitted because those are handling by the +** outermost parser. +** +** Not everything is nestable. This facility is designed to permit +** INSERT, UPDATE, and DELETE operations against the schema table. Use +** care if you decide to try to use this routine for some other purposes. +*/ +SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){ + va_list ap; + char *zSql; + char *zErrMsg = 0; + sqlite3 *db = pParse->db; + char saveBuf[PARSE_TAIL_SZ]; + + if( pParse->nErr ) return; + assert( pParse->nested<10 ); /* Nesting should only be of limited depth */ + va_start(ap, zFormat); + zSql = sqlite3VMPrintf(db, zFormat, ap); + va_end(ap); + if( zSql==0 ){ + /* This can result either from an OOM or because the formatted string + ** exceeds SQLITE_LIMIT_LENGTH. In the latter case, we need to set + ** an error */ + if( !db->mallocFailed ) pParse->rc = SQLITE_TOOBIG; + pParse->nErr++; + return; + } + pParse->nested++; + memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ); + memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ); + sqlite3RunParser(pParse, zSql, &zErrMsg); + sqlite3DbFree(db, zErrMsg); + sqlite3DbFree(db, zSql); + memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ); + pParse->nested--; +} + +#if SQLITE_USER_AUTHENTICATION +/* +** Return TRUE if zTable is the name of the system table that stores the +** list of users and their access credentials. +*/ +SQLITE_PRIVATE int sqlite3UserAuthTable(const char *zTable){ + return sqlite3_stricmp(zTable, "sqlite_user")==0; +} +#endif + +/* +** Locate the in-memory structure that describes a particular database +** table given the name of that table and (optionally) the name of the +** database containing the table. Return NULL if not found. +** +** If zDatabase is 0, all databases are searched for the table and the +** first matching table is returned. (No checking for duplicate table +** names is done.) The search order is TEMP first, then MAIN, then any +** auxiliary databases added using the ATTACH command. +** +** See also sqlite3LocateTable(). +*/ +SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){ + Table *p = 0; + int i; + + /* All mutexes are required for schema access. Make sure we hold them. */ + assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) ); +#if SQLITE_USER_AUTHENTICATION + /* Only the admin user is allowed to know that the sqlite_user table + ** exists */ + if( db->auth.authLevelnDb; i++){ + if( sqlite3StrICmp(zDatabase, db->aDb[i].zDbSName)==0 ) break; + } + if( i>=db->nDb ){ + /* No match against the official names. But always match "main" + ** to schema 0 as a legacy fallback. */ + if( sqlite3StrICmp(zDatabase,"main")==0 ){ + i = 0; + }else{ + return 0; + } + } + p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName); + if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){ + if( i==1 ){ + if( sqlite3StrICmp(zName+7, &ALT_TEMP_SCHEMA_TABLE[7])==0 + || sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0 + || sqlite3StrICmp(zName+7, &DFLT_SCHEMA_TABLE[7])==0 + ){ + p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, + DFLT_TEMP_SCHEMA_TABLE); + } + }else{ + if( sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0 ){ + p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, + DFLT_SCHEMA_TABLE); + } + } + } + }else{ + /* Match against TEMP first */ + p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, zName); + if( p ) return p; + /* The main database is second */ + p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, zName); + if( p ) return p; + /* Attached databases are in order of attachment */ + for(i=2; inDb; i++){ + assert( sqlite3SchemaMutexHeld(db, i, 0) ); + p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName); + if( p ) break; + } + if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){ + if( sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0 ){ + p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, DFLT_SCHEMA_TABLE); + }else if( sqlite3StrICmp(zName+7, &ALT_TEMP_SCHEMA_TABLE[7])==0 ){ + p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, + DFLT_TEMP_SCHEMA_TABLE); + } + } + } + return p; +} + +/* +** Locate the in-memory structure that describes a particular database +** table given the name of that table and (optionally) the name of the +** database containing the table. Return NULL if not found. Also leave an +** error message in pParse->zErrMsg. +** +** The difference between this routine and sqlite3FindTable() is that this +** routine leaves an error message in pParse->zErrMsg where +** sqlite3FindTable() does not. +*/ +SQLITE_PRIVATE Table *sqlite3LocateTable( + Parse *pParse, /* context in which to report errors */ + u32 flags, /* LOCATE_VIEW or LOCATE_NOERR */ + const char *zName, /* Name of the table we are looking for */ + const char *zDbase /* Name of the database. Might be NULL */ +){ + Table *p; + sqlite3 *db = pParse->db; + + /* Read the database schema. If an error occurs, leave an error message + ** and code in pParse and return NULL. */ + if( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0 + && SQLITE_OK!=sqlite3ReadSchema(pParse) + ){ + return 0; + } + + p = sqlite3FindTable(db, zName, zDbase); + if( p==0 ){ +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* If zName is the not the name of a table in the schema created using + ** CREATE, then check to see if it is the name of an virtual table that + ** can be an eponymous virtual table. */ + if( pParse->disableVtab==0 ){ + Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName); + if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){ + pMod = sqlite3PragmaVtabRegister(db, zName); + } + if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){ + return pMod->pEpoTab; + } + } +#endif + if( flags & LOCATE_NOERR ) return 0; + pParse->checkSchema = 1; + }else if( IsVirtual(p) && pParse->disableVtab ){ + p = 0; + } + + if( p==0 ){ + const char *zMsg = flags & LOCATE_VIEW ? "no such view" : "no such table"; + if( zDbase ){ + sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName); + }else{ + sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName); + } + } + + return p; +} + +/* +** Locate the table identified by *p. +** +** This is a wrapper around sqlite3LocateTable(). The difference between +** sqlite3LocateTable() and this function is that this function restricts +** the search to schema (p->pSchema) if it is not NULL. p->pSchema may be +** non-NULL if it is part of a view or trigger program definition. See +** sqlite3FixSrcList() for details. +*/ +SQLITE_PRIVATE Table *sqlite3LocateTableItem( + Parse *pParse, + u32 flags, + struct SrcList_item *p +){ + const char *zDb; + assert( p->pSchema==0 || p->zDatabase==0 ); + if( p->pSchema ){ + int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema); + zDb = pParse->db->aDb[iDb].zDbSName; + }else{ + zDb = p->zDatabase; + } + return sqlite3LocateTable(pParse, flags, p->zName, zDb); +} + +/* +** Locate the in-memory structure that describes +** a particular index given the name of that index +** and the name of the database that contains the index. +** Return NULL if not found. +** +** If zDatabase is 0, all databases are searched for the +** table and the first matching index is returned. (No checking +** for duplicate index names is done.) The search order is +** TEMP first, then MAIN, then any auxiliary databases added +** using the ATTACH command. +*/ +SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){ + Index *p = 0; + int i; + /* All mutexes are required for schema access. Make sure we hold them. */ + assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) ); + for(i=OMIT_TEMPDB; inDb; i++){ + int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */ + Schema *pSchema = db->aDb[j].pSchema; + assert( pSchema ); + if( zDb && sqlite3DbIsNamed(db, j, zDb)==0 ) continue; + assert( sqlite3SchemaMutexHeld(db, j, 0) ); + p = sqlite3HashFind(&pSchema->idxHash, zName); + if( p ) break; + } + return p; +} + +/* +** Reclaim the memory used by an index +*/ +SQLITE_PRIVATE void sqlite3FreeIndex(sqlite3 *db, Index *p){ +#ifndef SQLITE_OMIT_ANALYZE + sqlite3DeleteIndexSamples(db, p); +#endif + sqlite3ExprDelete(db, p->pPartIdxWhere); + sqlite3ExprListDelete(db, p->aColExpr); + sqlite3DbFree(db, p->zColAff); + if( p->isResized ) sqlite3DbFree(db, (void *)p->azColl); +#ifdef SQLITE_ENABLE_STAT4 + sqlite3_free(p->aiRowEst); +#endif + sqlite3DbFree(db, p); +} + +/* +** For the index called zIdxName which is found in the database iDb, +** unlike that index from its Table then remove the index from +** the index hash table and free all memory structures associated +** with the index. +*/ +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){ + Index *pIndex; + Hash *pHash; + + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pHash = &db->aDb[iDb].pSchema->idxHash; + pIndex = sqlite3HashInsert(pHash, zIdxName, 0); + if( ALWAYS(pIndex) ){ + if( pIndex->pTable->pIndex==pIndex ){ + pIndex->pTable->pIndex = pIndex->pNext; + }else{ + Index *p; + /* Justification of ALWAYS(); The index must be on the list of + ** indices. */ + p = pIndex->pTable->pIndex; + while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; } + if( ALWAYS(p && p->pNext==pIndex) ){ + p->pNext = pIndex->pNext; + } + } + sqlite3FreeIndex(db, pIndex); + } + db->mDbFlags |= DBFLAG_SchemaChange; +} + +/* +** Look through the list of open database files in db->aDb[] and if +** any have been closed, remove them from the list. Reallocate the +** db->aDb[] structure to a smaller size, if possible. +** +** Entry 0 (the "main" database) and entry 1 (the "temp" database) +** are never candidates for being collapsed. +*/ +SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3 *db){ + int i, j; + for(i=j=2; inDb; i++){ + struct Db *pDb = &db->aDb[i]; + if( pDb->pBt==0 ){ + sqlite3DbFree(db, pDb->zDbSName); + pDb->zDbSName = 0; + continue; + } + if( jaDb[j] = db->aDb[i]; + } + j++; + } + db->nDb = j; + if( db->nDb<=2 && db->aDb!=db->aDbStatic ){ + memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0])); + sqlite3DbFree(db, db->aDb); + db->aDb = db->aDbStatic; + } +} + +/* +** Reset the schema for the database at index iDb. Also reset the +** TEMP schema. The reset is deferred if db->nSchemaLock is not zero. +** Deferred resets may be run by calling with iDb<0. +*/ +SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3 *db, int iDb){ + int i; + assert( iDbnDb ); + + if( iDb>=0 ){ + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + DbSetProperty(db, iDb, DB_ResetWanted); + DbSetProperty(db, 1, DB_ResetWanted); + db->mDbFlags &= ~DBFLAG_SchemaKnownOk; + } + + if( db->nSchemaLock==0 ){ + for(i=0; inDb; i++){ + if( DbHasProperty(db, i, DB_ResetWanted) ){ + sqlite3SchemaClear(db->aDb[i].pSchema); + } + } + } +} + +/* +** Erase all schema information from all attached databases (including +** "main" and "temp") for a single database connection. +*/ +SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){ + int i; + sqlite3BtreeEnterAll(db); + for(i=0; inDb; i++){ + Db *pDb = &db->aDb[i]; + if( pDb->pSchema ){ + if( db->nSchemaLock==0 ){ + sqlite3SchemaClear(pDb->pSchema); + }else{ + DbSetProperty(db, i, DB_ResetWanted); + } + } + } + db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk); + sqlite3VtabUnlockList(db); + sqlite3BtreeLeaveAll(db); + if( db->nSchemaLock==0 ){ + sqlite3CollapseDatabaseArray(db); + } +} + +/* +** This routine is called when a commit occurs. +*/ +SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3 *db){ + db->mDbFlags &= ~DBFLAG_SchemaChange; +} + +/* +** Delete memory allocated for the column names of a table or view (the +** Table.aCol[] array). +*/ +SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable){ + int i; + Column *pCol; + assert( pTable!=0 ); + if( (pCol = pTable->aCol)!=0 ){ + for(i=0; inCol; i++, pCol++){ + assert( pCol->zName==0 || pCol->hName==sqlite3StrIHash(pCol->zName) ); + sqlite3DbFree(db, pCol->zName); + sqlite3ExprDelete(db, pCol->pDflt); + sqlite3DbFree(db, pCol->zColl); + } + sqlite3DbFree(db, pTable->aCol); + } +} + +/* +** Remove the memory data structures associated with the given +** Table. No changes are made to disk by this routine. +** +** This routine just deletes the data structure. It does not unlink +** the table data structure from the hash table. But it does destroy +** memory structures of the indices and foreign keys associated with +** the table. +** +** The db parameter is optional. It is needed if the Table object +** contains lookaside memory. (Table objects in the schema do not use +** lookaside memory, but some ephemeral Table objects do.) Or the +** db parameter can be used with db->pnBytesFreed to measure the memory +** used by the Table object. +*/ +static void SQLITE_NOINLINE deleteTable(sqlite3 *db, Table *pTable){ + Index *pIndex, *pNext; + +#ifdef SQLITE_DEBUG + /* Record the number of outstanding lookaside allocations in schema Tables + ** prior to doing any free() operations. Since schema Tables do not use + ** lookaside, this number should not change. + ** + ** If malloc has already failed, it may be that it failed while allocating + ** a Table object that was going to be marked ephemeral. So do not check + ** that no lookaside memory is used in this case either. */ + int nLookaside = 0; + if( db && !db->mallocFailed && (pTable->tabFlags & TF_Ephemeral)==0 ){ + nLookaside = sqlite3LookasideUsed(db, 0); + } +#endif + + /* Delete all indices associated with this table. */ + for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){ + pNext = pIndex->pNext; + assert( pIndex->pSchema==pTable->pSchema + || (IsVirtual(pTable) && pIndex->idxType!=SQLITE_IDXTYPE_APPDEF) ); + if( (db==0 || db->pnBytesFreed==0) && !IsVirtual(pTable) ){ + char *zName = pIndex->zName; + TESTONLY ( Index *pOld = ) sqlite3HashInsert( + &pIndex->pSchema->idxHash, zName, 0 + ); + assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) ); + assert( pOld==pIndex || pOld==0 ); + } + sqlite3FreeIndex(db, pIndex); + } + + /* Delete any foreign keys attached to this table. */ + sqlite3FkDelete(db, pTable); + + /* Delete the Table structure itself. + */ + sqlite3DeleteColumnNames(db, pTable); + sqlite3DbFree(db, pTable->zName); + sqlite3DbFree(db, pTable->zColAff); + sqlite3SelectDelete(db, pTable->pSelect); + sqlite3ExprListDelete(db, pTable->pCheck); +#ifndef SQLITE_OMIT_VIRTUALTABLE + sqlite3VtabClear(db, pTable); +#endif + sqlite3DbFree(db, pTable); + + /* Verify that no lookaside memory was used by schema tables */ + assert( nLookaside==0 || nLookaside==sqlite3LookasideUsed(db,0) ); +} +SQLITE_PRIVATE void sqlite3DeleteTable(sqlite3 *db, Table *pTable){ + /* Do not delete the table until the reference count reaches zero. */ + if( !pTable ) return; + if( ((!db || db->pnBytesFreed==0) && (--pTable->nTabRef)>0) ) return; + deleteTable(db, pTable); +} + + +/* +** Unlink the given table from the hash tables and the delete the +** table structure with all its indices and foreign keys. +*/ +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){ + Table *p; + Db *pDb; + + assert( db!=0 ); + assert( iDb>=0 && iDbnDb ); + assert( zTabName ); + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */ + pDb = &db->aDb[iDb]; + p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, 0); + sqlite3DeleteTable(db, p); + db->mDbFlags |= DBFLAG_SchemaChange; +} + +/* +** Given a token, return a string that consists of the text of that +** token. Space to hold the returned string +** is obtained from sqliteMalloc() and must be freed by the calling +** function. +** +** Any quotation marks (ex: "name", 'name', [name], or `name`) that +** surround the body of the token are removed. +** +** Tokens are often just pointers into the original SQL text and so +** are not \000 terminated and are not persistent. The returned string +** is \000 terminated and is persistent. +*/ +SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3 *db, Token *pName){ + char *zName; + if( pName ){ + zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n); + sqlite3Dequote(zName); + }else{ + zName = 0; + } + return zName; +} + +/* +** Open the sqlite_schema table stored in database number iDb for +** writing. The table is opened using cursor 0. +*/ +SQLITE_PRIVATE void sqlite3OpenSchemaTable(Parse *p, int iDb){ + Vdbe *v = sqlite3GetVdbe(p); + sqlite3TableLock(p, iDb, SCHEMA_ROOT, 1, DFLT_SCHEMA_TABLE); + sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, SCHEMA_ROOT, iDb, 5); + if( p->nTab==0 ){ + p->nTab = 1; + } +} + +/* +** Parameter zName points to a nul-terminated buffer containing the name +** of a database ("main", "temp" or the name of an attached db). This +** function returns the index of the named database in db->aDb[], or +** -1 if the named db cannot be found. +*/ +SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *db, const char *zName){ + int i = -1; /* Database number */ + if( zName ){ + Db *pDb; + for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){ + if( 0==sqlite3_stricmp(pDb->zDbSName, zName) ) break; + /* "main" is always an acceptable alias for the primary database + ** even if it has been renamed using SQLITE_DBCONFIG_MAINDBNAME. */ + if( i==0 && 0==sqlite3_stricmp("main", zName) ) break; + } + } + return i; +} + +/* +** The token *pName contains the name of a database (either "main" or +** "temp" or the name of an attached db). This routine returns the +** index of the named database in db->aDb[], or -1 if the named db +** does not exist. +*/ +SQLITE_PRIVATE int sqlite3FindDb(sqlite3 *db, Token *pName){ + int i; /* Database number */ + char *zName; /* Name we are searching for */ + zName = sqlite3NameFromToken(db, pName); + i = sqlite3FindDbName(db, zName); + sqlite3DbFree(db, zName); + return i; +} + +/* The table or view or trigger name is passed to this routine via tokens +** pName1 and pName2. If the table name was fully qualified, for example: +** +** CREATE TABLE xxx.yyy (...); +** +** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if +** the table name is not fully qualified, i.e.: +** +** CREATE TABLE yyy(...); +** +** Then pName1 is set to "yyy" and pName2 is "". +** +** This routine sets the *ppUnqual pointer to point at the token (pName1 or +** pName2) that stores the unqualified table name. The index of the +** database "xxx" is returned. +*/ +SQLITE_PRIVATE int sqlite3TwoPartName( + Parse *pParse, /* Parsing and code generating context */ + Token *pName1, /* The "xxx" in the name "xxx.yyy" or "xxx" */ + Token *pName2, /* The "yyy" in the name "xxx.yyy" */ + Token **pUnqual /* Write the unqualified object name here */ +){ + int iDb; /* Database holding the object */ + sqlite3 *db = pParse->db; + + assert( pName2!=0 ); + if( pName2->n>0 ){ + if( db->init.busy ) { + sqlite3ErrorMsg(pParse, "corrupt database"); + return -1; + } + *pUnqual = pName2; + iDb = sqlite3FindDb(db, pName1); + if( iDb<0 ){ + sqlite3ErrorMsg(pParse, "unknown database %T", pName1); + return -1; + } + }else{ + assert( db->init.iDb==0 || db->init.busy || IN_RENAME_OBJECT + || (db->mDbFlags & DBFLAG_Vacuum)!=0); + iDb = db->init.iDb; + *pUnqual = pName1; + } + return iDb; +} + +/* +** True if PRAGMA writable_schema is ON +*/ +SQLITE_PRIVATE int sqlite3WritableSchema(sqlite3 *db){ + testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==0 ); + testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))== + SQLITE_WriteSchema ); + testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))== + SQLITE_Defensive ); + testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))== + (SQLITE_WriteSchema|SQLITE_Defensive) ); + return (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==SQLITE_WriteSchema; +} + +/* +** This routine is used to check if the UTF-8 string zName is a legal +** unqualified name for a new schema object (table, index, view or +** trigger). All names are legal except those that begin with the string +** "sqlite_" (in upper, lower or mixed case). This portion of the namespace +** is reserved for internal use. +** +** When parsing the sqlite_schema table, this routine also checks to +** make sure the "type", "name", and "tbl_name" columns are consistent +** with the SQL. +*/ +SQLITE_PRIVATE int sqlite3CheckObjectName( + Parse *pParse, /* Parsing context */ + const char *zName, /* Name of the object to check */ + const char *zType, /* Type of this object */ + const char *zTblName /* Parent table name for triggers and indexes */ +){ + sqlite3 *db = pParse->db; + if( sqlite3WritableSchema(db) + || db->init.imposterTable + || !sqlite3Config.bExtraSchemaChecks + ){ + /* Skip these error checks for writable_schema=ON */ + return SQLITE_OK; + } + if( db->init.busy ){ + if( sqlite3_stricmp(zType, db->init.azInit[0]) + || sqlite3_stricmp(zName, db->init.azInit[1]) + || sqlite3_stricmp(zTblName, db->init.azInit[2]) + ){ + sqlite3ErrorMsg(pParse, ""); /* corruptSchema() will supply the error */ + return SQLITE_ERROR; + } + }else{ + if( (pParse->nested==0 && 0==sqlite3StrNICmp(zName, "sqlite_", 7)) + || (sqlite3ReadOnlyShadowTables(db) && sqlite3ShadowTableName(db, zName)) + ){ + sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", + zName); + return SQLITE_ERROR; + } + + } + return SQLITE_OK; +} + +/* +** Return the PRIMARY KEY index of a table +*/ +SQLITE_PRIVATE Index *sqlite3PrimaryKeyIndex(Table *pTab){ + Index *p; + for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){} + return p; +} + +/* +** Convert an table column number into a index column number. That is, +** for the column iCol in the table (as defined by the CREATE TABLE statement) +** find the (first) offset of that column in index pIdx. Or return -1 +** if column iCol is not used in index pIdx. +*/ +SQLITE_PRIVATE i16 sqlite3TableColumnToIndex(Index *pIdx, i16 iCol){ + int i; + for(i=0; inColumn; i++){ + if( iCol==pIdx->aiColumn[i] ) return i; + } + return -1; +} + +#ifndef SQLITE_OMIT_GENERATED_COLUMNS +/* Convert a storage column number into a table column number. +** +** The storage column number (0,1,2,....) is the index of the value +** as it appears in the record on disk. The true column number +** is the index (0,1,2,...) of the column in the CREATE TABLE statement. +** +** The storage column number is less than the table column number if +** and only there are VIRTUAL columns to the left. +** +** If SQLITE_OMIT_GENERATED_COLUMNS, this routine is a no-op macro. +*/ +SQLITE_PRIVATE i16 sqlite3StorageColumnToTable(Table *pTab, i16 iCol){ + if( pTab->tabFlags & TF_HasVirtual ){ + int i; + for(i=0; i<=iCol; i++){ + if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) iCol++; + } + } + return iCol; +} +#endif + +#ifndef SQLITE_OMIT_GENERATED_COLUMNS +/* Convert a table column number into a storage column number. +** +** The storage column number (0,1,2,....) is the index of the value +** as it appears in the record on disk. Or, if the input column is +** the N-th virtual column (zero-based) then the storage number is +** the number of non-virtual columns in the table plus N. +** +** The true column number is the index (0,1,2,...) of the column in +** the CREATE TABLE statement. +** +** If the input column is a VIRTUAL column, then it should not appear +** in storage. But the value sometimes is cached in registers that +** follow the range of registers used to construct storage. This +** avoids computing the same VIRTUAL column multiple times, and provides +** values for use by OP_Param opcodes in triggers. Hence, if the +** input column is a VIRTUAL table, put it after all the other columns. +** +** In the following, N means "normal column", S means STORED, and +** V means VIRTUAL. Suppose the CREATE TABLE has columns like this: +** +** CREATE TABLE ex(N,S,V,N,S,V,N,S,V); +** -- 0 1 2 3 4 5 6 7 8 +** +** Then the mapping from this function is as follows: +** +** INPUTS: 0 1 2 3 4 5 6 7 8 +** OUTPUTS: 0 1 6 2 3 7 4 5 8 +** +** So, in other words, this routine shifts all the virtual columns to +** the end. +** +** If SQLITE_OMIT_GENERATED_COLUMNS then there are no virtual columns and +** this routine is a no-op macro. If the pTab does not have any virtual +** columns, then this routine is no-op that always return iCol. If iCol +** is negative (indicating the ROWID column) then this routine return iCol. +*/ +SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){ + int i; + i16 n; + assert( iColnCol ); + if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol; + for(i=0, n=0; iaCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) n++; + } + if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ){ + /* iCol is a virtual column itself */ + return pTab->nNVCol + i - n; + }else{ + /* iCol is a normal or stored column */ + return n; + } +} +#endif + +/* +** Begin constructing a new table representation in memory. This is +** the first of several action routines that get called in response +** to a CREATE TABLE statement. In particular, this routine is called +** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp +** flag is true if the table should be stored in the auxiliary database +** file instead of in the main database file. This is normally the case +** when the "TEMP" or "TEMPORARY" keyword occurs in between +** CREATE and TABLE. +** +** The new table record is initialized and put in pParse->pNewTable. +** As more of the CREATE TABLE statement is parsed, additional action +** routines will be called to add more information to this record. +** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine +** is called to complete the construction of the new table record. +*/ +SQLITE_PRIVATE void sqlite3StartTable( + Parse *pParse, /* Parser context */ + Token *pName1, /* First part of the name of the table or view */ + Token *pName2, /* Second part of the name of the table or view */ + int isTemp, /* True if this is a TEMP table */ + int isView, /* True if this is a VIEW */ + int isVirtual, /* True if this is a VIRTUAL table */ + int noErr /* Do nothing if table already exists */ +){ + Table *pTable; + char *zName = 0; /* The name of the new table */ + sqlite3 *db = pParse->db; + Vdbe *v; + int iDb; /* Database number to create the table in */ + Token *pName; /* Unqualified name of the table to create */ + + if( db->init.busy && db->init.newTnum==1 ){ + /* Special case: Parsing the sqlite_schema or sqlite_temp_schema schema */ + iDb = db->init.iDb; + zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb)); + pName = pName1; + }else{ + /* The common case */ + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName); + if( iDb<0 ) return; + if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){ + /* If creating a temp table, the name may not be qualified. Unless + ** the database name is "temp" anyway. */ + sqlite3ErrorMsg(pParse, "temporary table name must be unqualified"); + return; + } + if( !OMIT_TEMPDB && isTemp ) iDb = 1; + zName = sqlite3NameFromToken(db, pName); + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenMap(pParse, (void*)zName, pName); + } + } + pParse->sNameToken = *pName; + if( zName==0 ) return; + if( sqlite3CheckObjectName(pParse, zName, isView?"view":"table", zName) ){ + goto begin_table_error; + } + if( db->init.iDb==1 ) isTemp = 1; +#ifndef SQLITE_OMIT_AUTHORIZATION + assert( isTemp==0 || isTemp==1 ); + assert( isView==0 || isView==1 ); + { + static const u8 aCode[] = { + SQLITE_CREATE_TABLE, + SQLITE_CREATE_TEMP_TABLE, + SQLITE_CREATE_VIEW, + SQLITE_CREATE_TEMP_VIEW + }; + char *zDb = db->aDb[iDb].zDbSName; + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){ + goto begin_table_error; + } + if( !isVirtual && sqlite3AuthCheck(pParse, (int)aCode[isTemp+2*isView], + zName, 0, zDb) ){ + goto begin_table_error; + } + } +#endif + + /* Make sure the new table name does not collide with an existing + ** index or table name in the same database. Issue an error message if + ** it does. The exception is if the statement being parsed was passed + ** to an sqlite3_declare_vtab() call. In that case only the column names + ** and types will be used, so there is no need to test for namespace + ** collisions. + */ + if( !IN_SPECIAL_PARSE ){ + char *zDb = db->aDb[iDb].zDbSName; + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto begin_table_error; + } + pTable = sqlite3FindTable(db, zName, zDb); + if( pTable ){ + if( !noErr ){ + sqlite3ErrorMsg(pParse, "table %T already exists", pName); + }else{ + assert( !db->init.busy || CORRUPT_DB ); + sqlite3CodeVerifySchema(pParse, iDb); + } + goto begin_table_error; + } + if( sqlite3FindIndex(db, zName, zDb)!=0 ){ + sqlite3ErrorMsg(pParse, "there is already an index named %s", zName); + goto begin_table_error; + } + } + + pTable = sqlite3DbMallocZero(db, sizeof(Table)); + if( pTable==0 ){ + assert( db->mallocFailed ); + pParse->rc = SQLITE_NOMEM_BKPT; + pParse->nErr++; + goto begin_table_error; + } + pTable->zName = zName; + pTable->iPKey = -1; + pTable->pSchema = db->aDb[iDb].pSchema; + pTable->nTabRef = 1; +#ifdef SQLITE_DEFAULT_ROWEST + pTable->nRowLogEst = sqlite3LogEst(SQLITE_DEFAULT_ROWEST); +#else + pTable->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) ); +#endif + assert( pParse->pNewTable==0 ); + pParse->pNewTable = pTable; + + /* If this is the magic sqlite_sequence table used by autoincrement, + ** then record a pointer to this table in the main database structure + ** so that INSERT can find the table easily. + */ +#ifndef SQLITE_OMIT_AUTOINCREMENT + if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){ + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pTable->pSchema->pSeqTab = pTable; + } +#endif + + /* Begin generating the code that will insert the table record into + ** the schema table. Note in particular that we must go ahead + ** and allocate the record number for the table entry now. Before any + ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause + ** indices to be created and the table record must come before the + ** indices. Hence, the record number for the table must be allocated + ** now. + */ + if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){ + int addr1; + int fileFormat; + int reg1, reg2, reg3; + /* nullRow[] is an OP_Record encoding of a row containing 5 NULLs */ + static const char nullRow[] = { 6, 0, 0, 0, 0, 0 }; + sqlite3BeginWriteOperation(pParse, 1, iDb); + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( isVirtual ){ + sqlite3VdbeAddOp0(v, OP_VBegin); + } +#endif + + /* If the file format and encoding in the database have not been set, + ** set them now. + */ + reg1 = pParse->regRowid = ++pParse->nMem; + reg2 = pParse->regRoot = ++pParse->nMem; + reg3 = ++pParse->nMem; + sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT); + sqlite3VdbeUsesBtree(v, iDb); + addr1 = sqlite3VdbeAddOp1(v, OP_If, reg3); VdbeCoverage(v); + fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ? + 1 : SQLITE_MAX_FILE_FORMAT; + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat); + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db)); + sqlite3VdbeJumpHere(v, addr1); + + /* This just creates a place-holder record in the sqlite_schema table. + ** The record created does not contain anything yet. It will be replaced + ** by the real entry in code generated at sqlite3EndTable(). + ** + ** The rowid for the new entry is left in register pParse->regRowid. + ** The root page number of the new table is left in reg pParse->regRoot. + ** The rowid and root page number values are needed by the code that + ** sqlite3EndTable will generate. + */ +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) + if( isView || isVirtual ){ + sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2); + }else +#endif + { + pParse->addrCrTab = + sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY); + } + sqlite3OpenSchemaTable(pParse, iDb); + sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1); + sqlite3VdbeAddOp4(v, OP_Blob, 6, reg3, 0, nullRow, P4_STATIC); + sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + sqlite3VdbeAddOp0(v, OP_Close); + } + + /* Normal (non-error) return. */ + return; + + /* If an error occurs, we jump here */ +begin_table_error: + sqlite3DbFree(db, zName); + return; +} + +/* Set properties of a table column based on the (magical) +** name of the column. +*/ +#if SQLITE_ENABLE_HIDDEN_COLUMNS +SQLITE_PRIVATE void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){ + if( sqlite3_strnicmp(pCol->zName, "__hidden__", 10)==0 ){ + pCol->colFlags |= COLFLAG_HIDDEN; + }else if( pTab && pCol!=pTab->aCol && (pCol[-1].colFlags & COLFLAG_HIDDEN) ){ + pTab->tabFlags |= TF_OOOHidden; + } +} +#endif + + +/* +** Add a new column to the table currently being constructed. +** +** The parser calls this routine once for each column declaration +** in a CREATE TABLE statement. sqlite3StartTable() gets called +** first to get things going. Then this routine is called for each +** column. +*/ +SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token *pName, Token *pType){ + Table *p; + int i; + char *z; + char *zType; + Column *pCol; + sqlite3 *db = pParse->db; + if( (p = pParse->pNewTable)==0 ) return; + if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){ + sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName); + return; + } + z = sqlite3DbMallocRaw(db, pName->n + pType->n + 2); + if( z==0 ) return; + if( IN_RENAME_OBJECT ) sqlite3RenameTokenMap(pParse, (void*)z, pName); + memcpy(z, pName->z, pName->n); + z[pName->n] = 0; + sqlite3Dequote(z); + for(i=0; inCol; i++){ + if( sqlite3_stricmp(z, p->aCol[i].zName)==0 ){ + sqlite3ErrorMsg(pParse, "duplicate column name: %s", z); + sqlite3DbFree(db, z); + return; + } + } + if( (p->nCol & 0x7)==0 ){ + Column *aNew; + aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0])); + if( aNew==0 ){ + sqlite3DbFree(db, z); + return; + } + p->aCol = aNew; + } + pCol = &p->aCol[p->nCol]; + memset(pCol, 0, sizeof(p->aCol[0])); + pCol->zName = z; + pCol->hName = sqlite3StrIHash(z); + sqlite3ColumnPropertiesFromName(p, pCol); + + if( pType->n==0 ){ + /* If there is no type specified, columns have the default affinity + ** 'BLOB' with a default size of 4 bytes. */ + pCol->affinity = SQLITE_AFF_BLOB; + pCol->szEst = 1; +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + if( 4>=sqlite3GlobalConfig.szSorterRef ){ + pCol->colFlags |= COLFLAG_SORTERREF; + } +#endif + }else{ + zType = z + sqlite3Strlen30(z) + 1; + memcpy(zType, pType->z, pType->n); + zType[pType->n] = 0; + sqlite3Dequote(zType); + pCol->affinity = sqlite3AffinityType(zType, pCol); + pCol->colFlags |= COLFLAG_HASTYPE; + } + p->nCol++; + p->nNVCol++; + pParse->constraintName.n = 0; +} + +/* +** This routine is called by the parser while in the middle of +** parsing a CREATE TABLE statement. A "NOT NULL" constraint has +** been seen on a column. This routine sets the notNull flag on +** the column currently under construction. +*/ +SQLITE_PRIVATE void sqlite3AddNotNull(Parse *pParse, int onError){ + Table *p; + Column *pCol; + p = pParse->pNewTable; + if( p==0 || NEVER(p->nCol<1) ) return; + pCol = &p->aCol[p->nCol-1]; + pCol->notNull = (u8)onError; + p->tabFlags |= TF_HasNotNull; + + /* Set the uniqNotNull flag on any UNIQUE or PK indexes already created + ** on this column. */ + if( pCol->colFlags & COLFLAG_UNIQUE ){ + Index *pIdx; + for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){ + assert( pIdx->nKeyCol==1 && pIdx->onError!=OE_None ); + if( pIdx->aiColumn[0]==p->nCol-1 ){ + pIdx->uniqNotNull = 1; + } + } + } +} + +/* +** Scan the column type name zType (length nType) and return the +** associated affinity type. +** +** This routine does a case-independent search of zType for the +** substrings in the following table. If one of the substrings is +** found, the corresponding affinity is returned. If zType contains +** more than one of the substrings, entries toward the top of +** the table take priority. For example, if zType is 'BLOBINT', +** SQLITE_AFF_INTEGER is returned. +** +** Substring | Affinity +** -------------------------------- +** 'INT' | SQLITE_AFF_INTEGER +** 'CHAR' | SQLITE_AFF_TEXT +** 'CLOB' | SQLITE_AFF_TEXT +** 'TEXT' | SQLITE_AFF_TEXT +** 'BLOB' | SQLITE_AFF_BLOB +** 'REAL' | SQLITE_AFF_REAL +** 'FLOA' | SQLITE_AFF_REAL +** 'DOUB' | SQLITE_AFF_REAL +** +** If none of the substrings in the above table are found, +** SQLITE_AFF_NUMERIC is returned. +*/ +SQLITE_PRIVATE char sqlite3AffinityType(const char *zIn, Column *pCol){ + u32 h = 0; + char aff = SQLITE_AFF_NUMERIC; + const char *zChar = 0; + + assert( zIn!=0 ); + while( zIn[0] ){ + h = (h<<8) + sqlite3UpperToLower[(*zIn)&0xff]; + zIn++; + if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){ /* CHAR */ + aff = SQLITE_AFF_TEXT; + zChar = zIn; + }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){ /* CLOB */ + aff = SQLITE_AFF_TEXT; + }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){ /* TEXT */ + aff = SQLITE_AFF_TEXT; + }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */ + && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){ + aff = SQLITE_AFF_BLOB; + if( zIn[0]=='(' ) zChar = zIn; +#ifndef SQLITE_OMIT_FLOATING_POINT + }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l') /* REAL */ + && aff==SQLITE_AFF_NUMERIC ){ + aff = SQLITE_AFF_REAL; + }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a') /* FLOA */ + && aff==SQLITE_AFF_NUMERIC ){ + aff = SQLITE_AFF_REAL; + }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b') /* DOUB */ + && aff==SQLITE_AFF_NUMERIC ){ + aff = SQLITE_AFF_REAL; +#endif + }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){ /* INT */ + aff = SQLITE_AFF_INTEGER; + break; + } + } + + /* If pCol is not NULL, store an estimate of the field size. The + ** estimate is scaled so that the size of an integer is 1. */ + if( pCol ){ + int v = 0; /* default size is approx 4 bytes */ + if( aff r=(k/4+1) */ + sqlite3GetInt32(zChar, &v); + break; + } + zChar++; + } + }else{ + v = 16; /* BLOB, TEXT, CLOB -> r=5 (approx 20 bytes)*/ + } + } +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + if( v>=sqlite3GlobalConfig.szSorterRef ){ + pCol->colFlags |= COLFLAG_SORTERREF; + } +#endif + v = v/4 + 1; + if( v>255 ) v = 255; + pCol->szEst = v; + } + return aff; +} + +/* +** The expression is the default value for the most recently added column +** of the table currently under construction. +** +** Default value expressions must be constant. Raise an exception if this +** is not the case. +** +** This routine is called by the parser while in the middle of +** parsing a CREATE TABLE statement. +*/ +SQLITE_PRIVATE void sqlite3AddDefaultValue( + Parse *pParse, /* Parsing context */ + Expr *pExpr, /* The parsed expression of the default value */ + const char *zStart, /* Start of the default value text */ + const char *zEnd /* First character past end of defaut value text */ +){ + Table *p; + Column *pCol; + sqlite3 *db = pParse->db; + p = pParse->pNewTable; + if( p!=0 ){ + int isInit = db->init.busy && db->init.iDb!=1; + pCol = &(p->aCol[p->nCol-1]); + if( !sqlite3ExprIsConstantOrFunction(pExpr, isInit) ){ + sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant", + pCol->zName); +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + }else if( pCol->colFlags & COLFLAG_GENERATED ){ + testcase( pCol->colFlags & COLFLAG_VIRTUAL ); + testcase( pCol->colFlags & COLFLAG_STORED ); + sqlite3ErrorMsg(pParse, "cannot use DEFAULT on a generated column"); +#endif + }else{ + /* A copy of pExpr is used instead of the original, as pExpr contains + ** tokens that point to volatile memory. + */ + Expr x; + sqlite3ExprDelete(db, pCol->pDflt); + memset(&x, 0, sizeof(x)); + x.op = TK_SPAN; + x.u.zToken = sqlite3DbSpanDup(db, zStart, zEnd); + x.pLeft = pExpr; + x.flags = EP_Skip; + pCol->pDflt = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE); + sqlite3DbFree(db, x.u.zToken); + } + } + if( IN_RENAME_OBJECT ){ + sqlite3RenameExprUnmap(pParse, pExpr); + } + sqlite3ExprDelete(db, pExpr); +} + +/* +** Backwards Compatibility Hack: +** +** Historical versions of SQLite accepted strings as column names in +** indexes and PRIMARY KEY constraints and in UNIQUE constraints. Example: +** +** CREATE TABLE xyz(a,b,c,d,e,PRIMARY KEY('a'),UNIQUE('b','c' COLLATE trim) +** CREATE INDEX abc ON xyz('c','d' DESC,'e' COLLATE nocase DESC); +** +** This is goofy. But to preserve backwards compatibility we continue to +** accept it. This routine does the necessary conversion. It converts +** the expression given in its argument from a TK_STRING into a TK_ID +** if the expression is just a TK_STRING with an optional COLLATE clause. +** If the expression is anything other than TK_STRING, the expression is +** unchanged. +*/ +static void sqlite3StringToId(Expr *p){ + if( p->op==TK_STRING ){ + p->op = TK_ID; + }else if( p->op==TK_COLLATE && p->pLeft->op==TK_STRING ){ + p->pLeft->op = TK_ID; + } +} + +/* +** Tag the given column as being part of the PRIMARY KEY +*/ +static void makeColumnPartOfPrimaryKey(Parse *pParse, Column *pCol){ + pCol->colFlags |= COLFLAG_PRIMKEY; +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( pCol->colFlags & COLFLAG_GENERATED ){ + testcase( pCol->colFlags & COLFLAG_VIRTUAL ); + testcase( pCol->colFlags & COLFLAG_STORED ); + sqlite3ErrorMsg(pParse, + "generated columns cannot be part of the PRIMARY KEY"); + } +#endif +} + +/* +** Designate the PRIMARY KEY for the table. pList is a list of names +** of columns that form the primary key. If pList is NULL, then the +** most recently added column of the table is the primary key. +** +** A table can have at most one primary key. If the table already has +** a primary key (and this is the second primary key) then create an +** error. +** +** If the PRIMARY KEY is on a single column whose datatype is INTEGER, +** then we will try to use that column as the rowid. Set the Table.iPKey +** field of the table under construction to be the index of the +** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is +** no INTEGER PRIMARY KEY. +** +** If the key is not an INTEGER PRIMARY KEY, then create a unique +** index for the key. No index is created for INTEGER PRIMARY KEYs. +*/ +SQLITE_PRIVATE void sqlite3AddPrimaryKey( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List of field names to be indexed */ + int onError, /* What to do with a uniqueness conflict */ + int autoInc, /* True if the AUTOINCREMENT keyword is present */ + int sortOrder /* SQLITE_SO_ASC or SQLITE_SO_DESC */ +){ + Table *pTab = pParse->pNewTable; + Column *pCol = 0; + int iCol = -1, i; + int nTerm; + if( pTab==0 ) goto primary_key_exit; + if( pTab->tabFlags & TF_HasPrimaryKey ){ + sqlite3ErrorMsg(pParse, + "table \"%s\" has more than one primary key", pTab->zName); + goto primary_key_exit; + } + pTab->tabFlags |= TF_HasPrimaryKey; + if( pList==0 ){ + iCol = pTab->nCol - 1; + pCol = &pTab->aCol[iCol]; + makeColumnPartOfPrimaryKey(pParse, pCol); + nTerm = 1; + }else{ + nTerm = pList->nExpr; + for(i=0; ia[i].pExpr); + assert( pCExpr!=0 ); + sqlite3StringToId(pCExpr); + if( pCExpr->op==TK_ID ){ + const char *zCName = pCExpr->u.zToken; + for(iCol=0; iColnCol; iCol++){ + if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zName)==0 ){ + pCol = &pTab->aCol[iCol]; + makeColumnPartOfPrimaryKey(pParse, pCol); + break; + } + } + } + } + } + if( nTerm==1 + && pCol + && sqlite3StrICmp(sqlite3ColumnType(pCol,""), "INTEGER")==0 + && sortOrder!=SQLITE_SO_DESC + ){ + if( IN_RENAME_OBJECT && pList ){ + Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr); + sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pCExpr); + } + pTab->iPKey = iCol; + pTab->keyConf = (u8)onError; + assert( autoInc==0 || autoInc==1 ); + pTab->tabFlags |= autoInc*TF_Autoincrement; + if( pList ) pParse->iPkSortOrder = pList->a[0].sortFlags; + (void)sqlite3HasExplicitNulls(pParse, pList); + }else if( autoInc ){ +#ifndef SQLITE_OMIT_AUTOINCREMENT + sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an " + "INTEGER PRIMARY KEY"); +#endif + }else{ + sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0, + 0, sortOrder, 0, SQLITE_IDXTYPE_PRIMARYKEY); + pList = 0; + } + +primary_key_exit: + sqlite3ExprListDelete(pParse->db, pList); + return; +} + +/* +** Add a new CHECK constraint to the table currently under construction. +*/ +SQLITE_PRIVATE void sqlite3AddCheckConstraint( + Parse *pParse, /* Parsing context */ + Expr *pCheckExpr, /* The check expression */ + const char *zStart, /* Opening "(" */ + const char *zEnd /* Closing ")" */ +){ +#ifndef SQLITE_OMIT_CHECK + Table *pTab = pParse->pNewTable; + sqlite3 *db = pParse->db; + if( pTab && !IN_DECLARE_VTAB + && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt) + ){ + pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr); + if( pParse->constraintName.n ){ + sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1); + }else{ + Token t; + for(zStart++; sqlite3Isspace(zStart[0]); zStart++){} + while( sqlite3Isspace(zEnd[-1]) ){ zEnd--; } + t.z = zStart; + t.n = (int)(zEnd - t.z); + sqlite3ExprListSetName(pParse, pTab->pCheck, &t, 1); + } + }else +#endif + { + sqlite3ExprDelete(pParse->db, pCheckExpr); + } +} + +/* +** Set the collation function of the most recently parsed table column +** to the CollSeq given. +*/ +SQLITE_PRIVATE void sqlite3AddCollateType(Parse *pParse, Token *pToken){ + Table *p; + int i; + char *zColl; /* Dequoted name of collation sequence */ + sqlite3 *db; + + if( (p = pParse->pNewTable)==0 || IN_RENAME_OBJECT ) return; + i = p->nCol-1; + db = pParse->db; + zColl = sqlite3NameFromToken(db, pToken); + if( !zColl ) return; + + if( sqlite3LocateCollSeq(pParse, zColl) ){ + Index *pIdx; + sqlite3DbFree(db, p->aCol[i].zColl); + p->aCol[i].zColl = zColl; + + /* If the column is declared as " PRIMARY KEY COLLATE ", + ** then an index may have been created on this column before the + ** collation type was added. Correct this if it is the case. + */ + for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){ + assert( pIdx->nKeyCol==1 ); + if( pIdx->aiColumn[0]==i ){ + pIdx->azColl[0] = p->aCol[i].zColl; + } + } + }else{ + sqlite3DbFree(db, zColl); + } +} + +/* Change the most recently parsed column to be a GENERATED ALWAYS AS +** column. +*/ +SQLITE_PRIVATE void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType){ +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + u8 eType = COLFLAG_VIRTUAL; + Table *pTab = pParse->pNewTable; + Column *pCol; + if( pTab==0 ){ + /* generated column in an CREATE TABLE IF NOT EXISTS that already exists */ + goto generated_done; + } + pCol = &(pTab->aCol[pTab->nCol-1]); + if( IN_DECLARE_VTAB ){ + sqlite3ErrorMsg(pParse, "virtual tables cannot use computed columns"); + goto generated_done; + } + if( pCol->pDflt ) goto generated_error; + if( pType ){ + if( pType->n==7 && sqlite3StrNICmp("virtual",pType->z,7)==0 ){ + /* no-op */ + }else if( pType->n==6 && sqlite3StrNICmp("stored",pType->z,6)==0 ){ + eType = COLFLAG_STORED; + }else{ + goto generated_error; + } + } + if( eType==COLFLAG_VIRTUAL ) pTab->nNVCol--; + pCol->colFlags |= eType; + assert( TF_HasVirtual==COLFLAG_VIRTUAL ); + assert( TF_HasStored==COLFLAG_STORED ); + pTab->tabFlags |= eType; + if( pCol->colFlags & COLFLAG_PRIMKEY ){ + makeColumnPartOfPrimaryKey(pParse, pCol); /* For the error message */ + } + pCol->pDflt = pExpr; + pExpr = 0; + goto generated_done; + +generated_error: + sqlite3ErrorMsg(pParse, "error in generated column \"%s\"", + pCol->zName); +generated_done: + sqlite3ExprDelete(pParse->db, pExpr); +#else + /* Throw and error for the GENERATED ALWAYS AS clause if the + ** SQLITE_OMIT_GENERATED_COLUMNS compile-time option is used. */ + sqlite3ErrorMsg(pParse, "generated columns not supported"); + sqlite3ExprDelete(pParse->db, pExpr); +#endif +} + +/* +** Generate code that will increment the schema cookie. +** +** The schema cookie is used to determine when the schema for the +** database changes. After each schema change, the cookie value +** changes. When a process first reads the schema it records the +** cookie. Thereafter, whenever it goes to access the database, +** it checks the cookie to make sure the schema has not changed +** since it was last read. +** +** This plan is not completely bullet-proof. It is possible for +** the schema to change multiple times and for the cookie to be +** set back to prior value. But schema changes are infrequent +** and the probability of hitting the same cookie value is only +** 1 chance in 2^32. So we're safe enough. +** +** IMPLEMENTATION-OF: R-34230-56049 SQLite automatically increments +** the schema-version whenever the schema changes. +*/ +SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){ + sqlite3 *db = pParse->db; + Vdbe *v = pParse->pVdbe; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION, + (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie)); +} + +/* +** Measure the number of characters needed to output the given +** identifier. The number returned includes any quotes used +** but does not include the null terminator. +** +** The estimate is conservative. It might be larger that what is +** really needed. +*/ +static int identLength(const char *z){ + int n; + for(n=0; *z; n++, z++){ + if( *z=='"' ){ n++; } + } + return n + 2; +} + +/* +** The first parameter is a pointer to an output buffer. The second +** parameter is a pointer to an integer that contains the offset at +** which to write into the output buffer. This function copies the +** nul-terminated string pointed to by the third parameter, zSignedIdent, +** to the specified offset in the buffer and updates *pIdx to refer +** to the first byte after the last byte written before returning. +** +** If the string zSignedIdent consists entirely of alpha-numeric +** characters, does not begin with a digit and is not an SQL keyword, +** then it is copied to the output buffer exactly as it is. Otherwise, +** it is quoted using double-quotes. +*/ +static void identPut(char *z, int *pIdx, char *zSignedIdent){ + unsigned char *zIdent = (unsigned char*)zSignedIdent; + int i, j, needQuote; + i = *pIdx; + + for(j=0; zIdent[j]; j++){ + if( !sqlite3Isalnum(zIdent[j]) && zIdent[j]!='_' ) break; + } + needQuote = sqlite3Isdigit(zIdent[0]) + || sqlite3KeywordCode(zIdent, j)!=TK_ID + || zIdent[j]!=0 + || j==0; + + if( needQuote ) z[i++] = '"'; + for(j=0; zIdent[j]; j++){ + z[i++] = zIdent[j]; + if( zIdent[j]=='"' ) z[i++] = '"'; + } + if( needQuote ) z[i++] = '"'; + z[i] = 0; + *pIdx = i; +} + +/* +** Generate a CREATE TABLE statement appropriate for the given +** table. Memory to hold the text of the statement is obtained +** from sqliteMalloc() and must be freed by the calling function. +*/ +static char *createTableStmt(sqlite3 *db, Table *p){ + int i, k, n; + char *zStmt; + char *zSep, *zSep2, *zEnd; + Column *pCol; + n = 0; + for(pCol = p->aCol, i=0; inCol; i++, pCol++){ + n += identLength(pCol->zName) + 5; + } + n += identLength(p->zName); + if( n<50 ){ + zSep = ""; + zSep2 = ","; + zEnd = ")"; + }else{ + zSep = "\n "; + zSep2 = ",\n "; + zEnd = "\n)"; + } + n += 35 + 6*p->nCol; + zStmt = sqlite3DbMallocRaw(0, n); + if( zStmt==0 ){ + sqlite3OomFault(db); + return 0; + } + sqlite3_snprintf(n, zStmt, "CREATE TABLE "); + k = sqlite3Strlen30(zStmt); + identPut(zStmt, &k, p->zName); + zStmt[k++] = '('; + for(pCol=p->aCol, i=0; inCol; i++, pCol++){ + static const char * const azType[] = { + /* SQLITE_AFF_BLOB */ "", + /* SQLITE_AFF_TEXT */ " TEXT", + /* SQLITE_AFF_NUMERIC */ " NUM", + /* SQLITE_AFF_INTEGER */ " INT", + /* SQLITE_AFF_REAL */ " REAL" + }; + int len; + const char *zType; + + sqlite3_snprintf(n-k, &zStmt[k], zSep); + k += sqlite3Strlen30(&zStmt[k]); + zSep = zSep2; + identPut(zStmt, &k, pCol->zName); + assert( pCol->affinity-SQLITE_AFF_BLOB >= 0 ); + assert( pCol->affinity-SQLITE_AFF_BLOB < ArraySize(azType) ); + testcase( pCol->affinity==SQLITE_AFF_BLOB ); + testcase( pCol->affinity==SQLITE_AFF_TEXT ); + testcase( pCol->affinity==SQLITE_AFF_NUMERIC ); + testcase( pCol->affinity==SQLITE_AFF_INTEGER ); + testcase( pCol->affinity==SQLITE_AFF_REAL ); + + zType = azType[pCol->affinity - SQLITE_AFF_BLOB]; + len = sqlite3Strlen30(zType); + assert( pCol->affinity==SQLITE_AFF_BLOB + || pCol->affinity==sqlite3AffinityType(zType, 0) ); + memcpy(&zStmt[k], zType, len); + k += len; + assert( k<=n ); + } + sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd); + return zStmt; +} + +/* +** Resize an Index object to hold N columns total. Return SQLITE_OK +** on success and SQLITE_NOMEM on an OOM error. +*/ +static int resizeIndexObject(sqlite3 *db, Index *pIdx, int N){ + char *zExtra; + int nByte; + if( pIdx->nColumn>=N ) return SQLITE_OK; + assert( pIdx->isResized==0 ); + nByte = (sizeof(char*) + sizeof(LogEst) + sizeof(i16) + 1)*N; + zExtra = sqlite3DbMallocZero(db, nByte); + if( zExtra==0 ) return SQLITE_NOMEM_BKPT; + memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn); + pIdx->azColl = (const char**)zExtra; + zExtra += sizeof(char*)*N; + memcpy(zExtra, pIdx->aiRowLogEst, sizeof(LogEst)*(pIdx->nKeyCol+1)); + pIdx->aiRowLogEst = (LogEst*)zExtra; + zExtra += sizeof(LogEst)*N; + memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn); + pIdx->aiColumn = (i16*)zExtra; + zExtra += sizeof(i16)*N; + memcpy(zExtra, pIdx->aSortOrder, pIdx->nColumn); + pIdx->aSortOrder = (u8*)zExtra; + pIdx->nColumn = N; + pIdx->isResized = 1; + return SQLITE_OK; +} + +/* +** Estimate the total row width for a table. +*/ +static void estimateTableWidth(Table *pTab){ + unsigned wTable = 0; + const Column *pTabCol; + int i; + for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){ + wTable += pTabCol->szEst; + } + if( pTab->iPKey<0 ) wTable++; + pTab->szTabRow = sqlite3LogEst(wTable*4); +} + +/* +** Estimate the average size of a row for an index. +*/ +static void estimateIndexWidth(Index *pIdx){ + unsigned wIndex = 0; + int i; + const Column *aCol = pIdx->pTable->aCol; + for(i=0; inColumn; i++){ + i16 x = pIdx->aiColumn[i]; + assert( xpTable->nCol ); + wIndex += x<0 ? 1 : aCol[pIdx->aiColumn[i]].szEst; + } + pIdx->szIdxRow = sqlite3LogEst(wIndex*4); +} + +/* Return true if column number x is any of the first nCol entries of aiCol[]. +** This is used to determine if the column number x appears in any of the +** first nCol entries of an index. +*/ +static int hasColumn(const i16 *aiCol, int nCol, int x){ + while( nCol-- > 0 ){ + assert( aiCol[0]>=0 ); + if( x==*(aiCol++) ){ + return 1; + } + } + return 0; +} + +/* +** Return true if any of the first nKey entries of index pIdx exactly +** match the iCol-th entry of pPk. pPk is always a WITHOUT ROWID +** PRIMARY KEY index. pIdx is an index on the same table. pIdx may +** or may not be the same index as pPk. +** +** The first nKey entries of pIdx are guaranteed to be ordinary columns, +** not a rowid or expression. +** +** This routine differs from hasColumn() in that both the column and the +** collating sequence must match for this routine, but for hasColumn() only +** the column name must match. +*/ +static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){ + int i, j; + assert( nKey<=pIdx->nColumn ); + assert( iColnColumn,pPk->nKeyCol) ); + assert( pPk->idxType==SQLITE_IDXTYPE_PRIMARYKEY ); + assert( pPk->pTable->tabFlags & TF_WithoutRowid ); + assert( pPk->pTable==pIdx->pTable ); + testcase( pPk==pIdx ); + j = pPk->aiColumn[iCol]; + assert( j!=XN_ROWID && j!=XN_EXPR ); + for(i=0; iaiColumn[i]>=0 || j>=0 ); + if( pIdx->aiColumn[i]==j + && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0 + ){ + return 1; + } + } + return 0; +} + +/* Recompute the colNotIdxed field of the Index. +** +** colNotIdxed is a bitmask that has a 0 bit representing each indexed +** columns that are within the first 63 columns of the table. The +** high-order bit of colNotIdxed is always 1. All unindexed columns +** of the table have a 1. +** +** 2019-10-24: For the purpose of this computation, virtual columns are +** not considered to be covered by the index, even if they are in the +** index, because we do not trust the logic in whereIndexExprTrans() to be +** able to find all instances of a reference to the indexed table column +** and convert them into references to the index. Hence we always want +** the actual table at hand in order to recompute the virtual column, if +** necessary. +** +** The colNotIdxed mask is AND-ed with the SrcList.a[].colUsed mask +** to determine if the index is covering index. +*/ +static void recomputeColumnsNotIndexed(Index *pIdx){ + Bitmask m = 0; + int j; + Table *pTab = pIdx->pTable; + for(j=pIdx->nColumn-1; j>=0; j--){ + int x = pIdx->aiColumn[j]; + if( x>=0 && (pTab->aCol[x].colFlags & COLFLAG_VIRTUAL)==0 ){ + testcase( x==BMS-1 ); + testcase( x==BMS-2 ); + if( xcolNotIdxed = ~m; + assert( (pIdx->colNotIdxed>>63)==1 ); +} + +/* +** This routine runs at the end of parsing a CREATE TABLE statement that +** has a WITHOUT ROWID clause. The job of this routine is to convert both +** internal schema data structures and the generated VDBE code so that they +** are appropriate for a WITHOUT ROWID table instead of a rowid table. +** Changes include: +** +** (1) Set all columns of the PRIMARY KEY schema object to be NOT NULL. +** (2) Convert P3 parameter of the OP_CreateBtree from BTREE_INTKEY +** into BTREE_BLOBKEY. +** (3) Bypass the creation of the sqlite_schema table entry +** for the PRIMARY KEY as the primary key index is now +** identified by the sqlite_schema table entry of the table itself. +** (4) Set the Index.tnum of the PRIMARY KEY Index object in the +** schema to the rootpage from the main table. +** (5) Add all table columns to the PRIMARY KEY Index object +** so that the PRIMARY KEY is a covering index. The surplus +** columns are part of KeyInfo.nAllField and are not used for +** sorting or lookup or uniqueness checks. +** (6) Replace the rowid tail on all automatically generated UNIQUE +** indices with the PRIMARY KEY columns. +** +** For virtual tables, only (1) is performed. +*/ +static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){ + Index *pIdx; + Index *pPk; + int nPk; + int nExtra; + int i, j; + sqlite3 *db = pParse->db; + Vdbe *v = pParse->pVdbe; + + /* Mark every PRIMARY KEY column as NOT NULL (except for imposter tables) + */ + if( !db->init.imposterTable ){ + for(i=0; inCol; i++){ + if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0 ){ + pTab->aCol[i].notNull = OE_Abort; + } + } + pTab->tabFlags |= TF_HasNotNull; + } + + /* Convert the P3 operand of the OP_CreateBtree opcode from BTREE_INTKEY + ** into BTREE_BLOBKEY. + */ + if( pParse->addrCrTab ){ + assert( v ); + sqlite3VdbeChangeP3(v, pParse->addrCrTab, BTREE_BLOBKEY); + } + + /* Locate the PRIMARY KEY index. Or, if this table was originally + ** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index. + */ + if( pTab->iPKey>=0 ){ + ExprList *pList; + Token ipkToken; + sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zName); + pList = sqlite3ExprListAppend(pParse, 0, + sqlite3ExprAlloc(db, TK_ID, &ipkToken, 0)); + if( pList==0 ) return; + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey); + } + pList->a[0].sortFlags = pParse->iPkSortOrder; + assert( pParse->pNewTable==pTab ); + pTab->iPKey = -1; + sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0, + SQLITE_IDXTYPE_PRIMARYKEY); + if( db->mallocFailed || pParse->nErr ) return; + pPk = sqlite3PrimaryKeyIndex(pTab); + assert( pPk->nKeyCol==1 ); + }else{ + pPk = sqlite3PrimaryKeyIndex(pTab); + assert( pPk!=0 ); + + /* + ** Remove all redundant columns from the PRIMARY KEY. For example, change + ** "PRIMARY KEY(a,b,a,b,c,b,c,d)" into just "PRIMARY KEY(a,b,c,d)". Later + ** code assumes the PRIMARY KEY contains no repeated columns. + */ + for(i=j=1; inKeyCol; i++){ + if( isDupColumn(pPk, j, pPk, i) ){ + pPk->nColumn--; + }else{ + testcase( hasColumn(pPk->aiColumn, j, pPk->aiColumn[i]) ); + pPk->azColl[j] = pPk->azColl[i]; + pPk->aSortOrder[j] = pPk->aSortOrder[i]; + pPk->aiColumn[j++] = pPk->aiColumn[i]; + } + } + pPk->nKeyCol = j; + } + assert( pPk!=0 ); + pPk->isCovering = 1; + if( !db->init.imposterTable ) pPk->uniqNotNull = 1; + nPk = pPk->nColumn = pPk->nKeyCol; + + /* Bypass the creation of the PRIMARY KEY btree and the sqlite_schema + ** table entry. This is only required if currently generating VDBE + ** code for a CREATE TABLE (not when parsing one as part of reading + ** a database schema). */ + if( v && pPk->tnum>0 ){ + assert( db->init.busy==0 ); + sqlite3VdbeChangeOpcode(v, (int)pPk->tnum, OP_Goto); + } + + /* The root page of the PRIMARY KEY is the table root page */ + pPk->tnum = pTab->tnum; + + /* Update the in-memory representation of all UNIQUE indices by converting + ** the final rowid column into one or more columns of the PRIMARY KEY. + */ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int n; + if( IsPrimaryKeyIndex(pIdx) ) continue; + for(i=n=0; inKeyCol, pPk, i) ){ + testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ); + n++; + } + } + if( n==0 ){ + /* This index is a superset of the primary key */ + pIdx->nColumn = pIdx->nKeyCol; + continue; + } + if( resizeIndexObject(db, pIdx, pIdx->nKeyCol+n) ) return; + for(i=0, j=pIdx->nKeyCol; inKeyCol, pPk, i) ){ + testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ); + pIdx->aiColumn[j] = pPk->aiColumn[i]; + pIdx->azColl[j] = pPk->azColl[i]; + if( pPk->aSortOrder[i] ){ + /* See ticket https://www.sqlite.org/src/info/bba7b69f9849b5bf */ + pIdx->bAscKeyBug = 1; + } + j++; + } + } + assert( pIdx->nColumn>=pIdx->nKeyCol+n ); + assert( pIdx->nColumn>=j ); + } + + /* Add all table columns to the PRIMARY KEY index + */ + nExtra = 0; + for(i=0; inCol; i++){ + if( !hasColumn(pPk->aiColumn, nPk, i) + && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) nExtra++; + } + if( resizeIndexObject(db, pPk, nPk+nExtra) ) return; + for(i=0, j=nPk; inCol; i++){ + if( !hasColumn(pPk->aiColumn, j, i) + && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 + ){ + assert( jnColumn ); + pPk->aiColumn[j] = i; + pPk->azColl[j] = sqlite3StrBINARY; + j++; + } + } + assert( pPk->nColumn==j ); + assert( pTab->nNVCol<=j ); + recomputeColumnsNotIndexed(pPk); +} + + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Return true if pTab is a virtual table and zName is a shadow table name +** for that virtual table. +*/ +SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *zName){ + int nName; /* Length of zName */ + Module *pMod; /* Module for the virtual table */ + + if( !IsVirtual(pTab) ) return 0; + nName = sqlite3Strlen30(pTab->zName); + if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0; + if( zName[nName]!='_' ) return 0; + pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->azModuleArg[0]); + if( pMod==0 ) return 0; + if( pMod->pModule->iVersion<3 ) return 0; + if( pMod->pModule->xShadowName==0 ) return 0; + return pMod->pModule->xShadowName(zName+nName+1); +} +#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Return true if zName is a shadow table name in the current database +** connection. +** +** zName is temporarily modified while this routine is running, but is +** restored to its original value prior to this routine returning. +*/ +SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName){ + char *zTail; /* Pointer to the last "_" in zName */ + Table *pTab; /* Table that zName is a shadow of */ + zTail = strrchr(zName, '_'); + if( zTail==0 ) return 0; + *zTail = 0; + pTab = sqlite3FindTable(db, zName, 0); + *zTail = '_'; + if( pTab==0 ) return 0; + if( !IsVirtual(pTab) ) return 0; + return sqlite3IsShadowTableOf(db, pTab, zName); +} +#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */ + + +#ifdef SQLITE_DEBUG +/* +** Mark all nodes of an expression as EP_Immutable, indicating that +** they should not be changed. Expressions attached to a table or +** index definition are tagged this way to help ensure that we do +** not pass them into code generator routines by mistake. +*/ +static int markImmutableExprStep(Walker *pWalker, Expr *pExpr){ + ExprSetVVAProperty(pExpr, EP_Immutable); + return WRC_Continue; +} +static void markExprListImmutable(ExprList *pList){ + if( pList ){ + Walker w; + memset(&w, 0, sizeof(w)); + w.xExprCallback = markImmutableExprStep; + w.xSelectCallback = sqlite3SelectWalkNoop; + w.xSelectCallback2 = 0; + sqlite3WalkExprList(&w, pList); + } +} +#else +#define markExprListImmutable(X) /* no-op */ +#endif /* SQLITE_DEBUG */ + + +/* +** This routine is called to report the final ")" that terminates +** a CREATE TABLE statement. +** +** The table structure that other action routines have been building +** is added to the internal hash tables, assuming no errors have +** occurred. +** +** An entry for the table is made in the schema table on disk, unless +** this is a temporary table or db->init.busy==1. When db->init.busy==1 +** it means we are reading the sqlite_schema table because we just +** connected to the database or because the sqlite_schema table has +** recently changed, so the entry for this table already exists in +** the sqlite_schema table. We do not want to create it again. +** +** If the pSelect argument is not NULL, it means that this routine +** was called to create a table generated from a +** "CREATE TABLE ... AS SELECT ..." statement. The column names of +** the new table will match the result set of the SELECT. +*/ +SQLITE_PRIVATE void sqlite3EndTable( + Parse *pParse, /* Parse context */ + Token *pCons, /* The ',' token after the last column defn. */ + Token *pEnd, /* The ')' before options in the CREATE TABLE */ + u8 tabOpts, /* Extra table options. Usually 0. */ + Select *pSelect /* Select from a "CREATE ... AS SELECT" */ +){ + Table *p; /* The new table */ + sqlite3 *db = pParse->db; /* The database connection */ + int iDb; /* Database in which the table lives */ + Index *pIdx; /* An implied index of the table */ + + if( pEnd==0 && pSelect==0 ){ + return; + } + assert( !db->mallocFailed ); + p = pParse->pNewTable; + if( p==0 ) return; + + if( pSelect==0 && sqlite3ShadowTableName(db, p->zName) ){ + p->tabFlags |= TF_Shadow; + } + + /* If the db->init.busy is 1 it means we are reading the SQL off the + ** "sqlite_schema" or "sqlite_temp_schema" table on the disk. + ** So do not write to the disk again. Extract the root page number + ** for the table from the db->init.newTnum field. (The page number + ** should have been put there by the sqliteOpenCb routine.) + ** + ** If the root page number is 1, that means this is the sqlite_schema + ** table itself. So mark it read-only. + */ + if( db->init.busy ){ + if( pSelect ){ + sqlite3ErrorMsg(pParse, ""); + return; + } + p->tnum = db->init.newTnum; + if( p->tnum==1 ) p->tabFlags |= TF_Readonly; + } + + assert( (p->tabFlags & TF_HasPrimaryKey)==0 + || p->iPKey>=0 || sqlite3PrimaryKeyIndex(p)!=0 ); + assert( (p->tabFlags & TF_HasPrimaryKey)!=0 + || (p->iPKey<0 && sqlite3PrimaryKeyIndex(p)==0) ); + + /* Special processing for WITHOUT ROWID Tables */ + if( tabOpts & TF_WithoutRowid ){ + if( (p->tabFlags & TF_Autoincrement) ){ + sqlite3ErrorMsg(pParse, + "AUTOINCREMENT not allowed on WITHOUT ROWID tables"); + return; + } + if( (p->tabFlags & TF_HasPrimaryKey)==0 ){ + sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName); + return; + } + p->tabFlags |= TF_WithoutRowid | TF_NoVisibleRowid; + convertToWithoutRowidTable(pParse, p); + } + iDb = sqlite3SchemaToIndex(db, p->pSchema); + +#ifndef SQLITE_OMIT_CHECK + /* Resolve names in all CHECK constraint expressions. + */ + if( p->pCheck ){ + sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, p->pCheck); + if( pParse->nErr ){ + /* If errors are seen, delete the CHECK constraints now, else they might + ** actually be used if PRAGMA writable_schema=ON is set. */ + sqlite3ExprListDelete(db, p->pCheck); + p->pCheck = 0; + }else{ + markExprListImmutable(p->pCheck); + } + } +#endif /* !defined(SQLITE_OMIT_CHECK) */ +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( p->tabFlags & TF_HasGenerated ){ + int ii, nNG = 0; + testcase( p->tabFlags & TF_HasVirtual ); + testcase( p->tabFlags & TF_HasStored ); + for(ii=0; iinCol; ii++){ + u32 colFlags = p->aCol[ii].colFlags; + if( (colFlags & COLFLAG_GENERATED)!=0 ){ + Expr *pX = p->aCol[ii].pDflt; + testcase( colFlags & COLFLAG_VIRTUAL ); + testcase( colFlags & COLFLAG_STORED ); + if( sqlite3ResolveSelfReference(pParse, p, NC_GenCol, pX, 0) ){ + /* If there are errors in resolving the expression, change the + ** expression to a NULL. This prevents code generators that operate + ** on the expression from inserting extra parts into the expression + ** tree that have been allocated from lookaside memory, which is + ** illegal in a schema and will lead to errors or heap corruption + ** when the database connection closes. */ + sqlite3ExprDelete(db, pX); + p->aCol[ii].pDflt = sqlite3ExprAlloc(db, TK_NULL, 0, 0); + } + }else{ + nNG++; + } + } + if( nNG==0 ){ + sqlite3ErrorMsg(pParse, "must have at least one non-generated column"); + return; + } + } +#endif + + /* Estimate the average row size for the table and for all implied indices */ + estimateTableWidth(p); + for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){ + estimateIndexWidth(pIdx); + } + + /* If not initializing, then create a record for the new table + ** in the schema table of the database. + ** + ** If this is a TEMPORARY table, write the entry into the auxiliary + ** file instead of into the main database file. + */ + if( !db->init.busy ){ + int n; + Vdbe *v; + char *zType; /* "view" or "table" */ + char *zType2; /* "VIEW" or "TABLE" */ + char *zStmt; /* Text of the CREATE TABLE or CREATE VIEW statement */ + + v = sqlite3GetVdbe(pParse); + if( NEVER(v==0) ) return; + + sqlite3VdbeAddOp1(v, OP_Close, 0); + + /* + ** Initialize zType for the new view or table. + */ + if( p->pSelect==0 ){ + /* A regular table */ + zType = "table"; + zType2 = "TABLE"; +#ifndef SQLITE_OMIT_VIEW + }else{ + /* A view */ + zType = "view"; + zType2 = "VIEW"; +#endif + } + + /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT + ** statement to populate the new table. The root-page number for the + ** new table is in register pParse->regRoot. + ** + ** Once the SELECT has been coded by sqlite3Select(), it is in a + ** suitable state to query for the column names and types to be used + ** by the new table. + ** + ** A shared-cache write-lock is not required to write to the new table, + ** as a schema-lock must have already been obtained to create it. Since + ** a schema-lock excludes all other database users, the write-lock would + ** be redundant. + */ + if( pSelect ){ + SelectDest dest; /* Where the SELECT should store results */ + int regYield; /* Register holding co-routine entry-point */ + int addrTop; /* Top of the co-routine */ + int regRec; /* A record to be insert into the new table */ + int regRowid; /* Rowid of the next row to insert */ + int addrInsLoop; /* Top of the loop for inserting rows */ + Table *pSelTab; /* A table that describes the SELECT results */ + + regYield = ++pParse->nMem; + regRec = ++pParse->nMem; + regRowid = ++pParse->nMem; + assert(pParse->nTab==1); + sqlite3MayAbort(pParse); + sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb); + sqlite3VdbeChangeP5(v, OPFLAG_P2ISREG); + pParse->nTab = 2; + addrTop = sqlite3VdbeCurrentAddr(v) + 1; + sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop); + if( pParse->nErr ) return; + pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect, SQLITE_AFF_BLOB); + if( pSelTab==0 ) return; + assert( p->aCol==0 ); + p->nCol = p->nNVCol = pSelTab->nCol; + p->aCol = pSelTab->aCol; + pSelTab->nCol = 0; + pSelTab->aCol = 0; + sqlite3DeleteTable(db, pSelTab); + sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield); + sqlite3Select(pParse, pSelect, &dest); + if( pParse->nErr ) return; + sqlite3VdbeEndCoroutine(v, regYield); + sqlite3VdbeJumpHere(v, addrTop - 1); + addrInsLoop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_MakeRecord, dest.iSdst, dest.nSdst, regRec); + sqlite3TableAffinity(v, p, 0); + sqlite3VdbeAddOp2(v, OP_NewRowid, 1, regRowid); + sqlite3VdbeAddOp3(v, OP_Insert, 1, regRec, regRowid); + sqlite3VdbeGoto(v, addrInsLoop); + sqlite3VdbeJumpHere(v, addrInsLoop); + sqlite3VdbeAddOp1(v, OP_Close, 1); + } + + /* Compute the complete text of the CREATE statement */ + if( pSelect ){ + zStmt = createTableStmt(db, p); + }else{ + Token *pEnd2 = tabOpts ? &pParse->sLastToken : pEnd; + n = (int)(pEnd2->z - pParse->sNameToken.z); + if( pEnd2->z[0]!=';' ) n += pEnd2->n; + zStmt = sqlite3MPrintf(db, + "CREATE %s %.*s", zType2, n, pParse->sNameToken.z + ); + } + + /* A slot for the record has already been allocated in the + ** schema table. We just need to update that slot with all + ** the information we've collected. + */ + sqlite3NestedParse(pParse, + "UPDATE %Q." DFLT_SCHEMA_TABLE + " SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q" + " WHERE rowid=#%d", + db->aDb[iDb].zDbSName, + zType, + p->zName, + p->zName, + pParse->regRoot, + zStmt, + pParse->regRowid + ); + sqlite3DbFree(db, zStmt); + sqlite3ChangeCookie(pParse, iDb); + +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* Check to see if we need to create an sqlite_sequence table for + ** keeping track of autoincrement keys. + */ + if( (p->tabFlags & TF_Autoincrement)!=0 ){ + Db *pDb = &db->aDb[iDb]; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( pDb->pSchema->pSeqTab==0 ){ + sqlite3NestedParse(pParse, + "CREATE TABLE %Q.sqlite_sequence(name,seq)", + pDb->zDbSName + ); + } + } +#endif + + /* Reparse everything to update our internal data structures */ + sqlite3VdbeAddParseSchemaOp(v, iDb, + sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName)); + } + + /* Add the table to the in-memory representation of the database. + */ + if( db->init.busy ){ + Table *pOld; + Schema *pSchema = p->pSchema; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p); + if( pOld ){ + assert( p==pOld ); /* Malloc must have failed inside HashInsert() */ + sqlite3OomFault(db); + return; + } + pParse->pNewTable = 0; + db->mDbFlags |= DBFLAG_SchemaChange; + +#ifndef SQLITE_OMIT_ALTERTABLE + if( !p->pSelect ){ + const char *zName = (const char *)pParse->sNameToken.z; + int nName; + assert( !pSelect && pCons && pEnd ); + if( pCons->z==0 ){ + pCons = pEnd; + } + nName = (int)((const char *)pCons->z - zName); + p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName); + } +#endif + } +} + +#ifndef SQLITE_OMIT_VIEW +/* +** The parser calls this routine in order to create a new VIEW +*/ +SQLITE_PRIVATE void sqlite3CreateView( + Parse *pParse, /* The parsing context */ + Token *pBegin, /* The CREATE token that begins the statement */ + Token *pName1, /* The token that holds the name of the view */ + Token *pName2, /* The token that holds the name of the view */ + ExprList *pCNames, /* Optional list of view column names */ + Select *pSelect, /* A SELECT statement that will become the new view */ + int isTemp, /* TRUE for a TEMPORARY view */ + int noErr /* Suppress error messages if VIEW already exists */ +){ + Table *p; + int n; + const char *z; + Token sEnd; + DbFixer sFix; + Token *pName = 0; + int iDb; + sqlite3 *db = pParse->db; + + if( pParse->nVar>0 ){ + sqlite3ErrorMsg(pParse, "parameters are not allowed in views"); + goto create_view_fail; + } + sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr); + p = pParse->pNewTable; + if( p==0 || pParse->nErr ) goto create_view_fail; + sqlite3TwoPartName(pParse, pName1, pName2, &pName); + iDb = sqlite3SchemaToIndex(db, p->pSchema); + sqlite3FixInit(&sFix, pParse, iDb, "view", pName); + if( sqlite3FixSelect(&sFix, pSelect) ) goto create_view_fail; + + /* Make a copy of the entire SELECT statement that defines the view. + ** This will force all the Expr.token.z values to be dynamically + ** allocated rather than point to the input string - which means that + ** they will persist after the current sqlite3_exec() call returns. + */ + pSelect->selFlags |= SF_View; + if( IN_RENAME_OBJECT ){ + p->pSelect = pSelect; + pSelect = 0; + }else{ + p->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); + } + p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE); + if( db->mallocFailed ) goto create_view_fail; + + /* Locate the end of the CREATE VIEW statement. Make sEnd point to + ** the end. + */ + sEnd = pParse->sLastToken; + assert( sEnd.z[0]!=0 || sEnd.n==0 ); + if( sEnd.z[0]!=';' ){ + sEnd.z += sEnd.n; + } + sEnd.n = 0; + n = (int)(sEnd.z - pBegin->z); + assert( n>0 ); + z = pBegin->z; + while( sqlite3Isspace(z[n-1]) ){ n--; } + sEnd.z = &z[n-1]; + sEnd.n = 1; + + /* Use sqlite3EndTable() to add the view to the schema table */ + sqlite3EndTable(pParse, 0, &sEnd, 0, 0); + +create_view_fail: + sqlite3SelectDelete(db, pSelect); + if( IN_RENAME_OBJECT ){ + sqlite3RenameExprlistUnmap(pParse, pCNames); + } + sqlite3ExprListDelete(db, pCNames); + return; +} +#endif /* SQLITE_OMIT_VIEW */ + +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) +/* +** The Table structure pTable is really a VIEW. Fill in the names of +** the columns of the view in the pTable structure. Return the number +** of errors. If an error is seen leave an error message in pParse->zErrMsg. +*/ +SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){ + Table *pSelTab; /* A fake table from which we get the result set */ + Select *pSel; /* Copy of the SELECT that implements the view */ + int nErr = 0; /* Number of errors encountered */ + int n; /* Temporarily holds the number of cursors assigned */ + sqlite3 *db = pParse->db; /* Database connection for malloc errors */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + int rc; +#endif +#ifndef SQLITE_OMIT_AUTHORIZATION + sqlite3_xauth xAuth; /* Saved xAuth pointer */ +#endif + + assert( pTable ); + +#ifndef SQLITE_OMIT_VIRTUALTABLE + db->nSchemaLock++; + rc = sqlite3VtabCallConnect(pParse, pTable); + db->nSchemaLock--; + if( rc ){ + return 1; + } + if( IsVirtual(pTable) ) return 0; +#endif + +#ifndef SQLITE_OMIT_VIEW + /* A positive nCol means the columns names for this view are + ** already known. + */ + if( pTable->nCol>0 ) return 0; + + /* A negative nCol is a special marker meaning that we are currently + ** trying to compute the column names. If we enter this routine with + ** a negative nCol, it means two or more views form a loop, like this: + ** + ** CREATE VIEW one AS SELECT * FROM two; + ** CREATE VIEW two AS SELECT * FROM one; + ** + ** Actually, the error above is now caught prior to reaching this point. + ** But the following test is still important as it does come up + ** in the following: + ** + ** CREATE TABLE main.ex1(a); + ** CREATE TEMP VIEW ex1 AS SELECT a FROM ex1; + ** SELECT * FROM temp.ex1; + */ + if( pTable->nCol<0 ){ + sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName); + return 1; + } + assert( pTable->nCol>=0 ); + + /* If we get this far, it means we need to compute the table names. + ** Note that the call to sqlite3ResultSetOfSelect() will expand any + ** "*" elements in the results set of the view and will assign cursors + ** to the elements of the FROM clause. But we do not want these changes + ** to be permanent. So the computation is done on a copy of the SELECT + ** statement that defines the view. + */ + assert( pTable->pSelect ); + pSel = sqlite3SelectDup(db, pTable->pSelect, 0); + if( pSel ){ + u8 eParseMode = pParse->eParseMode; + pParse->eParseMode = PARSE_MODE_NORMAL; + n = pParse->nTab; + sqlite3SrcListAssignCursors(pParse, pSel->pSrc); + pTable->nCol = -1; + DisableLookaside; +#ifndef SQLITE_OMIT_AUTHORIZATION + xAuth = db->xAuth; + db->xAuth = 0; + pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE); + db->xAuth = xAuth; +#else + pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE); +#endif + pParse->nTab = n; + if( pSelTab==0 ){ + pTable->nCol = 0; + nErr++; + }else if( pTable->pCheck ){ + /* CREATE VIEW name(arglist) AS ... + ** The names of the columns in the table are taken from + ** arglist which is stored in pTable->pCheck. The pCheck field + ** normally holds CHECK constraints on an ordinary table, but for + ** a VIEW it holds the list of column names. + */ + sqlite3ColumnsFromExprList(pParse, pTable->pCheck, + &pTable->nCol, &pTable->aCol); + if( db->mallocFailed==0 + && pParse->nErr==0 + && pTable->nCol==pSel->pEList->nExpr + ){ + sqlite3SelectAddColumnTypeAndCollation(pParse, pTable, pSel, + SQLITE_AFF_NONE); + } + }else{ + /* CREATE VIEW name AS... without an argument list. Construct + ** the column names from the SELECT statement that defines the view. + */ + assert( pTable->aCol==0 ); + pTable->nCol = pSelTab->nCol; + pTable->aCol = pSelTab->aCol; + pSelTab->nCol = 0; + pSelTab->aCol = 0; + assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) ); + } + pTable->nNVCol = pTable->nCol; + sqlite3DeleteTable(db, pSelTab); + sqlite3SelectDelete(db, pSel); + EnableLookaside; + pParse->eParseMode = eParseMode; + } else { + nErr++; + } + pTable->pSchema->schemaFlags |= DB_UnresetViews; + if( db->mallocFailed ){ + sqlite3DeleteColumnNames(db, pTable); + pTable->aCol = 0; + pTable->nCol = 0; + } +#endif /* SQLITE_OMIT_VIEW */ + return nErr; +} +#endif /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */ + +#ifndef SQLITE_OMIT_VIEW +/* +** Clear the column names from every VIEW in database idx. +*/ +static void sqliteViewResetAll(sqlite3 *db, int idx){ + HashElem *i; + assert( sqlite3SchemaMutexHeld(db, idx, 0) ); + if( !DbHasProperty(db, idx, DB_UnresetViews) ) return; + for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){ + Table *pTab = sqliteHashData(i); + if( pTab->pSelect ){ + sqlite3DeleteColumnNames(db, pTab); + pTab->aCol = 0; + pTab->nCol = 0; + } + } + DbClearProperty(db, idx, DB_UnresetViews); +} +#else +# define sqliteViewResetAll(A,B) +#endif /* SQLITE_OMIT_VIEW */ + +/* +** This function is called by the VDBE to adjust the internal schema +** used by SQLite when the btree layer moves a table root page. The +** root-page of a table or index in database iDb has changed from iFrom +** to iTo. +** +** Ticket #1728: The symbol table might still contain information +** on tables and/or indices that are the process of being deleted. +** If you are unlucky, one of those deleted indices or tables might +** have the same rootpage number as the real table or index that is +** being moved. So we cannot stop searching after the first match +** because the first match might be for one of the deleted indices +** or tables and not the table/index that is actually being moved. +** We must continue looping until all tables and indices with +** rootpage==iFrom have been converted to have a rootpage of iTo +** in order to be certain that we got the right one. +*/ +#ifndef SQLITE_OMIT_AUTOVACUUM +SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3 *db, int iDb, Pgno iFrom, Pgno iTo){ + HashElem *pElem; + Hash *pHash; + Db *pDb; + + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pDb = &db->aDb[iDb]; + pHash = &pDb->pSchema->tblHash; + for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){ + Table *pTab = sqliteHashData(pElem); + if( pTab->tnum==iFrom ){ + pTab->tnum = iTo; + } + } + pHash = &pDb->pSchema->idxHash; + for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){ + Index *pIdx = sqliteHashData(pElem); + if( pIdx->tnum==iFrom ){ + pIdx->tnum = iTo; + } + } +} +#endif + +/* +** Write code to erase the table with root-page iTable from database iDb. +** Also write code to modify the sqlite_schema table and internal schema +** if a root-page of another table is moved by the btree-layer whilst +** erasing iTable (this can happen with an auto-vacuum database). +*/ +static void destroyRootPage(Parse *pParse, int iTable, int iDb){ + Vdbe *v = sqlite3GetVdbe(pParse); + int r1 = sqlite3GetTempReg(pParse); + if( iTable<2 ) sqlite3ErrorMsg(pParse, "corrupt schema"); + sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb); + sqlite3MayAbort(pParse); +#ifndef SQLITE_OMIT_AUTOVACUUM + /* OP_Destroy stores an in integer r1. If this integer + ** is non-zero, then it is the root page number of a table moved to + ** location iTable. The following code modifies the sqlite_schema table to + ** reflect this. + ** + ** The "#NNN" in the SQL is a special constant that means whatever value + ** is in register NNN. See grammar rules associated with the TK_REGISTER + ** token for additional information. + */ + sqlite3NestedParse(pParse, + "UPDATE %Q." DFLT_SCHEMA_TABLE + " SET rootpage=%d WHERE #%d AND rootpage=#%d", + pParse->db->aDb[iDb].zDbSName, iTable, r1, r1); +#endif + sqlite3ReleaseTempReg(pParse, r1); +} + +/* +** Write VDBE code to erase table pTab and all associated indices on disk. +** Code to update the sqlite_schema tables and internal schema definitions +** in case a root-page belonging to another table is moved by the btree layer +** is also added (this can happen with an auto-vacuum database). +*/ +static void destroyTable(Parse *pParse, Table *pTab){ + /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM + ** is not defined), then it is important to call OP_Destroy on the + ** table and index root-pages in order, starting with the numerically + ** largest root-page number. This guarantees that none of the root-pages + ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the + ** following were coded: + ** + ** OP_Destroy 4 0 + ** ... + ** OP_Destroy 5 0 + ** + ** and root page 5 happened to be the largest root-page number in the + ** database, then root page 5 would be moved to page 4 by the + ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit + ** a free-list page. + */ + Pgno iTab = pTab->tnum; + Pgno iDestroyed = 0; + + while( 1 ){ + Index *pIdx; + Pgno iLargest = 0; + + if( iDestroyed==0 || iTabpIndex; pIdx; pIdx=pIdx->pNext){ + Pgno iIdx = pIdx->tnum; + assert( pIdx->pSchema==pTab->pSchema ); + if( (iDestroyed==0 || (iIdxiLargest ){ + iLargest = iIdx; + } + } + if( iLargest==0 ){ + return; + }else{ + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + assert( iDb>=0 && iDbdb->nDb ); + destroyRootPage(pParse, iLargest, iDb); + iDestroyed = iLargest; + } + } +} + +/* +** Remove entries from the sqlite_statN tables (for N in (1,2,3)) +** after a DROP INDEX or DROP TABLE command. +*/ +static void sqlite3ClearStatTables( + Parse *pParse, /* The parsing context */ + int iDb, /* The database number */ + const char *zType, /* "idx" or "tbl" */ + const char *zName /* Name of index or table */ +){ + int i; + const char *zDbName = pParse->db->aDb[iDb].zDbSName; + for(i=1; i<=4; i++){ + char zTab[24]; + sqlite3_snprintf(sizeof(zTab),zTab,"sqlite_stat%d",i); + if( sqlite3FindTable(pParse->db, zTab, zDbName) ){ + sqlite3NestedParse(pParse, + "DELETE FROM %Q.%s WHERE %s=%Q", + zDbName, zTab, zType, zName + ); + } + } +} + +/* +** Generate code to drop a table. +*/ +SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){ + Vdbe *v; + sqlite3 *db = pParse->db; + Trigger *pTrigger; + Db *pDb = &db->aDb[iDb]; + + v = sqlite3GetVdbe(pParse); + assert( v!=0 ); + sqlite3BeginWriteOperation(pParse, 1, iDb); + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + sqlite3VdbeAddOp0(v, OP_VBegin); + } +#endif + + /* Drop all triggers associated with the table being dropped. Code + ** is generated to remove entries from sqlite_schema and/or + ** sqlite_temp_schema if required. + */ + pTrigger = sqlite3TriggerList(pParse, pTab); + while( pTrigger ){ + assert( pTrigger->pSchema==pTab->pSchema || + pTrigger->pSchema==db->aDb[1].pSchema ); + sqlite3DropTriggerPtr(pParse, pTrigger); + pTrigger = pTrigger->pNext; + } + +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* Remove any entries of the sqlite_sequence table associated with + ** the table being dropped. This is done before the table is dropped + ** at the btree level, in case the sqlite_sequence table needs to + ** move as a result of the drop (can happen in auto-vacuum mode). + */ + if( pTab->tabFlags & TF_Autoincrement ){ + sqlite3NestedParse(pParse, + "DELETE FROM %Q.sqlite_sequence WHERE name=%Q", + pDb->zDbSName, pTab->zName + ); + } +#endif + + /* Drop all entries in the schema table that refer to the + ** table. The program name loops through the schema table and deletes + ** every row that refers to a table of the same name as the one being + ** dropped. Triggers are handled separately because a trigger can be + ** created in the temp database that refers to a table in another + ** database. + */ + sqlite3NestedParse(pParse, + "DELETE FROM %Q." DFLT_SCHEMA_TABLE + " WHERE tbl_name=%Q and type!='trigger'", + pDb->zDbSName, pTab->zName); + if( !isView && !IsVirtual(pTab) ){ + destroyTable(pParse, pTab); + } + + /* Remove the table entry from SQLite's internal schema and modify + ** the schema cookie. + */ + if( IsVirtual(pTab) ){ + sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0); + sqlite3MayAbort(pParse); + } + sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0); + sqlite3ChangeCookie(pParse, iDb); + sqliteViewResetAll(db, iDb); +} + +/* +** Return TRUE if shadow tables should be read-only in the current +** context. +*/ +SQLITE_PRIVATE int sqlite3ReadOnlyShadowTables(sqlite3 *db){ +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( (db->flags & SQLITE_Defensive)!=0 + && db->pVtabCtx==0 + && db->nVdbeExec==0 + ){ + return 1; + } +#endif + return 0; +} + +/* +** Return true if it is not allowed to drop the given table +*/ +static int tableMayNotBeDropped(sqlite3 *db, Table *pTab){ + if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){ + if( sqlite3StrNICmp(pTab->zName+7, "stat", 4)==0 ) return 0; + if( sqlite3StrNICmp(pTab->zName+7, "parameters", 10)==0 ) return 0; + return 1; + } + if( (pTab->tabFlags & TF_Shadow)!=0 && sqlite3ReadOnlyShadowTables(db) ){ + return 1; + } + return 0; +} + +/* +** This routine is called to do the work of a DROP TABLE statement. +** pName is the name of the table to be dropped. +*/ +SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){ + Table *pTab; + Vdbe *v; + sqlite3 *db = pParse->db; + int iDb; + + if( db->mallocFailed ){ + goto exit_drop_table; + } + assert( pParse->nErr==0 ); + assert( pName->nSrc==1 ); + if( sqlite3ReadSchema(pParse) ) goto exit_drop_table; + if( noErr ) db->suppressErr++; + assert( isView==0 || isView==LOCATE_VIEW ); + pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]); + if( noErr ) db->suppressErr--; + + if( pTab==0 ){ + if( noErr ) sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase); + goto exit_drop_table; + } + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDb>=0 && iDbnDb ); + + /* If pTab is a virtual table, call ViewGetColumnNames() to ensure + ** it is initialized. + */ + if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto exit_drop_table; + } +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int code; + const char *zTab = SCHEMA_TABLE(iDb); + const char *zDb = db->aDb[iDb].zDbSName; + const char *zArg2 = 0; + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){ + goto exit_drop_table; + } + if( isView ){ + if( !OMIT_TEMPDB && iDb==1 ){ + code = SQLITE_DROP_TEMP_VIEW; + }else{ + code = SQLITE_DROP_VIEW; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + }else if( IsVirtual(pTab) ){ + code = SQLITE_DROP_VTABLE; + zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName; +#endif + }else{ + if( !OMIT_TEMPDB && iDb==1 ){ + code = SQLITE_DROP_TEMP_TABLE; + }else{ + code = SQLITE_DROP_TABLE; + } + } + if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){ + goto exit_drop_table; + } + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){ + goto exit_drop_table; + } + } +#endif + if( tableMayNotBeDropped(db, pTab) ){ + sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName); + goto exit_drop_table; + } + +#ifndef SQLITE_OMIT_VIEW + /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used + ** on a table. + */ + if( isView && pTab->pSelect==0 ){ + sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName); + goto exit_drop_table; + } + if( !isView && pTab->pSelect ){ + sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName); + goto exit_drop_table; + } +#endif + + /* Generate code to remove the table from the schema table + ** on disk. + */ + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3BeginWriteOperation(pParse, 1, iDb); + if( !isView ){ + sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName); + sqlite3FkDropTable(pParse, pName, pTab); + } + sqlite3CodeDropTable(pParse, pTab, iDb, isView); + } + +exit_drop_table: + sqlite3SrcListDelete(db, pName); +} + +/* +** This routine is called to create a new foreign key on the table +** currently under construction. pFromCol determines which columns +** in the current table point to the foreign key. If pFromCol==0 then +** connect the key to the last column inserted. pTo is the name of +** the table referred to (a.k.a the "parent" table). pToCol is a list +** of tables in the parent pTo table. flags contains all +** information about the conflict resolution algorithms specified +** in the ON DELETE, ON UPDATE and ON INSERT clauses. +** +** An FKey structure is created and added to the table currently +** under construction in the pParse->pNewTable field. +** +** The foreign key is set for IMMEDIATE processing. A subsequent call +** to sqlite3DeferForeignKey() might change this to DEFERRED. +*/ +SQLITE_PRIVATE void sqlite3CreateForeignKey( + Parse *pParse, /* Parsing context */ + ExprList *pFromCol, /* Columns in this table that point to other table */ + Token *pTo, /* Name of the other table */ + ExprList *pToCol, /* Columns in the other table */ + int flags /* Conflict resolution algorithms. */ +){ + sqlite3 *db = pParse->db; +#ifndef SQLITE_OMIT_FOREIGN_KEY + FKey *pFKey = 0; + FKey *pNextTo; + Table *p = pParse->pNewTable; + int nByte; + int i; + int nCol; + char *z; + + assert( pTo!=0 ); + if( p==0 || IN_DECLARE_VTAB ) goto fk_end; + if( pFromCol==0 ){ + int iCol = p->nCol-1; + if( NEVER(iCol<0) ) goto fk_end; + if( pToCol && pToCol->nExpr!=1 ){ + sqlite3ErrorMsg(pParse, "foreign key on %s" + " should reference only one column of table %T", + p->aCol[iCol].zName, pTo); + goto fk_end; + } + nCol = 1; + }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){ + sqlite3ErrorMsg(pParse, + "number of columns in foreign key does not match the number of " + "columns in the referenced table"); + goto fk_end; + }else{ + nCol = pFromCol->nExpr; + } + nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1; + if( pToCol ){ + for(i=0; inExpr; i++){ + nByte += sqlite3Strlen30(pToCol->a[i].zEName) + 1; + } + } + pFKey = sqlite3DbMallocZero(db, nByte ); + if( pFKey==0 ){ + goto fk_end; + } + pFKey->pFrom = p; + pFKey->pNextFrom = p->pFKey; + z = (char*)&pFKey->aCol[nCol]; + pFKey->zTo = z; + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenMap(pParse, (void*)z, pTo); + } + memcpy(z, pTo->z, pTo->n); + z[pTo->n] = 0; + sqlite3Dequote(z); + z += pTo->n+1; + pFKey->nCol = nCol; + if( pFromCol==0 ){ + pFKey->aCol[0].iFrom = p->nCol-1; + }else{ + for(i=0; inCol; j++){ + if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zEName)==0 ){ + pFKey->aCol[i].iFrom = j; + break; + } + } + if( j>=p->nCol ){ + sqlite3ErrorMsg(pParse, + "unknown column \"%s\" in foreign key definition", + pFromCol->a[i].zEName); + goto fk_end; + } + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenRemap(pParse, &pFKey->aCol[i], pFromCol->a[i].zEName); + } + } + } + if( pToCol ){ + for(i=0; ia[i].zEName); + pFKey->aCol[i].zCol = z; + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenRemap(pParse, z, pToCol->a[i].zEName); + } + memcpy(z, pToCol->a[i].zEName, n); + z[n] = 0; + z += n+1; + } + } + pFKey->isDeferred = 0; + pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */ + pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */ + + assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) ); + pNextTo = (FKey *)sqlite3HashInsert(&p->pSchema->fkeyHash, + pFKey->zTo, (void *)pFKey + ); + if( pNextTo==pFKey ){ + sqlite3OomFault(db); + goto fk_end; + } + if( pNextTo ){ + assert( pNextTo->pPrevTo==0 ); + pFKey->pNextTo = pNextTo; + pNextTo->pPrevTo = pFKey; + } + + /* Link the foreign key to the table as the last step. + */ + p->pFKey = pFKey; + pFKey = 0; + +fk_end: + sqlite3DbFree(db, pFKey); +#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ + sqlite3ExprListDelete(db, pFromCol); + sqlite3ExprListDelete(db, pToCol); +} + +/* +** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED +** clause is seen as part of a foreign key definition. The isDeferred +** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE. +** The behavior of the most recently created foreign key is adjusted +** accordingly. +*/ +SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){ +#ifndef SQLITE_OMIT_FOREIGN_KEY + Table *pTab; + FKey *pFKey; + if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return; + assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */ + pFKey->isDeferred = (u8)isDeferred; +#endif +} + +/* +** Generate code that will erase and refill index *pIdx. This is +** used to initialize a newly created index or to recompute the +** content of an index in response to a REINDEX command. +** +** if memRootPage is not negative, it means that the index is newly +** created. The register specified by memRootPage contains the +** root page number of the index. If memRootPage is negative, then +** the index already exists and must be cleared before being refilled and +** the root page number of the index is taken from pIndex->tnum. +*/ +static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){ + Table *pTab = pIndex->pTable; /* The table that is indexed */ + int iTab = pParse->nTab++; /* Btree cursor used for pTab */ + int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */ + int iSorter; /* Cursor opened by OpenSorter (if in use) */ + int addr1; /* Address of top of loop */ + int addr2; /* Address to jump to for next iteration */ + Pgno tnum; /* Root page of index */ + int iPartIdxLabel; /* Jump to this label to skip a row */ + Vdbe *v; /* Generate code into this virtual machine */ + KeyInfo *pKey; /* KeyInfo for index */ + int regRecord; /* Register holding assembled index record */ + sqlite3 *db = pParse->db; /* The database connection */ + int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema); + +#ifndef SQLITE_OMIT_AUTHORIZATION + if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0, + db->aDb[iDb].zDbSName ) ){ + return; + } +#endif + + /* Require a write-lock on the table to perform this operation */ + sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName); + + v = sqlite3GetVdbe(pParse); + if( v==0 ) return; + if( memRootPage>=0 ){ + tnum = (Pgno)memRootPage; + }else{ + tnum = pIndex->tnum; + } + pKey = sqlite3KeyInfoOfIndex(pParse, pIndex); + assert( pKey!=0 || db->mallocFailed || pParse->nErr ); + + /* Open the sorter cursor if we are to use one. */ + iSorter = pParse->nTab++; + sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, pIndex->nKeyCol, (char*) + sqlite3KeyInfoRef(pKey), P4_KEYINFO); + + /* Open the table. Loop through all rows of the table, inserting index + ** records into the sorter. */ + sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead); + addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v); + regRecord = sqlite3GetTempReg(pParse); + sqlite3MultiWrite(pParse); + + sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0); + sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord); + sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel); + sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr1); + if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb); + sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, (int)tnum, iDb, + (char *)pKey, P4_KEYINFO); + sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR|((memRootPage>=0)?OPFLAG_P2ISREG:0)); + + addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v); + if( IsUniqueIndex(pIndex) ){ + int j2 = sqlite3VdbeGoto(v, 1); + addr2 = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeVerifyAbortable(v, OE_Abort); + sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord, + pIndex->nKeyCol); VdbeCoverage(v); + sqlite3UniqueConstraint(pParse, OE_Abort, pIndex); + sqlite3VdbeJumpHere(v, j2); + }else{ + /* Most CREATE INDEX and REINDEX statements that are not UNIQUE can not + ** abort. The exception is if one of the indexed expressions contains a + ** user function that throws an exception when it is evaluated. But the + ** overhead of adding a statement journal to a CREATE INDEX statement is + ** very small (since most of the pages written do not contain content that + ** needs to be restored if the statement aborts), so we call + ** sqlite3MayAbort() for all CREATE INDEX statements. */ + sqlite3MayAbort(pParse); + addr2 = sqlite3VdbeCurrentAddr(v); + } + sqlite3VdbeAddOp3(v, OP_SorterData, iSorter, regRecord, iIdx); + if( !pIndex->bAscKeyBug ){ + /* This OP_SeekEnd opcode makes index insert for a REINDEX go much + ** faster by avoiding unnecessary seeks. But the optimization does + ** not work for UNIQUE constraint indexes on WITHOUT ROWID tables + ** with DESC primary keys, since those indexes have there keys in + ** a different order from the main table. + ** See ticket: https://www.sqlite.org/src/info/bba7b69f9849b5bf + */ + sqlite3VdbeAddOp1(v, OP_SeekEnd, iIdx); + } + sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdx, regRecord); + sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + sqlite3ReleaseTempReg(pParse, regRecord); + sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr1); + + sqlite3VdbeAddOp1(v, OP_Close, iTab); + sqlite3VdbeAddOp1(v, OP_Close, iIdx); + sqlite3VdbeAddOp1(v, OP_Close, iSorter); +} + +/* +** Allocate heap space to hold an Index object with nCol columns. +** +** Increase the allocation size to provide an extra nExtra bytes +** of 8-byte aligned space after the Index object and return a +** pointer to this extra space in *ppExtra. +*/ +SQLITE_PRIVATE Index *sqlite3AllocateIndexObject( + sqlite3 *db, /* Database connection */ + i16 nCol, /* Total number of columns in the index */ + int nExtra, /* Number of bytes of extra space to alloc */ + char **ppExtra /* Pointer to the "extra" space */ +){ + Index *p; /* Allocated index object */ + int nByte; /* Bytes of space for Index object + arrays */ + + nByte = ROUND8(sizeof(Index)) + /* Index structure */ + ROUND8(sizeof(char*)*nCol) + /* Index.azColl */ + ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */ + sizeof(i16)*nCol + /* Index.aiColumn */ + sizeof(u8)*nCol); /* Index.aSortOrder */ + p = sqlite3DbMallocZero(db, nByte + nExtra); + if( p ){ + char *pExtra = ((char*)p)+ROUND8(sizeof(Index)); + p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol); + p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1); + p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol; + p->aSortOrder = (u8*)pExtra; + p->nColumn = nCol; + p->nKeyCol = nCol - 1; + *ppExtra = ((char*)p) + nByte; + } + return p; +} + +/* +** If expression list pList contains an expression that was parsed with +** an explicit "NULLS FIRST" or "NULLS LAST" clause, leave an error in +** pParse and return non-zero. Otherwise, return zero. +*/ +SQLITE_PRIVATE int sqlite3HasExplicitNulls(Parse *pParse, ExprList *pList){ + if( pList ){ + int i; + for(i=0; inExpr; i++){ + if( pList->a[i].bNulls ){ + u8 sf = pList->a[i].sortFlags; + sqlite3ErrorMsg(pParse, "unsupported use of NULLS %s", + (sf==0 || sf==3) ? "FIRST" : "LAST" + ); + return 1; + } + } + } + return 0; +} + +/* +** Create a new index for an SQL table. pName1.pName2 is the name of the index +** and pTblList is the name of the table that is to be indexed. Both will +** be NULL for a primary key or an index that is created to satisfy a +** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable +** as the table to be indexed. pParse->pNewTable is a table that is +** currently being constructed by a CREATE TABLE statement. +** +** pList is a list of columns to be indexed. pList will be NULL if this +** is a primary key or unique-constraint on the most recent column added +** to the table currently under construction. +*/ +SQLITE_PRIVATE void sqlite3CreateIndex( + Parse *pParse, /* All information about this parse */ + Token *pName1, /* First part of index name. May be NULL */ + Token *pName2, /* Second part of index name. May be NULL */ + SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */ + ExprList *pList, /* A list of columns to be indexed */ + int onError, /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ + Token *pStart, /* The CREATE token that begins this statement */ + Expr *pPIWhere, /* WHERE clause for partial indices */ + int sortOrder, /* Sort order of primary key when pList==NULL */ + int ifNotExist, /* Omit error if index already exists */ + u8 idxType /* The index type */ +){ + Table *pTab = 0; /* Table to be indexed */ + Index *pIndex = 0; /* The index to be created */ + char *zName = 0; /* Name of the index */ + int nName; /* Number of characters in zName */ + int i, j; + DbFixer sFix; /* For assigning database names to pTable */ + int sortOrderMask; /* 1 to honor DESC in index. 0 to ignore. */ + sqlite3 *db = pParse->db; + Db *pDb; /* The specific table containing the indexed database */ + int iDb; /* Index of the database that is being written */ + Token *pName = 0; /* Unqualified name of the index to create */ + struct ExprList_item *pListItem; /* For looping over pList */ + int nExtra = 0; /* Space allocated for zExtra[] */ + int nExtraCol; /* Number of extra columns needed */ + char *zExtra = 0; /* Extra space after the Index object */ + Index *pPk = 0; /* PRIMARY KEY index for WITHOUT ROWID tables */ + + if( db->mallocFailed || pParse->nErr>0 ){ + goto exit_create_index; + } + if( IN_DECLARE_VTAB && idxType!=SQLITE_IDXTYPE_PRIMARYKEY ){ + goto exit_create_index; + } + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto exit_create_index; + } + if( sqlite3HasExplicitNulls(pParse, pList) ){ + goto exit_create_index; + } + + /* + ** Find the table that is to be indexed. Return early if not found. + */ + if( pTblName!=0 ){ + + /* Use the two-part index name to determine the database + ** to search for the table. 'Fix' the table name to this db + ** before looking up the table. + */ + assert( pName1 && pName2 ); + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName); + if( iDb<0 ) goto exit_create_index; + assert( pName && pName->z ); + +#ifndef SQLITE_OMIT_TEMPDB + /* If the index name was unqualified, check if the table + ** is a temp table. If so, set the database to 1. Do not do this + ** if initialising a database schema. + */ + if( !db->init.busy ){ + pTab = sqlite3SrcListLookup(pParse, pTblName); + if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){ + iDb = 1; + } + } +#endif + + sqlite3FixInit(&sFix, pParse, iDb, "index", pName); + if( sqlite3FixSrcList(&sFix, pTblName) ){ + /* Because the parser constructs pTblName from a single identifier, + ** sqlite3FixSrcList can never fail. */ + assert(0); + } + pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]); + assert( db->mallocFailed==0 || pTab==0 ); + if( pTab==0 ) goto exit_create_index; + if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){ + sqlite3ErrorMsg(pParse, + "cannot create a TEMP index on non-TEMP table \"%s\"", + pTab->zName); + goto exit_create_index; + } + if( !HasRowid(pTab) ) pPk = sqlite3PrimaryKeyIndex(pTab); + }else{ + assert( pName==0 ); + assert( pStart==0 ); + pTab = pParse->pNewTable; + if( !pTab ) goto exit_create_index; + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + } + pDb = &db->aDb[iDb]; + + assert( pTab!=0 ); + assert( pParse->nErr==0 ); + if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 + && db->init.busy==0 + && pTblName!=0 +#if SQLITE_USER_AUTHENTICATION + && sqlite3UserAuthTable(pTab->zName)==0 +#endif + ){ + sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName); + goto exit_create_index; + } +#ifndef SQLITE_OMIT_VIEW + if( pTab->pSelect ){ + sqlite3ErrorMsg(pParse, "views may not be indexed"); + goto exit_create_index; + } +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + sqlite3ErrorMsg(pParse, "virtual tables may not be indexed"); + goto exit_create_index; + } +#endif + + /* + ** Find the name of the index. Make sure there is not already another + ** index or table with the same name. + ** + ** Exception: If we are reading the names of permanent indices from the + ** sqlite_schema table (because some other process changed the schema) and + ** one of the index names collides with the name of a temporary table or + ** index, then we will continue to process this index. + ** + ** If pName==0 it means that we are + ** dealing with a primary key or UNIQUE constraint. We have to invent our + ** own name. + */ + if( pName ){ + zName = sqlite3NameFromToken(db, pName); + if( zName==0 ) goto exit_create_index; + assert( pName->z!=0 ); + if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){ + goto exit_create_index; + } + if( !IN_RENAME_OBJECT ){ + if( !db->init.busy ){ + if( sqlite3FindTable(db, zName, 0)!=0 ){ + sqlite3ErrorMsg(pParse, "there is already a table named %s", zName); + goto exit_create_index; + } + } + if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){ + if( !ifNotExist ){ + sqlite3ErrorMsg(pParse, "index %s already exists", zName); + }else{ + assert( !db->init.busy ); + sqlite3CodeVerifySchema(pParse, iDb); + } + goto exit_create_index; + } + } + }else{ + int n; + Index *pLoop; + for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){} + zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n); + if( zName==0 ){ + goto exit_create_index; + } + + /* Automatic index names generated from within sqlite3_declare_vtab() + ** must have names that are distinct from normal automatic index names. + ** The following statement converts "sqlite3_autoindex..." into + ** "sqlite3_butoindex..." in order to make the names distinct. + ** The "vtab_err.test" test demonstrates the need of this statement. */ + if( IN_SPECIAL_PARSE ) zName[7]++; + } + + /* Check for authorization to create an index. + */ +#ifndef SQLITE_OMIT_AUTHORIZATION + if( !IN_RENAME_OBJECT ){ + const char *zDb = pDb->zDbSName; + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){ + goto exit_create_index; + } + i = SQLITE_CREATE_INDEX; + if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX; + if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){ + goto exit_create_index; + } + } +#endif + + /* If pList==0, it means this routine was called to make a primary + ** key out of the last column added to the table under construction. + ** So create a fake list to simulate this. + */ + if( pList==0 ){ + Token prevCol; + Column *pCol = &pTab->aCol[pTab->nCol-1]; + pCol->colFlags |= COLFLAG_UNIQUE; + sqlite3TokenInit(&prevCol, pCol->zName); + pList = sqlite3ExprListAppend(pParse, 0, + sqlite3ExprAlloc(db, TK_ID, &prevCol, 0)); + if( pList==0 ) goto exit_create_index; + assert( pList->nExpr==1 ); + sqlite3ExprListSetSortOrder(pList, sortOrder, SQLITE_SO_UNDEFINED); + }else{ + sqlite3ExprListCheckLength(pParse, pList, "index"); + if( pParse->nErr ) goto exit_create_index; + } + + /* Figure out how many bytes of space are required to store explicitly + ** specified collation sequence names. + */ + for(i=0; inExpr; i++){ + Expr *pExpr = pList->a[i].pExpr; + assert( pExpr!=0 ); + if( pExpr->op==TK_COLLATE ){ + nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken)); + } + } + + /* + ** Allocate the index structure. + */ + nName = sqlite3Strlen30(zName); + nExtraCol = pPk ? pPk->nKeyCol : 1; + assert( pList->nExpr + nExtraCol <= 32767 /* Fits in i16 */ ); + pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol, + nName + nExtra + 1, &zExtra); + if( db->mallocFailed ){ + goto exit_create_index; + } + assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowLogEst) ); + assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) ); + pIndex->zName = zExtra; + zExtra += nName + 1; + memcpy(pIndex->zName, zName, nName+1); + pIndex->pTable = pTab; + pIndex->onError = (u8)onError; + pIndex->uniqNotNull = onError!=OE_None; + pIndex->idxType = idxType; + pIndex->pSchema = db->aDb[iDb].pSchema; + pIndex->nKeyCol = pList->nExpr; + if( pPIWhere ){ + sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0); + pIndex->pPartIdxWhere = pPIWhere; + pPIWhere = 0; + } + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + + /* Check to see if we should honor DESC requests on index columns + */ + if( pDb->pSchema->file_format>=4 ){ + sortOrderMask = -1; /* Honor DESC */ + }else{ + sortOrderMask = 0; /* Ignore DESC */ + } + + /* Analyze the list of expressions that form the terms of the index and + ** report any errors. In the common case where the expression is exactly + ** a table column, store that column in aiColumn[]. For general expressions, + ** populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[]. + ** + ** TODO: Issue a warning if two or more columns of the index are identical. + ** TODO: Issue a warning if the table primary key is used as part of the + ** index key. + */ + pListItem = pList->a; + if( IN_RENAME_OBJECT ){ + pIndex->aColExpr = pList; + pList = 0; + } + for(i=0; inKeyCol; i++, pListItem++){ + Expr *pCExpr; /* The i-th index expression */ + int requestedSortOrder; /* ASC or DESC on the i-th expression */ + const char *zColl; /* Collation sequence name */ + + sqlite3StringToId(pListItem->pExpr); + sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0); + if( pParse->nErr ) goto exit_create_index; + pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr); + if( pCExpr->op!=TK_COLUMN ){ + if( pTab==pParse->pNewTable ){ + sqlite3ErrorMsg(pParse, "expressions prohibited in PRIMARY KEY and " + "UNIQUE constraints"); + goto exit_create_index; + } + if( pIndex->aColExpr==0 ){ + pIndex->aColExpr = pList; + pList = 0; + } + j = XN_EXPR; + pIndex->aiColumn[i] = XN_EXPR; + pIndex->uniqNotNull = 0; + }else{ + j = pCExpr->iColumn; + assert( j<=0x7fff ); + if( j<0 ){ + j = pTab->iPKey; + }else{ + if( pTab->aCol[j].notNull==0 ){ + pIndex->uniqNotNull = 0; + } + if( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL ){ + pIndex->bHasVCol = 1; + } + } + pIndex->aiColumn[i] = (i16)j; + } + zColl = 0; + if( pListItem->pExpr->op==TK_COLLATE ){ + int nColl; + zColl = pListItem->pExpr->u.zToken; + nColl = sqlite3Strlen30(zColl) + 1; + assert( nExtra>=nColl ); + memcpy(zExtra, zColl, nColl); + zColl = zExtra; + zExtra += nColl; + nExtra -= nColl; + }else if( j>=0 ){ + zColl = pTab->aCol[j].zColl; + } + if( !zColl ) zColl = sqlite3StrBINARY; + if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){ + goto exit_create_index; + } + pIndex->azColl[i] = zColl; + requestedSortOrder = pListItem->sortFlags & sortOrderMask; + pIndex->aSortOrder[i] = (u8)requestedSortOrder; + } + + /* Append the table key to the end of the index. For WITHOUT ROWID + ** tables (when pPk!=0) this will be the declared PRIMARY KEY. For + ** normal tables (when pPk==0) this will be the rowid. + */ + if( pPk ){ + for(j=0; jnKeyCol; j++){ + int x = pPk->aiColumn[j]; + assert( x>=0 ); + if( isDupColumn(pIndex, pIndex->nKeyCol, pPk, j) ){ + pIndex->nColumn--; + }else{ + testcase( hasColumn(pIndex->aiColumn,pIndex->nKeyCol,x) ); + pIndex->aiColumn[i] = x; + pIndex->azColl[i] = pPk->azColl[j]; + pIndex->aSortOrder[i] = pPk->aSortOrder[j]; + i++; + } + } + assert( i==pIndex->nColumn ); + }else{ + pIndex->aiColumn[i] = XN_ROWID; + pIndex->azColl[i] = sqlite3StrBINARY; + } + sqlite3DefaultRowEst(pIndex); + if( pParse->pNewTable==0 ) estimateIndexWidth(pIndex); + + /* If this index contains every column of its table, then mark + ** it as a covering index */ + assert( HasRowid(pTab) + || pTab->iPKey<0 || sqlite3TableColumnToIndex(pIndex, pTab->iPKey)>=0 ); + recomputeColumnsNotIndexed(pIndex); + if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){ + pIndex->isCovering = 1; + for(j=0; jnCol; j++){ + if( j==pTab->iPKey ) continue; + if( sqlite3TableColumnToIndex(pIndex,j)>=0 ) continue; + pIndex->isCovering = 0; + break; + } + } + + if( pTab==pParse->pNewTable ){ + /* This routine has been called to create an automatic index as a + ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or + ** a PRIMARY KEY or UNIQUE clause following the column definitions. + ** i.e. one of: + ** + ** CREATE TABLE t(x PRIMARY KEY, y); + ** CREATE TABLE t(x, y, UNIQUE(x, y)); + ** + ** Either way, check to see if the table already has such an index. If + ** so, don't bother creating this one. This only applies to + ** automatically created indices. Users can do as they wish with + ** explicit indices. + ** + ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent + ** (and thus suppressing the second one) even if they have different + ** sort orders. + ** + ** If there are different collating sequences or if the columns of + ** the constraint occur in different orders, then the constraints are + ** considered distinct and both result in separate indices. + */ + Index *pIdx; + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int k; + assert( IsUniqueIndex(pIdx) ); + assert( pIdx->idxType!=SQLITE_IDXTYPE_APPDEF ); + assert( IsUniqueIndex(pIndex) ); + + if( pIdx->nKeyCol!=pIndex->nKeyCol ) continue; + for(k=0; knKeyCol; k++){ + const char *z1; + const char *z2; + assert( pIdx->aiColumn[k]>=0 ); + if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break; + z1 = pIdx->azColl[k]; + z2 = pIndex->azColl[k]; + if( sqlite3StrICmp(z1, z2) ) break; + } + if( k==pIdx->nKeyCol ){ + if( pIdx->onError!=pIndex->onError ){ + /* This constraint creates the same index as a previous + ** constraint specified somewhere in the CREATE TABLE statement. + ** However the ON CONFLICT clauses are different. If both this + ** constraint and the previous equivalent constraint have explicit + ** ON CONFLICT clauses this is an error. Otherwise, use the + ** explicitly specified behavior for the index. + */ + if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){ + sqlite3ErrorMsg(pParse, + "conflicting ON CONFLICT clauses specified", 0); + } + if( pIdx->onError==OE_Default ){ + pIdx->onError = pIndex->onError; + } + } + if( idxType==SQLITE_IDXTYPE_PRIMARYKEY ) pIdx->idxType = idxType; + if( IN_RENAME_OBJECT ){ + pIndex->pNext = pParse->pNewIndex; + pParse->pNewIndex = pIndex; + pIndex = 0; + } + goto exit_create_index; + } + } + } + + if( !IN_RENAME_OBJECT ){ + + /* Link the new Index structure to its table and to the other + ** in-memory database structures. + */ + assert( pParse->nErr==0 ); + if( db->init.busy ){ + Index *p; + assert( !IN_SPECIAL_PARSE ); + assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) ); + if( pTblName!=0 ){ + pIndex->tnum = db->init.newTnum; + if( sqlite3IndexHasDuplicateRootPage(pIndex) ){ + sqlite3ErrorMsg(pParse, "invalid rootpage"); + pParse->rc = SQLITE_CORRUPT_BKPT; + goto exit_create_index; + } + } + p = sqlite3HashInsert(&pIndex->pSchema->idxHash, + pIndex->zName, pIndex); + if( p ){ + assert( p==pIndex ); /* Malloc must have failed */ + sqlite3OomFault(db); + goto exit_create_index; + } + db->mDbFlags |= DBFLAG_SchemaChange; + } + + /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the + ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then + ** emit code to allocate the index rootpage on disk and make an entry for + ** the index in the sqlite_schema table and populate the index with + ** content. But, do not do this if we are simply reading the sqlite_schema + ** table to parse the schema, or if this index is the PRIMARY KEY index + ** of a WITHOUT ROWID table. + ** + ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY + ** or UNIQUE index in a CREATE TABLE statement. Since the table + ** has just been created, it contains no data and the index initialization + ** step can be skipped. + */ + else if( HasRowid(pTab) || pTblName!=0 ){ + Vdbe *v; + char *zStmt; + int iMem = ++pParse->nMem; + + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto exit_create_index; + + sqlite3BeginWriteOperation(pParse, 1, iDb); + + /* Create the rootpage for the index using CreateIndex. But before + ** doing so, code a Noop instruction and store its address in + ** Index.tnum. This is required in case this index is actually a + ** PRIMARY KEY and the table is actually a WITHOUT ROWID table. In + ** that case the convertToWithoutRowidTable() routine will replace + ** the Noop with a Goto to jump over the VDBE code generated below. */ + pIndex->tnum = (Pgno)sqlite3VdbeAddOp0(v, OP_Noop); + sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY); + + /* Gather the complete text of the CREATE INDEX statement into + ** the zStmt variable + */ + assert( pName!=0 || pStart==0 ); + if( pStart ){ + int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n; + if( pName->z[n-1]==';' ) n--; + /* A named index with an explicit CREATE INDEX statement */ + zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s", + onError==OE_None ? "" : " UNIQUE", n, pName->z); + }else{ + /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */ + /* zStmt = sqlite3MPrintf(""); */ + zStmt = 0; + } + + /* Add an entry in sqlite_schema for this index + */ + sqlite3NestedParse(pParse, + "INSERT INTO %Q." DFLT_SCHEMA_TABLE " VALUES('index',%Q,%Q,#%d,%Q);", + db->aDb[iDb].zDbSName, + pIndex->zName, + pTab->zName, + iMem, + zStmt + ); + sqlite3DbFree(db, zStmt); + + /* Fill the index with data and reparse the schema. Code an OP_Expire + ** to invalidate all pre-compiled statements. + */ + if( pTblName ){ + sqlite3RefillIndex(pParse, pIndex, iMem); + sqlite3ChangeCookie(pParse, iDb); + sqlite3VdbeAddParseSchemaOp(v, iDb, + sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName)); + sqlite3VdbeAddOp2(v, OP_Expire, 0, 1); + } + + sqlite3VdbeJumpHere(v, (int)pIndex->tnum); + } + } + if( db->init.busy || pTblName==0 ){ + pIndex->pNext = pTab->pIndex; + pTab->pIndex = pIndex; + pIndex = 0; + } + else if( IN_RENAME_OBJECT ){ + assert( pParse->pNewIndex==0 ); + pParse->pNewIndex = pIndex; + pIndex = 0; + } + + /* Clean up before exiting */ +exit_create_index: + if( pIndex ) sqlite3FreeIndex(db, pIndex); + if( pTab ){ /* Ensure all REPLACE indexes are at the end of the list */ + Index **ppFrom = &pTab->pIndex; + Index *pThis; + for(ppFrom=&pTab->pIndex; (pThis = *ppFrom)!=0; ppFrom=&pThis->pNext){ + Index *pNext; + if( pThis->onError!=OE_Replace ) continue; + while( (pNext = pThis->pNext)!=0 && pNext->onError!=OE_Replace ){ + *ppFrom = pNext; + pThis->pNext = pNext->pNext; + pNext->pNext = pThis; + ppFrom = &pNext->pNext; + } + break; + } + } + sqlite3ExprDelete(db, pPIWhere); + sqlite3ExprListDelete(db, pList); + sqlite3SrcListDelete(db, pTblName); + sqlite3DbFree(db, zName); +} + +/* +** Fill the Index.aiRowEst[] array with default information - information +** to be used when we have not run the ANALYZE command. +** +** aiRowEst[0] is supposed to contain the number of elements in the index. +** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the +** number of rows in the table that match any particular value of the +** first column of the index. aiRowEst[2] is an estimate of the number +** of rows that match any particular combination of the first 2 columns +** of the index. And so forth. It must always be the case that +* +** aiRowEst[N]<=aiRowEst[N-1] +** aiRowEst[N]>=1 +** +** Apart from that, we have little to go on besides intuition as to +** how aiRowEst[] should be initialized. The numbers generated here +** are based on typical values found in actual indices. +*/ +SQLITE_PRIVATE void sqlite3DefaultRowEst(Index *pIdx){ + /* 10, 9, 8, 7, 6 */ + static const LogEst aVal[] = { 33, 32, 30, 28, 26 }; + LogEst *a = pIdx->aiRowLogEst; + LogEst x; + int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol); + int i; + + /* Indexes with default row estimates should not have stat1 data */ + assert( !pIdx->hasStat1 ); + + /* Set the first entry (number of rows in the index) to the estimated + ** number of rows in the table, or half the number of rows in the table + ** for a partial index. + ** + ** 2020-05-27: If some of the stat data is coming from the sqlite_stat1 + ** table but other parts we are having to guess at, then do not let the + ** estimated number of rows in the table be less than 1000 (LogEst 99). + ** Failure to do this can cause the indexes for which we do not have + ** stat1 data to be ignored by the query planner. + */ + x = pIdx->pTable->nRowLogEst; + assert( 99==sqlite3LogEst(1000) ); + if( x<99 ){ + pIdx->pTable->nRowLogEst = x = 99; + } + if( pIdx->pPartIdxWhere!=0 ) x -= 10; assert( 10==sqlite3LogEst(2) ); + a[0] = x; + + /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is + ** 6 and each subsequent value (if any) is 5. */ + memcpy(&a[1], aVal, nCopy*sizeof(LogEst)); + for(i=nCopy+1; i<=pIdx->nKeyCol; i++){ + a[i] = 23; assert( 23==sqlite3LogEst(5) ); + } + + assert( 0==sqlite3LogEst(1) ); + if( IsUniqueIndex(pIdx) ) a[pIdx->nKeyCol] = 0; +} + +/* +** This routine will drop an existing named index. This routine +** implements the DROP INDEX statement. +*/ +SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){ + Index *pIndex; + Vdbe *v; + sqlite3 *db = pParse->db; + int iDb; + + assert( pParse->nErr==0 ); /* Never called with prior errors */ + if( db->mallocFailed ){ + goto exit_drop_index; + } + assert( pName->nSrc==1 ); + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto exit_drop_index; + } + pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase); + if( pIndex==0 ){ + if( !ifExists ){ + sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0); + }else{ + sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase); + } + pParse->checkSchema = 1; + goto exit_drop_index; + } + if( pIndex->idxType!=SQLITE_IDXTYPE_APPDEF ){ + sqlite3ErrorMsg(pParse, "index associated with UNIQUE " + "or PRIMARY KEY constraint cannot be dropped", 0); + goto exit_drop_index; + } + iDb = sqlite3SchemaToIndex(db, pIndex->pSchema); +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int code = SQLITE_DROP_INDEX; + Table *pTab = pIndex->pTable; + const char *zDb = db->aDb[iDb].zDbSName; + const char *zTab = SCHEMA_TABLE(iDb); + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){ + goto exit_drop_index; + } + if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX; + if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){ + goto exit_drop_index; + } + } +#endif + + /* Generate code to remove the index and from the schema table */ + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3BeginWriteOperation(pParse, 1, iDb); + sqlite3NestedParse(pParse, + "DELETE FROM %Q." DFLT_SCHEMA_TABLE " WHERE name=%Q AND type='index'", + db->aDb[iDb].zDbSName, pIndex->zName + ); + sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName); + sqlite3ChangeCookie(pParse, iDb); + destroyRootPage(pParse, pIndex->tnum, iDb); + sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0); + } + +exit_drop_index: + sqlite3SrcListDelete(db, pName); +} + +/* +** pArray is a pointer to an array of objects. Each object in the +** array is szEntry bytes in size. This routine uses sqlite3DbRealloc() +** to extend the array so that there is space for a new object at the end. +** +** When this function is called, *pnEntry contains the current size of +** the array (in entries - so the allocation is ((*pnEntry) * szEntry) bytes +** in total). +** +** If the realloc() is successful (i.e. if no OOM condition occurs), the +** space allocated for the new object is zeroed, *pnEntry updated to +** reflect the new size of the array and a pointer to the new allocation +** returned. *pIdx is set to the index of the new array entry in this case. +** +** Otherwise, if the realloc() fails, *pIdx is set to -1, *pnEntry remains +** unchanged and a copy of pArray returned. +*/ +SQLITE_PRIVATE void *sqlite3ArrayAllocate( + sqlite3 *db, /* Connection to notify of malloc failures */ + void *pArray, /* Array of objects. Might be reallocated */ + int szEntry, /* Size of each object in the array */ + int *pnEntry, /* Number of objects currently in use */ + int *pIdx /* Write the index of a new slot here */ +){ + char *z; + sqlite3_int64 n = *pIdx = *pnEntry; + if( (n & (n-1))==0 ){ + sqlite3_int64 sz = (n==0) ? 1 : 2*n; + void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry); + if( pNew==0 ){ + *pIdx = -1; + return pArray; + } + pArray = pNew; + } + z = (char*)pArray; + memset(&z[n * szEntry], 0, szEntry); + ++*pnEntry; + return pArray; +} + +/* +** Append a new element to the given IdList. Create a new IdList if +** need be. +** +** A new IdList is returned, or NULL if malloc() fails. +*/ +SQLITE_PRIVATE IdList *sqlite3IdListAppend(Parse *pParse, IdList *pList, Token *pToken){ + sqlite3 *db = pParse->db; + int i; + if( pList==0 ){ + pList = sqlite3DbMallocZero(db, sizeof(IdList) ); + if( pList==0 ) return 0; + } + pList->a = sqlite3ArrayAllocate( + db, + pList->a, + sizeof(pList->a[0]), + &pList->nId, + &i + ); + if( i<0 ){ + sqlite3IdListDelete(db, pList); + return 0; + } + pList->a[i].zName = sqlite3NameFromToken(db, pToken); + if( IN_RENAME_OBJECT && pList->a[i].zName ){ + sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken); + } + return pList; +} + +/* +** Delete an IdList. +*/ +SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3 *db, IdList *pList){ + int i; + if( pList==0 ) return; + for(i=0; inId; i++){ + sqlite3DbFree(db, pList->a[i].zName); + } + sqlite3DbFree(db, pList->a); + sqlite3DbFreeNN(db, pList); +} + +/* +** Return the index in pList of the identifier named zId. Return -1 +** if not found. +*/ +SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){ + int i; + if( pList==0 ) return -1; + for(i=0; inId; i++){ + if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i; + } + return -1; +} + +/* +** Maximum size of a SrcList object. +** The SrcList object is used to represent the FROM clause of a +** SELECT statement, and the query planner cannot deal with more +** than 64 tables in a join. So any value larger than 64 here +** is sufficient for most uses. Smaller values, like say 10, are +** appropriate for small and memory-limited applications. +*/ +#ifndef SQLITE_MAX_SRCLIST +# define SQLITE_MAX_SRCLIST 200 +#endif + +/* +** Expand the space allocated for the given SrcList object by +** creating nExtra new slots beginning at iStart. iStart is zero based. +** New slots are zeroed. +** +** For example, suppose a SrcList initially contains two entries: A,B. +** To append 3 new entries onto the end, do this: +** +** sqlite3SrcListEnlarge(db, pSrclist, 3, 2); +** +** After the call above it would contain: A, B, nil, nil, nil. +** If the iStart argument had been 1 instead of 2, then the result +** would have been: A, nil, nil, nil, B. To prepend the new slots, +** the iStart value would be 0. The result then would +** be: nil, nil, nil, A, B. +** +** If a memory allocation fails or the SrcList becomes too large, leave +** the original SrcList unchanged, return NULL, and leave an error message +** in pParse. +*/ +SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge( + Parse *pParse, /* Parsing context into which errors are reported */ + SrcList *pSrc, /* The SrcList to be enlarged */ + int nExtra, /* Number of new slots to add to pSrc->a[] */ + int iStart /* Index in pSrc->a[] of first new slot */ +){ + int i; + + /* Sanity checking on calling parameters */ + assert( iStart>=0 ); + assert( nExtra>=1 ); + assert( pSrc!=0 ); + assert( iStart<=pSrc->nSrc ); + + /* Allocate additional space if needed */ + if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){ + SrcList *pNew; + sqlite3_int64 nAlloc = 2*(sqlite3_int64)pSrc->nSrc+nExtra; + sqlite3 *db = pParse->db; + + if( pSrc->nSrc+nExtra>=SQLITE_MAX_SRCLIST ){ + sqlite3ErrorMsg(pParse, "too many FROM clause terms, max: %d", + SQLITE_MAX_SRCLIST); + return 0; + } + if( nAlloc>SQLITE_MAX_SRCLIST ) nAlloc = SQLITE_MAX_SRCLIST; + pNew = sqlite3DbRealloc(db, pSrc, + sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) ); + if( pNew==0 ){ + assert( db->mallocFailed ); + return 0; + } + pSrc = pNew; + pSrc->nAlloc = nAlloc; + } + + /* Move existing slots that come after the newly inserted slots + ** out of the way */ + for(i=pSrc->nSrc-1; i>=iStart; i--){ + pSrc->a[i+nExtra] = pSrc->a[i]; + } + pSrc->nSrc += nExtra; + + /* Zero the newly allocated slots */ + memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra); + for(i=iStart; ia[i].iCursor = -1; + } + + /* Return a pointer to the enlarged SrcList */ + return pSrc; +} + + +/* +** Append a new table name to the given SrcList. Create a new SrcList if +** need be. A new entry is created in the SrcList even if pTable is NULL. +** +** A SrcList is returned, or NULL if there is an OOM error or if the +** SrcList grows to large. The returned +** SrcList might be the same as the SrcList that was input or it might be +** a new one. If an OOM error does occurs, then the prior value of pList +** that is input to this routine is automatically freed. +** +** If pDatabase is not null, it means that the table has an optional +** database name prefix. Like this: "database.table". The pDatabase +** points to the table name and the pTable points to the database name. +** The SrcList.a[].zName field is filled with the table name which might +** come from pTable (if pDatabase is NULL) or from pDatabase. +** SrcList.a[].zDatabase is filled with the database name from pTable, +** or with NULL if no database is specified. +** +** In other words, if call like this: +** +** sqlite3SrcListAppend(D,A,B,0); +** +** Then B is a table name and the database name is unspecified. If called +** like this: +** +** sqlite3SrcListAppend(D,A,B,C); +** +** Then C is the table name and B is the database name. If C is defined +** then so is B. In other words, we never have a case where: +** +** sqlite3SrcListAppend(D,A,0,C); +** +** Both pTable and pDatabase are assumed to be quoted. They are dequoted +** before being added to the SrcList. +*/ +SQLITE_PRIVATE SrcList *sqlite3SrcListAppend( + Parse *pParse, /* Parsing context, in which errors are reported */ + SrcList *pList, /* Append to this SrcList. NULL creates a new SrcList */ + Token *pTable, /* Table to append */ + Token *pDatabase /* Database of the table */ +){ + struct SrcList_item *pItem; + sqlite3 *db; + assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */ + assert( pParse!=0 ); + assert( pParse->db!=0 ); + db = pParse->db; + if( pList==0 ){ + pList = sqlite3DbMallocRawNN(pParse->db, sizeof(SrcList) ); + if( pList==0 ) return 0; + pList->nAlloc = 1; + pList->nSrc = 1; + memset(&pList->a[0], 0, sizeof(pList->a[0])); + pList->a[0].iCursor = -1; + }else{ + SrcList *pNew = sqlite3SrcListEnlarge(pParse, pList, 1, pList->nSrc); + if( pNew==0 ){ + sqlite3SrcListDelete(db, pList); + return 0; + }else{ + pList = pNew; + } + } + pItem = &pList->a[pList->nSrc-1]; + if( pDatabase && pDatabase->z==0 ){ + pDatabase = 0; + } + if( pDatabase ){ + pItem->zName = sqlite3NameFromToken(db, pDatabase); + pItem->zDatabase = sqlite3NameFromToken(db, pTable); + }else{ + pItem->zName = sqlite3NameFromToken(db, pTable); + pItem->zDatabase = 0; + } + return pList; +} + +/* +** Assign VdbeCursor index numbers to all tables in a SrcList +*/ +SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){ + int i; + struct SrcList_item *pItem; + assert(pList || pParse->db->mallocFailed ); + if( pList ){ + for(i=0, pItem=pList->a; inSrc; i++, pItem++){ + if( pItem->iCursor>=0 ) continue; + pItem->iCursor = pParse->nTab++; + if( pItem->pSelect ){ + sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc); + } + } + } +} + +/* +** Delete an entire SrcList including all its substructure. +*/ +SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){ + int i; + struct SrcList_item *pItem; + if( pList==0 ) return; + for(pItem=pList->a, i=0; inSrc; i++, pItem++){ + if( pItem->zDatabase ) sqlite3DbFreeNN(db, pItem->zDatabase); + sqlite3DbFree(db, pItem->zName); + if( pItem->zAlias ) sqlite3DbFreeNN(db, pItem->zAlias); + if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy); + if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg); + sqlite3DeleteTable(db, pItem->pTab); + if( pItem->pSelect ) sqlite3SelectDelete(db, pItem->pSelect); + if( pItem->pOn ) sqlite3ExprDelete(db, pItem->pOn); + if( pItem->pUsing ) sqlite3IdListDelete(db, pItem->pUsing); + } + sqlite3DbFreeNN(db, pList); +} + +/* +** This routine is called by the parser to add a new term to the +** end of a growing FROM clause. The "p" parameter is the part of +** the FROM clause that has already been constructed. "p" is NULL +** if this is the first term of the FROM clause. pTable and pDatabase +** are the name of the table and database named in the FROM clause term. +** pDatabase is NULL if the database name qualifier is missing - the +** usual case. If the term has an alias, then pAlias points to the +** alias token. If the term is a subquery, then pSubquery is the +** SELECT statement that the subquery encodes. The pTable and +** pDatabase parameters are NULL for subqueries. The pOn and pUsing +** parameters are the content of the ON and USING clauses. +** +** Return a new SrcList which encodes is the FROM with the new +** term added. +*/ +SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm( + Parse *pParse, /* Parsing context */ + SrcList *p, /* The left part of the FROM clause already seen */ + Token *pTable, /* Name of the table to add to the FROM clause */ + Token *pDatabase, /* Name of the database containing pTable */ + Token *pAlias, /* The right-hand side of the AS subexpression */ + Select *pSubquery, /* A subquery used in place of a table name */ + Expr *pOn, /* The ON clause of a join */ + IdList *pUsing /* The USING clause of a join */ +){ + struct SrcList_item *pItem; + sqlite3 *db = pParse->db; + if( !p && (pOn || pUsing) ){ + sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s", + (pOn ? "ON" : "USING") + ); + goto append_from_error; + } + p = sqlite3SrcListAppend(pParse, p, pTable, pDatabase); + if( p==0 ){ + goto append_from_error; + } + assert( p->nSrc>0 ); + pItem = &p->a[p->nSrc-1]; + assert( (pTable==0)==(pDatabase==0) ); + assert( pItem->zName==0 || pDatabase!=0 ); + if( IN_RENAME_OBJECT && pItem->zName ){ + Token *pToken = (ALWAYS(pDatabase) && pDatabase->z) ? pDatabase : pTable; + sqlite3RenameTokenMap(pParse, pItem->zName, pToken); + } + assert( pAlias!=0 ); + if( pAlias->n ){ + pItem->zAlias = sqlite3NameFromToken(db, pAlias); + } + pItem->pSelect = pSubquery; + pItem->pOn = pOn; + pItem->pUsing = pUsing; + return p; + + append_from_error: + assert( p==0 ); + sqlite3ExprDelete(db, pOn); + sqlite3IdListDelete(db, pUsing); + sqlite3SelectDelete(db, pSubquery); + return 0; +} + +/* +** Add an INDEXED BY or NOT INDEXED clause to the most recently added +** element of the source-list passed as the second argument. +*/ +SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){ + assert( pIndexedBy!=0 ); + if( p && pIndexedBy->n>0 ){ + struct SrcList_item *pItem; + assert( p->nSrc>0 ); + pItem = &p->a[p->nSrc-1]; + assert( pItem->fg.notIndexed==0 ); + assert( pItem->fg.isIndexedBy==0 ); + assert( pItem->fg.isTabFunc==0 ); + if( pIndexedBy->n==1 && !pIndexedBy->z ){ + /* A "NOT INDEXED" clause was supplied. See parse.y + ** construct "indexed_opt" for details. */ + pItem->fg.notIndexed = 1; + }else{ + pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy); + pItem->fg.isIndexedBy = 1; + } + } +} + +/* +** Append the contents of SrcList p2 to SrcList p1 and return the resulting +** SrcList. Or, if an error occurs, return NULL. In all cases, p1 and p2 +** are deleted by this function. +*/ +SQLITE_PRIVATE SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2){ + assert( p1 && p1->nSrc==1 ); + if( p2 ){ + SrcList *pNew = sqlite3SrcListEnlarge(pParse, p1, p2->nSrc, 1); + if( pNew==0 ){ + sqlite3SrcListDelete(pParse->db, p2); + }else{ + p1 = pNew; + memcpy(&p1->a[1], p2->a, p2->nSrc*sizeof(struct SrcList_item)); + sqlite3DbFree(pParse->db, p2); + } + } + return p1; +} + +/* +** Add the list of function arguments to the SrcList entry for a +** table-valued-function. +*/ +SQLITE_PRIVATE void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){ + if( p ){ + struct SrcList_item *pItem = &p->a[p->nSrc-1]; + assert( pItem->fg.notIndexed==0 ); + assert( pItem->fg.isIndexedBy==0 ); + assert( pItem->fg.isTabFunc==0 ); + pItem->u1.pFuncArg = pList; + pItem->fg.isTabFunc = 1; + }else{ + sqlite3ExprListDelete(pParse->db, pList); + } +} + +/* +** When building up a FROM clause in the parser, the join operator +** is initially attached to the left operand. But the code generator +** expects the join operator to be on the right operand. This routine +** Shifts all join operators from left to right for an entire FROM +** clause. +** +** Example: Suppose the join is like this: +** +** A natural cross join B +** +** The operator is "natural cross join". The A and B operands are stored +** in p->a[0] and p->a[1], respectively. The parser initially stores the +** operator with A. This routine shifts that operator over to B. +*/ +SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList *p){ + if( p ){ + int i; + for(i=p->nSrc-1; i>0; i--){ + p->a[i].fg.jointype = p->a[i-1].fg.jointype; + } + p->a[0].fg.jointype = 0; + } +} + +/* +** Generate VDBE code for a BEGIN statement. +*/ +SQLITE_PRIVATE void sqlite3BeginTransaction(Parse *pParse, int type){ + sqlite3 *db; + Vdbe *v; + int i; + + assert( pParse!=0 ); + db = pParse->db; + assert( db!=0 ); + if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){ + return; + } + v = sqlite3GetVdbe(pParse); + if( !v ) return; + if( type!=TK_DEFERRED ){ + for(i=0; inDb; i++){ + int eTxnType; + Btree *pBt = db->aDb[i].pBt; + if( pBt && sqlite3BtreeIsReadonly(pBt) ){ + eTxnType = 0; /* Read txn */ + }else if( type==TK_EXCLUSIVE ){ + eTxnType = 2; /* Exclusive txn */ + }else{ + eTxnType = 1; /* Write txn */ + } + sqlite3VdbeAddOp2(v, OP_Transaction, i, eTxnType); + sqlite3VdbeUsesBtree(v, i); + } + } + sqlite3VdbeAddOp0(v, OP_AutoCommit); +} + +/* +** Generate VDBE code for a COMMIT or ROLLBACK statement. +** Code for ROLLBACK is generated if eType==TK_ROLLBACK. Otherwise +** code is generated for a COMMIT. +*/ +SQLITE_PRIVATE void sqlite3EndTransaction(Parse *pParse, int eType){ + Vdbe *v; + int isRollback; + + assert( pParse!=0 ); + assert( pParse->db!=0 ); + assert( eType==TK_COMMIT || eType==TK_END || eType==TK_ROLLBACK ); + isRollback = eType==TK_ROLLBACK; + if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, + isRollback ? "ROLLBACK" : "COMMIT", 0, 0) ){ + return; + } + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, isRollback); + } +} + +/* +** This function is called by the parser when it parses a command to create, +** release or rollback an SQL savepoint. +*/ +SQLITE_PRIVATE void sqlite3Savepoint(Parse *pParse, int op, Token *pName){ + char *zName = sqlite3NameFromToken(pParse->db, pName); + if( zName ){ + Vdbe *v = sqlite3GetVdbe(pParse); +#ifndef SQLITE_OMIT_AUTHORIZATION + static const char * const az[] = { "BEGIN", "RELEASE", "ROLLBACK" }; + assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 ); +#endif + if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){ + sqlite3DbFree(pParse->db, zName); + return; + } + sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC); + } +} + +/* +** Make sure the TEMP database is open and available for use. Return +** the number of errors. Leave any error messages in the pParse structure. +*/ +SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *pParse){ + sqlite3 *db = pParse->db; + if( db->aDb[1].pBt==0 && !pParse->explain ){ + int rc; + Btree *pBt; + static const int flags = + SQLITE_OPEN_READWRITE | + SQLITE_OPEN_CREATE | + SQLITE_OPEN_EXCLUSIVE | + SQLITE_OPEN_DELETEONCLOSE | + SQLITE_OPEN_TEMP_DB; + + rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags); + if( rc!=SQLITE_OK ){ + sqlite3ErrorMsg(pParse, "unable to open a temporary database " + "file for storing temporary tables"); + pParse->rc = rc; + return 1; + } + db->aDb[1].pBt = pBt; + assert( db->aDb[1].pSchema ); + if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, 0, 0) ){ + sqlite3OomFault(db); + return 1; + } + } + return 0; +} + +/* +** Record the fact that the schema cookie will need to be verified +** for database iDb. The code to actually verify the schema cookie +** will occur at the end of the top-level VDBE and will be generated +** later, by sqlite3FinishCoding(). +*/ +static void sqlite3CodeVerifySchemaAtToplevel(Parse *pToplevel, int iDb){ + assert( iDb>=0 && iDbdb->nDb ); + assert( pToplevel->db->aDb[iDb].pBt!=0 || iDb==1 ); + assert( iDbdb, iDb, 0) ); + if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){ + DbMaskSet(pToplevel->cookieMask, iDb); + if( !OMIT_TEMPDB && iDb==1 ){ + sqlite3OpenTempDatabase(pToplevel); + } + } +} +SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){ + sqlite3CodeVerifySchemaAtToplevel(sqlite3ParseToplevel(pParse), iDb); +} + + +/* +** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each +** attached database. Otherwise, invoke it for the database named zDb only. +*/ +SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){ + sqlite3 *db = pParse->db; + int i; + for(i=0; inDb; i++){ + Db *pDb = &db->aDb[i]; + if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zDbSName)) ){ + sqlite3CodeVerifySchema(pParse, i); + } + } +} + +/* +** Generate VDBE code that prepares for doing an operation that +** might change the database. +** +** This routine starts a new transaction if we are not already within +** a transaction. If we are already within a transaction, then a checkpoint +** is set if the setStatement parameter is true. A checkpoint should +** be set for operations that might fail (due to a constraint) part of +** the way through and which will need to undo some writes without having to +** rollback the whole transaction. For operations where all constraints +** can be checked before any changes are made to the database, it is never +** necessary to undo a write and the checkpoint should not be set. +*/ +SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + sqlite3CodeVerifySchemaAtToplevel(pToplevel, iDb); + DbMaskSet(pToplevel->writeMask, iDb); + pToplevel->isMultiWrite |= setStatement; +} + +/* +** Indicate that the statement currently under construction might write +** more than one entry (example: deleting one row then inserting another, +** inserting multiple rows in a table, or inserting a row and index entries.) +** If an abort occurs after some of these writes have completed, then it will +** be necessary to undo the completed writes. +*/ +SQLITE_PRIVATE void sqlite3MultiWrite(Parse *pParse){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + pToplevel->isMultiWrite = 1; +} + +/* +** The code generator calls this routine if is discovers that it is +** possible to abort a statement prior to completion. In order to +** perform this abort without corrupting the database, we need to make +** sure that the statement is protected by a statement transaction. +** +** Technically, we only need to set the mayAbort flag if the +** isMultiWrite flag was previously set. There is a time dependency +** such that the abort must occur after the multiwrite. This makes +** some statements involving the REPLACE conflict resolution algorithm +** go a little faster. But taking advantage of this time dependency +** makes it more difficult to prove that the code is correct (in +** particular, it prevents us from writing an effective +** implementation of sqlite3AssertMayAbort()) and so we have chosen +** to take the safe route and skip the optimization. +*/ +SQLITE_PRIVATE void sqlite3MayAbort(Parse *pParse){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + pToplevel->mayAbort = 1; +} + +/* +** Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT +** error. The onError parameter determines which (if any) of the statement +** and/or current transaction is rolled back. +*/ +SQLITE_PRIVATE void sqlite3HaltConstraint( + Parse *pParse, /* Parsing context */ + int errCode, /* extended error code */ + int onError, /* Constraint type */ + char *p4, /* Error message */ + i8 p4type, /* P4_STATIC or P4_TRANSIENT */ + u8 p5Errmsg /* P5_ErrMsg type */ +){ + Vdbe *v; + assert( pParse->pVdbe!=0 ); + v = sqlite3GetVdbe(pParse); + assert( (errCode&0xff)==SQLITE_CONSTRAINT || pParse->nested ); + if( onError==OE_Abort ){ + sqlite3MayAbort(pParse); + } + sqlite3VdbeAddOp4(v, OP_Halt, errCode, onError, 0, p4, p4type); + sqlite3VdbeChangeP5(v, p5Errmsg); +} + +/* +** Code an OP_Halt due to UNIQUE or PRIMARY KEY constraint violation. +*/ +SQLITE_PRIVATE void sqlite3UniqueConstraint( + Parse *pParse, /* Parsing context */ + int onError, /* Constraint type */ + Index *pIdx /* The index that triggers the constraint */ +){ + char *zErr; + int j; + StrAccum errMsg; + Table *pTab = pIdx->pTable; + + sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0, + pParse->db->aLimit[SQLITE_LIMIT_LENGTH]); + if( pIdx->aColExpr ){ + sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName); + }else{ + for(j=0; jnKeyCol; j++){ + char *zCol; + assert( pIdx->aiColumn[j]>=0 ); + zCol = pTab->aCol[pIdx->aiColumn[j]].zName; + if( j ) sqlite3_str_append(&errMsg, ", ", 2); + sqlite3_str_appendall(&errMsg, pTab->zName); + sqlite3_str_append(&errMsg, ".", 1); + sqlite3_str_appendall(&errMsg, zCol); + } + } + zErr = sqlite3StrAccumFinish(&errMsg); + sqlite3HaltConstraint(pParse, + IsPrimaryKeyIndex(pIdx) ? SQLITE_CONSTRAINT_PRIMARYKEY + : SQLITE_CONSTRAINT_UNIQUE, + onError, zErr, P4_DYNAMIC, P5_ConstraintUnique); +} + + +/* +** Code an OP_Halt due to non-unique rowid. +*/ +SQLITE_PRIVATE void sqlite3RowidConstraint( + Parse *pParse, /* Parsing context */ + int onError, /* Conflict resolution algorithm */ + Table *pTab /* The table with the non-unique rowid */ +){ + char *zMsg; + int rc; + if( pTab->iPKey>=0 ){ + zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName, + pTab->aCol[pTab->iPKey].zName); + rc = SQLITE_CONSTRAINT_PRIMARYKEY; + }else{ + zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName); + rc = SQLITE_CONSTRAINT_ROWID; + } + sqlite3HaltConstraint(pParse, rc, onError, zMsg, P4_DYNAMIC, + P5_ConstraintUnique); +} + +/* +** Check to see if pIndex uses the collating sequence pColl. Return +** true if it does and false if it does not. +*/ +#ifndef SQLITE_OMIT_REINDEX +static int collationMatch(const char *zColl, Index *pIndex){ + int i; + assert( zColl!=0 ); + for(i=0; inColumn; i++){ + const char *z = pIndex->azColl[i]; + assert( z!=0 || pIndex->aiColumn[i]<0 ); + if( pIndex->aiColumn[i]>=0 && 0==sqlite3StrICmp(z, zColl) ){ + return 1; + } + } + return 0; +} +#endif + +/* +** Recompute all indices of pTab that use the collating sequence pColl. +** If pColl==0 then recompute all indices of pTab. +*/ +#ifndef SQLITE_OMIT_REINDEX +static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){ + if( !IsVirtual(pTab) ){ + Index *pIndex; /* An index associated with pTab */ + + for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){ + if( zColl==0 || collationMatch(zColl, pIndex) ){ + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3RefillIndex(pParse, pIndex, -1); + } + } + } +} +#endif + +/* +** Recompute all indices of all tables in all databases where the +** indices use the collating sequence pColl. If pColl==0 then recompute +** all indices everywhere. +*/ +#ifndef SQLITE_OMIT_REINDEX +static void reindexDatabases(Parse *pParse, char const *zColl){ + Db *pDb; /* A single database */ + int iDb; /* The database index number */ + sqlite3 *db = pParse->db; /* The database connection */ + HashElem *k; /* For looping over tables in pDb */ + Table *pTab; /* A table in the database */ + + assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */ + for(iDb=0, pDb=db->aDb; iDbnDb; iDb++, pDb++){ + assert( pDb!=0 ); + for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){ + pTab = (Table*)sqliteHashData(k); + reindexTable(pParse, pTab, zColl); + } + } +} +#endif + +/* +** Generate code for the REINDEX command. +** +** REINDEX -- 1 +** REINDEX -- 2 +** REINDEX ?.? -- 3 +** REINDEX ?.? -- 4 +** +** Form 1 causes all indices in all attached databases to be rebuilt. +** Form 2 rebuilds all indices in all databases that use the named +** collating function. Forms 3 and 4 rebuild the named index or all +** indices associated with the named table. +*/ +#ifndef SQLITE_OMIT_REINDEX +SQLITE_PRIVATE void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){ + CollSeq *pColl; /* Collating sequence to be reindexed, or NULL */ + char *z; /* Name of a table or index */ + const char *zDb; /* Name of the database */ + Table *pTab; /* A table in the database */ + Index *pIndex; /* An index associated with pTab */ + int iDb; /* The database index number */ + sqlite3 *db = pParse->db; /* The database connection */ + Token *pObjName; /* Name of the table or index to be reindexed */ + + /* Read the database schema. If an error occurs, leave an error message + ** and code in pParse and return NULL. */ + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + return; + } + + if( pName1==0 ){ + reindexDatabases(pParse, 0); + return; + }else if( NEVER(pName2==0) || pName2->z==0 ){ + char *zColl; + assert( pName1->z ); + zColl = sqlite3NameFromToken(pParse->db, pName1); + if( !zColl ) return; + pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0); + if( pColl ){ + reindexDatabases(pParse, zColl); + sqlite3DbFree(db, zColl); + return; + } + sqlite3DbFree(db, zColl); + } + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName); + if( iDb<0 ) return; + z = sqlite3NameFromToken(db, pObjName); + if( z==0 ) return; + zDb = db->aDb[iDb].zDbSName; + pTab = sqlite3FindTable(db, z, zDb); + if( pTab ){ + reindexTable(pParse, pTab, 0); + sqlite3DbFree(db, z); + return; + } + pIndex = sqlite3FindIndex(db, z, zDb); + sqlite3DbFree(db, z); + if( pIndex ){ + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3RefillIndex(pParse, pIndex, -1); + return; + } + sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed"); +} +#endif + +/* +** Return a KeyInfo structure that is appropriate for the given Index. +** +** The caller should invoke sqlite3KeyInfoUnref() on the returned object +** when it has finished using it. +*/ +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){ + int i; + int nCol = pIdx->nColumn; + int nKey = pIdx->nKeyCol; + KeyInfo *pKey; + if( pParse->nErr ) return 0; + if( pIdx->uniqNotNull ){ + pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey); + }else{ + pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0); + } + if( pKey ){ + assert( sqlite3KeyInfoIsWriteable(pKey) ); + for(i=0; iazColl[i]; + pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 : + sqlite3LocateCollSeq(pParse, zColl); + pKey->aSortFlags[i] = pIdx->aSortOrder[i]; + assert( 0==(pKey->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) ); + } + if( pParse->nErr ){ + assert( pParse->rc==SQLITE_ERROR_MISSING_COLLSEQ ); + if( pIdx->bNoQuery==0 ){ + /* Deactivate the index because it contains an unknown collating + ** sequence. The only way to reactive the index is to reload the + ** schema. Adding the missing collating sequence later does not + ** reactive the index. The application had the chance to register + ** the missing index using the collation-needed callback. For + ** simplicity, SQLite will not give the application a second chance. + */ + pIdx->bNoQuery = 1; + pParse->rc = SQLITE_ERROR_RETRY; + } + sqlite3KeyInfoUnref(pKey); + pKey = 0; + } + } + return pKey; +} + +#ifndef SQLITE_OMIT_CTE +/* +** This routine is invoked once per CTE by the parser while parsing a +** WITH clause. +*/ +SQLITE_PRIVATE With *sqlite3WithAdd( + Parse *pParse, /* Parsing context */ + With *pWith, /* Existing WITH clause, or NULL */ + Token *pName, /* Name of the common-table */ + ExprList *pArglist, /* Optional column name list for the table */ + Select *pQuery /* Query used to initialize the table */ +){ + sqlite3 *db = pParse->db; + With *pNew; + char *zName; + + /* Check that the CTE name is unique within this WITH clause. If + ** not, store an error in the Parse structure. */ + zName = sqlite3NameFromToken(pParse->db, pName); + if( zName && pWith ){ + int i; + for(i=0; inCte; i++){ + if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){ + sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName); + } + } + } + + if( pWith ){ + sqlite3_int64 nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte); + pNew = sqlite3DbRealloc(db, pWith, nByte); + }else{ + pNew = sqlite3DbMallocZero(db, sizeof(*pWith)); + } + assert( (pNew!=0 && zName!=0) || db->mallocFailed ); + + if( db->mallocFailed ){ + sqlite3ExprListDelete(db, pArglist); + sqlite3SelectDelete(db, pQuery); + sqlite3DbFree(db, zName); + pNew = pWith; + }else{ + pNew->a[pNew->nCte].pSelect = pQuery; + pNew->a[pNew->nCte].pCols = pArglist; + pNew->a[pNew->nCte].zName = zName; + pNew->a[pNew->nCte].zCteErr = 0; + pNew->nCte++; + } + + return pNew; +} + +/* +** Free the contents of the With object passed as the second argument. +*/ +SQLITE_PRIVATE void sqlite3WithDelete(sqlite3 *db, With *pWith){ + if( pWith ){ + int i; + for(i=0; inCte; i++){ + struct Cte *pCte = &pWith->a[i]; + sqlite3ExprListDelete(db, pCte->pCols); + sqlite3SelectDelete(db, pCte->pSelect); + sqlite3DbFree(db, pCte->zName); + } + sqlite3DbFree(db, pWith); + } +} +#endif /* !defined(SQLITE_OMIT_CTE) */ + +/************** End of build.c ***********************************************/ +/************** Begin file callback.c ****************************************/ +/* +** 2005 May 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains functions used to access the internal hash tables +** of user defined functions and collation sequences. +*/ + +/* #include "sqliteInt.h" */ + +/* +** Invoke the 'collation needed' callback to request a collation sequence +** in the encoding enc of name zName, length nName. +*/ +static void callCollNeeded(sqlite3 *db, int enc, const char *zName){ + assert( !db->xCollNeeded || !db->xCollNeeded16 ); + if( db->xCollNeeded ){ + char *zExternal = sqlite3DbStrDup(db, zName); + if( !zExternal ) return; + db->xCollNeeded(db->pCollNeededArg, db, enc, zExternal); + sqlite3DbFree(db, zExternal); + } +#ifndef SQLITE_OMIT_UTF16 + if( db->xCollNeeded16 ){ + char const *zExternal; + sqlite3_value *pTmp = sqlite3ValueNew(db); + sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC); + zExternal = sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE); + if( zExternal ){ + db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal); + } + sqlite3ValueFree(pTmp); + } +#endif +} + +/* +** This routine is called if the collation factory fails to deliver a +** collation function in the best encoding but there may be other versions +** of this collation function (for other text encodings) available. Use one +** of these instead if they exist. Avoid a UTF-8 <-> UTF-16 conversion if +** possible. +*/ +static int synthCollSeq(sqlite3 *db, CollSeq *pColl){ + CollSeq *pColl2; + char *z = pColl->zName; + int i; + static const u8 aEnc[] = { SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8 }; + for(i=0; i<3; i++){ + pColl2 = sqlite3FindCollSeq(db, aEnc[i], z, 0); + if( pColl2->xCmp!=0 ){ + memcpy(pColl, pColl2, sizeof(CollSeq)); + pColl->xDel = 0; /* Do not copy the destructor */ + return SQLITE_OK; + } + } + return SQLITE_ERROR; +} + +/* +** This routine is called on a collation sequence before it is used to +** check that it is defined. An undefined collation sequence exists when +** a database is loaded that contains references to collation sequences +** that have not been defined by sqlite3_create_collation() etc. +** +** If required, this routine calls the 'collation needed' callback to +** request a definition of the collating sequence. If this doesn't work, +** an equivalent collating sequence that uses a text encoding different +** from the main database is substituted, if one is available. +*/ +SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){ + if( pColl && pColl->xCmp==0 ){ + const char *zName = pColl->zName; + sqlite3 *db = pParse->db; + CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName); + if( !p ){ + return SQLITE_ERROR; + } + assert( p==pColl ); + } + return SQLITE_OK; +} + + + +/* +** Locate and return an entry from the db.aCollSeq hash table. If the entry +** specified by zName and nName is not found and parameter 'create' is +** true, then create a new entry. Otherwise return NULL. +** +** Each pointer stored in the sqlite3.aCollSeq hash table contains an +** array of three CollSeq structures. The first is the collation sequence +** preferred for UTF-8, the second UTF-16le, and the third UTF-16be. +** +** Stored immediately after the three collation sequences is a copy of +** the collation sequence name. A pointer to this string is stored in +** each collation sequence structure. +*/ +static CollSeq *findCollSeqEntry( + sqlite3 *db, /* Database connection */ + const char *zName, /* Name of the collating sequence */ + int create /* Create a new entry if true */ +){ + CollSeq *pColl; + pColl = sqlite3HashFind(&db->aCollSeq, zName); + + if( 0==pColl && create ){ + int nName = sqlite3Strlen30(zName) + 1; + pColl = sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName); + if( pColl ){ + CollSeq *pDel = 0; + pColl[0].zName = (char*)&pColl[3]; + pColl[0].enc = SQLITE_UTF8; + pColl[1].zName = (char*)&pColl[3]; + pColl[1].enc = SQLITE_UTF16LE; + pColl[2].zName = (char*)&pColl[3]; + pColl[2].enc = SQLITE_UTF16BE; + memcpy(pColl[0].zName, zName, nName); + pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl); + + /* If a malloc() failure occurred in sqlite3HashInsert(), it will + ** return the pColl pointer to be deleted (because it wasn't added + ** to the hash table). + */ + assert( pDel==0 || pDel==pColl ); + if( pDel!=0 ){ + sqlite3OomFault(db); + sqlite3DbFree(db, pDel); + pColl = 0; + } + } + } + return pColl; +} + +/* +** Parameter zName points to a UTF-8 encoded string nName bytes long. +** Return the CollSeq* pointer for the collation sequence named zName +** for the encoding 'enc' from the database 'db'. +** +** If the entry specified is not found and 'create' is true, then create a +** new entry. Otherwise return NULL. +** +** A separate function sqlite3LocateCollSeq() is a wrapper around +** this routine. sqlite3LocateCollSeq() invokes the collation factory +** if necessary and generates an error message if the collating sequence +** cannot be found. +** +** See also: sqlite3LocateCollSeq(), sqlite3GetCollSeq() +*/ +SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq( + sqlite3 *db, /* Database connection to search */ + u8 enc, /* Desired text encoding */ + const char *zName, /* Name of the collating sequence. Might be NULL */ + int create /* True to create CollSeq if doesn't already exist */ +){ + CollSeq *pColl; + assert( SQLITE_UTF8==1 && SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); + assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE ); + if( zName ){ + pColl = findCollSeqEntry(db, zName, create); + if( pColl ) pColl += enc-1; + }else{ + pColl = db->pDfltColl; + } + return pColl; +} + +/* +** Change the text encoding for a database connection. This means that +** the pDfltColl must change as well. +*/ +SQLITE_PRIVATE void sqlite3SetTextEncoding(sqlite3 *db, u8 enc){ + assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); + db->enc = enc; + /* EVIDENCE-OF: R-08308-17224 The default collating function for all + ** strings is BINARY. + */ + db->pDfltColl = sqlite3FindCollSeq(db, enc, sqlite3StrBINARY, 0); +} + +/* +** This function is responsible for invoking the collation factory callback +** or substituting a collation sequence of a different encoding when the +** requested collation sequence is not available in the desired encoding. +** +** If it is not NULL, then pColl must point to the database native encoding +** collation sequence with name zName, length nName. +** +** The return value is either the collation sequence to be used in database +** db for collation type name zName, length nName, or NULL, if no collation +** sequence can be found. If no collation is found, leave an error message. +** +** See also: sqlite3LocateCollSeq(), sqlite3FindCollSeq() +*/ +SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq( + Parse *pParse, /* Parsing context */ + u8 enc, /* The desired encoding for the collating sequence */ + CollSeq *pColl, /* Collating sequence with native encoding, or NULL */ + const char *zName /* Collating sequence name */ +){ + CollSeq *p; + sqlite3 *db = pParse->db; + + p = pColl; + if( !p ){ + p = sqlite3FindCollSeq(db, enc, zName, 0); + } + if( !p || !p->xCmp ){ + /* No collation sequence of this type for this encoding is registered. + ** Call the collation factory to see if it can supply us with one. + */ + callCollNeeded(db, enc, zName); + p = sqlite3FindCollSeq(db, enc, zName, 0); + } + if( p && !p->xCmp && synthCollSeq(db, p) ){ + p = 0; + } + assert( !p || p->xCmp ); + if( p==0 ){ + sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName); + pParse->rc = SQLITE_ERROR_MISSING_COLLSEQ; + } + return p; +} + +/* +** This function returns the collation sequence for database native text +** encoding identified by the string zName. +** +** If the requested collation sequence is not available, or not available +** in the database native encoding, the collation factory is invoked to +** request it. If the collation factory does not supply such a sequence, +** and the sequence is available in another text encoding, then that is +** returned instead. +** +** If no versions of the requested collations sequence are available, or +** another error occurs, NULL is returned and an error message written into +** pParse. +** +** This routine is a wrapper around sqlite3FindCollSeq(). This routine +** invokes the collation factory if the named collation cannot be found +** and generates an error message. +** +** See also: sqlite3FindCollSeq(), sqlite3GetCollSeq() +*/ +SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){ + sqlite3 *db = pParse->db; + u8 enc = ENC(db); + u8 initbusy = db->init.busy; + CollSeq *pColl; + + pColl = sqlite3FindCollSeq(db, enc, zName, initbusy); + if( !initbusy && (!pColl || !pColl->xCmp) ){ + pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName); + } + + return pColl; +} + +/* During the search for the best function definition, this procedure +** is called to test how well the function passed as the first argument +** matches the request for a function with nArg arguments in a system +** that uses encoding enc. The value returned indicates how well the +** request is matched. A higher value indicates a better match. +** +** If nArg is -1 that means to only return a match (non-zero) if p->nArg +** is also -1. In other words, we are searching for a function that +** takes a variable number of arguments. +** +** If nArg is -2 that means that we are searching for any function +** regardless of the number of arguments it uses, so return a positive +** match score for any +** +** The returned value is always between 0 and 6, as follows: +** +** 0: Not a match. +** 1: UTF8/16 conversion required and function takes any number of arguments. +** 2: UTF16 byte order change required and function takes any number of args. +** 3: encoding matches and function takes any number of arguments +** 4: UTF8/16 conversion required - argument count matches exactly +** 5: UTF16 byte order conversion required - argument count matches exactly +** 6: Perfect match: encoding and argument count match exactly. +** +** If nArg==(-2) then any function with a non-null xSFunc is +** a perfect match and any function with xSFunc NULL is +** a non-match. +*/ +#define FUNC_PERFECT_MATCH 6 /* The score for a perfect match */ +static int matchQuality( + FuncDef *p, /* The function we are evaluating for match quality */ + int nArg, /* Desired number of arguments. (-1)==any */ + u8 enc /* Desired text encoding */ +){ + int match; + assert( p->nArg>=-1 ); + + /* Wrong number of arguments means "no match" */ + if( p->nArg!=nArg ){ + if( nArg==(-2) ) return (p->xSFunc==0) ? 0 : FUNC_PERFECT_MATCH; + if( p->nArg>=0 ) return 0; + } + + /* Give a better score to a function with a specific number of arguments + ** than to function that accepts any number of arguments. */ + if( p->nArg==nArg ){ + match = 4; + }else{ + match = 1; + } + + /* Bonus points if the text encoding matches */ + if( enc==(p->funcFlags & SQLITE_FUNC_ENCMASK) ){ + match += 2; /* Exact encoding match */ + }else if( (enc & p->funcFlags & 2)!=0 ){ + match += 1; /* Both are UTF16, but with different byte orders */ + } + + return match; +} + +/* +** Search a FuncDefHash for a function with the given name. Return +** a pointer to the matching FuncDef if found, or 0 if there is no match. +*/ +SQLITE_PRIVATE FuncDef *sqlite3FunctionSearch( + int h, /* Hash of the name */ + const char *zFunc /* Name of function */ +){ + FuncDef *p; + for(p=sqlite3BuiltinFunctions.a[h]; p; p=p->u.pHash){ + if( sqlite3StrICmp(p->zName, zFunc)==0 ){ + return p; + } + } + return 0; +} + +/* +** Insert a new FuncDef into a FuncDefHash hash table. +*/ +SQLITE_PRIVATE void sqlite3InsertBuiltinFuncs( + FuncDef *aDef, /* List of global functions to be inserted */ + int nDef /* Length of the apDef[] list */ +){ + int i; + for(i=0; i='a' && zName[0]<='z' ); + pOther = sqlite3FunctionSearch(h, zName); + if( pOther ){ + assert( pOther!=&aDef[i] && pOther->pNext!=&aDef[i] ); + aDef[i].pNext = pOther->pNext; + pOther->pNext = &aDef[i]; + }else{ + aDef[i].pNext = 0; + aDef[i].u.pHash = sqlite3BuiltinFunctions.a[h]; + sqlite3BuiltinFunctions.a[h] = &aDef[i]; + } + } +} + + + +/* +** Locate a user function given a name, a number of arguments and a flag +** indicating whether the function prefers UTF-16 over UTF-8. Return a +** pointer to the FuncDef structure that defines that function, or return +** NULL if the function does not exist. +** +** If the createFlag argument is true, then a new (blank) FuncDef +** structure is created and liked into the "db" structure if a +** no matching function previously existed. +** +** If nArg is -2, then the first valid function found is returned. A +** function is valid if xSFunc is non-zero. The nArg==(-2) +** case is used to see if zName is a valid function name for some number +** of arguments. If nArg is -2, then createFlag must be 0. +** +** If createFlag is false, then a function with the required name and +** number of arguments may be returned even if the eTextRep flag does not +** match that requested. +*/ +SQLITE_PRIVATE FuncDef *sqlite3FindFunction( + sqlite3 *db, /* An open database */ + const char *zName, /* Name of the function. zero-terminated */ + int nArg, /* Number of arguments. -1 means any number */ + u8 enc, /* Preferred text encoding */ + u8 createFlag /* Create new entry if true and does not otherwise exist */ +){ + FuncDef *p; /* Iterator variable */ + FuncDef *pBest = 0; /* Best match found so far */ + int bestScore = 0; /* Score of best match */ + int h; /* Hash value */ + int nName; /* Length of the name */ + + assert( nArg>=(-2) ); + assert( nArg>=(-1) || createFlag==0 ); + nName = sqlite3Strlen30(zName); + + /* First search for a match amongst the application-defined functions. + */ + p = (FuncDef*)sqlite3HashFind(&db->aFunc, zName); + while( p ){ + int score = matchQuality(p, nArg, enc); + if( score>bestScore ){ + pBest = p; + bestScore = score; + } + p = p->pNext; + } + + /* If no match is found, search the built-in functions. + ** + ** If the DBFLAG_PreferBuiltin flag is set, then search the built-in + ** functions even if a prior app-defined function was found. And give + ** priority to built-in functions. + ** + ** Except, if createFlag is true, that means that we are trying to + ** install a new function. Whatever FuncDef structure is returned it will + ** have fields overwritten with new information appropriate for the + ** new function. But the FuncDefs for built-in functions are read-only. + ** So we must not search for built-ins when creating a new function. + */ + if( !createFlag && (pBest==0 || (db->mDbFlags & DBFLAG_PreferBuiltin)!=0) ){ + bestScore = 0; + h = SQLITE_FUNC_HASH(sqlite3UpperToLower[(u8)zName[0]], nName); + p = sqlite3FunctionSearch(h, zName); + while( p ){ + int score = matchQuality(p, nArg, enc); + if( score>bestScore ){ + pBest = p; + bestScore = score; + } + p = p->pNext; + } + } + + /* If the createFlag parameter is true and the search did not reveal an + ** exact match for the name, number of arguments and encoding, then add a + ** new entry to the hash table and return it. + */ + if( createFlag && bestScorezName = (const char*)&pBest[1]; + pBest->nArg = (u16)nArg; + pBest->funcFlags = enc; + memcpy((char*)&pBest[1], zName, nName+1); + for(z=(u8*)pBest->zName; *z; z++) *z = sqlite3UpperToLower[*z]; + pOther = (FuncDef*)sqlite3HashInsert(&db->aFunc, pBest->zName, pBest); + if( pOther==pBest ){ + sqlite3DbFree(db, pBest); + sqlite3OomFault(db); + return 0; + }else{ + pBest->pNext = pOther; + } + } + + if( pBest && (pBest->xSFunc || createFlag) ){ + return pBest; + } + return 0; +} + +/* +** Free all resources held by the schema structure. The void* argument points +** at a Schema struct. This function does not call sqlite3DbFree(db, ) on the +** pointer itself, it just cleans up subsidiary resources (i.e. the contents +** of the schema hash tables). +** +** The Schema.cache_size variable is not cleared. +*/ +SQLITE_PRIVATE void sqlite3SchemaClear(void *p){ + Hash temp1; + Hash temp2; + HashElem *pElem; + Schema *pSchema = (Schema *)p; + + temp1 = pSchema->tblHash; + temp2 = pSchema->trigHash; + sqlite3HashInit(&pSchema->trigHash); + sqlite3HashClear(&pSchema->idxHash); + for(pElem=sqliteHashFirst(&temp2); pElem; pElem=sqliteHashNext(pElem)){ + sqlite3DeleteTrigger(0, (Trigger*)sqliteHashData(pElem)); + } + sqlite3HashClear(&temp2); + sqlite3HashInit(&pSchema->tblHash); + for(pElem=sqliteHashFirst(&temp1); pElem; pElem=sqliteHashNext(pElem)){ + Table *pTab = sqliteHashData(pElem); + sqlite3DeleteTable(0, pTab); + } + sqlite3HashClear(&temp1); + sqlite3HashClear(&pSchema->fkeyHash); + pSchema->pSeqTab = 0; + if( pSchema->schemaFlags & DB_SchemaLoaded ){ + pSchema->iGeneration++; + } + pSchema->schemaFlags &= ~(DB_SchemaLoaded|DB_ResetWanted); +} + +/* +** Find and return the schema associated with a BTree. Create +** a new one if necessary. +*/ +SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){ + Schema * p; + if( pBt ){ + p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear); + }else{ + p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema)); + } + if( !p ){ + sqlite3OomFault(db); + }else if ( 0==p->file_format ){ + sqlite3HashInit(&p->tblHash); + sqlite3HashInit(&p->idxHash); + sqlite3HashInit(&p->trigHash); + sqlite3HashInit(&p->fkeyHash); + p->enc = SQLITE_UTF8; + } + return p; +} + +/************** End of callback.c ********************************************/ +/************** Begin file delete.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** in order to generate code for DELETE FROM statements. +*/ +/* #include "sqliteInt.h" */ + +/* +** While a SrcList can in general represent multiple tables and subqueries +** (as in the FROM clause of a SELECT statement) in this case it contains +** the name of a single table, as one might find in an INSERT, DELETE, +** or UPDATE statement. Look up that table in the symbol table and +** return a pointer. Set an error message and return NULL if the table +** name is not found or if any other error occurs. +** +** The following fields are initialized appropriate in pSrc: +** +** pSrc->a[0].pTab Pointer to the Table object +** pSrc->a[0].pIndex Pointer to the INDEXED BY index, if there is one +** +*/ +SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){ + struct SrcList_item *pItem = pSrc->a; + Table *pTab; + assert( pItem && pSrc->nSrc>=1 ); + pTab = sqlite3LocateTableItem(pParse, 0, pItem); + sqlite3DeleteTable(pParse->db, pItem->pTab); + pItem->pTab = pTab; + if( pTab ){ + pTab->nTabRef++; + } + if( sqlite3IndexedByLookup(pParse, pItem) ){ + pTab = 0; + } + return pTab; +} + +/* Return true if table pTab is read-only. +** +** A table is read-only if any of the following are true: +** +** 1) It is a virtual table and no implementation of the xUpdate method +** has been provided +** +** 2) It is a system table (i.e. sqlite_schema), this call is not +** part of a nested parse and writable_schema pragma has not +** been specified +** +** 3) The table is a shadow table, the database connection is in +** defensive mode, and the current sqlite3_prepare() +** is for a top-level SQL statement. +*/ +static int tabIsReadOnly(Parse *pParse, Table *pTab){ + sqlite3 *db; + if( IsVirtual(pTab) ){ + return sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0; + } + if( (pTab->tabFlags & (TF_Readonly|TF_Shadow))==0 ) return 0; + db = pParse->db; + if( (pTab->tabFlags & TF_Readonly)!=0 ){ + return sqlite3WritableSchema(db)==0 && pParse->nested==0; + } + assert( pTab->tabFlags & TF_Shadow ); + return sqlite3ReadOnlyShadowTables(db); +} + +/* +** Check to make sure the given table is writable. If it is not +** writable, generate an error message and return 1. If it is +** writable return 0; +*/ +SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){ + if( tabIsReadOnly(pParse, pTab) ){ + sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName); + return 1; + } +#ifndef SQLITE_OMIT_VIEW + if( !viewOk && pTab->pSelect ){ + sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName); + return 1; + } +#endif + return 0; +} + + +#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) +/* +** Evaluate a view and store its result in an ephemeral table. The +** pWhere argument is an optional WHERE clause that restricts the +** set of rows in the view that are to be added to the ephemeral table. +*/ +SQLITE_PRIVATE void sqlite3MaterializeView( + Parse *pParse, /* Parsing context */ + Table *pView, /* View definition */ + Expr *pWhere, /* Optional WHERE clause to be added */ + ExprList *pOrderBy, /* Optional ORDER BY clause */ + Expr *pLimit, /* Optional LIMIT clause */ + int iCur /* Cursor number for ephemeral table */ +){ + SelectDest dest; + Select *pSel; + SrcList *pFrom; + sqlite3 *db = pParse->db; + int iDb = sqlite3SchemaToIndex(db, pView->pSchema); + pWhere = sqlite3ExprDup(db, pWhere, 0); + pFrom = sqlite3SrcListAppend(pParse, 0, 0, 0); + if( pFrom ){ + assert( pFrom->nSrc==1 ); + pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName); + pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName); + assert( pFrom->a[0].pOn==0 ); + assert( pFrom->a[0].pUsing==0 ); + } + pSel = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, pOrderBy, + SF_IncludeHidden, pLimit); + sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur); + sqlite3Select(pParse, pSel, &dest); + sqlite3SelectDelete(db, pSel); +} +#endif /* !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) */ + +#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) +/* +** Generate an expression tree to implement the WHERE, ORDER BY, +** and LIMIT/OFFSET portion of DELETE and UPDATE statements. +** +** DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1; +** \__________________________/ +** pLimitWhere (pInClause) +*/ +SQLITE_PRIVATE Expr *sqlite3LimitWhere( + Parse *pParse, /* The parser context */ + SrcList *pSrc, /* the FROM clause -- which tables to scan */ + Expr *pWhere, /* The WHERE clause. May be null */ + ExprList *pOrderBy, /* The ORDER BY clause. May be null */ + Expr *pLimit, /* The LIMIT clause. May be null */ + char *zStmtType /* Either DELETE or UPDATE. For err msgs. */ +){ + sqlite3 *db = pParse->db; + Expr *pLhs = NULL; /* LHS of IN(SELECT...) operator */ + Expr *pInClause = NULL; /* WHERE rowid IN ( select ) */ + ExprList *pEList = NULL; /* Expression list contaning only pSelectRowid */ + SrcList *pSelectSrc = NULL; /* SELECT rowid FROM x ... (dup of pSrc) */ + Select *pSelect = NULL; /* Complete SELECT tree */ + Table *pTab; + + /* Check that there isn't an ORDER BY without a LIMIT clause. + */ + if( pOrderBy && pLimit==0 ) { + sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType); + sqlite3ExprDelete(pParse->db, pWhere); + sqlite3ExprListDelete(pParse->db, pOrderBy); + return 0; + } + + /* We only need to generate a select expression if there + ** is a limit/offset term to enforce. + */ + if( pLimit == 0 ) { + return pWhere; + } + + /* Generate a select expression tree to enforce the limit/offset + ** term for the DELETE or UPDATE statement. For example: + ** DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1 + ** becomes: + ** DELETE FROM table_a WHERE rowid IN ( + ** SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1 + ** ); + */ + + pTab = pSrc->a[0].pTab; + if( HasRowid(pTab) ){ + pLhs = sqlite3PExpr(pParse, TK_ROW, 0, 0); + pEList = sqlite3ExprListAppend( + pParse, 0, sqlite3PExpr(pParse, TK_ROW, 0, 0) + ); + }else{ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + if( pPk->nKeyCol==1 ){ + const char *zName = pTab->aCol[pPk->aiColumn[0]].zName; + pLhs = sqlite3Expr(db, TK_ID, zName); + pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, zName)); + }else{ + int i; + for(i=0; inKeyCol; i++){ + Expr *p = sqlite3Expr(db, TK_ID, pTab->aCol[pPk->aiColumn[i]].zName); + pEList = sqlite3ExprListAppend(pParse, pEList, p); + } + pLhs = sqlite3PExpr(pParse, TK_VECTOR, 0, 0); + if( pLhs ){ + pLhs->x.pList = sqlite3ExprListDup(db, pEList, 0); + } + } + } + + /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree + ** and the SELECT subtree. */ + pSrc->a[0].pTab = 0; + pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc, 0); + pSrc->a[0].pTab = pTab; + pSrc->a[0].pIBIndex = 0; + + /* generate the SELECT expression tree. */ + pSelect = sqlite3SelectNew(pParse, pEList, pSelectSrc, pWhere, 0 ,0, + pOrderBy,0,pLimit + ); + + /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */ + pInClause = sqlite3PExpr(pParse, TK_IN, pLhs, 0); + sqlite3PExprAddSelect(pParse, pInClause, pSelect); + return pInClause; +} +#endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) */ + /* && !defined(SQLITE_OMIT_SUBQUERY) */ + +/* +** Generate code for a DELETE FROM statement. +** +** DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL; +** \________/ \________________/ +** pTabList pWhere +*/ +SQLITE_PRIVATE void sqlite3DeleteFrom( + Parse *pParse, /* The parser context */ + SrcList *pTabList, /* The table from which we should delete things */ + Expr *pWhere, /* The WHERE clause. May be null */ + ExprList *pOrderBy, /* ORDER BY clause. May be null */ + Expr *pLimit /* LIMIT clause. May be null */ +){ + Vdbe *v; /* The virtual database engine */ + Table *pTab; /* The table from which records will be deleted */ + int i; /* Loop counter */ + WhereInfo *pWInfo; /* Information about the WHERE clause */ + Index *pIdx; /* For looping over indices of the table */ + int iTabCur; /* Cursor number for the table */ + int iDataCur = 0; /* VDBE cursor for the canonical data source */ + int iIdxCur = 0; /* Cursor number of the first index */ + int nIdx; /* Number of indices */ + sqlite3 *db; /* Main database structure */ + AuthContext sContext; /* Authorization context */ + NameContext sNC; /* Name context to resolve expressions in */ + int iDb; /* Database number */ + int memCnt = 0; /* Memory cell used for change counting */ + int rcauth; /* Value returned by authorization callback */ + int eOnePass; /* ONEPASS_OFF or _SINGLE or _MULTI */ + int aiCurOnePass[2]; /* The write cursors opened by WHERE_ONEPASS */ + u8 *aToOpen = 0; /* Open cursor iTabCur+j if aToOpen[j] is true */ + Index *pPk; /* The PRIMARY KEY index on the table */ + int iPk = 0; /* First of nPk registers holding PRIMARY KEY value */ + i16 nPk = 1; /* Number of columns in the PRIMARY KEY */ + int iKey; /* Memory cell holding key of row to be deleted */ + i16 nKey; /* Number of memory cells in the row key */ + int iEphCur = 0; /* Ephemeral table holding all primary key values */ + int iRowSet = 0; /* Register for rowset of rows to delete */ + int addrBypass = 0; /* Address of jump over the delete logic */ + int addrLoop = 0; /* Top of the delete loop */ + int addrEphOpen = 0; /* Instruction to open the Ephemeral table */ + int bComplex; /* True if there are triggers or FKs or + ** subqueries in the WHERE clause */ + +#ifndef SQLITE_OMIT_TRIGGER + int isView; /* True if attempting to delete from a view */ + Trigger *pTrigger; /* List of table triggers, if required */ +#endif + + memset(&sContext, 0, sizeof(sContext)); + db = pParse->db; + if( pParse->nErr || db->mallocFailed ){ + goto delete_from_cleanup; + } + assert( pTabList->nSrc==1 ); + + + /* Locate the table which we want to delete. This table has to be + ** put in an SrcList structure because some of the subroutines we + ** will be calling are designed to work with multiple tables and expect + ** an SrcList* parameter instead of just a Table* parameter. + */ + pTab = sqlite3SrcListLookup(pParse, pTabList); + if( pTab==0 ) goto delete_from_cleanup; + + /* Figure out if we have any triggers and if the table being + ** deleted from is a view + */ +#ifndef SQLITE_OMIT_TRIGGER + pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0); + isView = pTab->pSelect!=0; +#else +# define pTrigger 0 +# define isView 0 +#endif + bComplex = pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0); +#ifdef SQLITE_OMIT_VIEW +# undef isView +# define isView 0 +#endif + +#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT + if( !isView ){ + pWhere = sqlite3LimitWhere( + pParse, pTabList, pWhere, pOrderBy, pLimit, "DELETE" + ); + pOrderBy = 0; + pLimit = 0; + } +#endif + + /* If pTab is really a view, make sure it has been initialized. + */ + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto delete_from_cleanup; + } + + if( sqlite3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){ + goto delete_from_cleanup; + } + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDbnDb ); + rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, + db->aDb[iDb].zDbSName); + assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE ); + if( rcauth==SQLITE_DENY ){ + goto delete_from_cleanup; + } + assert(!isView || pTrigger); + + /* Assign cursor numbers to the table and all its indices. + */ + assert( pTabList->nSrc==1 ); + iTabCur = pTabList->a[0].iCursor = pParse->nTab++; + for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ + pParse->nTab++; + } + + /* Start the view context + */ + if( isView ){ + sqlite3AuthContextPush(pParse, &sContext, pTab->zName); + } + + /* Begin generating code. + */ + v = sqlite3GetVdbe(pParse); + if( v==0 ){ + goto delete_from_cleanup; + } + if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); + sqlite3BeginWriteOperation(pParse, bComplex, iDb); + + /* If we are trying to delete from a view, realize that view into + ** an ephemeral table. + */ +#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) + if( isView ){ + sqlite3MaterializeView(pParse, pTab, + pWhere, pOrderBy, pLimit, iTabCur + ); + iDataCur = iIdxCur = iTabCur; + pOrderBy = 0; + pLimit = 0; + } +#endif + + /* Resolve the column names in the WHERE clause. + */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pSrcList = pTabList; + if( sqlite3ResolveExprNames(&sNC, pWhere) ){ + goto delete_from_cleanup; + } + + /* Initialize the counter of the number of rows deleted, if + ** we are counting rows. + */ + if( (db->flags & SQLITE_CountRows)!=0 + && !pParse->nested + && !pParse->pTriggerTab + ){ + memCnt = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt); + } + +#ifndef SQLITE_OMIT_TRUNCATE_OPTIMIZATION + /* Special case: A DELETE without a WHERE clause deletes everything. + ** It is easier just to erase the whole table. Prior to version 3.6.5, + ** this optimization caused the row change count (the value returned by + ** API function sqlite3_count_changes) to be set incorrectly. + ** + ** The "rcauth==SQLITE_OK" terms is the + ** IMPLEMENTATION-OF: R-17228-37124 If the action code is SQLITE_DELETE and + ** the callback returns SQLITE_IGNORE then the DELETE operation proceeds but + ** the truncate optimization is disabled and all rows are deleted + ** individually. + */ + if( rcauth==SQLITE_OK + && pWhere==0 + && !bComplex + && !IsVirtual(pTab) +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + && db->xPreUpdateCallback==0 +#endif + ){ + assert( !isView ); + sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName); + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt ? memCnt : -1, + pTab->zName, P4_STATIC); + } + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + assert( pIdx->pSchema==pTab->pSchema ); + sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb); + } + }else +#endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */ + { + u16 wcf = WHERE_ONEPASS_DESIRED|WHERE_DUPLICATES_OK; + if( sNC.ncFlags & NC_VarSelect ) bComplex = 1; + wcf |= (bComplex ? 0 : WHERE_ONEPASS_MULTIROW); + if( HasRowid(pTab) ){ + /* For a rowid table, initialize the RowSet to an empty set */ + pPk = 0; + nPk = 1; + iRowSet = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Null, 0, iRowSet); + }else{ + /* For a WITHOUT ROWID table, create an ephemeral table used to + ** hold all primary keys for rows to be deleted. */ + pPk = sqlite3PrimaryKeyIndex(pTab); + assert( pPk!=0 ); + nPk = pPk->nKeyCol; + iPk = pParse->nMem+1; + pParse->nMem += nPk; + iEphCur = pParse->nTab++; + addrEphOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEphCur, nPk); + sqlite3VdbeSetP4KeyInfo(pParse, pPk); + } + + /* Construct a query to find the rowid or primary key for every row + ** to be deleted, based on the WHERE clause. Set variable eOnePass + ** to indicate the strategy used to implement this delete: + ** + ** ONEPASS_OFF: Two-pass approach - use a FIFO for rowids/PK values. + ** ONEPASS_SINGLE: One-pass approach - at most one row deleted. + ** ONEPASS_MULTI: One-pass approach - any number of rows may be deleted. + */ + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, wcf, iTabCur+1); + if( pWInfo==0 ) goto delete_from_cleanup; + eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass); + assert( IsVirtual(pTab)==0 || eOnePass!=ONEPASS_MULTI ); + assert( IsVirtual(pTab) || bComplex || eOnePass!=ONEPASS_OFF ); + if( eOnePass!=ONEPASS_SINGLE ) sqlite3MultiWrite(pParse); + if( sqlite3WhereUsesDeferredSeek(pWInfo) ){ + sqlite3VdbeAddOp1(v, OP_FinishSeek, iTabCur); + } + + /* Keep track of the number of rows to be deleted */ + if( memCnt ){ + sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1); + } + + /* Extract the rowid or primary key for the current row */ + if( pPk ){ + for(i=0; iaiColumn[i]>=0 ); + sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, + pPk->aiColumn[i], iPk+i); + } + iKey = iPk; + }else{ + iKey = ++pParse->nMem; + sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, -1, iKey); + } + + if( eOnePass!=ONEPASS_OFF ){ + /* For ONEPASS, no need to store the rowid/primary-key. There is only + ** one, so just keep it in its register(s) and fall through to the + ** delete code. */ + nKey = nPk; /* OP_Found will use an unpacked key */ + aToOpen = sqlite3DbMallocRawNN(db, nIdx+2); + if( aToOpen==0 ){ + sqlite3WhereEnd(pWInfo); + goto delete_from_cleanup; + } + memset(aToOpen, 1, nIdx+1); + aToOpen[nIdx+1] = 0; + if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iTabCur] = 0; + if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iTabCur] = 0; + if( addrEphOpen ) sqlite3VdbeChangeToNoop(v, addrEphOpen); + addrBypass = sqlite3VdbeMakeLabel(pParse); + }else{ + if( pPk ){ + /* Add the PK key for this row to the temporary table */ + iKey = ++pParse->nMem; + nKey = 0; /* Zero tells OP_Found to use a composite key */ + sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, iKey, + sqlite3IndexAffinityStr(pParse->db, pPk), nPk); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEphCur, iKey, iPk, nPk); + }else{ + /* Add the rowid of the row to be deleted to the RowSet */ + nKey = 1; /* OP_DeferredSeek always uses a single rowid */ + sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, iKey); + } + sqlite3WhereEnd(pWInfo); + } + + /* Unless this is a view, open cursors for the table we are + ** deleting from and all its indices. If this is a view, then the + ** only effect this statement has is to fire the INSTEAD OF + ** triggers. + */ + if( !isView ){ + int iAddrOnce = 0; + if( eOnePass==ONEPASS_MULTI ){ + iAddrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + } + testcase( IsVirtual(pTab) ); + sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, OPFLAG_FORDELETE, + iTabCur, aToOpen, &iDataCur, &iIdxCur); + assert( pPk || IsVirtual(pTab) || iDataCur==iTabCur ); + assert( pPk || IsVirtual(pTab) || iIdxCur==iDataCur+1 ); + if( eOnePass==ONEPASS_MULTI ){ + sqlite3VdbeJumpHereOrPopInst(v, iAddrOnce); + } + } + + /* Set up a loop over the rowids/primary-keys that were found in the + ** where-clause loop above. + */ + if( eOnePass!=ONEPASS_OFF ){ + assert( nKey==nPk ); /* OP_Found will use an unpacked key */ + if( !IsVirtual(pTab) && aToOpen[iDataCur-iTabCur] ){ + assert( pPk!=0 || pTab->pSelect!=0 ); + sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, addrBypass, iKey, nKey); + VdbeCoverage(v); + } + }else if( pPk ){ + addrLoop = sqlite3VdbeAddOp1(v, OP_Rewind, iEphCur); VdbeCoverage(v); + if( IsVirtual(pTab) ){ + sqlite3VdbeAddOp3(v, OP_Column, iEphCur, 0, iKey); + }else{ + sqlite3VdbeAddOp2(v, OP_RowData, iEphCur, iKey); + } + assert( nKey==0 ); /* OP_Found will use a composite key */ + }else{ + addrLoop = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, 0, iKey); + VdbeCoverage(v); + assert( nKey==1 ); + } + + /* Delete the row */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + const char *pVTab = (const char *)sqlite3GetVTable(db, pTab); + sqlite3VtabMakeWritable(pParse, pTab); + assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE ); + sqlite3MayAbort(pParse); + if( eOnePass==ONEPASS_SINGLE ){ + sqlite3VdbeAddOp1(v, OP_Close, iTabCur); + if( sqlite3IsToplevel(pParse) ){ + pParse->isMultiWrite = 0; + } + } + sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iKey, pVTab, P4_VTAB); + sqlite3VdbeChangeP5(v, OE_Abort); + }else +#endif + { + int count = (pParse->nested==0); /* True to count changes */ + sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur, + iKey, nKey, count, OE_Default, eOnePass, aiCurOnePass[1]); + } + + /* End of the loop over all rowids/primary-keys. */ + if( eOnePass!=ONEPASS_OFF ){ + sqlite3VdbeResolveLabel(v, addrBypass); + sqlite3WhereEnd(pWInfo); + }else if( pPk ){ + sqlite3VdbeAddOp2(v, OP_Next, iEphCur, addrLoop+1); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addrLoop); + }else{ + sqlite3VdbeGoto(v, addrLoop); + sqlite3VdbeJumpHere(v, addrLoop); + } + } /* End non-truncate path */ + + /* Update the sqlite_sequence table by storing the content of the + ** maximum rowid counter values recorded while inserting into + ** autoincrement tables. + */ + if( pParse->nested==0 && pParse->pTriggerTab==0 ){ + sqlite3AutoincrementEnd(pParse); + } + + /* Return the number of rows that were deleted. If this routine is + ** generating code because of a call to sqlite3NestedParse(), do not + ** invoke the callback function. + */ + if( memCnt ){ + sqlite3VdbeAddOp2(v, OP_ResultRow, memCnt, 1); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", SQLITE_STATIC); + } + +delete_from_cleanup: + sqlite3AuthContextPop(&sContext); + sqlite3SrcListDelete(db, pTabList); + sqlite3ExprDelete(db, pWhere); +#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) + sqlite3ExprListDelete(db, pOrderBy); + sqlite3ExprDelete(db, pLimit); +#endif + sqlite3DbFree(db, aToOpen); + return; +} +/* Make sure "isView" and other macros defined above are undefined. Otherwise +** they may interfere with compilation of other functions in this file +** (or in another file, if this file becomes part of the amalgamation). */ +#ifdef isView + #undef isView +#endif +#ifdef pTrigger + #undef pTrigger +#endif + +/* +** This routine generates VDBE code that causes a single row of a +** single table to be deleted. Both the original table entry and +** all indices are removed. +** +** Preconditions: +** +** 1. iDataCur is an open cursor on the btree that is the canonical data +** store for the table. (This will be either the table itself, +** in the case of a rowid table, or the PRIMARY KEY index in the case +** of a WITHOUT ROWID table.) +** +** 2. Read/write cursors for all indices of pTab must be open as +** cursor number iIdxCur+i for the i-th index. +** +** 3. The primary key for the row to be deleted must be stored in a +** sequence of nPk memory cells starting at iPk. If nPk==0 that means +** that a search record formed from OP_MakeRecord is contained in the +** single memory location iPk. +** +** eMode: +** Parameter eMode may be passed either ONEPASS_OFF (0), ONEPASS_SINGLE, or +** ONEPASS_MULTI. If eMode is not ONEPASS_OFF, then the cursor +** iDataCur already points to the row to delete. If eMode is ONEPASS_OFF +** then this function must seek iDataCur to the entry identified by iPk +** and nPk before reading from it. +** +** If eMode is ONEPASS_MULTI, then this call is being made as part +** of a ONEPASS delete that affects multiple rows. In this case, if +** iIdxNoSeek is a valid cursor number (>=0) and is not the same as +** iDataCur, then its position should be preserved following the delete +** operation. Or, if iIdxNoSeek is not a valid cursor number, the +** position of iDataCur should be preserved instead. +** +** iIdxNoSeek: +** If iIdxNoSeek is a valid cursor number (>=0) not equal to iDataCur, +** then it identifies an index cursor (from within array of cursors +** starting at iIdxCur) that already points to the index entry to be deleted. +** Except, this optimization is disabled if there are BEFORE triggers since +** the trigger body might have moved the cursor. +*/ +SQLITE_PRIVATE void sqlite3GenerateRowDelete( + Parse *pParse, /* Parsing context */ + Table *pTab, /* Table containing the row to be deleted */ + Trigger *pTrigger, /* List of triggers to (potentially) fire */ + int iDataCur, /* Cursor from which column data is extracted */ + int iIdxCur, /* First index cursor */ + int iPk, /* First memory cell containing the PRIMARY KEY */ + i16 nPk, /* Number of PRIMARY KEY memory cells */ + u8 count, /* If non-zero, increment the row change counter */ + u8 onconf, /* Default ON CONFLICT policy for triggers */ + u8 eMode, /* ONEPASS_OFF, _SINGLE, or _MULTI. See above */ + int iIdxNoSeek /* Cursor number of cursor that does not need seeking */ +){ + Vdbe *v = pParse->pVdbe; /* Vdbe */ + int iOld = 0; /* First register in OLD.* array */ + int iLabel; /* Label resolved to end of generated code */ + u8 opSeek; /* Seek opcode */ + + /* Vdbe is guaranteed to have been allocated by this stage. */ + assert( v ); + VdbeModuleComment((v, "BEGIN: GenRowDel(%d,%d,%d,%d)", + iDataCur, iIdxCur, iPk, (int)nPk)); + + /* Seek cursor iCur to the row to delete. If this row no longer exists + ** (this can happen if a trigger program has already deleted it), do + ** not attempt to delete it or fire any DELETE triggers. */ + iLabel = sqlite3VdbeMakeLabel(pParse); + opSeek = HasRowid(pTab) ? OP_NotExists : OP_NotFound; + if( eMode==ONEPASS_OFF ){ + sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk); + VdbeCoverageIf(v, opSeek==OP_NotExists); + VdbeCoverageIf(v, opSeek==OP_NotFound); + } + + /* If there are any triggers to fire, allocate a range of registers to + ** use for the old.* references in the triggers. */ + if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){ + u32 mask; /* Mask of OLD.* columns in use */ + int iCol; /* Iterator used while populating OLD.* */ + int addrStart; /* Start of BEFORE trigger programs */ + + /* TODO: Could use temporary registers here. Also could attempt to + ** avoid copying the contents of the rowid register. */ + mask = sqlite3TriggerColmask( + pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf + ); + mask |= sqlite3FkOldmask(pParse, pTab); + iOld = pParse->nMem+1; + pParse->nMem += (1 + pTab->nCol); + + /* Populate the OLD.* pseudo-table register array. These values will be + ** used by any BEFORE and AFTER triggers that exist. */ + sqlite3VdbeAddOp2(v, OP_Copy, iPk, iOld); + for(iCol=0; iColnCol; iCol++){ + testcase( mask!=0xffffffff && iCol==31 ); + testcase( mask!=0xffffffff && iCol==32 ); + if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){ + int kk = sqlite3TableColumnToStorage(pTab, iCol); + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+kk+1); + } + } + + /* Invoke BEFORE DELETE trigger programs. */ + addrStart = sqlite3VdbeCurrentAddr(v); + sqlite3CodeRowTrigger(pParse, pTrigger, + TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel + ); + + /* If any BEFORE triggers were coded, then seek the cursor to the + ** row to be deleted again. It may be that the BEFORE triggers moved + ** the cursor or already deleted the row that the cursor was + ** pointing to. + ** + ** Also disable the iIdxNoSeek optimization since the BEFORE trigger + ** may have moved that cursor. + */ + if( addrStart=0 ); + iIdxNoSeek = -1; + } + + /* Do FK processing. This call checks that any FK constraints that + ** refer to this table (i.e. constraints attached to other tables) + ** are not violated by deleting this row. */ + sqlite3FkCheck(pParse, pTab, iOld, 0, 0, 0); + } + + /* Delete the index and table entries. Skip this step if pTab is really + ** a view (in which case the only effect of the DELETE statement is to + ** fire the INSTEAD OF triggers). + ** + ** If variable 'count' is non-zero, then this OP_Delete instruction should + ** invoke the update-hook. The pre-update-hook, on the other hand should + ** be invoked unless table pTab is a system table. The difference is that + ** the update-hook is not invoked for rows removed by REPLACE, but the + ** pre-update-hook is. + */ + if( pTab->pSelect==0 ){ + u8 p5 = 0; + sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,iIdxNoSeek); + sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, (count?OPFLAG_NCHANGE:0)); + if( pParse->nested==0 || 0==sqlite3_stricmp(pTab->zName, "sqlite_stat1") ){ + sqlite3VdbeAppendP4(v, (char*)pTab, P4_TABLE); + } + if( eMode!=ONEPASS_OFF ){ + sqlite3VdbeChangeP5(v, OPFLAG_AUXDELETE); + } + if( iIdxNoSeek>=0 && iIdxNoSeek!=iDataCur ){ + sqlite3VdbeAddOp1(v, OP_Delete, iIdxNoSeek); + } + if( eMode==ONEPASS_MULTI ) p5 |= OPFLAG_SAVEPOSITION; + sqlite3VdbeChangeP5(v, p5); + } + + /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to + ** handle rows (possibly in other tables) that refer via a foreign key + ** to the row just deleted. */ + sqlite3FkActions(pParse, pTab, 0, iOld, 0, 0); + + /* Invoke AFTER DELETE trigger programs. */ + sqlite3CodeRowTrigger(pParse, pTrigger, + TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel + ); + + /* Jump here if the row had already been deleted before any BEFORE + ** trigger programs were invoked. Or if a trigger program throws a + ** RAISE(IGNORE) exception. */ + sqlite3VdbeResolveLabel(v, iLabel); + VdbeModuleComment((v, "END: GenRowDel()")); +} + +/* +** This routine generates VDBE code that causes the deletion of all +** index entries associated with a single row of a single table, pTab +** +** Preconditions: +** +** 1. A read/write cursor "iDataCur" must be open on the canonical storage +** btree for the table pTab. (This will be either the table itself +** for rowid tables or to the primary key index for WITHOUT ROWID +** tables.) +** +** 2. Read/write cursors for all indices of pTab must be open as +** cursor number iIdxCur+i for the i-th index. (The pTab->pIndex +** index is the 0-th index.) +** +** 3. The "iDataCur" cursor must be already be positioned on the row +** that is to be deleted. +*/ +SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete( + Parse *pParse, /* Parsing and code generating context */ + Table *pTab, /* Table containing the row to be deleted */ + int iDataCur, /* Cursor of table holding data. */ + int iIdxCur, /* First index cursor */ + int *aRegIdx, /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */ + int iIdxNoSeek /* Do not delete from this cursor */ +){ + int i; /* Index loop counter */ + int r1 = -1; /* Register holding an index key */ + int iPartIdxLabel; /* Jump destination for skipping partial index entries */ + Index *pIdx; /* Current index */ + Index *pPrior = 0; /* Prior index */ + Vdbe *v; /* The prepared statement under construction */ + Index *pPk; /* PRIMARY KEY index, or NULL for rowid tables */ + + v = pParse->pVdbe; + pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab); + for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ + assert( iIdxCur+i!=iDataCur || pPk==pIdx ); + if( aRegIdx!=0 && aRegIdx[i]==0 ) continue; + if( pIdx==pPk ) continue; + if( iIdxCur+i==iIdxNoSeek ) continue; + VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName)); + r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 1, + &iPartIdxLabel, pPrior, r1); + sqlite3VdbeAddOp3(v, OP_IdxDelete, iIdxCur+i, r1, + pIdx->uniqNotNull ? pIdx->nKeyCol : pIdx->nColumn); + sqlite3VdbeChangeP5(v, 1); /* Cause IdxDelete to error if no entry found */ + sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel); + pPrior = pIdx; + } +} + +/* +** Generate code that will assemble an index key and stores it in register +** regOut. The key with be for index pIdx which is an index on pTab. +** iCur is the index of a cursor open on the pTab table and pointing to +** the entry that needs indexing. If pTab is a WITHOUT ROWID table, then +** iCur must be the cursor of the PRIMARY KEY index. +** +** Return a register number which is the first in a block of +** registers that holds the elements of the index key. The +** block of registers has already been deallocated by the time +** this routine returns. +** +** If *piPartIdxLabel is not NULL, fill it in with a label and jump +** to that label if pIdx is a partial index that should be skipped. +** The label should be resolved using sqlite3ResolvePartIdxLabel(). +** A partial index should be skipped if its WHERE clause evaluates +** to false or null. If pIdx is not a partial index, *piPartIdxLabel +** will be set to zero which is an empty label that is ignored by +** sqlite3ResolvePartIdxLabel(). +** +** The pPrior and regPrior parameters are used to implement a cache to +** avoid unnecessary register loads. If pPrior is not NULL, then it is +** a pointer to a different index for which an index key has just been +** computed into register regPrior. If the current pIdx index is generating +** its key into the same sequence of registers and if pPrior and pIdx share +** a column in common, then the register corresponding to that column already +** holds the correct value and the loading of that register is skipped. +** This optimization is helpful when doing a DELETE or an INTEGRITY_CHECK +** on a table with multiple indices, and especially with the ROWID or +** PRIMARY KEY columns of the index. +*/ +SQLITE_PRIVATE int sqlite3GenerateIndexKey( + Parse *pParse, /* Parsing context */ + Index *pIdx, /* The index for which to generate a key */ + int iDataCur, /* Cursor number from which to take column data */ + int regOut, /* Put the new key into this register if not 0 */ + int prefixOnly, /* Compute only a unique prefix of the key */ + int *piPartIdxLabel, /* OUT: Jump to this label to skip partial index */ + Index *pPrior, /* Previously generated index key */ + int regPrior /* Register holding previous generated key */ +){ + Vdbe *v = pParse->pVdbe; + int j; + int regBase; + int nCol; + + if( piPartIdxLabel ){ + if( pIdx->pPartIdxWhere ){ + *piPartIdxLabel = sqlite3VdbeMakeLabel(pParse); + pParse->iSelfTab = iDataCur + 1; + sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, *piPartIdxLabel, + SQLITE_JUMPIFNULL); + pParse->iSelfTab = 0; + pPrior = 0; /* Ticket a9efb42811fa41ee 2019-11-02; + ** pPartIdxWhere may have corrupted regPrior registers */ + }else{ + *piPartIdxLabel = 0; + } + } + nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn; + regBase = sqlite3GetTempRange(pParse, nCol); + if( pPrior && (regBase!=regPrior || pPrior->pPartIdxWhere) ) pPrior = 0; + for(j=0; jaiColumn[j]==pIdx->aiColumn[j] + && pPrior->aiColumn[j]!=XN_EXPR + ){ + /* This column was already computed by the previous index */ + continue; + } + sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iDataCur, j, regBase+j); + /* If the column affinity is REAL but the number is an integer, then it + ** might be stored in the table as an integer (using a compact + ** representation) then converted to REAL by an OP_RealAffinity opcode. + ** But we are getting ready to store this value back into an index, where + ** it should be converted by to INTEGER again. So omit the OP_RealAffinity + ** opcode if it is present */ + sqlite3VdbeDeletePriorOpcode(v, OP_RealAffinity); + } + if( regOut ){ + sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut); + } + sqlite3ReleaseTempRange(pParse, regBase, nCol); + return regBase; +} + +/* +** If a prior call to sqlite3GenerateIndexKey() generated a jump-over label +** because it was a partial index, then this routine should be called to +** resolve that label. +*/ +SQLITE_PRIVATE void sqlite3ResolvePartIdxLabel(Parse *pParse, int iLabel){ + if( iLabel ){ + sqlite3VdbeResolveLabel(pParse->pVdbe, iLabel); + } +} + +/************** End of delete.c **********************************************/ +/************** Begin file func.c ********************************************/ +/* +** 2002 February 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C-language implementations for many of the SQL +** functions of SQLite. (Some function, and in particular the date and +** time functions, are implemented separately.) +*/ +/* #include "sqliteInt.h" */ +/* #include */ +/* #include */ +#ifndef SQLITE_OMIT_FLOATING_POINT +/* #include */ +#endif +/* #include "vdbeInt.h" */ + +/* +** Return the collating function associated with a function. +*/ +static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){ + VdbeOp *pOp; + assert( context->pVdbe!=0 ); + pOp = &context->pVdbe->aOp[context->iOp-1]; + assert( pOp->opcode==OP_CollSeq ); + assert( pOp->p4type==P4_COLLSEQ ); + return pOp->p4.pColl; +} + +/* +** Indicate that the accumulator load should be skipped on this +** iteration of the aggregate loop. +*/ +static void sqlite3SkipAccumulatorLoad(sqlite3_context *context){ + assert( context->isError<=0 ); + context->isError = -1; + context->skipFlag = 1; +} + +/* +** Implementation of the non-aggregate min() and max() functions +*/ +static void minmaxFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int i; + int mask; /* 0 for min() or 0xffffffff for max() */ + int iBest; + CollSeq *pColl; + + assert( argc>1 ); + mask = sqlite3_user_data(context)==0 ? 0 : -1; + pColl = sqlite3GetFuncCollSeq(context); + assert( pColl ); + assert( mask==-1 || mask==0 ); + iBest = 0; + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + for(i=1; i=0 ){ + testcase( mask==0 ); + iBest = i; + } + } + sqlite3_result_value(context, argv[iBest]); +} + +/* +** Return the type of the argument. +*/ +static void typeofFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + static const char *azType[] = { "integer", "real", "text", "blob", "null" }; + int i = sqlite3_value_type(argv[0]) - 1; + UNUSED_PARAMETER(NotUsed); + assert( i>=0 && i=0xc0 ){ + while( (*z & 0xc0)==0x80 ){ z++; z0++; } + } + } + sqlite3_result_int(context, (int)(z-z0)); + break; + } + default: { + sqlite3_result_null(context); + break; + } + } +} + +/* +** Implementation of the abs() function. +** +** IMP: R-23979-26855 The abs(X) function returns the absolute value of +** the numeric argument X. +*/ +static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + assert( argc==1 ); + UNUSED_PARAMETER(argc); + switch( sqlite3_value_type(argv[0]) ){ + case SQLITE_INTEGER: { + i64 iVal = sqlite3_value_int64(argv[0]); + if( iVal<0 ){ + if( iVal==SMALLEST_INT64 ){ + /* IMP: R-31676-45509 If X is the integer -9223372036854775808 + ** then abs(X) throws an integer overflow error since there is no + ** equivalent positive 64-bit two complement value. */ + sqlite3_result_error(context, "integer overflow", -1); + return; + } + iVal = -iVal; + } + sqlite3_result_int64(context, iVal); + break; + } + case SQLITE_NULL: { + /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */ + sqlite3_result_null(context); + break; + } + default: { + /* Because sqlite3_value_double() returns 0.0 if the argument is not + ** something that can be converted into a number, we have: + ** IMP: R-01992-00519 Abs(X) returns 0.0 if X is a string or blob + ** that cannot be converted to a numeric value. + */ + double rVal = sqlite3_value_double(argv[0]); + if( rVal<0 ) rVal = -rVal; + sqlite3_result_double(context, rVal); + break; + } + } +} + +/* +** Implementation of the instr() function. +** +** instr(haystack,needle) finds the first occurrence of needle +** in haystack and returns the number of previous characters plus 1, +** or 0 if needle does not occur within haystack. +** +** If both haystack and needle are BLOBs, then the result is one more than +** the number of bytes in haystack prior to the first occurrence of needle, +** or 0 if needle never occurs in haystack. +*/ +static void instrFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zHaystack; + const unsigned char *zNeedle; + int nHaystack; + int nNeedle; + int typeHaystack, typeNeedle; + int N = 1; + int isText; + unsigned char firstChar; + sqlite3_value *pC1 = 0; + sqlite3_value *pC2 = 0; + + UNUSED_PARAMETER(argc); + typeHaystack = sqlite3_value_type(argv[0]); + typeNeedle = sqlite3_value_type(argv[1]); + if( typeHaystack==SQLITE_NULL || typeNeedle==SQLITE_NULL ) return; + nHaystack = sqlite3_value_bytes(argv[0]); + nNeedle = sqlite3_value_bytes(argv[1]); + if( nNeedle>0 ){ + if( typeHaystack==SQLITE_BLOB && typeNeedle==SQLITE_BLOB ){ + zHaystack = sqlite3_value_blob(argv[0]); + zNeedle = sqlite3_value_blob(argv[1]); + isText = 0; + }else if( typeHaystack!=SQLITE_BLOB && typeNeedle!=SQLITE_BLOB ){ + zHaystack = sqlite3_value_text(argv[0]); + zNeedle = sqlite3_value_text(argv[1]); + isText = 1; + }else{ + pC1 = sqlite3_value_dup(argv[0]); + zHaystack = sqlite3_value_text(pC1); + if( zHaystack==0 ) goto endInstrOOM; + nHaystack = sqlite3_value_bytes(pC1); + pC2 = sqlite3_value_dup(argv[1]); + zNeedle = sqlite3_value_text(pC2); + if( zNeedle==0 ) goto endInstrOOM; + nNeedle = sqlite3_value_bytes(pC2); + isText = 1; + } + if( zNeedle==0 || (nHaystack && zHaystack==0) ) goto endInstrOOM; + firstChar = zNeedle[0]; + while( nNeedle<=nHaystack + && (zHaystack[0]!=firstChar || memcmp(zHaystack, zNeedle, nNeedle)!=0) + ){ + N++; + do{ + nHaystack--; + zHaystack++; + }while( isText && (zHaystack[0]&0xc0)==0x80 ); + } + if( nNeedle>nHaystack ) N = 0; + } + sqlite3_result_int(context, N); +endInstr: + sqlite3_value_free(pC1); + sqlite3_value_free(pC2); + return; +endInstrOOM: + sqlite3_result_error_nomem(context); + goto endInstr; +} + +/* +** Implementation of the printf() function. +*/ +static void printfFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + PrintfArguments x; + StrAccum str; + const char *zFormat; + int n; + sqlite3 *db = sqlite3_context_db_handle(context); + + if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){ + x.nArg = argc-1; + x.nUsed = 0; + x.apArg = argv+1; + sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]); + str.printfFlags = SQLITE_PRINTF_SQLFUNC; + sqlite3_str_appendf(&str, zFormat, &x); + n = str.nChar; + sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n, + SQLITE_DYNAMIC); + } +} + +/* +** Implementation of the substr() function. +** +** substr(x,p1,p2) returns p2 characters of x[] beginning with p1. +** p1 is 1-indexed. So substr(x,1,1) returns the first character +** of x. If x is text, then we actually count UTF-8 characters. +** If x is a blob, then we count bytes. +** +** If p1 is negative, then we begin abs(p1) from the end of x[]. +** +** If p2 is negative, return the p2 characters preceding p1. +*/ +static void substrFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *z; + const unsigned char *z2; + int len; + int p0type; + i64 p1, p2; + int negP2 = 0; + + assert( argc==3 || argc==2 ); + if( sqlite3_value_type(argv[1])==SQLITE_NULL + || (argc==3 && sqlite3_value_type(argv[2])==SQLITE_NULL) + ){ + return; + } + p0type = sqlite3_value_type(argv[0]); + p1 = sqlite3_value_int(argv[1]); + if( p0type==SQLITE_BLOB ){ + len = sqlite3_value_bytes(argv[0]); + z = sqlite3_value_blob(argv[0]); + if( z==0 ) return; + assert( len==sqlite3_value_bytes(argv[0]) ); + }else{ + z = sqlite3_value_text(argv[0]); + if( z==0 ) return; + len = 0; + if( p1<0 ){ + for(z2=z; *z2; len++){ + SQLITE_SKIP_UTF8(z2); + } + } + } +#ifdef SQLITE_SUBSTR_COMPATIBILITY + /* If SUBSTR_COMPATIBILITY is defined then substr(X,0,N) work the same as + ** as substr(X,1,N) - it returns the first N characters of X. This + ** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8] + ** from 2009-02-02 for compatibility of applications that exploited the + ** old buggy behavior. */ + if( p1==0 ) p1 = 1; /* */ +#endif + if( argc==3 ){ + p2 = sqlite3_value_int(argv[2]); + if( p2<0 ){ + p2 = -p2; + negP2 = 1; + } + }else{ + p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH]; + } + if( p1<0 ){ + p1 += len; + if( p1<0 ){ + p2 += p1; + if( p2<0 ) p2 = 0; + p1 = 0; + } + }else if( p1>0 ){ + p1--; + }else if( p2>0 ){ + p2--; + } + if( negP2 ){ + p1 -= p2; + if( p1<0 ){ + p2 += p1; + p1 = 0; + } + } + assert( p1>=0 && p2>=0 ); + if( p0type!=SQLITE_BLOB ){ + while( *z && p1 ){ + SQLITE_SKIP_UTF8(z); + p1--; + } + for(z2=z; *z2 && p2; p2--){ + SQLITE_SKIP_UTF8(z2); + } + sqlite3_result_text64(context, (char*)z, z2-z, SQLITE_TRANSIENT, + SQLITE_UTF8); + }else{ + if( p1+p2>len ){ + p2 = len-p1; + if( p2<0 ) p2 = 0; + } + sqlite3_result_blob64(context, (char*)&z[p1], (u64)p2, SQLITE_TRANSIENT); + } +} + +/* +** Implementation of the round() function +*/ +#ifndef SQLITE_OMIT_FLOATING_POINT +static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + int n = 0; + double r; + char *zBuf; + assert( argc==1 || argc==2 ); + if( argc==2 ){ + if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return; + n = sqlite3_value_int(argv[1]); + if( n>30 ) n = 30; + if( n<0 ) n = 0; + } + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + r = sqlite3_value_double(argv[0]); + /* If Y==0 and X will fit in a 64-bit int, + ** handle the rounding directly, + ** otherwise use printf. + */ + if( r<-4503599627370496.0 || r>+4503599627370496.0 ){ + /* The value has no fractional part so there is nothing to round */ + }else if( n==0 ){ + r = (double)((sqlite_int64)(r+(r<0?-0.5:+0.5))); + }else{ + zBuf = sqlite3_mprintf("%.*f",n,r); + if( zBuf==0 ){ + sqlite3_result_error_nomem(context); + return; + } + sqlite3AtoF(zBuf, &r, sqlite3Strlen30(zBuf), SQLITE_UTF8); + sqlite3_free(zBuf); + } + sqlite3_result_double(context, r); +} +#endif + +/* +** Allocate nByte bytes of space using sqlite3Malloc(). If the +** allocation fails, call sqlite3_result_error_nomem() to notify +** the database handle that malloc() has failed and return NULL. +** If nByte is larger than the maximum string or blob length, then +** raise an SQLITE_TOOBIG exception and return NULL. +*/ +static void *contextMalloc(sqlite3_context *context, i64 nByte){ + char *z; + sqlite3 *db = sqlite3_context_db_handle(context); + assert( nByte>0 ); + testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] ); + testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 ); + if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){ + sqlite3_result_error_toobig(context); + z = 0; + }else{ + z = sqlite3Malloc(nByte); + if( !z ){ + sqlite3_result_error_nomem(context); + } + } + return z; +} + +/* +** Implementation of the upper() and lower() SQL functions. +*/ +static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + char *z1; + const char *z2; + int i, n; + UNUSED_PARAMETER(argc); + z2 = (char*)sqlite3_value_text(argv[0]); + n = sqlite3_value_bytes(argv[0]); + /* Verify that the call to _bytes() does not invalidate the _text() pointer */ + assert( z2==(char*)sqlite3_value_text(argv[0]) ); + if( z2 ){ + z1 = contextMalloc(context, ((i64)n)+1); + if( z1 ){ + for(i=0; imatchOne; /* "?" or "_" */ + u32 matchAll = pInfo->matchAll; /* "*" or "%" */ + u8 noCase = pInfo->noCase; /* True if uppercase==lowercase */ + const u8 *zEscaped = 0; /* One past the last escaped input char */ + + while( (c = Utf8Read(zPattern))!=0 ){ + if( c==matchAll ){ /* Match "*" */ + /* Skip over multiple "*" characters in the pattern. If there + ** are also "?" characters, skip those as well, but consume a + ** single character of the input string for each "?" skipped */ + while( (c=Utf8Read(zPattern)) == matchAll || c == matchOne ){ + if( c==matchOne && sqlite3Utf8Read(&zString)==0 ){ + return SQLITE_NOWILDCARDMATCH; + } + } + if( c==0 ){ + return SQLITE_MATCH; /* "*" at the end of the pattern matches */ + }else if( c==matchOther ){ + if( pInfo->matchSet==0 ){ + c = sqlite3Utf8Read(&zPattern); + if( c==0 ) return SQLITE_NOWILDCARDMATCH; + }else{ + /* "[...]" immediately follows the "*". We have to do a slow + ** recursive search in this case, but it is an unusual case. */ + assert( matchOther<0x80 ); /* '[' is a single-byte character */ + while( *zString ){ + int bMatch = patternCompare(&zPattern[-1],zString,pInfo,matchOther); + if( bMatch!=SQLITE_NOMATCH ) return bMatch; + SQLITE_SKIP_UTF8(zString); + } + return SQLITE_NOWILDCARDMATCH; + } + } + + /* At this point variable c contains the first character of the + ** pattern string past the "*". Search in the input string for the + ** first matching character and recursively continue the match from + ** that point. + ** + ** For a case-insensitive search, set variable cx to be the same as + ** c but in the other case and search the input string for either + ** c or cx. + */ + if( c<=0x80 ){ + char zStop[3]; + int bMatch; + if( noCase ){ + zStop[0] = sqlite3Toupper(c); + zStop[1] = sqlite3Tolower(c); + zStop[2] = 0; + }else{ + zStop[0] = c; + zStop[1] = 0; + } + while(1){ + zString += strcspn((const char*)zString, zStop); + if( zString[0]==0 ) break; + zString++; + bMatch = patternCompare(zPattern,zString,pInfo,matchOther); + if( bMatch!=SQLITE_NOMATCH ) return bMatch; + } + }else{ + int bMatch; + while( (c2 = Utf8Read(zString))!=0 ){ + if( c2!=c ) continue; + bMatch = patternCompare(zPattern,zString,pInfo,matchOther); + if( bMatch!=SQLITE_NOMATCH ) return bMatch; + } + } + return SQLITE_NOWILDCARDMATCH; + } + if( c==matchOther ){ + if( pInfo->matchSet==0 ){ + c = sqlite3Utf8Read(&zPattern); + if( c==0 ) return SQLITE_NOMATCH; + zEscaped = zPattern; + }else{ + u32 prior_c = 0; + int seen = 0; + int invert = 0; + c = sqlite3Utf8Read(&zString); + if( c==0 ) return SQLITE_NOMATCH; + c2 = sqlite3Utf8Read(&zPattern); + if( c2=='^' ){ + invert = 1; + c2 = sqlite3Utf8Read(&zPattern); + } + if( c2==']' ){ + if( c==']' ) seen = 1; + c2 = sqlite3Utf8Read(&zPattern); + } + while( c2 && c2!=']' ){ + if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){ + c2 = sqlite3Utf8Read(&zPattern); + if( c>=prior_c && c<=c2 ) seen = 1; + prior_c = 0; + }else{ + if( c==c2 ){ + seen = 1; + } + prior_c = c2; + } + c2 = sqlite3Utf8Read(&zPattern); + } + if( c2==0 || (seen ^ invert)==0 ){ + return SQLITE_NOMATCH; + } + continue; + } + } + c2 = Utf8Read(zString); + if( c==c2 ) continue; + if( noCase && sqlite3Tolower(c)==sqlite3Tolower(c2) && c<0x80 && c2<0x80 ){ + continue; + } + if( c==matchOne && zPattern!=zEscaped && c2!=0 ) continue; + return SQLITE_NOMATCH; + } + return *zString==0 ? SQLITE_MATCH : SQLITE_NOMATCH; +} + +/* +** The sqlite3_strglob() interface. Return 0 on a match (like strcmp()) and +** non-zero if there is no match. +*/ +SQLITE_API int sqlite3_strglob(const char *zGlobPattern, const char *zString){ + return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, '['); +} + +/* +** The sqlite3_strlike() interface. Return 0 on a match and non-zero for +** a miss - like strcmp(). +*/ +SQLITE_API int sqlite3_strlike(const char *zPattern, const char *zStr, unsigned int esc){ + return patternCompare((u8*)zPattern, (u8*)zStr, &likeInfoNorm, esc); +} + +/* +** Count the number of times that the LIKE operator (or GLOB which is +** just a variation of LIKE) gets called. This is used for testing +** only. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_like_count = 0; +#endif + + +/* +** Implementation of the like() SQL function. This function implements +** the build-in LIKE operator. The first argument to the function is the +** pattern and the second argument is the string. So, the SQL statements: +** +** A LIKE B +** +** is implemented as like(B,A). +** +** This same function (with a different compareInfo structure) computes +** the GLOB operator. +*/ +static void likeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zA, *zB; + u32 escape; + int nPat; + sqlite3 *db = sqlite3_context_db_handle(context); + struct compareInfo *pInfo = sqlite3_user_data(context); + struct compareInfo backupInfo; + +#ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS + if( sqlite3_value_type(argv[0])==SQLITE_BLOB + || sqlite3_value_type(argv[1])==SQLITE_BLOB + ){ +#ifdef SQLITE_TEST + sqlite3_like_count++; +#endif + sqlite3_result_int(context, 0); + return; + } +#endif + + /* Limit the length of the LIKE or GLOB pattern to avoid problems + ** of deep recursion and N*N behavior in patternCompare(). + */ + nPat = sqlite3_value_bytes(argv[0]); + testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ); + testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 ); + if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){ + sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1); + return; + } + if( argc==3 ){ + /* The escape character string must consist of a single UTF-8 character. + ** Otherwise, return an error. + */ + const unsigned char *zEsc = sqlite3_value_text(argv[2]); + if( zEsc==0 ) return; + if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){ + sqlite3_result_error(context, + "ESCAPE expression must be a single character", -1); + return; + } + escape = sqlite3Utf8Read(&zEsc); + if( escape==pInfo->matchAll || escape==pInfo->matchOne ){ + memcpy(&backupInfo, pInfo, sizeof(backupInfo)); + pInfo = &backupInfo; + if( escape==pInfo->matchAll ) pInfo->matchAll = 0; + if( escape==pInfo->matchOne ) pInfo->matchOne = 0; + } + }else{ + escape = pInfo->matchSet; + } + zB = sqlite3_value_text(argv[0]); + zA = sqlite3_value_text(argv[1]); + if( zA && zB ){ +#ifdef SQLITE_TEST + sqlite3_like_count++; +#endif + sqlite3_result_int(context, + patternCompare(zB, zA, pInfo, escape)==SQLITE_MATCH); + } +} + +/* +** Implementation of the NULLIF(x,y) function. The result is the first +** argument if the arguments are different. The result is NULL if the +** arguments are equal to each other. +*/ +static void nullifFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + CollSeq *pColl = sqlite3GetFuncCollSeq(context); + UNUSED_PARAMETER(NotUsed); + if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){ + sqlite3_result_value(context, argv[0]); + } +} + +/* +** Implementation of the sqlite_version() function. The result is the version +** of the SQLite library that is running. +*/ +static void versionFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **NotUsed2 +){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + /* IMP: R-48699-48617 This function is an SQL wrapper around the + ** sqlite3_libversion() C-interface. */ + sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC); +} + +/* +** Implementation of the sqlite_source_id() function. The result is a string +** that identifies the particular version of the source code used to build +** SQLite. +*/ +static void sourceidFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **NotUsed2 +){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + /* IMP: R-24470-31136 This function is an SQL wrapper around the + ** sqlite3_sourceid() C interface. */ + sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC); +} + +/* +** Implementation of the sqlite_log() function. This is a wrapper around +** sqlite3_log(). The return value is NULL. The function exists purely for +** its side-effects. +*/ +static void errlogFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(context); + sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1])); +} + +/* +** Implementation of the sqlite_compileoption_used() function. +** The result is an integer that identifies if the compiler option +** was used to build SQLite. +*/ +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +static void compileoptionusedFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zOptName; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL + ** function is a wrapper around the sqlite3_compileoption_used() C/C++ + ** function. + */ + if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){ + sqlite3_result_int(context, sqlite3_compileoption_used(zOptName)); + } +} +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ + +/* +** Implementation of the sqlite_compileoption_get() function. +** The result is a string that identifies the compiler options +** used to build SQLite. +*/ +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +static void compileoptiongetFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int n; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function + ** is a wrapper around the sqlite3_compileoption_get() C/C++ function. + */ + n = sqlite3_value_int(argv[0]); + sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC); +} +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ + +/* Array for converting from half-bytes (nybbles) into ASCII hex +** digits. */ +static const char hexdigits[] = { + '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' +}; + +/* +** Implementation of the QUOTE() function. This function takes a single +** argument. If the argument is numeric, the return value is the same as +** the argument. If the argument is NULL, the return value is the string +** "NULL". Otherwise, the argument is enclosed in single quotes with +** single-quote escapes. +*/ +static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + assert( argc==1 ); + UNUSED_PARAMETER(argc); + switch( sqlite3_value_type(argv[0]) ){ + case SQLITE_FLOAT: { + double r1, r2; + char zBuf[50]; + r1 = sqlite3_value_double(argv[0]); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.15g", r1); + sqlite3AtoF(zBuf, &r2, 20, SQLITE_UTF8); + if( r1!=r2 ){ + sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.20e", r1); + } + sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT); + break; + } + case SQLITE_INTEGER: { + sqlite3_result_value(context, argv[0]); + break; + } + case SQLITE_BLOB: { + char *zText = 0; + char const *zBlob = sqlite3_value_blob(argv[0]); + int nBlob = sqlite3_value_bytes(argv[0]); + assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ + zText = (char *)contextMalloc(context, (2*(i64)nBlob)+4); + if( zText ){ + int i; + for(i=0; i>4)&0x0F]; + zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F]; + } + zText[(nBlob*2)+2] = '\''; + zText[(nBlob*2)+3] = '\0'; + zText[0] = 'X'; + zText[1] = '\''; + sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT); + sqlite3_free(zText); + } + break; + } + case SQLITE_TEXT: { + int i,j; + u64 n; + const unsigned char *zArg = sqlite3_value_text(argv[0]); + char *z; + + if( zArg==0 ) return; + for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; } + z = contextMalloc(context, ((i64)i)+((i64)n)+3); + if( z ){ + z[0] = '\''; + for(i=0, j=1; zArg[i]; i++){ + z[j++] = zArg[i]; + if( zArg[i]=='\'' ){ + z[j++] = '\''; + } + } + z[j++] = '\''; + z[j] = 0; + sqlite3_result_text(context, z, j, sqlite3_free); + } + break; + } + default: { + assert( sqlite3_value_type(argv[0])==SQLITE_NULL ); + sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC); + break; + } + } +} + +/* +** The unicode() function. Return the integer unicode code-point value +** for the first character of the input string. +*/ +static void unicodeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *z = sqlite3_value_text(argv[0]); + (void)argc; + if( z && z[0] ) sqlite3_result_int(context, sqlite3Utf8Read(&z)); +} + +/* +** The char() function takes zero or more arguments, each of which is +** an integer. It constructs a string where each character of the string +** is the unicode character for the corresponding integer argument. +*/ +static void charFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + unsigned char *z, *zOut; + int i; + zOut = z = sqlite3_malloc64( argc*4+1 ); + if( z==0 ){ + sqlite3_result_error_nomem(context); + return; + } + for(i=0; i0x10ffff ) x = 0xfffd; + c = (unsigned)(x & 0x1fffff); + if( c<0x00080 ){ + *zOut++ = (u8)(c&0xFF); + }else if( c<0x00800 ){ + *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); + *zOut++ = 0x80 + (u8)(c & 0x3F); + }else if( c<0x10000 ){ + *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); + *zOut++ = 0x80 + (u8)(c & 0x3F); + }else{ + *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); + *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); + *zOut++ = 0x80 + (u8)(c & 0x3F); + } \ + } + sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8); +} + +/* +** The hex() function. Interpret the argument as a blob. Return +** a hexadecimal rendering as text. +*/ +static void hexFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int i, n; + const unsigned char *pBlob; + char *zHex, *z; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + pBlob = sqlite3_value_blob(argv[0]); + n = sqlite3_value_bytes(argv[0]); + assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ + z = zHex = contextMalloc(context, ((i64)n)*2 + 1); + if( zHex ){ + for(i=0; i>4)&0xf]; + *(z++) = hexdigits[c&0xf]; + } + *z = 0; + sqlite3_result_text(context, zHex, n*2, sqlite3_free); + } +} + +/* +** The zeroblob(N) function returns a zero-filled blob of size N bytes. +*/ +static void zeroblobFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + i64 n; + int rc; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + n = sqlite3_value_int64(argv[0]); + if( n<0 ) n = 0; + rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */ + if( rc ){ + sqlite3_result_error_code(context, rc); + } +} + +/* +** The replace() function. Three arguments are all strings: call +** them A, B, and C. The result is also a string which is derived +** from A by replacing every occurrence of B with C. The match +** must be exact. Collating sequences are not used. +*/ +static void replaceFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zStr; /* The input string A */ + const unsigned char *zPattern; /* The pattern string B */ + const unsigned char *zRep; /* The replacement string C */ + unsigned char *zOut; /* The output */ + int nStr; /* Size of zStr */ + int nPattern; /* Size of zPattern */ + int nRep; /* Size of zRep */ + i64 nOut; /* Maximum size of zOut */ + int loopLimit; /* Last zStr[] that might match zPattern[] */ + int i, j; /* Loop counters */ + unsigned cntExpand; /* Number zOut expansions */ + sqlite3 *db = sqlite3_context_db_handle(context); + + assert( argc==3 ); + UNUSED_PARAMETER(argc); + zStr = sqlite3_value_text(argv[0]); + if( zStr==0 ) return; + nStr = sqlite3_value_bytes(argv[0]); + assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */ + zPattern = sqlite3_value_text(argv[1]); + if( zPattern==0 ){ + assert( sqlite3_value_type(argv[1])==SQLITE_NULL + || sqlite3_context_db_handle(context)->mallocFailed ); + return; + } + if( zPattern[0]==0 ){ + assert( sqlite3_value_type(argv[1])!=SQLITE_NULL ); + sqlite3_result_value(context, argv[0]); + return; + } + nPattern = sqlite3_value_bytes(argv[1]); + assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */ + zRep = sqlite3_value_text(argv[2]); + if( zRep==0 ) return; + nRep = sqlite3_value_bytes(argv[2]); + assert( zRep==sqlite3_value_text(argv[2]) ); + nOut = nStr + 1; + assert( nOutnPattern ){ + nOut += nRep - nPattern; + testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] ); + testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] ); + if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){ + sqlite3_result_error_toobig(context); + sqlite3_free(zOut); + return; + } + cntExpand++; + if( (cntExpand&(cntExpand-1))==0 ){ + /* Grow the size of the output buffer only on substitutions + ** whose index is a power of two: 1, 2, 4, 8, 16, 32, ... */ + u8 *zOld; + zOld = zOut; + zOut = sqlite3Realloc(zOut, (int)nOut + (nOut - nStr - 1)); + if( zOut==0 ){ + sqlite3_result_error_nomem(context); + sqlite3_free(zOld); + return; + } + } + } + memcpy(&zOut[j], zRep, nRep); + j += nRep; + i += nPattern-1; + } + } + assert( j+nStr-i+1<=nOut ); + memcpy(&zOut[j], &zStr[i], nStr-i); + j += nStr - i; + assert( j<=nOut ); + zOut[j] = 0; + sqlite3_result_text(context, (char*)zOut, j, sqlite3_free); +} + +/* +** Implementation of the TRIM(), LTRIM(), and RTRIM() functions. +** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both. +*/ +static void trimFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zIn; /* Input string */ + const unsigned char *zCharSet; /* Set of characters to trim */ + int nIn; /* Number of bytes in input */ + int flags; /* 1: trimleft 2: trimright 3: trim */ + int i; /* Loop counter */ + unsigned char *aLen = 0; /* Length of each character in zCharSet */ + unsigned char **azChar = 0; /* Individual characters in zCharSet */ + int nChar; /* Number of characters in zCharSet */ + + if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ + return; + } + zIn = sqlite3_value_text(argv[0]); + if( zIn==0 ) return; + nIn = sqlite3_value_bytes(argv[0]); + assert( zIn==sqlite3_value_text(argv[0]) ); + if( argc==1 ){ + static const unsigned char lenOne[] = { 1 }; + static unsigned char * const azOne[] = { (u8*)" " }; + nChar = 1; + aLen = (u8*)lenOne; + azChar = (unsigned char **)azOne; + zCharSet = 0; + }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){ + return; + }else{ + const unsigned char *z; + for(z=zCharSet, nChar=0; *z; nChar++){ + SQLITE_SKIP_UTF8(z); + } + if( nChar>0 ){ + azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1)); + if( azChar==0 ){ + return; + } + aLen = (unsigned char*)&azChar[nChar]; + for(z=zCharSet, nChar=0; *z; nChar++){ + azChar[nChar] = (unsigned char *)z; + SQLITE_SKIP_UTF8(z); + aLen[nChar] = (u8)(z - azChar[nChar]); + } + } + } + if( nChar>0 ){ + flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context)); + if( flags & 1 ){ + while( nIn>0 ){ + int len = 0; + for(i=0; i=nChar ) break; + zIn += len; + nIn -= len; + } + } + if( flags & 2 ){ + while( nIn>0 ){ + int len = 0; + for(i=0; i=nChar ) break; + nIn -= len; + } + } + if( zCharSet ){ + sqlite3_free(azChar); + } + } + sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT); +} + + +#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION +/* +** The "unknown" function is automatically substituted in place of +** any unrecognized function name when doing an EXPLAIN or EXPLAIN QUERY PLAN +** when the SQLITE_ENABLE_UNKNOWN_FUNCTION compile-time option is used. +** When the "sqlite3" command-line shell is built using this functionality, +** that allows an EXPLAIN or EXPLAIN QUERY PLAN for complex queries +** involving application-defined functions to be examined in a generic +** sqlite3 shell. +*/ +static void unknownFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + /* no-op */ +} +#endif /*SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION*/ + + +/* IMP: R-25361-16150 This function is omitted from SQLite by default. It +** is only available if the SQLITE_SOUNDEX compile-time option is used +** when SQLite is built. +*/ +#ifdef SQLITE_SOUNDEX +/* +** Compute the soundex encoding of a word. +** +** IMP: R-59782-00072 The soundex(X) function returns a string that is the +** soundex encoding of the string X. +*/ +static void soundexFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + char zResult[8]; + const u8 *zIn; + int i, j; + static const unsigned char iCode[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, + 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, + 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, + }; + assert( argc==1 ); + zIn = (u8*)sqlite3_value_text(argv[0]); + if( zIn==0 ) zIn = (u8*)""; + for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){} + if( zIn[i] ){ + u8 prevcode = iCode[zIn[i]&0x7f]; + zResult[0] = sqlite3Toupper(zIn[i]); + for(j=1; j<4 && zIn[i]; i++){ + int code = iCode[zIn[i]&0x7f]; + if( code>0 ){ + if( code!=prevcode ){ + prevcode = code; + zResult[j++] = code + '0'; + } + }else{ + prevcode = 0; + } + } + while( j<4 ){ + zResult[j++] = '0'; + } + zResult[j] = 0; + sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT); + }else{ + /* IMP: R-64894-50321 The string "?000" is returned if the argument + ** is NULL or contains no ASCII alphabetic characters. */ + sqlite3_result_text(context, "?000", 4, SQLITE_STATIC); + } +} +#endif /* SQLITE_SOUNDEX */ + +#ifndef SQLITE_OMIT_LOAD_EXTENSION +/* +** A function that loads a shared-library extension then returns NULL. +*/ +static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){ + const char *zFile = (const char *)sqlite3_value_text(argv[0]); + const char *zProc; + sqlite3 *db = sqlite3_context_db_handle(context); + char *zErrMsg = 0; + + /* Disallow the load_extension() SQL function unless the SQLITE_LoadExtFunc + ** flag is set. See the sqlite3_enable_load_extension() API. + */ + if( (db->flags & SQLITE_LoadExtFunc)==0 ){ + sqlite3_result_error(context, "not authorized", -1); + return; + } + + if( argc==2 ){ + zProc = (const char *)sqlite3_value_text(argv[1]); + }else{ + zProc = 0; + } + if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){ + sqlite3_result_error(context, zErrMsg, -1); + sqlite3_free(zErrMsg); + } +} +#endif + + +/* +** An instance of the following structure holds the context of a +** sum() or avg() aggregate computation. +*/ +typedef struct SumCtx SumCtx; +struct SumCtx { + double rSum; /* Floating point sum */ + i64 iSum; /* Integer sum */ + i64 cnt; /* Number of elements summed */ + u8 overflow; /* True if integer overflow seen */ + u8 approx; /* True if non-integer value was input to the sum */ +}; + +/* +** Routines used to compute the sum, average, and total. +** +** The SUM() function follows the (broken) SQL standard which means +** that it returns NULL if it sums over no inputs. TOTAL returns +** 0.0 in that case. In addition, TOTAL always returns a float where +** SUM might return an integer if it never encounters a floating point +** value. TOTAL never fails, but SUM might through an exception if +** it overflows an integer. +*/ +static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){ + SumCtx *p; + int type; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + p = sqlite3_aggregate_context(context, sizeof(*p)); + type = sqlite3_value_numeric_type(argv[0]); + if( p && type!=SQLITE_NULL ){ + p->cnt++; + if( type==SQLITE_INTEGER ){ + i64 v = sqlite3_value_int64(argv[0]); + p->rSum += v; + if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){ + p->approx = p->overflow = 1; + } + }else{ + p->rSum += sqlite3_value_double(argv[0]); + p->approx = 1; + } + } +} +#ifndef SQLITE_OMIT_WINDOWFUNC +static void sumInverse(sqlite3_context *context, int argc, sqlite3_value**argv){ + SumCtx *p; + int type; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + p = sqlite3_aggregate_context(context, sizeof(*p)); + type = sqlite3_value_numeric_type(argv[0]); + /* p is always non-NULL because sumStep() will have been called first + ** to initialize it */ + if( ALWAYS(p) && type!=SQLITE_NULL ){ + assert( p->cnt>0 ); + p->cnt--; + assert( type==SQLITE_INTEGER || p->approx ); + if( type==SQLITE_INTEGER && p->approx==0 ){ + i64 v = sqlite3_value_int64(argv[0]); + p->rSum -= v; + p->iSum -= v; + }else{ + p->rSum -= sqlite3_value_double(argv[0]); + } + } +} +#else +# define sumInverse 0 +#endif /* SQLITE_OMIT_WINDOWFUNC */ +static void sumFinalize(sqlite3_context *context){ + SumCtx *p; + p = sqlite3_aggregate_context(context, 0); + if( p && p->cnt>0 ){ + if( p->overflow ){ + sqlite3_result_error(context,"integer overflow",-1); + }else if( p->approx ){ + sqlite3_result_double(context, p->rSum); + }else{ + sqlite3_result_int64(context, p->iSum); + } + } +} +static void avgFinalize(sqlite3_context *context){ + SumCtx *p; + p = sqlite3_aggregate_context(context, 0); + if( p && p->cnt>0 ){ + sqlite3_result_double(context, p->rSum/(double)p->cnt); + } +} +static void totalFinalize(sqlite3_context *context){ + SumCtx *p; + p = sqlite3_aggregate_context(context, 0); + /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ + sqlite3_result_double(context, p ? p->rSum : (double)0); +} + +/* +** The following structure keeps track of state information for the +** count() aggregate function. +*/ +typedef struct CountCtx CountCtx; +struct CountCtx { + i64 n; +#ifdef SQLITE_DEBUG + int bInverse; /* True if xInverse() ever called */ +#endif +}; + +/* +** Routines to implement the count() aggregate function. +*/ +static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){ + CountCtx *p; + p = sqlite3_aggregate_context(context, sizeof(*p)); + if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){ + p->n++; + } + +#ifndef SQLITE_OMIT_DEPRECATED + /* The sqlite3_aggregate_count() function is deprecated. But just to make + ** sure it still operates correctly, verify that its count agrees with our + ** internal count when using count(*) and when the total count can be + ** expressed as a 32-bit integer. */ + assert( argc==1 || p==0 || p->n>0x7fffffff || p->bInverse + || p->n==sqlite3_aggregate_count(context) ); +#endif +} +static void countFinalize(sqlite3_context *context){ + CountCtx *p; + p = sqlite3_aggregate_context(context, 0); + sqlite3_result_int64(context, p ? p->n : 0); +} +#ifndef SQLITE_OMIT_WINDOWFUNC +static void countInverse(sqlite3_context *ctx, int argc, sqlite3_value **argv){ + CountCtx *p; + p = sqlite3_aggregate_context(ctx, sizeof(*p)); + /* p is always non-NULL since countStep() will have been called first */ + if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && ALWAYS(p) ){ + p->n--; +#ifdef SQLITE_DEBUG + p->bInverse = 1; +#endif + } +} +#else +# define countInverse 0 +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +/* +** Routines to implement min() and max() aggregate functions. +*/ +static void minmaxStep( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + Mem *pArg = (Mem *)argv[0]; + Mem *pBest; + UNUSED_PARAMETER(NotUsed); + + pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest)); + if( !pBest ) return; + + if( sqlite3_value_type(pArg)==SQLITE_NULL ){ + if( pBest->flags ) sqlite3SkipAccumulatorLoad(context); + }else if( pBest->flags ){ + int max; + int cmp; + CollSeq *pColl = sqlite3GetFuncCollSeq(context); + /* This step function is used for both the min() and max() aggregates, + ** the only difference between the two being that the sense of the + ** comparison is inverted. For the max() aggregate, the + ** sqlite3_user_data() function returns (void *)-1. For min() it + ** returns (void *)db, where db is the sqlite3* database pointer. + ** Therefore the next statement sets variable 'max' to 1 for the max() + ** aggregate, or 0 for min(). + */ + max = sqlite3_user_data(context)!=0; + cmp = sqlite3MemCompare(pBest, pArg, pColl); + if( (max && cmp<0) || (!max && cmp>0) ){ + sqlite3VdbeMemCopy(pBest, pArg); + }else{ + sqlite3SkipAccumulatorLoad(context); + } + }else{ + pBest->db = sqlite3_context_db_handle(context); + sqlite3VdbeMemCopy(pBest, pArg); + } +} +static void minMaxValueFinalize(sqlite3_context *context, int bValue){ + sqlite3_value *pRes; + pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0); + if( pRes ){ + if( pRes->flags ){ + sqlite3_result_value(context, pRes); + } + if( bValue==0 ) sqlite3VdbeMemRelease(pRes); + } +} +#ifndef SQLITE_OMIT_WINDOWFUNC +static void minMaxValue(sqlite3_context *context){ + minMaxValueFinalize(context, 1); +} +#else +# define minMaxValue 0 +#endif /* SQLITE_OMIT_WINDOWFUNC */ +static void minMaxFinalize(sqlite3_context *context){ + minMaxValueFinalize(context, 0); +} + +/* +** group_concat(EXPR, ?SEPARATOR?) +*/ +static void groupConcatStep( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zVal; + StrAccum *pAccum; + const char *zSep; + int nVal, nSep; + assert( argc==1 || argc==2 ); + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum)); + + if( pAccum ){ + sqlite3 *db = sqlite3_context_db_handle(context); + int firstTerm = pAccum->mxAlloc==0; + pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH]; + if( !firstTerm ){ + if( argc==2 ){ + zSep = (char*)sqlite3_value_text(argv[1]); + nSep = sqlite3_value_bytes(argv[1]); + }else{ + zSep = ","; + nSep = 1; + } + if( zSep ) sqlite3_str_append(pAccum, zSep, nSep); + } + zVal = (char*)sqlite3_value_text(argv[0]); + nVal = sqlite3_value_bytes(argv[0]); + if( zVal ) sqlite3_str_append(pAccum, zVal, nVal); + } +} +#ifndef SQLITE_OMIT_WINDOWFUNC +static void groupConcatInverse( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int n; + StrAccum *pAccum; + assert( argc==1 || argc==2 ); + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum)); + /* pAccum is always non-NULL since groupConcatStep() will have always + ** run frist to initialize it */ + if( ALWAYS(pAccum) ){ + n = sqlite3_value_bytes(argv[0]); + if( argc==2 ){ + n += sqlite3_value_bytes(argv[1]); + }else{ + n++; + } + if( n>=(int)pAccum->nChar ){ + pAccum->nChar = 0; + }else{ + pAccum->nChar -= n; + memmove(pAccum->zText, &pAccum->zText[n], pAccum->nChar); + } + if( pAccum->nChar==0 ) pAccum->mxAlloc = 0; + } +} +#else +# define groupConcatInverse 0 +#endif /* SQLITE_OMIT_WINDOWFUNC */ +static void groupConcatFinalize(sqlite3_context *context){ + StrAccum *pAccum; + pAccum = sqlite3_aggregate_context(context, 0); + if( pAccum ){ + if( pAccum->accError==SQLITE_TOOBIG ){ + sqlite3_result_error_toobig(context); + }else if( pAccum->accError==SQLITE_NOMEM ){ + sqlite3_result_error_nomem(context); + }else{ + sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1, + sqlite3_free); + } + } +} +#ifndef SQLITE_OMIT_WINDOWFUNC +static void groupConcatValue(sqlite3_context *context){ + sqlite3_str *pAccum; + pAccum = (sqlite3_str*)sqlite3_aggregate_context(context, 0); + if( pAccum ){ + if( pAccum->accError==SQLITE_TOOBIG ){ + sqlite3_result_error_toobig(context); + }else if( pAccum->accError==SQLITE_NOMEM ){ + sqlite3_result_error_nomem(context); + }else{ + const char *zText = sqlite3_str_value(pAccum); + sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT); + } + } +} +#else +# define groupConcatValue 0 +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +/* +** This routine does per-connection function registration. Most +** of the built-in functions above are part of the global function set. +** This routine only deals with those that are not global. +*/ +SQLITE_PRIVATE void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3 *db){ + int rc = sqlite3_overload_function(db, "MATCH", 2); + assert( rc==SQLITE_NOMEM || rc==SQLITE_OK ); + if( rc==SQLITE_NOMEM ){ + sqlite3OomFault(db); + } +} + +/* +** Re-register the built-in LIKE functions. The caseSensitive +** parameter determines whether or not the LIKE operator is case +** sensitive. +*/ +SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){ + struct compareInfo *pInfo; + int flags; + if( caseSensitive ){ + pInfo = (struct compareInfo*)&likeInfoAlt; + flags = SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE; + }else{ + pInfo = (struct compareInfo*)&likeInfoNorm; + flags = SQLITE_FUNC_LIKE; + } + sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0); + sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0); + sqlite3FindFunction(db, "like", 2, SQLITE_UTF8, 0)->funcFlags |= flags; + sqlite3FindFunction(db, "like", 3, SQLITE_UTF8, 0)->funcFlags |= flags; +} + +/* +** pExpr points to an expression which implements a function. If +** it is appropriate to apply the LIKE optimization to that function +** then set aWc[0] through aWc[2] to the wildcard characters and the +** escape character and then return TRUE. If the function is not a +** LIKE-style function then return FALSE. +** +** The expression "a LIKE b ESCAPE c" is only considered a valid LIKE +** operator if c is a string literal that is exactly one byte in length. +** That one byte is stored in aWc[3]. aWc[3] is set to zero if there is +** no ESCAPE clause. +** +** *pIsNocase is set to true if uppercase and lowercase are equivalent for +** the function (default for LIKE). If the function makes the distinction +** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to +** false. +*/ +SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){ + FuncDef *pDef; + int nExpr; + if( pExpr->op!=TK_FUNCTION || !pExpr->x.pList ){ + return 0; + } + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + nExpr = pExpr->x.pList->nExpr; + pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0); +#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION + if( pDef==0 ) return 0; +#endif + if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){ + return 0; + } + + /* The memcpy() statement assumes that the wildcard characters are + ** the first three statements in the compareInfo structure. The + ** asserts() that follow verify that assumption + */ + memcpy(aWc, pDef->pUserData, 3); + assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll ); + assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne ); + assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet ); + + if( nExpr<3 ){ + aWc[3] = 0; + }else{ + Expr *pEscape = pExpr->x.pList->a[2].pExpr; + char *zEscape; + if( pEscape->op!=TK_STRING ) return 0; + zEscape = pEscape->u.zToken; + if( zEscape[0]==0 || zEscape[1]!=0 ) return 0; + if( zEscape[0]==aWc[0] ) return 0; + if( zEscape[0]==aWc[1] ) return 0; + aWc[3] = zEscape[0]; + } + + *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0; + return 1; +} + +/* +** All of the FuncDef structures in the aBuiltinFunc[] array above +** to the global function hash table. This occurs at start-time (as +** a consequence of calling sqlite3_initialize()). +** +** After this routine runs +*/ +SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){ + /* + ** The following array holds FuncDef structures for all of the functions + ** defined in this file. + ** + ** The array cannot be constant since changes are made to the + ** FuncDef.pHash elements at start-time. The elements of this array + ** are read-only after initialization is complete. + ** + ** For peak efficiency, put the most frequently used function last. + */ + static FuncDef aBuiltinFunc[] = { +/***** Functions only available with SQLITE_TESTCTRL_INTERNAL_FUNCTIONS *****/ + TEST_FUNC(implies_nonnull_row, 2, INLINEFUNC_implies_nonnull_row, 0), + TEST_FUNC(expr_compare, 2, INLINEFUNC_expr_compare, 0), + TEST_FUNC(expr_implies_expr, 2, INLINEFUNC_expr_implies_expr, 0), +#ifdef SQLITE_DEBUG + TEST_FUNC(affinity, 1, INLINEFUNC_affinity, 0), +#endif +/***** Regular functions *****/ +#ifdef SQLITE_SOUNDEX + FUNCTION(soundex, 1, 0, 0, soundexFunc ), +#endif +#ifndef SQLITE_OMIT_LOAD_EXTENSION + SFUNCTION(load_extension, 1, 0, 0, loadExt ), + SFUNCTION(load_extension, 2, 0, 0, loadExt ), +#endif +#if SQLITE_USER_AUTHENTICATION + FUNCTION(sqlite_crypt, 2, 0, 0, sqlite3CryptFunc ), +#endif +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS + DFUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc ), + DFUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc ), +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ + INLINE_FUNC(unlikely, 1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY), + INLINE_FUNC(likelihood, 2, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY), + INLINE_FUNC(likely, 1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY), +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC + FUNCTION2(sqlite_offset, 1, 0, 0, noopFunc, SQLITE_FUNC_OFFSET| + SQLITE_FUNC_TYPEOF), +#endif + FUNCTION(ltrim, 1, 1, 0, trimFunc ), + FUNCTION(ltrim, 2, 1, 0, trimFunc ), + FUNCTION(rtrim, 1, 2, 0, trimFunc ), + FUNCTION(rtrim, 2, 2, 0, trimFunc ), + FUNCTION(trim, 1, 3, 0, trimFunc ), + FUNCTION(trim, 2, 3, 0, trimFunc ), + FUNCTION(min, -1, 0, 1, minmaxFunc ), + FUNCTION(min, 0, 0, 1, 0 ), + WAGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize, minMaxValue, 0, + SQLITE_FUNC_MINMAX ), + FUNCTION(max, -1, 1, 1, minmaxFunc ), + FUNCTION(max, 0, 1, 1, 0 ), + WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0, + SQLITE_FUNC_MINMAX ), + FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF), + FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH), + FUNCTION(instr, 2, 0, 0, instrFunc ), + FUNCTION(printf, -1, 0, 0, printfFunc ), + FUNCTION(unicode, 1, 0, 0, unicodeFunc ), + FUNCTION(char, -1, 0, 0, charFunc ), + FUNCTION(abs, 1, 0, 0, absFunc ), +#ifndef SQLITE_OMIT_FLOATING_POINT + FUNCTION(round, 1, 0, 0, roundFunc ), + FUNCTION(round, 2, 0, 0, roundFunc ), +#endif + FUNCTION(upper, 1, 0, 0, upperFunc ), + FUNCTION(lower, 1, 0, 0, lowerFunc ), + FUNCTION(hex, 1, 0, 0, hexFunc ), + INLINE_FUNC(ifnull, 2, INLINEFUNC_coalesce, 0 ), + VFUNCTION(random, 0, 0, 0, randomFunc ), + VFUNCTION(randomblob, 1, 0, 0, randomBlob ), + FUNCTION(nullif, 2, 0, 1, nullifFunc ), + DFUNCTION(sqlite_version, 0, 0, 0, versionFunc ), + DFUNCTION(sqlite_source_id, 0, 0, 0, sourceidFunc ), + FUNCTION(sqlite_log, 2, 0, 0, errlogFunc ), + FUNCTION(quote, 1, 0, 0, quoteFunc ), + VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid), + VFUNCTION(changes, 0, 0, 0, changes ), + VFUNCTION(total_changes, 0, 0, 0, total_changes ), + FUNCTION(replace, 3, 0, 0, replaceFunc ), + FUNCTION(zeroblob, 1, 0, 0, zeroblobFunc ), + FUNCTION(substr, 2, 0, 0, substrFunc ), + FUNCTION(substr, 3, 0, 0, substrFunc ), + FUNCTION(substring, 2, 0, 0, substrFunc ), + FUNCTION(substring, 3, 0, 0, substrFunc ), + WAGGREGATE(sum, 1,0,0, sumStep, sumFinalize, sumFinalize, sumInverse, 0), + WAGGREGATE(total, 1,0,0, sumStep,totalFinalize,totalFinalize,sumInverse, 0), + WAGGREGATE(avg, 1,0,0, sumStep, avgFinalize, avgFinalize, sumInverse, 0), + WAGGREGATE(count, 0,0,0, countStep, + countFinalize, countFinalize, countInverse, SQLITE_FUNC_COUNT ), + WAGGREGATE(count, 1,0,0, countStep, + countFinalize, countFinalize, countInverse, 0 ), + WAGGREGATE(group_concat, 1, 0, 0, groupConcatStep, + groupConcatFinalize, groupConcatValue, groupConcatInverse, 0), + WAGGREGATE(group_concat, 2, 0, 0, groupConcatStep, + groupConcatFinalize, groupConcatValue, groupConcatInverse, 0), + + LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), +#ifdef SQLITE_CASE_SENSITIVE_LIKE + LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), + LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), +#else + LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE), + LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE), +#endif +#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION + FUNCTION(unknown, -1, 0, 0, unknownFunc ), +#endif + FUNCTION(coalesce, 1, 0, 0, 0 ), + FUNCTION(coalesce, 0, 0, 0, 0 ), + INLINE_FUNC(coalesce, -1, INLINEFUNC_coalesce, 0 ), + INLINE_FUNC(iif, 3, INLINEFUNC_iif, 0 ), + }; +#ifndef SQLITE_OMIT_ALTERTABLE + sqlite3AlterFunctions(); +#endif + sqlite3WindowFunctions(); + sqlite3RegisterDateTimeFunctions(); + sqlite3InsertBuiltinFuncs(aBuiltinFunc, ArraySize(aBuiltinFunc)); + +#if 0 /* Enable to print out how the built-in functions are hashed */ + { + int i; + FuncDef *p; + for(i=0; iu.pHash){ + int n = sqlite3Strlen30(p->zName); + int h = p->zName[0] + n; + printf(" %s(%d)", p->zName, h); + } + printf("\n"); + } + } +#endif +} + +/************** End of func.c ************************************************/ +/************** Begin file fkey.c ********************************************/ +/* +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used by the compiler to add foreign key +** support to compiled SQL statements. +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_FOREIGN_KEY +#ifndef SQLITE_OMIT_TRIGGER + +/* +** Deferred and Immediate FKs +** -------------------------- +** +** Foreign keys in SQLite come in two flavours: deferred and immediate. +** If an immediate foreign key constraint is violated, +** SQLITE_CONSTRAINT_FOREIGNKEY is returned and the current +** statement transaction rolled back. If a +** deferred foreign key constraint is violated, no action is taken +** immediately. However if the application attempts to commit the +** transaction before fixing the constraint violation, the attempt fails. +** +** Deferred constraints are implemented using a simple counter associated +** with the database handle. The counter is set to zero each time a +** database transaction is opened. Each time a statement is executed +** that causes a foreign key violation, the counter is incremented. Each +** time a statement is executed that removes an existing violation from +** the database, the counter is decremented. When the transaction is +** committed, the commit fails if the current value of the counter is +** greater than zero. This scheme has two big drawbacks: +** +** * When a commit fails due to a deferred foreign key constraint, +** there is no way to tell which foreign constraint is not satisfied, +** or which row it is not satisfied for. +** +** * If the database contains foreign key violations when the +** transaction is opened, this may cause the mechanism to malfunction. +** +** Despite these problems, this approach is adopted as it seems simpler +** than the alternatives. +** +** INSERT operations: +** +** I.1) For each FK for which the table is the child table, search +** the parent table for a match. If none is found increment the +** constraint counter. +** +** I.2) For each FK for which the table is the parent table, +** search the child table for rows that correspond to the new +** row in the parent table. Decrement the counter for each row +** found (as the constraint is now satisfied). +** +** DELETE operations: +** +** D.1) For each FK for which the table is the child table, +** search the parent table for a row that corresponds to the +** deleted row in the child table. If such a row is not found, +** decrement the counter. +** +** D.2) For each FK for which the table is the parent table, search +** the child table for rows that correspond to the deleted row +** in the parent table. For each found increment the counter. +** +** UPDATE operations: +** +** An UPDATE command requires that all 4 steps above are taken, but only +** for FK constraints for which the affected columns are actually +** modified (values must be compared at runtime). +** +** Note that I.1 and D.1 are very similar operations, as are I.2 and D.2. +** This simplifies the implementation a bit. +** +** For the purposes of immediate FK constraints, the OR REPLACE conflict +** resolution is considered to delete rows before the new row is inserted. +** If a delete caused by OR REPLACE violates an FK constraint, an exception +** is thrown, even if the FK constraint would be satisfied after the new +** row is inserted. +** +** Immediate constraints are usually handled similarly. The only difference +** is that the counter used is stored as part of each individual statement +** object (struct Vdbe). If, after the statement has run, its immediate +** constraint counter is greater than zero, +** it returns SQLITE_CONSTRAINT_FOREIGNKEY +** and the statement transaction is rolled back. An exception is an INSERT +** statement that inserts a single row only (no triggers). In this case, +** instead of using a counter, an exception is thrown immediately if the +** INSERT violates a foreign key constraint. This is necessary as such +** an INSERT does not open a statement transaction. +** +** TODO: How should dropping a table be handled? How should renaming a +** table be handled? +** +** +** Query API Notes +** --------------- +** +** Before coding an UPDATE or DELETE row operation, the code-generator +** for those two operations needs to know whether or not the operation +** requires any FK processing and, if so, which columns of the original +** row are required by the FK processing VDBE code (i.e. if FKs were +** implemented using triggers, which of the old.* columns would be +** accessed). No information is required by the code-generator before +** coding an INSERT operation. The functions used by the UPDATE/DELETE +** generation code to query for this information are: +** +** sqlite3FkRequired() - Test to see if FK processing is required. +** sqlite3FkOldmask() - Query for the set of required old.* columns. +** +** +** Externally accessible module functions +** -------------------------------------- +** +** sqlite3FkCheck() - Check for foreign key violations. +** sqlite3FkActions() - Code triggers for ON UPDATE/ON DELETE actions. +** sqlite3FkDelete() - Delete an FKey structure. +*/ + +/* +** VDBE Calling Convention +** ----------------------- +** +** Example: +** +** For the following INSERT statement: +** +** CREATE TABLE t1(a, b INTEGER PRIMARY KEY, c); +** INSERT INTO t1 VALUES(1, 2, 3.1); +** +** Register (x): 2 (type integer) +** Register (x+1): 1 (type integer) +** Register (x+2): NULL (type NULL) +** Register (x+3): 3.1 (type real) +*/ + +/* +** A foreign key constraint requires that the key columns in the parent +** table are collectively subject to a UNIQUE or PRIMARY KEY constraint. +** Given that pParent is the parent table for foreign key constraint pFKey, +** search the schema for a unique index on the parent key columns. +** +** If successful, zero is returned. If the parent key is an INTEGER PRIMARY +** KEY column, then output variable *ppIdx is set to NULL. Otherwise, *ppIdx +** is set to point to the unique index. +** +** If the parent key consists of a single column (the foreign key constraint +** is not a composite foreign key), output variable *paiCol is set to NULL. +** Otherwise, it is set to point to an allocated array of size N, where +** N is the number of columns in the parent key. The first element of the +** array is the index of the child table column that is mapped by the FK +** constraint to the parent table column stored in the left-most column +** of index *ppIdx. The second element of the array is the index of the +** child table column that corresponds to the second left-most column of +** *ppIdx, and so on. +** +** If the required index cannot be found, either because: +** +** 1) The named parent key columns do not exist, or +** +** 2) The named parent key columns do exist, but are not subject to a +** UNIQUE or PRIMARY KEY constraint, or +** +** 3) No parent key columns were provided explicitly as part of the +** foreign key definition, and the parent table does not have a +** PRIMARY KEY, or +** +** 4) No parent key columns were provided explicitly as part of the +** foreign key definition, and the PRIMARY KEY of the parent table +** consists of a different number of columns to the child key in +** the child table. +** +** then non-zero is returned, and a "foreign key mismatch" error loaded +** into pParse. If an OOM error occurs, non-zero is returned and the +** pParse->db->mallocFailed flag is set. +*/ +SQLITE_PRIVATE int sqlite3FkLocateIndex( + Parse *pParse, /* Parse context to store any error in */ + Table *pParent, /* Parent table of FK constraint pFKey */ + FKey *pFKey, /* Foreign key to find index for */ + Index **ppIdx, /* OUT: Unique index on parent table */ + int **paiCol /* OUT: Map of index columns in pFKey */ +){ + Index *pIdx = 0; /* Value to return via *ppIdx */ + int *aiCol = 0; /* Value to return via *paiCol */ + int nCol = pFKey->nCol; /* Number of columns in parent key */ + char *zKey = pFKey->aCol[0].zCol; /* Name of left-most parent key column */ + + /* The caller is responsible for zeroing output parameters. */ + assert( ppIdx && *ppIdx==0 ); + assert( !paiCol || *paiCol==0 ); + assert( pParse ); + + /* If this is a non-composite (single column) foreign key, check if it + ** maps to the INTEGER PRIMARY KEY of table pParent. If so, leave *ppIdx + ** and *paiCol set to zero and return early. + ** + ** Otherwise, for a composite foreign key (more than one column), allocate + ** space for the aiCol array (returned via output parameter *paiCol). + ** Non-composite foreign keys do not require the aiCol array. + */ + if( nCol==1 ){ + /* The FK maps to the IPK if any of the following are true: + ** + ** 1) There is an INTEGER PRIMARY KEY column and the FK is implicitly + ** mapped to the primary key of table pParent, or + ** 2) The FK is explicitly mapped to a column declared as INTEGER + ** PRIMARY KEY. + */ + if( pParent->iPKey>=0 ){ + if( !zKey ) return 0; + if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zName, zKey) ) return 0; + } + }else if( paiCol ){ + assert( nCol>1 ); + aiCol = (int *)sqlite3DbMallocRawNN(pParse->db, nCol*sizeof(int)); + if( !aiCol ) return 1; + *paiCol = aiCol; + } + + for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){ + if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) && pIdx->pPartIdxWhere==0 ){ + /* pIdx is a UNIQUE index (or a PRIMARY KEY) and has the right number + ** of columns. If each indexed column corresponds to a foreign key + ** column of pFKey, then this index is a winner. */ + + if( zKey==0 ){ + /* If zKey is NULL, then this foreign key is implicitly mapped to + ** the PRIMARY KEY of table pParent. The PRIMARY KEY index may be + ** identified by the test. */ + if( IsPrimaryKeyIndex(pIdx) ){ + if( aiCol ){ + int i; + for(i=0; iaCol[i].iFrom; + } + break; + } + }else{ + /* If zKey is non-NULL, then this foreign key was declared to + ** map to an explicit list of columns in table pParent. Check if this + ** index matches those columns. Also, check that the index uses + ** the default collation sequences for each column. */ + int i, j; + for(i=0; iaiColumn[i]; /* Index of column in parent tbl */ + const char *zDfltColl; /* Def. collation for column */ + char *zIdxCol; /* Name of indexed column */ + + if( iCol<0 ) break; /* No foreign keys against expression indexes */ + + /* If the index uses a collation sequence that is different from + ** the default collation sequence for the column, this index is + ** unusable. Bail out early in this case. */ + zDfltColl = pParent->aCol[iCol].zColl; + if( !zDfltColl ) zDfltColl = sqlite3StrBINARY; + if( sqlite3StrICmp(pIdx->azColl[i], zDfltColl) ) break; + + zIdxCol = pParent->aCol[iCol].zName; + for(j=0; jaCol[j].zCol, zIdxCol)==0 ){ + if( aiCol ) aiCol[i] = pFKey->aCol[j].iFrom; + break; + } + } + if( j==nCol ) break; + } + if( i==nCol ) break; /* pIdx is usable */ + } + } + } + + if( !pIdx ){ + if( !pParse->disableTriggers ){ + sqlite3ErrorMsg(pParse, + "foreign key mismatch - \"%w\" referencing \"%w\"", + pFKey->pFrom->zName, pFKey->zTo); + } + sqlite3DbFree(pParse->db, aiCol); + return 1; + } + + *ppIdx = pIdx; + return 0; +} + +/* +** This function is called when a row is inserted into or deleted from the +** child table of foreign key constraint pFKey. If an SQL UPDATE is executed +** on the child table of pFKey, this function is invoked twice for each row +** affected - once to "delete" the old row, and then again to "insert" the +** new row. +** +** Each time it is called, this function generates VDBE code to locate the +** row in the parent table that corresponds to the row being inserted into +** or deleted from the child table. If the parent row can be found, no +** special action is taken. Otherwise, if the parent row can *not* be +** found in the parent table: +** +** Operation | FK type | Action taken +** -------------------------------------------------------------------------- +** INSERT immediate Increment the "immediate constraint counter". +** +** DELETE immediate Decrement the "immediate constraint counter". +** +** INSERT deferred Increment the "deferred constraint counter". +** +** DELETE deferred Decrement the "deferred constraint counter". +** +** These operations are identified in the comment at the top of this file +** (fkey.c) as "I.1" and "D.1". +*/ +static void fkLookupParent( + Parse *pParse, /* Parse context */ + int iDb, /* Index of database housing pTab */ + Table *pTab, /* Parent table of FK pFKey */ + Index *pIdx, /* Unique index on parent key columns in pTab */ + FKey *pFKey, /* Foreign key constraint */ + int *aiCol, /* Map from parent key columns to child table columns */ + int regData, /* Address of array containing child table row */ + int nIncr, /* Increment constraint counter by this */ + int isIgnore /* If true, pretend pTab contains all NULL values */ +){ + int i; /* Iterator variable */ + Vdbe *v = sqlite3GetVdbe(pParse); /* Vdbe to add code to */ + int iCur = pParse->nTab - 1; /* Cursor number to use */ + int iOk = sqlite3VdbeMakeLabel(pParse); /* jump here if parent key found */ + + sqlite3VdbeVerifyAbortable(v, + (!pFKey->isDeferred + && !(pParse->db->flags & SQLITE_DeferFKs) + && !pParse->pToplevel + && !pParse->isMultiWrite) ? OE_Abort : OE_Ignore); + + /* If nIncr is less than zero, then check at runtime if there are any + ** outstanding constraints to resolve. If there are not, there is no need + ** to check if deleting this row resolves any outstanding violations. + ** + ** Check if any of the key columns in the child table row are NULL. If + ** any are, then the constraint is considered satisfied. No need to + ** search for a matching row in the parent table. */ + if( nIncr<0 ){ + sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, iOk); + VdbeCoverage(v); + } + for(i=0; inCol; i++){ + int iReg = sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[i]) + regData + 1; + sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iOk); VdbeCoverage(v); + } + + if( isIgnore==0 ){ + if( pIdx==0 ){ + /* If pIdx is NULL, then the parent key is the INTEGER PRIMARY KEY + ** column of the parent table (table pTab). */ + int iMustBeInt; /* Address of MustBeInt instruction */ + int regTemp = sqlite3GetTempReg(pParse); + + /* Invoke MustBeInt to coerce the child key value to an integer (i.e. + ** apply the affinity of the parent key). If this fails, then there + ** is no matching parent key. Before using MustBeInt, make a copy of + ** the value. Otherwise, the value inserted into the child key column + ** will have INTEGER affinity applied to it, which may not be correct. */ + sqlite3VdbeAddOp2(v, OP_SCopy, + sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[0])+1+regData, regTemp); + iMustBeInt = sqlite3VdbeAddOp2(v, OP_MustBeInt, regTemp, 0); + VdbeCoverage(v); + + /* If the parent table is the same as the child table, and we are about + ** to increment the constraint-counter (i.e. this is an INSERT operation), + ** then check if the row being inserted matches itself. If so, do not + ** increment the constraint-counter. */ + if( pTab==pFKey->pFrom && nIncr==1 ){ + sqlite3VdbeAddOp3(v, OP_Eq, regData, iOk, regTemp); VdbeCoverage(v); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + } + + sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead); + sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regTemp); VdbeCoverage(v); + sqlite3VdbeGoto(v, iOk); + sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2); + sqlite3VdbeJumpHere(v, iMustBeInt); + sqlite3ReleaseTempReg(pParse, regTemp); + }else{ + int nCol = pFKey->nCol; + int regTemp = sqlite3GetTempRange(pParse, nCol); + int regRec = sqlite3GetTempReg(pParse); + + sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + for(i=0; ipFrom, aiCol[i])+1+regData, + regTemp+i); + } + + /* If the parent table is the same as the child table, and we are about + ** to increment the constraint-counter (i.e. this is an INSERT operation), + ** then check if the row being inserted matches itself. If so, do not + ** increment the constraint-counter. + ** + ** If any of the parent-key values are NULL, then the row cannot match + ** itself. So set JUMPIFNULL to make sure we do the OP_Found if any + ** of the parent-key values are NULL (at this point it is known that + ** none of the child key values are). + */ + if( pTab==pFKey->pFrom && nIncr==1 ){ + int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1; + for(i=0; ipFrom,aiCol[i]) + +1+regData; + int iParent = 1+regData; + iParent += sqlite3TableColumnToStorage(pIdx->pTable, + pIdx->aiColumn[i]); + assert( pIdx->aiColumn[i]>=0 ); + assert( aiCol[i]!=pTab->iPKey ); + if( pIdx->aiColumn[i]==pTab->iPKey ){ + /* The parent key is a composite key that includes the IPK column */ + iParent = regData; + } + sqlite3VdbeAddOp3(v, OP_Ne, iChild, iJump, iParent); VdbeCoverage(v); + sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL); + } + sqlite3VdbeGoto(v, iOk); + } + + sqlite3VdbeAddOp4(v, OP_MakeRecord, regTemp, nCol, regRec, + sqlite3IndexAffinityStr(pParse->db,pIdx), nCol); + sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regRec, 0); VdbeCoverage(v); + + sqlite3ReleaseTempReg(pParse, regRec); + sqlite3ReleaseTempRange(pParse, regTemp, nCol); + } + } + + if( !pFKey->isDeferred && !(pParse->db->flags & SQLITE_DeferFKs) + && !pParse->pToplevel + && !pParse->isMultiWrite + ){ + /* Special case: If this is an INSERT statement that will insert exactly + ** one row into the table, raise a constraint immediately instead of + ** incrementing a counter. This is necessary as the VM code is being + ** generated for will not open a statement transaction. */ + assert( nIncr==1 ); + sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY, + OE_Abort, 0, P4_STATIC, P5_ConstraintFK); + }else{ + if( nIncr>0 && pFKey->isDeferred==0 ){ + sqlite3MayAbort(pParse); + } + sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr); + } + + sqlite3VdbeResolveLabel(v, iOk); + sqlite3VdbeAddOp1(v, OP_Close, iCur); +} + + +/* +** Return an Expr object that refers to a memory register corresponding +** to column iCol of table pTab. +** +** regBase is the first of an array of register that contains the data +** for pTab. regBase itself holds the rowid. regBase+1 holds the first +** column. regBase+2 holds the second column, and so forth. +*/ +static Expr *exprTableRegister( + Parse *pParse, /* Parsing and code generating context */ + Table *pTab, /* The table whose content is at r[regBase]... */ + int regBase, /* Contents of table pTab */ + i16 iCol /* Which column of pTab is desired */ +){ + Expr *pExpr; + Column *pCol; + const char *zColl; + sqlite3 *db = pParse->db; + + pExpr = sqlite3Expr(db, TK_REGISTER, 0); + if( pExpr ){ + if( iCol>=0 && iCol!=pTab->iPKey ){ + pCol = &pTab->aCol[iCol]; + pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1; + pExpr->affExpr = pCol->affinity; + zColl = pCol->zColl; + if( zColl==0 ) zColl = db->pDfltColl->zName; + pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl); + }else{ + pExpr->iTable = regBase; + pExpr->affExpr = SQLITE_AFF_INTEGER; + } + } + return pExpr; +} + +/* +** Return an Expr object that refers to column iCol of table pTab which +** has cursor iCur. +*/ +static Expr *exprTableColumn( + sqlite3 *db, /* The database connection */ + Table *pTab, /* The table whose column is desired */ + int iCursor, /* The open cursor on the table */ + i16 iCol /* The column that is wanted */ +){ + Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0); + if( pExpr ){ + pExpr->y.pTab = pTab; + pExpr->iTable = iCursor; + pExpr->iColumn = iCol; + } + return pExpr; +} + +/* +** This function is called to generate code executed when a row is deleted +** from the parent table of foreign key constraint pFKey and, if pFKey is +** deferred, when a row is inserted into the same table. When generating +** code for an SQL UPDATE operation, this function may be called twice - +** once to "delete" the old row and once to "insert" the new row. +** +** Parameter nIncr is passed -1 when inserting a row (as this may decrease +** the number of FK violations in the db) or +1 when deleting one (as this +** may increase the number of FK constraint problems). +** +** The code generated by this function scans through the rows in the child +** table that correspond to the parent table row being deleted or inserted. +** For each child row found, one of the following actions is taken: +** +** Operation | FK type | Action taken +** -------------------------------------------------------------------------- +** DELETE immediate Increment the "immediate constraint counter". +** Or, if the ON (UPDATE|DELETE) action is RESTRICT, +** throw a "FOREIGN KEY constraint failed" exception. +** +** INSERT immediate Decrement the "immediate constraint counter". +** +** DELETE deferred Increment the "deferred constraint counter". +** Or, if the ON (UPDATE|DELETE) action is RESTRICT, +** throw a "FOREIGN KEY constraint failed" exception. +** +** INSERT deferred Decrement the "deferred constraint counter". +** +** These operations are identified in the comment at the top of this file +** (fkey.c) as "I.2" and "D.2". +*/ +static void fkScanChildren( + Parse *pParse, /* Parse context */ + SrcList *pSrc, /* The child table to be scanned */ + Table *pTab, /* The parent table */ + Index *pIdx, /* Index on parent covering the foreign key */ + FKey *pFKey, /* The foreign key linking pSrc to pTab */ + int *aiCol, /* Map from pIdx cols to child table cols */ + int regData, /* Parent row data starts here */ + int nIncr /* Amount to increment deferred counter by */ +){ + sqlite3 *db = pParse->db; /* Database handle */ + int i; /* Iterator variable */ + Expr *pWhere = 0; /* WHERE clause to scan with */ + NameContext sNameContext; /* Context used to resolve WHERE clause */ + WhereInfo *pWInfo; /* Context used by sqlite3WhereXXX() */ + int iFkIfZero = 0; /* Address of OP_FkIfZero */ + Vdbe *v = sqlite3GetVdbe(pParse); + + assert( pIdx==0 || pIdx->pTable==pTab ); + assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol ); + assert( pIdx!=0 || pFKey->nCol==1 ); + assert( pIdx!=0 || HasRowid(pTab) ); + + if( nIncr<0 ){ + iFkIfZero = sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, 0); + VdbeCoverage(v); + } + + /* Create an Expr object representing an SQL expression like: + ** + ** = AND = ... + ** + ** The collation sequence used for the comparison should be that of + ** the parent key columns. The affinity of the parent key column should + ** be applied to each child key value before the comparison takes place. + */ + for(i=0; inCol; i++){ + Expr *pLeft; /* Value from parent table row */ + Expr *pRight; /* Column ref to child table */ + Expr *pEq; /* Expression (pLeft = pRight) */ + i16 iCol; /* Index of column in child table */ + const char *zCol; /* Name of column in child table */ + + iCol = pIdx ? pIdx->aiColumn[i] : -1; + pLeft = exprTableRegister(pParse, pTab, regData, iCol); + iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom; + assert( iCol>=0 ); + zCol = pFKey->pFrom->aCol[iCol].zName; + pRight = sqlite3Expr(db, TK_ID, zCol); + pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight); + pWhere = sqlite3ExprAnd(pParse, pWhere, pEq); + } + + /* If the child table is the same as the parent table, then add terms + ** to the WHERE clause that prevent this entry from being scanned. + ** The added WHERE clause terms are like this: + ** + ** $current_rowid!=rowid + ** NOT( $current_a==a AND $current_b==b AND ... ) + ** + ** The first form is used for rowid tables. The second form is used + ** for WITHOUT ROWID tables. In the second form, the *parent* key is + ** (a,b,...). Either the parent or primary key could be used to + ** uniquely identify the current row, but the parent key is more convenient + ** as the required values have already been loaded into registers + ** by the caller. + */ + if( pTab==pFKey->pFrom && nIncr>0 ){ + Expr *pNe; /* Expression (pLeft != pRight) */ + Expr *pLeft; /* Value from parent table row */ + Expr *pRight; /* Column ref to child table */ + if( HasRowid(pTab) ){ + pLeft = exprTableRegister(pParse, pTab, regData, -1); + pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, -1); + pNe = sqlite3PExpr(pParse, TK_NE, pLeft, pRight); + }else{ + Expr *pEq, *pAll = 0; + assert( pIdx!=0 ); + for(i=0; inKeyCol; i++){ + i16 iCol = pIdx->aiColumn[i]; + assert( iCol>=0 ); + pLeft = exprTableRegister(pParse, pTab, regData, iCol); + pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zName); + pEq = sqlite3PExpr(pParse, TK_IS, pLeft, pRight); + pAll = sqlite3ExprAnd(pParse, pAll, pEq); + } + pNe = sqlite3PExpr(pParse, TK_NOT, pAll, 0); + } + pWhere = sqlite3ExprAnd(pParse, pWhere, pNe); + } + + /* Resolve the references in the WHERE clause. */ + memset(&sNameContext, 0, sizeof(NameContext)); + sNameContext.pSrcList = pSrc; + sNameContext.pParse = pParse; + sqlite3ResolveExprNames(&sNameContext, pWhere); + + /* Create VDBE to loop through the entries in pSrc that match the WHERE + ** clause. For each row found, increment either the deferred or immediate + ** foreign key constraint counter. */ + if( pParse->nErr==0 ){ + pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0, 0, 0, 0); + sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr); + if( pWInfo ){ + sqlite3WhereEnd(pWInfo); + } + } + + /* Clean up the WHERE clause constructed above. */ + sqlite3ExprDelete(db, pWhere); + if( iFkIfZero ){ + sqlite3VdbeJumpHereOrPopInst(v, iFkIfZero); + } +} + +/* +** This function returns a linked list of FKey objects (connected by +** FKey.pNextTo) holding all children of table pTab. For example, +** given the following schema: +** +** CREATE TABLE t1(a PRIMARY KEY); +** CREATE TABLE t2(b REFERENCES t1(a); +** +** Calling this function with table "t1" as an argument returns a pointer +** to the FKey structure representing the foreign key constraint on table +** "t2". Calling this function with "t2" as the argument would return a +** NULL pointer (as there are no FK constraints for which t2 is the parent +** table). +*/ +SQLITE_PRIVATE FKey *sqlite3FkReferences(Table *pTab){ + return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName); +} + +/* +** The second argument is a Trigger structure allocated by the +** fkActionTrigger() routine. This function deletes the Trigger structure +** and all of its sub-components. +** +** The Trigger structure or any of its sub-components may be allocated from +** the lookaside buffer belonging to database handle dbMem. +*/ +static void fkTriggerDelete(sqlite3 *dbMem, Trigger *p){ + if( p ){ + TriggerStep *pStep = p->step_list; + sqlite3ExprDelete(dbMem, pStep->pWhere); + sqlite3ExprListDelete(dbMem, pStep->pExprList); + sqlite3SelectDelete(dbMem, pStep->pSelect); + sqlite3ExprDelete(dbMem, p->pWhen); + sqlite3DbFree(dbMem, p); + } +} + +/* +** This function is called to generate code that runs when table pTab is +** being dropped from the database. The SrcList passed as the second argument +** to this function contains a single entry guaranteed to resolve to +** table pTab. +** +** Normally, no code is required. However, if either +** +** (a) The table is the parent table of a FK constraint, or +** (b) The table is the child table of a deferred FK constraint and it is +** determined at runtime that there are outstanding deferred FK +** constraint violations in the database, +** +** then the equivalent of "DELETE FROM " is executed before dropping +** the table from the database. Triggers are disabled while running this +** DELETE, but foreign key actions are not. +*/ +SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){ + sqlite3 *db = pParse->db; + if( (db->flags&SQLITE_ForeignKeys) && !IsVirtual(pTab) ){ + int iSkip = 0; + Vdbe *v = sqlite3GetVdbe(pParse); + + assert( v ); /* VDBE has already been allocated */ + assert( pTab->pSelect==0 ); /* Not a view */ + if( sqlite3FkReferences(pTab)==0 ){ + /* Search for a deferred foreign key constraint for which this table + ** is the child table. If one cannot be found, return without + ** generating any VDBE code. If one can be found, then jump over + ** the entire DELETE if there are no outstanding deferred constraints + ** when this statement is run. */ + FKey *p; + for(p=pTab->pFKey; p; p=p->pNextFrom){ + if( p->isDeferred || (db->flags & SQLITE_DeferFKs) ) break; + } + if( !p ) return; + iSkip = sqlite3VdbeMakeLabel(pParse); + sqlite3VdbeAddOp2(v, OP_FkIfZero, 1, iSkip); VdbeCoverage(v); + } + + pParse->disableTriggers = 1; + sqlite3DeleteFrom(pParse, sqlite3SrcListDup(db, pName, 0), 0, 0, 0); + pParse->disableTriggers = 0; + + /* If the DELETE has generated immediate foreign key constraint + ** violations, halt the VDBE and return an error at this point, before + ** any modifications to the schema are made. This is because statement + ** transactions are not able to rollback schema changes. + ** + ** If the SQLITE_DeferFKs flag is set, then this is not required, as + ** the statement transaction will not be rolled back even if FK + ** constraints are violated. + */ + if( (db->flags & SQLITE_DeferFKs)==0 ){ + sqlite3VdbeVerifyAbortable(v, OE_Abort); + sqlite3VdbeAddOp2(v, OP_FkIfZero, 0, sqlite3VdbeCurrentAddr(v)+2); + VdbeCoverage(v); + sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY, + OE_Abort, 0, P4_STATIC, P5_ConstraintFK); + } + + if( iSkip ){ + sqlite3VdbeResolveLabel(v, iSkip); + } + } +} + + +/* +** The second argument points to an FKey object representing a foreign key +** for which pTab is the child table. An UPDATE statement against pTab +** is currently being processed. For each column of the table that is +** actually updated, the corresponding element in the aChange[] array +** is zero or greater (if a column is unmodified the corresponding element +** is set to -1). If the rowid column is modified by the UPDATE statement +** the bChngRowid argument is non-zero. +** +** This function returns true if any of the columns that are part of the +** child key for FK constraint *p are modified. +*/ +static int fkChildIsModified( + Table *pTab, /* Table being updated */ + FKey *p, /* Foreign key for which pTab is the child */ + int *aChange, /* Array indicating modified columns */ + int bChngRowid /* True if rowid is modified by this update */ +){ + int i; + for(i=0; inCol; i++){ + int iChildKey = p->aCol[i].iFrom; + if( aChange[iChildKey]>=0 ) return 1; + if( iChildKey==pTab->iPKey && bChngRowid ) return 1; + } + return 0; +} + +/* +** The second argument points to an FKey object representing a foreign key +** for which pTab is the parent table. An UPDATE statement against pTab +** is currently being processed. For each column of the table that is +** actually updated, the corresponding element in the aChange[] array +** is zero or greater (if a column is unmodified the corresponding element +** is set to -1). If the rowid column is modified by the UPDATE statement +** the bChngRowid argument is non-zero. +** +** This function returns true if any of the columns that are part of the +** parent key for FK constraint *p are modified. +*/ +static int fkParentIsModified( + Table *pTab, + FKey *p, + int *aChange, + int bChngRowid +){ + int i; + for(i=0; inCol; i++){ + char *zKey = p->aCol[i].zCol; + int iKey; + for(iKey=0; iKeynCol; iKey++){ + if( aChange[iKey]>=0 || (iKey==pTab->iPKey && bChngRowid) ){ + Column *pCol = &pTab->aCol[iKey]; + if( zKey ){ + if( 0==sqlite3StrICmp(pCol->zName, zKey) ) return 1; + }else if( pCol->colFlags & COLFLAG_PRIMKEY ){ + return 1; + } + } + } + } + return 0; +} + +/* +** Return true if the parser passed as the first argument is being +** used to code a trigger that is really a "SET NULL" action belonging +** to trigger pFKey. +*/ +static int isSetNullAction(Parse *pParse, FKey *pFKey){ + Parse *pTop = sqlite3ParseToplevel(pParse); + if( pTop->pTriggerPrg ){ + Trigger *p = pTop->pTriggerPrg->pTrigger; + if( (p==pFKey->apTrigger[0] && pFKey->aAction[0]==OE_SetNull) + || (p==pFKey->apTrigger[1] && pFKey->aAction[1]==OE_SetNull) + ){ + return 1; + } + } + return 0; +} + +/* +** This function is called when inserting, deleting or updating a row of +** table pTab to generate VDBE code to perform foreign key constraint +** processing for the operation. +** +** For a DELETE operation, parameter regOld is passed the index of the +** first register in an array of (pTab->nCol+1) registers containing the +** rowid of the row being deleted, followed by each of the column values +** of the row being deleted, from left to right. Parameter regNew is passed +** zero in this case. +** +** For an INSERT operation, regOld is passed zero and regNew is passed the +** first register of an array of (pTab->nCol+1) registers containing the new +** row data. +** +** For an UPDATE operation, this function is called twice. Once before +** the original record is deleted from the table using the calling convention +** described for DELETE. Then again after the original record is deleted +** but before the new record is inserted using the INSERT convention. +*/ +SQLITE_PRIVATE void sqlite3FkCheck( + Parse *pParse, /* Parse context */ + Table *pTab, /* Row is being deleted from this table */ + int regOld, /* Previous row data is stored here */ + int regNew, /* New row data is stored here */ + int *aChange, /* Array indicating UPDATEd columns (or 0) */ + int bChngRowid /* True if rowid is UPDATEd */ +){ + sqlite3 *db = pParse->db; /* Database handle */ + FKey *pFKey; /* Used to iterate through FKs */ + int iDb; /* Index of database containing pTab */ + const char *zDb; /* Name of database containing pTab */ + int isIgnoreErrors = pParse->disableTriggers; + + /* Exactly one of regOld and regNew should be non-zero. */ + assert( (regOld==0)!=(regNew==0) ); + + /* If foreign-keys are disabled, this function is a no-op. */ + if( (db->flags&SQLITE_ForeignKeys)==0 ) return; + + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + zDb = db->aDb[iDb].zDbSName; + + /* Loop through all the foreign key constraints for which pTab is the + ** child table (the table that the foreign key definition is part of). */ + for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){ + Table *pTo; /* Parent table of foreign key pFKey */ + Index *pIdx = 0; /* Index on key columns in pTo */ + int *aiFree = 0; + int *aiCol; + int iCol; + int i; + int bIgnore = 0; + + if( aChange + && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0 + && fkChildIsModified(pTab, pFKey, aChange, bChngRowid)==0 + ){ + continue; + } + + /* Find the parent table of this foreign key. Also find a unique index + ** on the parent key columns in the parent table. If either of these + ** schema items cannot be located, set an error in pParse and return + ** early. */ + if( pParse->disableTriggers ){ + pTo = sqlite3FindTable(db, pFKey->zTo, zDb); + }else{ + pTo = sqlite3LocateTable(pParse, 0, pFKey->zTo, zDb); + } + if( !pTo || sqlite3FkLocateIndex(pParse, pTo, pFKey, &pIdx, &aiFree) ){ + assert( isIgnoreErrors==0 || (regOld!=0 && regNew==0) ); + if( !isIgnoreErrors || db->mallocFailed ) return; + if( pTo==0 ){ + /* If isIgnoreErrors is true, then a table is being dropped. In this + ** case SQLite runs a "DELETE FROM xxx" on the table being dropped + ** before actually dropping it in order to check FK constraints. + ** If the parent table of an FK constraint on the current table is + ** missing, behave as if it is empty. i.e. decrement the relevant + ** FK counter for each row of the current table with non-NULL keys. + */ + Vdbe *v = sqlite3GetVdbe(pParse); + int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1; + for(i=0; inCol; i++){ + int iFromCol, iReg; + iFromCol = pFKey->aCol[i].iFrom; + iReg = sqlite3TableColumnToStorage(pFKey->pFrom,iFromCol) + regOld+1; + sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iJump); VdbeCoverage(v); + } + sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, -1); + } + continue; + } + assert( pFKey->nCol==1 || (aiFree && pIdx) ); + + if( aiFree ){ + aiCol = aiFree; + }else{ + iCol = pFKey->aCol[0].iFrom; + aiCol = &iCol; + } + for(i=0; inCol; i++){ + if( aiCol[i]==pTab->iPKey ){ + aiCol[i] = -1; + } + assert( pIdx==0 || pIdx->aiColumn[i]>=0 ); +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Request permission to read the parent key columns. If the + ** authorization callback returns SQLITE_IGNORE, behave as if any + ** values read from the parent table are NULL. */ + if( db->xAuth ){ + int rcauth; + char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zName; + rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb); + bIgnore = (rcauth==SQLITE_IGNORE); + } +#endif + } + + /* Take a shared-cache advisory read-lock on the parent table. Allocate + ** a cursor to use to search the unique index on the parent key columns + ** in the parent table. */ + sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName); + pParse->nTab++; + + if( regOld!=0 ){ + /* A row is being removed from the child table. Search for the parent. + ** If the parent does not exist, removing the child row resolves an + ** outstanding foreign key constraint violation. */ + fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore); + } + if( regNew!=0 && !isSetNullAction(pParse, pFKey) ){ + /* A row is being added to the child table. If a parent row cannot + ** be found, adding the child row has violated the FK constraint. + ** + ** If this operation is being performed as part of a trigger program + ** that is actually a "SET NULL" action belonging to this very + ** foreign key, then omit this scan altogether. As all child key + ** values are guaranteed to be NULL, it is not possible for adding + ** this row to cause an FK violation. */ + fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1, bIgnore); + } + + sqlite3DbFree(db, aiFree); + } + + /* Loop through all the foreign key constraints that refer to this table. + ** (the "child" constraints) */ + for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){ + Index *pIdx = 0; /* Foreign key index for pFKey */ + SrcList *pSrc; + int *aiCol = 0; + + if( aChange && fkParentIsModified(pTab, pFKey, aChange, bChngRowid)==0 ){ + continue; + } + + if( !pFKey->isDeferred && !(db->flags & SQLITE_DeferFKs) + && !pParse->pToplevel && !pParse->isMultiWrite + ){ + assert( regOld==0 && regNew!=0 ); + /* Inserting a single row into a parent table cannot cause (or fix) + ** an immediate foreign key violation. So do nothing in this case. */ + continue; + } + + if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){ + if( !isIgnoreErrors || db->mallocFailed ) return; + continue; + } + assert( aiCol || pFKey->nCol==1 ); + + /* Create a SrcList structure containing the child table. We need the + ** child table as a SrcList for sqlite3WhereBegin() */ + pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); + if( pSrc ){ + struct SrcList_item *pItem = pSrc->a; + pItem->pTab = pFKey->pFrom; + pItem->zName = pFKey->pFrom->zName; + pItem->pTab->nTabRef++; + pItem->iCursor = pParse->nTab++; + + if( regNew!=0 ){ + fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1); + } + if( regOld!=0 ){ + int eAction = pFKey->aAction[aChange!=0]; + fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1); + /* If this is a deferred FK constraint, or a CASCADE or SET NULL + ** action applies, then any foreign key violations caused by + ** removing the parent key will be rectified by the action trigger. + ** So do not set the "may-abort" flag in this case. + ** + ** Note 1: If the FK is declared "ON UPDATE CASCADE", then the + ** may-abort flag will eventually be set on this statement anyway + ** (when this function is called as part of processing the UPDATE + ** within the action trigger). + ** + ** Note 2: At first glance it may seem like SQLite could simply omit + ** all OP_FkCounter related scans when either CASCADE or SET NULL + ** applies. The trouble starts if the CASCADE or SET NULL action + ** trigger causes other triggers or action rules attached to the + ** child table to fire. In these cases the fk constraint counters + ** might be set incorrectly if any OP_FkCounter related scans are + ** omitted. */ + if( !pFKey->isDeferred && eAction!=OE_Cascade && eAction!=OE_SetNull ){ + sqlite3MayAbort(pParse); + } + } + pItem->zName = 0; + sqlite3SrcListDelete(db, pSrc); + } + sqlite3DbFree(db, aiCol); + } +} + +#define COLUMN_MASK(x) (((x)>31) ? 0xffffffff : ((u32)1<<(x))) + +/* +** This function is called before generating code to update or delete a +** row contained in table pTab. +*/ +SQLITE_PRIVATE u32 sqlite3FkOldmask( + Parse *pParse, /* Parse context */ + Table *pTab /* Table being modified */ +){ + u32 mask = 0; + if( pParse->db->flags&SQLITE_ForeignKeys ){ + FKey *p; + int i; + for(p=pTab->pFKey; p; p=p->pNextFrom){ + for(i=0; inCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom); + } + for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){ + Index *pIdx = 0; + sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0); + if( pIdx ){ + for(i=0; inKeyCol; i++){ + assert( pIdx->aiColumn[i]>=0 ); + mask |= COLUMN_MASK(pIdx->aiColumn[i]); + } + } + } + } + return mask; +} + + +/* +** This function is called before generating code to update or delete a +** row contained in table pTab. If the operation is a DELETE, then +** parameter aChange is passed a NULL value. For an UPDATE, aChange points +** to an array of size N, where N is the number of columns in table pTab. +** If the i'th column is not modified by the UPDATE, then the corresponding +** entry in the aChange[] array is set to -1. If the column is modified, +** the value is 0 or greater. Parameter chngRowid is set to true if the +** UPDATE statement modifies the rowid fields of the table. +** +** If any foreign key processing will be required, this function returns +** non-zero. If there is no foreign key related processing, this function +** returns zero. +** +** For an UPDATE, this function returns 2 if: +** +** * There are any FKs for which pTab is the child and the parent table, or +** * the UPDATE modifies one or more parent keys for which the action is +** not "NO ACTION" (i.e. is CASCADE, SET DEFAULT or SET NULL). +** +** Or, assuming some other foreign key processing is required, 1. +*/ +SQLITE_PRIVATE int sqlite3FkRequired( + Parse *pParse, /* Parse context */ + Table *pTab, /* Table being modified */ + int *aChange, /* Non-NULL for UPDATE operations */ + int chngRowid /* True for UPDATE that affects rowid */ +){ + int eRet = 0; + if( pParse->db->flags&SQLITE_ForeignKeys ){ + if( !aChange ){ + /* A DELETE operation. Foreign key processing is required if the + ** table in question is either the child or parent table for any + ** foreign key constraint. */ + eRet = (sqlite3FkReferences(pTab) || pTab->pFKey); + }else{ + /* This is an UPDATE. Foreign key processing is only required if the + ** operation modifies one or more child or parent key columns. */ + FKey *p; + + /* Check if any child key columns are being modified. */ + for(p=pTab->pFKey; p; p=p->pNextFrom){ + if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) return 2; + if( fkChildIsModified(pTab, p, aChange, chngRowid) ){ + eRet = 1; + } + } + + /* Check if any parent key columns are being modified. */ + for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){ + if( fkParentIsModified(pTab, p, aChange, chngRowid) ){ + if( p->aAction[1]!=OE_None ) return 2; + eRet = 1; + } + } + } + } + return eRet; +} + +/* +** This function is called when an UPDATE or DELETE operation is being +** compiled on table pTab, which is the parent table of foreign-key pFKey. +** If the current operation is an UPDATE, then the pChanges parameter is +** passed a pointer to the list of columns being modified. If it is a +** DELETE, pChanges is passed a NULL pointer. +** +** It returns a pointer to a Trigger structure containing a trigger +** equivalent to the ON UPDATE or ON DELETE action specified by pFKey. +** If the action is "NO ACTION" or "RESTRICT", then a NULL pointer is +** returned (these actions require no special handling by the triggers +** sub-system, code for them is created by fkScanChildren()). +** +** For example, if pFKey is the foreign key and pTab is table "p" in +** the following schema: +** +** CREATE TABLE p(pk PRIMARY KEY); +** CREATE TABLE c(ck REFERENCES p ON DELETE CASCADE); +** +** then the returned trigger structure is equivalent to: +** +** CREATE TRIGGER ... DELETE ON p BEGIN +** DELETE FROM c WHERE ck = old.pk; +** END; +** +** The returned pointer is cached as part of the foreign key object. It +** is eventually freed along with the rest of the foreign key object by +** sqlite3FkDelete(). +*/ +static Trigger *fkActionTrigger( + Parse *pParse, /* Parse context */ + Table *pTab, /* Table being updated or deleted from */ + FKey *pFKey, /* Foreign key to get action for */ + ExprList *pChanges /* Change-list for UPDATE, NULL for DELETE */ +){ + sqlite3 *db = pParse->db; /* Database handle */ + int action; /* One of OE_None, OE_Cascade etc. */ + Trigger *pTrigger; /* Trigger definition to return */ + int iAction = (pChanges!=0); /* 1 for UPDATE, 0 for DELETE */ + + action = pFKey->aAction[iAction]; + if( action==OE_Restrict && (db->flags & SQLITE_DeferFKs) ){ + return 0; + } + pTrigger = pFKey->apTrigger[iAction]; + + if( action!=OE_None && !pTrigger ){ + char const *zFrom; /* Name of child table */ + int nFrom; /* Length in bytes of zFrom */ + Index *pIdx = 0; /* Parent key index for this FK */ + int *aiCol = 0; /* child table cols -> parent key cols */ + TriggerStep *pStep = 0; /* First (only) step of trigger program */ + Expr *pWhere = 0; /* WHERE clause of trigger step */ + ExprList *pList = 0; /* Changes list if ON UPDATE CASCADE */ + Select *pSelect = 0; /* If RESTRICT, "SELECT RAISE(...)" */ + int i; /* Iterator variable */ + Expr *pWhen = 0; /* WHEN clause for the trigger */ + + if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0; + assert( aiCol || pFKey->nCol==1 ); + + for(i=0; inCol; i++){ + Token tOld = { "old", 3 }; /* Literal "old" token */ + Token tNew = { "new", 3 }; /* Literal "new" token */ + Token tFromCol; /* Name of column in child table */ + Token tToCol; /* Name of column in parent table */ + int iFromCol; /* Idx of column in child table */ + Expr *pEq; /* tFromCol = OLD.tToCol */ + + iFromCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom; + assert( iFromCol>=0 ); + assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKeynCol) ); + assert( pIdx==0 || pIdx->aiColumn[i]>=0 ); + sqlite3TokenInit(&tToCol, + pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zName); + sqlite3TokenInit(&tFromCol, pFKey->pFrom->aCol[iFromCol].zName); + + /* Create the expression "OLD.zToCol = zFromCol". It is important + ** that the "OLD.zToCol" term is on the LHS of the = operator, so + ** that the affinity and collation sequence associated with the + ** parent table are used for the comparison. */ + pEq = sqlite3PExpr(pParse, TK_EQ, + sqlite3PExpr(pParse, TK_DOT, + sqlite3ExprAlloc(db, TK_ID, &tOld, 0), + sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)), + sqlite3ExprAlloc(db, TK_ID, &tFromCol, 0) + ); + pWhere = sqlite3ExprAnd(pParse, pWhere, pEq); + + /* For ON UPDATE, construct the next term of the WHEN clause. + ** The final WHEN clause will be like this: + ** + ** WHEN NOT(old.col1 IS new.col1 AND ... AND old.colN IS new.colN) + */ + if( pChanges ){ + pEq = sqlite3PExpr(pParse, TK_IS, + sqlite3PExpr(pParse, TK_DOT, + sqlite3ExprAlloc(db, TK_ID, &tOld, 0), + sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)), + sqlite3PExpr(pParse, TK_DOT, + sqlite3ExprAlloc(db, TK_ID, &tNew, 0), + sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)) + ); + pWhen = sqlite3ExprAnd(pParse, pWhen, pEq); + } + + if( action!=OE_Restrict && (action!=OE_Cascade || pChanges) ){ + Expr *pNew; + if( action==OE_Cascade ){ + pNew = sqlite3PExpr(pParse, TK_DOT, + sqlite3ExprAlloc(db, TK_ID, &tNew, 0), + sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)); + }else if( action==OE_SetDflt ){ + Column *pCol = pFKey->pFrom->aCol + iFromCol; + Expr *pDflt; + if( pCol->colFlags & COLFLAG_GENERATED ){ + testcase( pCol->colFlags & COLFLAG_VIRTUAL ); + testcase( pCol->colFlags & COLFLAG_STORED ); + pDflt = 0; + }else{ + pDflt = pCol->pDflt; + } + if( pDflt ){ + pNew = sqlite3ExprDup(db, pDflt, 0); + }else{ + pNew = sqlite3ExprAlloc(db, TK_NULL, 0, 0); + } + }else{ + pNew = sqlite3ExprAlloc(db, TK_NULL, 0, 0); + } + pList = sqlite3ExprListAppend(pParse, pList, pNew); + sqlite3ExprListSetName(pParse, pList, &tFromCol, 0); + } + } + sqlite3DbFree(db, aiCol); + + zFrom = pFKey->pFrom->zName; + nFrom = sqlite3Strlen30(zFrom); + + if( action==OE_Restrict ){ + Token tFrom; + Expr *pRaise; + + tFrom.z = zFrom; + tFrom.n = nFrom; + pRaise = sqlite3Expr(db, TK_RAISE, "FOREIGN KEY constraint failed"); + if( pRaise ){ + pRaise->affExpr = OE_Abort; + } + pSelect = sqlite3SelectNew(pParse, + sqlite3ExprListAppend(pParse, 0, pRaise), + sqlite3SrcListAppend(pParse, 0, &tFrom, 0), + pWhere, + 0, 0, 0, 0, 0 + ); + pWhere = 0; + } + + /* Disable lookaside memory allocation */ + DisableLookaside; + + pTrigger = (Trigger *)sqlite3DbMallocZero(db, + sizeof(Trigger) + /* struct Trigger */ + sizeof(TriggerStep) + /* Single step in trigger program */ + nFrom + 1 /* Space for pStep->zTarget */ + ); + if( pTrigger ){ + pStep = pTrigger->step_list = (TriggerStep *)&pTrigger[1]; + pStep->zTarget = (char *)&pStep[1]; + memcpy((char *)pStep->zTarget, zFrom, nFrom); + + pStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); + pStep->pExprList = sqlite3ExprListDup(db, pList, EXPRDUP_REDUCE); + pStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); + if( pWhen ){ + pWhen = sqlite3PExpr(pParse, TK_NOT, pWhen, 0); + pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE); + } + } + + /* Re-enable the lookaside buffer, if it was disabled earlier. */ + EnableLookaside; + + sqlite3ExprDelete(db, pWhere); + sqlite3ExprDelete(db, pWhen); + sqlite3ExprListDelete(db, pList); + sqlite3SelectDelete(db, pSelect); + if( db->mallocFailed==1 ){ + fkTriggerDelete(db, pTrigger); + return 0; + } + assert( pStep!=0 ); + assert( pTrigger!=0 ); + + switch( action ){ + case OE_Restrict: + pStep->op = TK_SELECT; + break; + case OE_Cascade: + if( !pChanges ){ + pStep->op = TK_DELETE; + break; + } + /* no break */ deliberate_fall_through + default: + pStep->op = TK_UPDATE; + } + pStep->pTrig = pTrigger; + pTrigger->pSchema = pTab->pSchema; + pTrigger->pTabSchema = pTab->pSchema; + pFKey->apTrigger[iAction] = pTrigger; + pTrigger->op = (pChanges ? TK_UPDATE : TK_DELETE); + } + + return pTrigger; +} + +/* +** This function is called when deleting or updating a row to implement +** any required CASCADE, SET NULL or SET DEFAULT actions. +*/ +SQLITE_PRIVATE void sqlite3FkActions( + Parse *pParse, /* Parse context */ + Table *pTab, /* Table being updated or deleted from */ + ExprList *pChanges, /* Change-list for UPDATE, NULL for DELETE */ + int regOld, /* Address of array containing old row */ + int *aChange, /* Array indicating UPDATEd columns (or 0) */ + int bChngRowid /* True if rowid is UPDATEd */ +){ + /* If foreign-key support is enabled, iterate through all FKs that + ** refer to table pTab. If there is an action associated with the FK + ** for this operation (either update or delete), invoke the associated + ** trigger sub-program. */ + if( pParse->db->flags&SQLITE_ForeignKeys ){ + FKey *pFKey; /* Iterator variable */ + for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){ + if( aChange==0 || fkParentIsModified(pTab, pFKey, aChange, bChngRowid) ){ + Trigger *pAct = fkActionTrigger(pParse, pTab, pFKey, pChanges); + if( pAct ){ + sqlite3CodeRowTriggerDirect(pParse, pAct, pTab, regOld, OE_Abort, 0); + } + } + } + } +} + +#endif /* ifndef SQLITE_OMIT_TRIGGER */ + +/* +** Free all memory associated with foreign key definitions attached to +** table pTab. Remove the deleted foreign keys from the Schema.fkeyHash +** hash table. +*/ +SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *db, Table *pTab){ + FKey *pFKey; /* Iterator variable */ + FKey *pNext; /* Copy of pFKey->pNextFrom */ + + assert( db==0 || IsVirtual(pTab) + || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) ); + for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){ + + /* Remove the FK from the fkeyHash hash table. */ + if( !db || db->pnBytesFreed==0 ){ + if( pFKey->pPrevTo ){ + pFKey->pPrevTo->pNextTo = pFKey->pNextTo; + }else{ + void *p = (void *)pFKey->pNextTo; + const char *z = (p ? pFKey->pNextTo->zTo : pFKey->zTo); + sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, p); + } + if( pFKey->pNextTo ){ + pFKey->pNextTo->pPrevTo = pFKey->pPrevTo; + } + } + + /* EV: R-30323-21917 Each foreign key constraint in SQLite is + ** classified as either immediate or deferred. + */ + assert( pFKey->isDeferred==0 || pFKey->isDeferred==1 ); + + /* Delete any triggers created to implement actions for this FK. */ +#ifndef SQLITE_OMIT_TRIGGER + fkTriggerDelete(db, pFKey->apTrigger[0]); + fkTriggerDelete(db, pFKey->apTrigger[1]); +#endif + + pNext = pFKey->pNextFrom; + sqlite3DbFree(db, pFKey); + } +} +#endif /* ifndef SQLITE_OMIT_FOREIGN_KEY */ + +/************** End of fkey.c ************************************************/ +/************** Begin file insert.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** to handle INSERT statements in SQLite. +*/ +/* #include "sqliteInt.h" */ + +/* +** Generate code that will +** +** (1) acquire a lock for table pTab then +** (2) open pTab as cursor iCur. +** +** If pTab is a WITHOUT ROWID table, then it is the PRIMARY KEY index +** for that table that is actually opened. +*/ +SQLITE_PRIVATE void sqlite3OpenTable( + Parse *pParse, /* Generate code into this VDBE */ + int iCur, /* The cursor number of the table */ + int iDb, /* The database index in sqlite3.aDb[] */ + Table *pTab, /* The table to be opened */ + int opcode /* OP_OpenRead or OP_OpenWrite */ +){ + Vdbe *v; + assert( !IsVirtual(pTab) ); + assert( pParse->pVdbe!=0 ); + v = pParse->pVdbe; + assert( opcode==OP_OpenWrite || opcode==OP_OpenRead ); + sqlite3TableLock(pParse, iDb, pTab->tnum, + (opcode==OP_OpenWrite)?1:0, pTab->zName); + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol); + VdbeComment((v, "%s", pTab->zName)); + }else{ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + assert( pPk!=0 ); + assert( pPk->tnum==pTab->tnum ); + sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pPk); + VdbeComment((v, "%s", pTab->zName)); + } +} + +/* +** Return a pointer to the column affinity string associated with index +** pIdx. A column affinity string has one character for each column in +** the table, according to the affinity of the column: +** +** Character Column affinity +** ------------------------------ +** 'A' BLOB +** 'B' TEXT +** 'C' NUMERIC +** 'D' INTEGER +** 'F' REAL +** +** An extra 'D' is appended to the end of the string to cover the +** rowid that appears as the last column in every index. +** +** Memory for the buffer containing the column index affinity string +** is managed along with the rest of the Index structure. It will be +** released when sqlite3DeleteIndex() is called. +*/ +SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3 *db, Index *pIdx){ + if( !pIdx->zColAff ){ + /* The first time a column affinity string for a particular index is + ** required, it is allocated and populated here. It is then stored as + ** a member of the Index structure for subsequent use. + ** + ** The column affinity string will eventually be deleted by + ** sqliteDeleteIndex() when the Index structure itself is cleaned + ** up. + */ + int n; + Table *pTab = pIdx->pTable; + pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1); + if( !pIdx->zColAff ){ + sqlite3OomFault(db); + return 0; + } + for(n=0; nnColumn; n++){ + i16 x = pIdx->aiColumn[n]; + char aff; + if( x>=0 ){ + aff = pTab->aCol[x].affinity; + }else if( x==XN_ROWID ){ + aff = SQLITE_AFF_INTEGER; + }else{ + assert( x==XN_EXPR ); + assert( pIdx->aColExpr!=0 ); + aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr); + } + if( affSQLITE_AFF_NUMERIC) aff = SQLITE_AFF_NUMERIC; + pIdx->zColAff[n] = aff; + } + pIdx->zColAff[n] = 0; + } + + return pIdx->zColAff; +} + +/* +** Compute the affinity string for table pTab, if it has not already been +** computed. As an optimization, omit trailing SQLITE_AFF_BLOB affinities. +** +** If the affinity exists (if it is no entirely SQLITE_AFF_BLOB values) and +** if iReg>0 then code an OP_Affinity opcode that will set the affinities +** for register iReg and following. Or if affinities exists and iReg==0, +** then just set the P4 operand of the previous opcode (which should be +** an OP_MakeRecord) to the affinity string. +** +** A column affinity string has one character per column: +** +** Character Column affinity +** ------------------------------ +** 'A' BLOB +** 'B' TEXT +** 'C' NUMERIC +** 'D' INTEGER +** 'E' REAL +*/ +SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){ + int i, j; + char *zColAff = pTab->zColAff; + if( zColAff==0 ){ + sqlite3 *db = sqlite3VdbeDb(v); + zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1); + if( !zColAff ){ + sqlite3OomFault(db); + return; + } + + for(i=j=0; inCol; i++){ + assert( pTab->aCol[i].affinity!=0 ); + if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){ + zColAff[j++] = pTab->aCol[i].affinity; + } + } + do{ + zColAff[j--] = 0; + }while( j>=0 && zColAff[j]<=SQLITE_AFF_BLOB ); + pTab->zColAff = zColAff; + } + assert( zColAff!=0 ); + i = sqlite3Strlen30NN(zColAff); + if( i ){ + if( iReg ){ + sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i); + }else{ + sqlite3VdbeChangeP4(v, -1, zColAff, i); + } + } +} + +/* +** Return non-zero if the table pTab in database iDb or any of its indices +** have been opened at any point in the VDBE program. This is used to see if +** a statement of the form "INSERT INTO SELECT ..." can +** run without using a temporary table for the results of the SELECT. +*/ +static int readsTable(Parse *p, int iDb, Table *pTab){ + Vdbe *v = sqlite3GetVdbe(p); + int i; + int iEnd = sqlite3VdbeCurrentAddr(v); +#ifndef SQLITE_OMIT_VIRTUALTABLE + VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0; +#endif + + for(i=1; iopcode==OP_OpenRead && pOp->p3==iDb ){ + Index *pIndex; + Pgno tnum = pOp->p2; + if( tnum==pTab->tnum ){ + return 1; + } + for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){ + if( tnum==pIndex->tnum ){ + return 1; + } + } + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( pOp->opcode==OP_VOpen && pOp->p4.pVtab==pVTab ){ + assert( pOp->p4.pVtab!=0 ); + assert( pOp->p4type==P4_VTAB ); + return 1; + } +#endif + } + return 0; +} + +/* This walker callback will compute the union of colFlags flags for all +** referenced columns in a CHECK constraint or generated column expression. +*/ +static int exprColumnFlagUnion(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 ){ + assert( pExpr->iColumn < pWalker->u.pTab->nCol ); + pWalker->eCode |= pWalker->u.pTab->aCol[pExpr->iColumn].colFlags; + } + return WRC_Continue; +} + +#ifndef SQLITE_OMIT_GENERATED_COLUMNS +/* +** All regular columns for table pTab have been puts into registers +** starting with iRegStore. The registers that correspond to STORED +** or VIRTUAL columns have not yet been initialized. This routine goes +** back and computes the values for those columns based on the previously +** computed normal columns. +*/ +SQLITE_PRIVATE void sqlite3ComputeGeneratedColumns( + Parse *pParse, /* Parsing context */ + int iRegStore, /* Register holding the first column */ + Table *pTab /* The table */ +){ + int i; + Walker w; + Column *pRedo; + int eProgress; + VdbeOp *pOp; + + assert( pTab->tabFlags & TF_HasGenerated ); + testcase( pTab->tabFlags & TF_HasVirtual ); + testcase( pTab->tabFlags & TF_HasStored ); + + /* Before computing generated columns, first go through and make sure + ** that appropriate affinity has been applied to the regular columns + */ + sqlite3TableAffinity(pParse->pVdbe, pTab, iRegStore); + if( (pTab->tabFlags & TF_HasStored)!=0 + && (pOp = sqlite3VdbeGetOp(pParse->pVdbe,-1))->opcode==OP_Affinity + ){ + /* Change the OP_Affinity argument to '@' (NONE) for all stored + ** columns. '@' is the no-op affinity and those columns have not + ** yet been computed. */ + int ii, jj; + char *zP4 = pOp->p4.z; + assert( zP4!=0 ); + assert( pOp->p4type==P4_DYNAMIC ); + for(ii=jj=0; zP4[jj]; ii++){ + if( pTab->aCol[ii].colFlags & COLFLAG_VIRTUAL ){ + continue; + } + if( pTab->aCol[ii].colFlags & COLFLAG_STORED ){ + zP4[jj] = SQLITE_AFF_NONE; + } + jj++; + } + } + + /* Because there can be multiple generated columns that refer to one another, + ** this is a two-pass algorithm. On the first pass, mark all generated + ** columns as "not available". + */ + for(i=0; inCol; i++){ + if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){ + testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ); + testcase( pTab->aCol[i].colFlags & COLFLAG_STORED ); + pTab->aCol[i].colFlags |= COLFLAG_NOTAVAIL; + } + } + + w.u.pTab = pTab; + w.xExprCallback = exprColumnFlagUnion; + w.xSelectCallback = 0; + w.xSelectCallback2 = 0; + + /* On the second pass, compute the value of each NOT-AVAILABLE column. + ** Companion code in the TK_COLUMN case of sqlite3ExprCodeTarget() will + ** compute dependencies and mark remove the COLSPAN_NOTAVAIL mark, as + ** they are needed. + */ + pParse->iSelfTab = -iRegStore; + do{ + eProgress = 0; + pRedo = 0; + for(i=0; inCol; i++){ + Column *pCol = pTab->aCol + i; + if( (pCol->colFlags & COLFLAG_NOTAVAIL)!=0 ){ + int x; + pCol->colFlags |= COLFLAG_BUSY; + w.eCode = 0; + sqlite3WalkExpr(&w, pCol->pDflt); + pCol->colFlags &= ~COLFLAG_BUSY; + if( w.eCode & COLFLAG_NOTAVAIL ){ + pRedo = pCol; + continue; + } + eProgress = 1; + assert( pCol->colFlags & COLFLAG_GENERATED ); + x = sqlite3TableColumnToStorage(pTab, i) + iRegStore; + sqlite3ExprCodeGeneratedColumn(pParse, pCol, x); + pCol->colFlags &= ~COLFLAG_NOTAVAIL; + } + } + }while( pRedo && eProgress ); + if( pRedo ){ + sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pRedo->zName); + } + pParse->iSelfTab = 0; +} +#endif /* SQLITE_OMIT_GENERATED_COLUMNS */ + + +#ifndef SQLITE_OMIT_AUTOINCREMENT +/* +** Locate or create an AutoincInfo structure associated with table pTab +** which is in database iDb. Return the register number for the register +** that holds the maximum rowid. Return zero if pTab is not an AUTOINCREMENT +** table. (Also return zero when doing a VACUUM since we do not want to +** update the AUTOINCREMENT counters during a VACUUM.) +** +** There is at most one AutoincInfo structure per table even if the +** same table is autoincremented multiple times due to inserts within +** triggers. A new AutoincInfo structure is created if this is the +** first use of table pTab. On 2nd and subsequent uses, the original +** AutoincInfo structure is used. +** +** Four consecutive registers are allocated: +** +** (1) The name of the pTab table. +** (2) The maximum ROWID of pTab. +** (3) The rowid in sqlite_sequence of pTab +** (4) The original value of the max ROWID in pTab, or NULL if none +** +** The 2nd register is the one that is returned. That is all the +** insert routine needs to know about. +*/ +static int autoIncBegin( + Parse *pParse, /* Parsing context */ + int iDb, /* Index of the database holding pTab */ + Table *pTab /* The table we are writing to */ +){ + int memId = 0; /* Register holding maximum rowid */ + assert( pParse->db->aDb[iDb].pSchema!=0 ); + if( (pTab->tabFlags & TF_Autoincrement)!=0 + && (pParse->db->mDbFlags & DBFLAG_Vacuum)==0 + ){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + AutoincInfo *pInfo; + Table *pSeqTab = pParse->db->aDb[iDb].pSchema->pSeqTab; + + /* Verify that the sqlite_sequence table exists and is an ordinary + ** rowid table with exactly two columns. + ** Ticket d8dc2b3a58cd5dc2918a1d4acb 2018-05-23 */ + if( pSeqTab==0 + || !HasRowid(pSeqTab) + || IsVirtual(pSeqTab) + || pSeqTab->nCol!=2 + ){ + pParse->nErr++; + pParse->rc = SQLITE_CORRUPT_SEQUENCE; + return 0; + } + + pInfo = pToplevel->pAinc; + while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; } + if( pInfo==0 ){ + pInfo = sqlite3DbMallocRawNN(pParse->db, sizeof(*pInfo)); + if( pInfo==0 ) return 0; + pInfo->pNext = pToplevel->pAinc; + pToplevel->pAinc = pInfo; + pInfo->pTab = pTab; + pInfo->iDb = iDb; + pToplevel->nMem++; /* Register to hold name of table */ + pInfo->regCtr = ++pToplevel->nMem; /* Max rowid register */ + pToplevel->nMem +=2; /* Rowid in sqlite_sequence + orig max val */ + } + memId = pInfo->regCtr; + } + return memId; +} + +/* +** This routine generates code that will initialize all of the +** register used by the autoincrement tracker. +*/ +SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse){ + AutoincInfo *p; /* Information about an AUTOINCREMENT */ + sqlite3 *db = pParse->db; /* The database connection */ + Db *pDb; /* Database only autoinc table */ + int memId; /* Register holding max rowid */ + Vdbe *v = pParse->pVdbe; /* VDBE under construction */ + + /* This routine is never called during trigger-generation. It is + ** only called from the top-level */ + assert( pParse->pTriggerTab==0 ); + assert( sqlite3IsToplevel(pParse) ); + + assert( v ); /* We failed long ago if this is not so */ + for(p = pParse->pAinc; p; p = p->pNext){ + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList autoInc[] = { + /* 0 */ {OP_Null, 0, 0, 0}, + /* 1 */ {OP_Rewind, 0, 10, 0}, + /* 2 */ {OP_Column, 0, 0, 0}, + /* 3 */ {OP_Ne, 0, 9, 0}, + /* 4 */ {OP_Rowid, 0, 0, 0}, + /* 5 */ {OP_Column, 0, 1, 0}, + /* 6 */ {OP_AddImm, 0, 0, 0}, + /* 7 */ {OP_Copy, 0, 0, 0}, + /* 8 */ {OP_Goto, 0, 11, 0}, + /* 9 */ {OP_Next, 0, 2, 0}, + /* 10 */ {OP_Integer, 0, 0, 0}, + /* 11 */ {OP_Close, 0, 0, 0} + }; + VdbeOp *aOp; + pDb = &db->aDb[p->iDb]; + memId = p->regCtr; + assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) ); + sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead); + sqlite3VdbeLoadString(v, memId-1, p->pTab->zName); + aOp = sqlite3VdbeAddOpList(v, ArraySize(autoInc), autoInc, iLn); + if( aOp==0 ) break; + aOp[0].p2 = memId; + aOp[0].p3 = memId+2; + aOp[2].p3 = memId; + aOp[3].p1 = memId-1; + aOp[3].p3 = memId; + aOp[3].p5 = SQLITE_JUMPIFNULL; + aOp[4].p2 = memId+1; + aOp[5].p3 = memId; + aOp[6].p1 = memId; + aOp[7].p2 = memId+2; + aOp[7].p1 = memId; + aOp[10].p2 = memId; + if( pParse->nTab==0 ) pParse->nTab = 1; + } +} + +/* +** Update the maximum rowid for an autoincrement calculation. +** +** This routine should be called when the regRowid register holds a +** new rowid that is about to be inserted. If that new rowid is +** larger than the maximum rowid in the memId memory cell, then the +** memory cell is updated. +*/ +static void autoIncStep(Parse *pParse, int memId, int regRowid){ + if( memId>0 ){ + sqlite3VdbeAddOp2(pParse->pVdbe, OP_MemMax, memId, regRowid); + } +} + +/* +** This routine generates the code needed to write autoincrement +** maximum rowid values back into the sqlite_sequence register. +** Every statement that might do an INSERT into an autoincrement +** table (either directly or through triggers) needs to call this +** routine just before the "exit" code. +*/ +static SQLITE_NOINLINE void autoIncrementEnd(Parse *pParse){ + AutoincInfo *p; + Vdbe *v = pParse->pVdbe; + sqlite3 *db = pParse->db; + + assert( v ); + for(p = pParse->pAinc; p; p = p->pNext){ + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList autoIncEnd[] = { + /* 0 */ {OP_NotNull, 0, 2, 0}, + /* 1 */ {OP_NewRowid, 0, 0, 0}, + /* 2 */ {OP_MakeRecord, 0, 2, 0}, + /* 3 */ {OP_Insert, 0, 0, 0}, + /* 4 */ {OP_Close, 0, 0, 0} + }; + VdbeOp *aOp; + Db *pDb = &db->aDb[p->iDb]; + int iRec; + int memId = p->regCtr; + + iRec = sqlite3GetTempReg(pParse); + assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) ); + sqlite3VdbeAddOp3(v, OP_Le, memId+2, sqlite3VdbeCurrentAddr(v)+7, memId); + VdbeCoverage(v); + sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite); + aOp = sqlite3VdbeAddOpList(v, ArraySize(autoIncEnd), autoIncEnd, iLn); + if( aOp==0 ) break; + aOp[0].p1 = memId+1; + aOp[1].p2 = memId+1; + aOp[2].p1 = memId-1; + aOp[2].p3 = iRec; + aOp[3].p2 = iRec; + aOp[3].p3 = memId+1; + aOp[3].p5 = OPFLAG_APPEND; + sqlite3ReleaseTempReg(pParse, iRec); + } +} +SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse){ + if( pParse->pAinc ) autoIncrementEnd(pParse); +} +#else +/* +** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines +** above are all no-ops +*/ +# define autoIncBegin(A,B,C) (0) +# define autoIncStep(A,B,C) +#endif /* SQLITE_OMIT_AUTOINCREMENT */ + + +/* Forward declaration */ +static int xferOptimization( + Parse *pParse, /* Parser context */ + Table *pDest, /* The table we are inserting into */ + Select *pSelect, /* A SELECT statement to use as the data source */ + int onError, /* How to handle constraint errors */ + int iDbDest /* The database of pDest */ +); + +/* +** This routine is called to handle SQL of the following forms: +** +** insert into TABLE (IDLIST) values(EXPRLIST),(EXPRLIST),... +** insert into TABLE (IDLIST) select +** insert into TABLE (IDLIST) default values +** +** The IDLIST following the table name is always optional. If omitted, +** then a list of all (non-hidden) columns for the table is substituted. +** The IDLIST appears in the pColumn parameter. pColumn is NULL if IDLIST +** is omitted. +** +** For the pSelect parameter holds the values to be inserted for the +** first two forms shown above. A VALUES clause is really just short-hand +** for a SELECT statement that omits the FROM clause and everything else +** that follows. If the pSelect parameter is NULL, that means that the +** DEFAULT VALUES form of the INSERT statement is intended. +** +** The code generated follows one of four templates. For a simple +** insert with data coming from a single-row VALUES clause, the code executes +** once straight down through. Pseudo-code follows (we call this +** the "1st template"): +** +** open write cursor to
    and its indices +** put VALUES clause expressions into registers +** write the resulting record into
    +** cleanup +** +** The three remaining templates assume the statement is of the form +** +** INSERT INTO
    SELECT ... +** +** If the SELECT clause is of the restricted form "SELECT * FROM " - +** in other words if the SELECT pulls all columns from a single table +** and there is no WHERE or LIMIT or GROUP BY or ORDER BY clauses, and +** if and are distinct tables but have identical +** schemas, including all the same indices, then a special optimization +** is invoked that copies raw records from over to . +** See the xferOptimization() function for the implementation of this +** template. This is the 2nd template. +** +** open a write cursor to
    +** open read cursor on +** transfer all records in over to
    +** close cursors +** foreach index on
    +** open a write cursor on the
    index +** open a read cursor on the corresponding index +** transfer all records from the read to the write cursors +** close cursors +** end foreach +** +** The 3rd template is for when the second template does not apply +** and the SELECT clause does not read from
    at any time. +** The generated code follows this template: +** +** X <- A +** goto B +** A: setup for the SELECT +** loop over the rows in the SELECT +** load values into registers R..R+n +** yield X +** end loop +** cleanup after the SELECT +** end-coroutine X +** B: open write cursor to
    and its indices +** C: yield X, at EOF goto D +** insert the select result into
    from R..R+n +** goto C +** D: cleanup +** +** The 4th template is used if the insert statement takes its +** values from a SELECT but the data is being inserted into a table +** that is also read as part of the SELECT. In the third form, +** we have to use an intermediate table to store the results of +** the select. The template is like this: +** +** X <- A +** goto B +** A: setup for the SELECT +** loop over the tables in the SELECT +** load value into register R..R+n +** yield X +** end loop +** cleanup after the SELECT +** end co-routine R +** B: open temp table +** L: yield X, at EOF goto M +** insert row from R..R+n into temp table +** goto L +** M: open write cursor to
    and its indices +** rewind temp table +** C: loop over rows of intermediate table +** transfer values form intermediate table into
    +** end loop +** D: cleanup +*/ +SQLITE_PRIVATE void sqlite3Insert( + Parse *pParse, /* Parser context */ + SrcList *pTabList, /* Name of table into which we are inserting */ + Select *pSelect, /* A SELECT statement to use as the data source */ + IdList *pColumn, /* Column names corresponding to IDLIST, or NULL. */ + int onError, /* How to handle constraint errors */ + Upsert *pUpsert /* ON CONFLICT clauses for upsert, or NULL */ +){ + sqlite3 *db; /* The main database structure */ + Table *pTab; /* The table to insert into. aka TABLE */ + int i, j; /* Loop counters */ + Vdbe *v; /* Generate code into this virtual machine */ + Index *pIdx; /* For looping over indices of the table */ + int nColumn; /* Number of columns in the data */ + int nHidden = 0; /* Number of hidden columns if TABLE is virtual */ + int iDataCur = 0; /* VDBE cursor that is the main data repository */ + int iIdxCur = 0; /* First index cursor */ + int ipkColumn = -1; /* Column that is the INTEGER PRIMARY KEY */ + int endOfLoop; /* Label for the end of the insertion loop */ + int srcTab = 0; /* Data comes from this temporary cursor if >=0 */ + int addrInsTop = 0; /* Jump to label "D" */ + int addrCont = 0; /* Top of insert loop. Label "C" in templates 3 and 4 */ + SelectDest dest; /* Destination for SELECT on rhs of INSERT */ + int iDb; /* Index of database holding TABLE */ + u8 useTempTable = 0; /* Store SELECT results in intermediate table */ + u8 appendFlag = 0; /* True if the insert is likely to be an append */ + u8 withoutRowid; /* 0 for normal table. 1 for WITHOUT ROWID table */ + u8 bIdListInOrder; /* True if IDLIST is in table order */ + ExprList *pList = 0; /* List of VALUES() to be inserted */ + int iRegStore; /* Register in which to store next column */ + + /* Register allocations */ + int regFromSelect = 0;/* Base register for data coming from SELECT */ + int regAutoinc = 0; /* Register holding the AUTOINCREMENT counter */ + int regRowCount = 0; /* Memory cell used for the row counter */ + int regIns; /* Block of regs holding rowid+data being inserted */ + int regRowid; /* registers holding insert rowid */ + int regData; /* register holding first column to insert */ + int *aRegIdx = 0; /* One register allocated to each index */ + +#ifndef SQLITE_OMIT_TRIGGER + int isView; /* True if attempting to insert into a view */ + Trigger *pTrigger; /* List of triggers on pTab, if required */ + int tmask; /* Mask of trigger times */ +#endif + + db = pParse->db; + if( pParse->nErr || db->mallocFailed ){ + goto insert_cleanup; + } + dest.iSDParm = 0; /* Suppress a harmless compiler warning */ + + /* If the Select object is really just a simple VALUES() list with a + ** single row (the common case) then keep that one row of values + ** and discard the other (unused) parts of the pSelect object + */ + if( pSelect && (pSelect->selFlags & SF_Values)!=0 && pSelect->pPrior==0 ){ + pList = pSelect->pEList; + pSelect->pEList = 0; + sqlite3SelectDelete(db, pSelect); + pSelect = 0; + } + + /* Locate the table into which we will be inserting new information. + */ + assert( pTabList->nSrc==1 ); + pTab = sqlite3SrcListLookup(pParse, pTabList); + if( pTab==0 ){ + goto insert_cleanup; + } + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDbnDb ); + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, + db->aDb[iDb].zDbSName) ){ + goto insert_cleanup; + } + withoutRowid = !HasRowid(pTab); + + /* Figure out if we have any triggers and if the table being + ** inserted into is a view + */ +#ifndef SQLITE_OMIT_TRIGGER + pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask); + isView = pTab->pSelect!=0; +#else +# define pTrigger 0 +# define tmask 0 +# define isView 0 +#endif +#ifdef SQLITE_OMIT_VIEW +# undef isView +# define isView 0 +#endif + assert( (pTrigger && tmask) || (pTrigger==0 && tmask==0) ); + + /* If pTab is really a view, make sure it has been initialized. + ** ViewGetColumnNames() is a no-op if pTab is not a view. + */ + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto insert_cleanup; + } + + /* Cannot insert into a read-only table. + */ + if( sqlite3IsReadOnly(pParse, pTab, tmask) ){ + goto insert_cleanup; + } + + /* Allocate a VDBE + */ + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto insert_cleanup; + if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); + sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb); + +#ifndef SQLITE_OMIT_XFER_OPT + /* If the statement is of the form + ** + ** INSERT INTO SELECT * FROM ; + ** + ** Then special optimizations can be applied that make the transfer + ** very fast and which reduce fragmentation of indices. + ** + ** This is the 2nd template. + */ + if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){ + assert( !pTrigger ); + assert( pList==0 ); + goto insert_end; + } +#endif /* SQLITE_OMIT_XFER_OPT */ + + /* If this is an AUTOINCREMENT table, look up the sequence number in the + ** sqlite_sequence table and store it in memory cell regAutoinc. + */ + regAutoinc = autoIncBegin(pParse, iDb, pTab); + + /* Allocate a block registers to hold the rowid and the values + ** for all columns of the new row. + */ + regRowid = regIns = pParse->nMem+1; + pParse->nMem += pTab->nCol + 1; + if( IsVirtual(pTab) ){ + regRowid++; + pParse->nMem++; + } + regData = regRowid+1; + + /* If the INSERT statement included an IDLIST term, then make sure + ** all elements of the IDLIST really are columns of the table and + ** remember the column indices. + ** + ** If the table has an INTEGER PRIMARY KEY column and that column + ** is named in the IDLIST, then record in the ipkColumn variable + ** the index into IDLIST of the primary key column. ipkColumn is + ** the index of the primary key as it appears in IDLIST, not as + ** is appears in the original table. (The index of the INTEGER + ** PRIMARY KEY in the original table is pTab->iPKey.) After this + ** loop, if ipkColumn==(-1), that means that integer primary key + ** is unspecified, and hence the table is either WITHOUT ROWID or + ** it will automatically generated an integer primary key. + ** + ** bIdListInOrder is true if the columns in IDLIST are in storage + ** order. This enables an optimization that avoids shuffling the + ** columns into storage order. False negatives are harmless, + ** but false positives will cause database corruption. + */ + bIdListInOrder = (pTab->tabFlags & (TF_OOOHidden|TF_HasStored))==0; + if( pColumn ){ + for(i=0; inId; i++){ + pColumn->a[i].idx = -1; + } + for(i=0; inId; i++){ + for(j=0; jnCol; j++){ + if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){ + pColumn->a[i].idx = j; + if( i!=j ) bIdListInOrder = 0; + if( j==pTab->iPKey ){ + ipkColumn = i; assert( !withoutRowid ); + } +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( pTab->aCol[j].colFlags & (COLFLAG_STORED|COLFLAG_VIRTUAL) ){ + sqlite3ErrorMsg(pParse, + "cannot INSERT into generated column \"%s\"", + pTab->aCol[j].zName); + goto insert_cleanup; + } +#endif + break; + } + } + if( j>=pTab->nCol ){ + if( sqlite3IsRowid(pColumn->a[i].zName) && !withoutRowid ){ + ipkColumn = i; + bIdListInOrder = 0; + }else{ + sqlite3ErrorMsg(pParse, "table %S has no column named %s", + pTabList, 0, pColumn->a[i].zName); + pParse->checkSchema = 1; + goto insert_cleanup; + } + } + } + } + + /* Figure out how many columns of data are supplied. If the data + ** is coming from a SELECT statement, then generate a co-routine that + ** produces a single row of the SELECT on each invocation. The + ** co-routine is the common header to the 3rd and 4th templates. + */ + if( pSelect ){ + /* Data is coming from a SELECT or from a multi-row VALUES clause. + ** Generate a co-routine to run the SELECT. */ + int regYield; /* Register holding co-routine entry-point */ + int addrTop; /* Top of the co-routine */ + int rc; /* Result code */ + + regYield = ++pParse->nMem; + addrTop = sqlite3VdbeCurrentAddr(v) + 1; + sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop); + sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield); + dest.iSdst = bIdListInOrder ? regData : 0; + dest.nSdst = pTab->nCol; + rc = sqlite3Select(pParse, pSelect, &dest); + regFromSelect = dest.iSdst; + if( rc || db->mallocFailed || pParse->nErr ) goto insert_cleanup; + sqlite3VdbeEndCoroutine(v, regYield); + sqlite3VdbeJumpHere(v, addrTop - 1); /* label B: */ + assert( pSelect->pEList ); + nColumn = pSelect->pEList->nExpr; + + /* Set useTempTable to TRUE if the result of the SELECT statement + ** should be written into a temporary table (template 4). Set to + ** FALSE if each output row of the SELECT can be written directly into + ** the destination table (template 3). + ** + ** A temp table must be used if the table being updated is also one + ** of the tables being read by the SELECT statement. Also use a + ** temp table in the case of row triggers. + */ + if( pTrigger || readsTable(pParse, iDb, pTab) ){ + useTempTable = 1; + } + + if( useTempTable ){ + /* Invoke the coroutine to extract information from the SELECT + ** and add it to a transient table srcTab. The code generated + ** here is from the 4th template: + ** + ** B: open temp table + ** L: yield X, goto M at EOF + ** insert row from R..R+n into temp table + ** goto L + ** M: ... + */ + int regRec; /* Register to hold packed record */ + int regTempRowid; /* Register to hold temp table ROWID */ + int addrL; /* Label "L" */ + + srcTab = pParse->nTab++; + regRec = sqlite3GetTempReg(pParse); + regTempRowid = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, srcTab, nColumn); + addrL = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regFromSelect, nColumn, regRec); + sqlite3VdbeAddOp2(v, OP_NewRowid, srcTab, regTempRowid); + sqlite3VdbeAddOp3(v, OP_Insert, srcTab, regRec, regTempRowid); + sqlite3VdbeGoto(v, addrL); + sqlite3VdbeJumpHere(v, addrL); + sqlite3ReleaseTempReg(pParse, regRec); + sqlite3ReleaseTempReg(pParse, regTempRowid); + } + }else{ + /* This is the case if the data for the INSERT is coming from a + ** single-row VALUES clause + */ + NameContext sNC; + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + srcTab = -1; + assert( useTempTable==0 ); + if( pList ){ + nColumn = pList->nExpr; + if( sqlite3ResolveExprListNames(&sNC, pList) ){ + goto insert_cleanup; + } + }else{ + nColumn = 0; + } + } + + /* If there is no IDLIST term but the table has an integer primary + ** key, the set the ipkColumn variable to the integer primary key + ** column index in the original table definition. + */ + if( pColumn==0 && nColumn>0 ){ + ipkColumn = pTab->iPKey; +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( ipkColumn>=0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){ + testcase( pTab->tabFlags & TF_HasVirtual ); + testcase( pTab->tabFlags & TF_HasStored ); + for(i=ipkColumn-1; i>=0; i--){ + if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){ + testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ); + testcase( pTab->aCol[i].colFlags & COLFLAG_STORED ); + ipkColumn--; + } + } + } +#endif + } + + /* Make sure the number of columns in the source data matches the number + ** of columns to be inserted into the table. + */ + for(i=0; inCol; i++){ + if( pTab->aCol[i].colFlags & COLFLAG_NOINSERT ) nHidden++; + } + if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){ + sqlite3ErrorMsg(pParse, + "table %S has %d columns but %d values were supplied", + pTabList, 0, pTab->nCol-nHidden, nColumn); + goto insert_cleanup; + } + if( pColumn!=0 && nColumn!=pColumn->nId ){ + sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId); + goto insert_cleanup; + } + + /* Initialize the count of rows to be inserted + */ + if( (db->flags & SQLITE_CountRows)!=0 + && !pParse->nested + && !pParse->pTriggerTab + ){ + regRowCount = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount); + } + + /* If this is not a view, open the table and and all indices */ + if( !isView ){ + int nIdx; + nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, -1, 0, + &iDataCur, &iIdxCur); + aRegIdx = sqlite3DbMallocRawNN(db, sizeof(int)*(nIdx+2)); + if( aRegIdx==0 ){ + goto insert_cleanup; + } + for(i=0, pIdx=pTab->pIndex; ipNext, i++){ + assert( pIdx ); + aRegIdx[i] = ++pParse->nMem; + pParse->nMem += pIdx->nColumn; + } + aRegIdx[i] = ++pParse->nMem; /* Register to store the table record */ + } +#ifndef SQLITE_OMIT_UPSERT + if( pUpsert ){ + if( IsVirtual(pTab) ){ + sqlite3ErrorMsg(pParse, "UPSERT not implemented for virtual table \"%s\"", + pTab->zName); + goto insert_cleanup; + } + if( pTab->pSelect ){ + sqlite3ErrorMsg(pParse, "cannot UPSERT a view"); + goto insert_cleanup; + } + if( sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget) ){ + goto insert_cleanup; + } + pTabList->a[0].iCursor = iDataCur; + pUpsert->pUpsertSrc = pTabList; + pUpsert->regData = regData; + pUpsert->iDataCur = iDataCur; + pUpsert->iIdxCur = iIdxCur; + if( pUpsert->pUpsertTarget ){ + sqlite3UpsertAnalyzeTarget(pParse, pTabList, pUpsert); + } + } +#endif + + + /* This is the top of the main insertion loop */ + if( useTempTable ){ + /* This block codes the top of loop only. The complete loop is the + ** following pseudocode (template 4): + ** + ** rewind temp table, if empty goto D + ** C: loop over rows of intermediate table + ** transfer values form intermediate table into
    + ** end loop + ** D: ... + */ + addrInsTop = sqlite3VdbeAddOp1(v, OP_Rewind, srcTab); VdbeCoverage(v); + addrCont = sqlite3VdbeCurrentAddr(v); + }else if( pSelect ){ + /* This block codes the top of loop only. The complete loop is the + ** following pseudocode (template 3): + ** + ** C: yield X, at EOF goto D + ** insert the select result into
    from R..R+n + ** goto C + ** D: ... + */ + sqlite3VdbeReleaseRegisters(pParse, regData, pTab->nCol, 0, 0); + addrInsTop = addrCont = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm); + VdbeCoverage(v); + if( ipkColumn>=0 ){ + /* tag-20191021-001: If the INTEGER PRIMARY KEY is being generated by the + ** SELECT, go ahead and copy the value into the rowid slot now, so that + ** the value does not get overwritten by a NULL at tag-20191021-002. */ + sqlite3VdbeAddOp2(v, OP_Copy, regFromSelect+ipkColumn, regRowid); + } + } + + /* Compute data for ordinary columns of the new entry. Values + ** are written in storage order into registers starting with regData. + ** Only ordinary columns are computed in this loop. The rowid + ** (if there is one) is computed later and generated columns are + ** computed after the rowid since they might depend on the value + ** of the rowid. + */ + nHidden = 0; + iRegStore = regData; assert( regData==regRowid+1 ); + for(i=0; inCol; i++, iRegStore++){ + int k; + u32 colFlags; + assert( i>=nHidden ); + if( i==pTab->iPKey ){ + /* tag-20191021-002: References to the INTEGER PRIMARY KEY are filled + ** using the rowid. So put a NULL in the IPK slot of the record to avoid + ** using excess space. The file format definition requires this extra + ** NULL - we cannot optimize further by skipping the column completely */ + sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore); + continue; + } + if( ((colFlags = pTab->aCol[i].colFlags) & COLFLAG_NOINSERT)!=0 ){ + nHidden++; + if( (colFlags & COLFLAG_VIRTUAL)!=0 ){ + /* Virtual columns do not participate in OP_MakeRecord. So back up + ** iRegStore by one slot to compensate for the iRegStore++ in the + ** outer for() loop */ + iRegStore--; + continue; + }else if( (colFlags & COLFLAG_STORED)!=0 ){ + /* Stored columns are computed later. But if there are BEFORE + ** triggers, the slots used for stored columns will be OP_Copy-ed + ** to a second block of registers, so the register needs to be + ** initialized to NULL to avoid an uninitialized register read */ + if( tmask & TRIGGER_BEFORE ){ + sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore); + } + continue; + }else if( pColumn==0 ){ + /* Hidden columns that are not explicitly named in the INSERT + ** get there default value */ + sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore); + continue; + } + } + if( pColumn ){ + for(j=0; jnId && pColumn->a[j].idx!=i; j++){} + if( j>=pColumn->nId ){ + /* A column not named in the insert column list gets its + ** default value */ + sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore); + continue; + } + k = j; + }else if( nColumn==0 ){ + /* This is INSERT INTO ... DEFAULT VALUES. Load the default value. */ + sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore); + continue; + }else{ + k = i - nHidden; + } + + if( useTempTable ){ + sqlite3VdbeAddOp3(v, OP_Column, srcTab, k, iRegStore); + }else if( pSelect ){ + if( regFromSelect!=regData ){ + sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+k, iRegStore); + } + }else{ + sqlite3ExprCode(pParse, pList->a[k].pExpr, iRegStore); + } + } + + + /* Run the BEFORE and INSTEAD OF triggers, if there are any + */ + endOfLoop = sqlite3VdbeMakeLabel(pParse); + if( tmask & TRIGGER_BEFORE ){ + int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1); + + /* build the NEW.* reference row. Note that if there is an INTEGER + ** PRIMARY KEY into which a NULL is being inserted, that NULL will be + ** translated into a unique ID for the row. But on a BEFORE trigger, + ** we do not know what the unique ID will be (because the insert has + ** not happened yet) so we substitute a rowid of -1 + */ + if( ipkColumn<0 ){ + sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols); + }else{ + int addr1; + assert( !withoutRowid ); + if( useTempTable ){ + sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regCols); + }else{ + assert( pSelect==0 ); /* Otherwise useTempTable is true */ + sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols); + } + addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regCols); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp1(v, OP_MustBeInt, regCols); VdbeCoverage(v); + } + + /* Cannot have triggers on a virtual table. If it were possible, + ** this block would have to account for hidden column. + */ + assert( !IsVirtual(pTab) ); + + /* Copy the new data already generated. */ + assert( pTab->nNVCol>0 ); + sqlite3VdbeAddOp3(v, OP_Copy, regRowid+1, regCols+1, pTab->nNVCol-1); + +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + /* Compute the new value for generated columns after all other + ** columns have already been computed. This must be done after + ** computing the ROWID in case one of the generated columns + ** refers to the ROWID. */ + if( pTab->tabFlags & TF_HasGenerated ){ + testcase( pTab->tabFlags & TF_HasVirtual ); + testcase( pTab->tabFlags & TF_HasStored ); + sqlite3ComputeGeneratedColumns(pParse, regCols+1, pTab); + } +#endif + + /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger, + ** do not attempt any conversions before assembling the record. + ** If this is a real table, attempt conversions as required by the + ** table column affinities. + */ + if( !isView ){ + sqlite3TableAffinity(v, pTab, regCols+1); + } + + /* Fire BEFORE or INSTEAD OF triggers */ + sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_BEFORE, + pTab, regCols-pTab->nCol-1, onError, endOfLoop); + + sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1); + } + + if( !isView ){ + if( IsVirtual(pTab) ){ + /* The row that the VUpdate opcode will delete: none */ + sqlite3VdbeAddOp2(v, OP_Null, 0, regIns); + } + if( ipkColumn>=0 ){ + /* Compute the new rowid */ + if( useTempTable ){ + sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regRowid); + }else if( pSelect ){ + /* Rowid already initialized at tag-20191021-001 */ + }else{ + Expr *pIpk = pList->a[ipkColumn].pExpr; + if( pIpk->op==TK_NULL && !IsVirtual(pTab) ){ + sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc); + appendFlag = 1; + }else{ + sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid); + } + } + /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid + ** to generate a unique primary key value. + */ + if( !appendFlag ){ + int addr1; + if( !IsVirtual(pTab) ){ + addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc); + sqlite3VdbeJumpHere(v, addr1); + }else{ + addr1 = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp2(v, OP_IsNull, regRowid, addr1+2); VdbeCoverage(v); + } + sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid); VdbeCoverage(v); + } + }else if( IsVirtual(pTab) || withoutRowid ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, regRowid); + }else{ + sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc); + appendFlag = 1; + } + autoIncStep(pParse, regAutoinc, regRowid); + +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + /* Compute the new value for generated columns after all other + ** columns have already been computed. This must be done after + ** computing the ROWID in case one of the generated columns + ** is derived from the INTEGER PRIMARY KEY. */ + if( pTab->tabFlags & TF_HasGenerated ){ + sqlite3ComputeGeneratedColumns(pParse, regRowid+1, pTab); + } +#endif + + /* Generate code to check constraints and generate index keys and + ** do the insertion. + */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + const char *pVTab = (const char *)sqlite3GetVTable(db, pTab); + sqlite3VtabMakeWritable(pParse, pTab); + sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB); + sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError); + sqlite3MayAbort(pParse); + }else +#endif + { + int isReplace; /* Set to true if constraints may cause a replace */ + int bUseSeek; /* True to use OPFLAG_SEEKRESULT */ + sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur, + regIns, 0, ipkColumn>=0, onError, endOfLoop, &isReplace, 0, pUpsert + ); + sqlite3FkCheck(pParse, pTab, 0, regIns, 0, 0); + + /* Set the OPFLAG_USESEEKRESULT flag if either (a) there are no REPLACE + ** constraints or (b) there are no triggers and this table is not a + ** parent table in a foreign key constraint. It is safe to set the + ** flag in the second case as if any REPLACE constraint is hit, an + ** OP_Delete or OP_IdxDelete instruction will be executed on each + ** cursor that is disturbed. And these instructions both clear the + ** VdbeCursor.seekResult variable, disabling the OPFLAG_USESEEKRESULT + ** functionality. */ + bUseSeek = (isReplace==0 || !sqlite3VdbeHasSubProgram(v)); + sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur, + regIns, aRegIdx, 0, appendFlag, bUseSeek + ); + } + } + + /* Update the count of rows that are inserted + */ + if( regRowCount ){ + sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1); + } + + if( pTrigger ){ + /* Code AFTER triggers */ + sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_AFTER, + pTab, regData-2-pTab->nCol, onError, endOfLoop); + } + + /* The bottom of the main insertion loop, if the data source + ** is a SELECT statement. + */ + sqlite3VdbeResolveLabel(v, endOfLoop); + if( useTempTable ){ + sqlite3VdbeAddOp2(v, OP_Next, srcTab, addrCont); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addrInsTop); + sqlite3VdbeAddOp1(v, OP_Close, srcTab); + }else if( pSelect ){ + sqlite3VdbeGoto(v, addrCont); +#ifdef SQLITE_DEBUG + /* If we are jumping back to an OP_Yield that is preceded by an + ** OP_ReleaseReg, set the p5 flag on the OP_Goto so that the + ** OP_ReleaseReg will be included in the loop. */ + if( sqlite3VdbeGetOp(v, addrCont-1)->opcode==OP_ReleaseReg ){ + assert( sqlite3VdbeGetOp(v, addrCont)->opcode==OP_Yield ); + sqlite3VdbeChangeP5(v, 1); + } +#endif + sqlite3VdbeJumpHere(v, addrInsTop); + } + +insert_end: + /* Update the sqlite_sequence table by storing the content of the + ** maximum rowid counter values recorded while inserting into + ** autoincrement tables. + */ + if( pParse->nested==0 && pParse->pTriggerTab==0 ){ + sqlite3AutoincrementEnd(pParse); + } + + /* + ** Return the number of rows inserted. If this routine is + ** generating code because of a call to sqlite3NestedParse(), do not + ** invoke the callback function. + */ + if( regRowCount ){ + sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", SQLITE_STATIC); + } + +insert_cleanup: + sqlite3SrcListDelete(db, pTabList); + sqlite3ExprListDelete(db, pList); + sqlite3UpsertDelete(db, pUpsert); + sqlite3SelectDelete(db, pSelect); + sqlite3IdListDelete(db, pColumn); + sqlite3DbFree(db, aRegIdx); +} + +/* Make sure "isView" and other macros defined above are undefined. Otherwise +** they may interfere with compilation of other functions in this file +** (or in another file, if this file becomes part of the amalgamation). */ +#ifdef isView + #undef isView +#endif +#ifdef pTrigger + #undef pTrigger +#endif +#ifdef tmask + #undef tmask +#endif + +/* +** Meanings of bits in of pWalker->eCode for +** sqlite3ExprReferencesUpdatedColumn() +*/ +#define CKCNSTRNT_COLUMN 0x01 /* CHECK constraint uses a changing column */ +#define CKCNSTRNT_ROWID 0x02 /* CHECK constraint references the ROWID */ + +/* This is the Walker callback from sqlite3ExprReferencesUpdatedColumn(). +* Set bit 0x01 of pWalker->eCode if pWalker->eCode to 0 and if this +** expression node references any of the +** columns that are being modifed by an UPDATE statement. +*/ +static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_COLUMN ){ + assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 ); + if( pExpr->iColumn>=0 ){ + if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){ + pWalker->eCode |= CKCNSTRNT_COLUMN; + } + }else{ + pWalker->eCode |= CKCNSTRNT_ROWID; + } + } + return WRC_Continue; +} + +/* +** pExpr is a CHECK constraint on a row that is being UPDATE-ed. The +** only columns that are modified by the UPDATE are those for which +** aiChng[i]>=0, and also the ROWID is modified if chngRowid is true. +** +** Return true if CHECK constraint pExpr uses any of the +** changing columns (or the rowid if it is changing). In other words, +** return true if this CHECK constraint must be validated for +** the new row in the UPDATE statement. +** +** 2018-09-15: pExpr might also be an expression for an index-on-expressions. +** The operation of this routine is the same - return true if an only if +** the expression uses one or more of columns identified by the second and +** third arguments. +*/ +SQLITE_PRIVATE int sqlite3ExprReferencesUpdatedColumn( + Expr *pExpr, /* The expression to be checked */ + int *aiChng, /* aiChng[x]>=0 if column x changed by the UPDATE */ + int chngRowid /* True if UPDATE changes the rowid */ +){ + Walker w; + memset(&w, 0, sizeof(w)); + w.eCode = 0; + w.xExprCallback = checkConstraintExprNode; + w.u.aiCol = aiChng; + sqlite3WalkExpr(&w, pExpr); + if( !chngRowid ){ + testcase( (w.eCode & CKCNSTRNT_ROWID)!=0 ); + w.eCode &= ~CKCNSTRNT_ROWID; + } + testcase( w.eCode==0 ); + testcase( w.eCode==CKCNSTRNT_COLUMN ); + testcase( w.eCode==CKCNSTRNT_ROWID ); + testcase( w.eCode==(CKCNSTRNT_ROWID|CKCNSTRNT_COLUMN) ); + return w.eCode!=0; +} + +/* +** Generate code to do constraint checks prior to an INSERT or an UPDATE +** on table pTab. +** +** The regNewData parameter is the first register in a range that contains +** the data to be inserted or the data after the update. There will be +** pTab->nCol+1 registers in this range. The first register (the one +** that regNewData points to) will contain the new rowid, or NULL in the +** case of a WITHOUT ROWID table. The second register in the range will +** contain the content of the first table column. The third register will +** contain the content of the second table column. And so forth. +** +** The regOldData parameter is similar to regNewData except that it contains +** the data prior to an UPDATE rather than afterwards. regOldData is zero +** for an INSERT. This routine can distinguish between UPDATE and INSERT by +** checking regOldData for zero. +** +** For an UPDATE, the pkChng boolean is true if the true primary key (the +** rowid for a normal table or the PRIMARY KEY for a WITHOUT ROWID table) +** might be modified by the UPDATE. If pkChng is false, then the key of +** the iDataCur content table is guaranteed to be unchanged by the UPDATE. +** +** For an INSERT, the pkChng boolean indicates whether or not the rowid +** was explicitly specified as part of the INSERT statement. If pkChng +** is zero, it means that the either rowid is computed automatically or +** that the table is a WITHOUT ROWID table and has no rowid. On an INSERT, +** pkChng will only be true if the INSERT statement provides an integer +** value for either the rowid column or its INTEGER PRIMARY KEY alias. +** +** The code generated by this routine will store new index entries into +** registers identified by aRegIdx[]. No index entry is created for +** indices where aRegIdx[i]==0. The order of indices in aRegIdx[] is +** the same as the order of indices on the linked list of indices +** at pTab->pIndex. +** +** (2019-05-07) The generated code also creates a new record for the +** main table, if pTab is a rowid table, and stores that record in the +** register identified by aRegIdx[nIdx] - in other words in the first +** entry of aRegIdx[] past the last index. It is important that the +** record be generated during constraint checks to avoid affinity changes +** to the register content that occur after constraint checks but before +** the new record is inserted. +** +** The caller must have already opened writeable cursors on the main +** table and all applicable indices (that is to say, all indices for which +** aRegIdx[] is not zero). iDataCur is the cursor for the main table when +** inserting or updating a rowid table, or the cursor for the PRIMARY KEY +** index when operating on a WITHOUT ROWID table. iIdxCur is the cursor +** for the first index in the pTab->pIndex list. Cursors for other indices +** are at iIdxCur+N for the N-th element of the pTab->pIndex list. +** +** This routine also generates code to check constraints. NOT NULL, +** CHECK, and UNIQUE constraints are all checked. If a constraint fails, +** then the appropriate action is performed. There are five possible +** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE. +** +** Constraint type Action What Happens +** --------------- ---------- ---------------------------------------- +** any ROLLBACK The current transaction is rolled back and +** sqlite3_step() returns immediately with a +** return code of SQLITE_CONSTRAINT. +** +** any ABORT Back out changes from the current command +** only (do not do a complete rollback) then +** cause sqlite3_step() to return immediately +** with SQLITE_CONSTRAINT. +** +** any FAIL Sqlite3_step() returns immediately with a +** return code of SQLITE_CONSTRAINT. The +** transaction is not rolled back and any +** changes to prior rows are retained. +** +** any IGNORE The attempt in insert or update the current +** row is skipped, without throwing an error. +** Processing continues with the next row. +** (There is an immediate jump to ignoreDest.) +** +** NOT NULL REPLACE The NULL value is replace by the default +** value for that column. If the default value +** is NULL, the action is the same as ABORT. +** +** UNIQUE REPLACE The other row that conflicts with the row +** being inserted is removed. +** +** CHECK REPLACE Illegal. The results in an exception. +** +** Which action to take is determined by the overrideError parameter. +** Or if overrideError==OE_Default, then the pParse->onError parameter +** is used. Or if pParse->onError==OE_Default then the onError value +** for the constraint is used. +*/ +SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( + Parse *pParse, /* The parser context */ + Table *pTab, /* The table being inserted or updated */ + int *aRegIdx, /* Use register aRegIdx[i] for index i. 0 for unused */ + int iDataCur, /* Canonical data cursor (main table or PK index) */ + int iIdxCur, /* First index cursor */ + int regNewData, /* First register in a range holding values to insert */ + int regOldData, /* Previous content. 0 for INSERTs */ + u8 pkChng, /* Non-zero if the rowid or PRIMARY KEY changed */ + u8 overrideError, /* Override onError to this if not OE_Default */ + int ignoreDest, /* Jump to this label on an OE_Ignore resolution */ + int *pbMayReplace, /* OUT: Set to true if constraint may cause a replace */ + int *aiChng, /* column i is unchanged if aiChng[i]<0 */ + Upsert *pUpsert /* ON CONFLICT clauses, if any. NULL otherwise */ +){ + Vdbe *v; /* VDBE under constrution */ + Index *pIdx; /* Pointer to one of the indices */ + Index *pPk = 0; /* The PRIMARY KEY index */ + sqlite3 *db; /* Database connection */ + int i; /* loop counter */ + int ix; /* Index loop counter */ + int nCol; /* Number of columns */ + int onError; /* Conflict resolution strategy */ + int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */ + int nPkField; /* Number of fields in PRIMARY KEY. 1 for ROWID tables */ + Index *pUpIdx = 0; /* Index to which to apply the upsert */ + u8 isUpdate; /* True if this is an UPDATE operation */ + u8 bAffinityDone = 0; /* True if the OP_Affinity operation has been run */ + int upsertBypass = 0; /* Address of Goto to bypass upsert subroutine */ + int upsertJump = 0; /* Address of Goto that jumps into upsert subroutine */ + int ipkTop = 0; /* Top of the IPK uniqueness check */ + int ipkBottom = 0; /* OP_Goto at the end of the IPK uniqueness check */ + /* Variables associated with retesting uniqueness constraints after + ** replace triggers fire have run */ + int regTrigCnt; /* Register used to count replace trigger invocations */ + int addrRecheck = 0; /* Jump here to recheck all uniqueness constraints */ + int lblRecheckOk = 0; /* Each recheck jumps to this label if it passes */ + Trigger *pTrigger; /* List of DELETE triggers on the table pTab */ + int nReplaceTrig = 0; /* Number of replace triggers coded */ + + isUpdate = regOldData!=0; + db = pParse->db; + v = pParse->pVdbe; + assert( v!=0 ); + assert( pTab->pSelect==0 ); /* This table is not a VIEW */ + nCol = pTab->nCol; + + /* pPk is the PRIMARY KEY index for WITHOUT ROWID tables and NULL for + ** normal rowid tables. nPkField is the number of key fields in the + ** pPk index or 1 for a rowid table. In other words, nPkField is the + ** number of fields in the true primary key of the table. */ + if( HasRowid(pTab) ){ + pPk = 0; + nPkField = 1; + }else{ + pPk = sqlite3PrimaryKeyIndex(pTab); + nPkField = pPk->nKeyCol; + } + + /* Record that this module has started */ + VdbeModuleComment((v, "BEGIN: GenCnstCks(%d,%d,%d,%d,%d)", + iDataCur, iIdxCur, regNewData, regOldData, pkChng)); + + /* Test all NOT NULL constraints. + */ + if( pTab->tabFlags & TF_HasNotNull ){ + int b2ndPass = 0; /* True if currently running 2nd pass */ + int nSeenReplace = 0; /* Number of ON CONFLICT REPLACE operations */ + int nGenerated = 0; /* Number of generated columns with NOT NULL */ + while(1){ /* Make 2 passes over columns. Exit loop via "break" */ + for(i=0; iaCol[i]; /* The column to check for NOT NULL */ + int isGenerated; /* non-zero if column is generated */ + onError = pCol->notNull; + if( onError==OE_None ) continue; /* No NOT NULL on this column */ + if( i==pTab->iPKey ){ + continue; /* ROWID is never NULL */ + } + isGenerated = pCol->colFlags & COLFLAG_GENERATED; + if( isGenerated && !b2ndPass ){ + nGenerated++; + continue; /* Generated columns processed on 2nd pass */ + } + if( aiChng && aiChng[i]<0 && !isGenerated ){ + /* Do not check NOT NULL on columns that do not change */ + continue; + } + if( overrideError!=OE_Default ){ + onError = overrideError; + }else if( onError==OE_Default ){ + onError = OE_Abort; + } + if( onError==OE_Replace ){ + if( b2ndPass /* REPLACE becomes ABORT on the 2nd pass */ + || pCol->pDflt==0 /* REPLACE is ABORT if no DEFAULT value */ + ){ + testcase( pCol->colFlags & COLFLAG_VIRTUAL ); + testcase( pCol->colFlags & COLFLAG_STORED ); + testcase( pCol->colFlags & COLFLAG_GENERATED ); + onError = OE_Abort; + }else{ + assert( !isGenerated ); + } + }else if( b2ndPass && !isGenerated ){ + continue; + } + assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail + || onError==OE_Ignore || onError==OE_Replace ); + testcase( i!=sqlite3TableColumnToStorage(pTab, i) ); + iReg = sqlite3TableColumnToStorage(pTab, i) + regNewData + 1; + switch( onError ){ + case OE_Replace: { + int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, iReg); + VdbeCoverage(v); + assert( (pCol->colFlags & COLFLAG_GENERATED)==0 ); + nSeenReplace++; + sqlite3ExprCodeCopy(pParse, pCol->pDflt, iReg); + sqlite3VdbeJumpHere(v, addr1); + break; + } + case OE_Abort: + sqlite3MayAbort(pParse); + /* no break */ deliberate_fall_through + case OE_Rollback: + case OE_Fail: { + char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName, + pCol->zName); + sqlite3VdbeAddOp3(v, OP_HaltIfNull, SQLITE_CONSTRAINT_NOTNULL, + onError, iReg); + sqlite3VdbeAppendP4(v, zMsg, P4_DYNAMIC); + sqlite3VdbeChangeP5(v, P5_ConstraintNotNull); + VdbeCoverage(v); + break; + } + default: { + assert( onError==OE_Ignore ); + sqlite3VdbeAddOp2(v, OP_IsNull, iReg, ignoreDest); + VdbeCoverage(v); + break; + } + } /* end switch(onError) */ + } /* end loop i over columns */ + if( nGenerated==0 && nSeenReplace==0 ){ + /* If there are no generated columns with NOT NULL constraints + ** and no NOT NULL ON CONFLICT REPLACE constraints, then a single + ** pass is sufficient */ + break; + } + if( b2ndPass ) break; /* Never need more than 2 passes */ + b2ndPass = 1; +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( nSeenReplace>0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){ + /* If any NOT NULL ON CONFLICT REPLACE constraints fired on the + ** first pass, recomputed values for all generated columns, as + ** those values might depend on columns affected by the REPLACE. + */ + sqlite3ComputeGeneratedColumns(pParse, regNewData+1, pTab); + } +#endif + } /* end of 2-pass loop */ + } /* end if( has-not-null-constraints ) */ + + /* Test all CHECK constraints + */ +#ifndef SQLITE_OMIT_CHECK + if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){ + ExprList *pCheck = pTab->pCheck; + pParse->iSelfTab = -(regNewData+1); + onError = overrideError!=OE_Default ? overrideError : OE_Abort; + for(i=0; inExpr; i++){ + int allOk; + Expr *pCopy; + Expr *pExpr = pCheck->a[i].pExpr; + if( aiChng + && !sqlite3ExprReferencesUpdatedColumn(pExpr, aiChng, pkChng) + ){ + /* The check constraints do not reference any of the columns being + ** updated so there is no point it verifying the check constraint */ + continue; + } + if( bAffinityDone==0 ){ + sqlite3TableAffinity(v, pTab, regNewData+1); + bAffinityDone = 1; + } + allOk = sqlite3VdbeMakeLabel(pParse); + sqlite3VdbeVerifyAbortable(v, onError); + pCopy = sqlite3ExprDup(db, pExpr, 0); + if( !db->mallocFailed ){ + sqlite3ExprIfTrue(pParse, pCopy, allOk, SQLITE_JUMPIFNULL); + } + sqlite3ExprDelete(db, pCopy); + if( onError==OE_Ignore ){ + sqlite3VdbeGoto(v, ignoreDest); + }else{ + char *zName = pCheck->a[i].zEName; + assert( zName!=0 || pParse->db->mallocFailed ); + if( onError==OE_Replace ) onError = OE_Abort; /* IMP: R-26383-51744 */ + sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_CHECK, + onError, zName, P4_TRANSIENT, + P5_ConstraintCheck); + } + sqlite3VdbeResolveLabel(v, allOk); + } + pParse->iSelfTab = 0; + } +#endif /* !defined(SQLITE_OMIT_CHECK) */ + + /* UNIQUE and PRIMARY KEY constraints should be handled in the following + ** order: + ** + ** (1) OE_Update + ** (2) OE_Abort, OE_Fail, OE_Rollback, OE_Ignore + ** (3) OE_Replace + ** + ** OE_Fail and OE_Ignore must happen before any changes are made. + ** OE_Update guarantees that only a single row will change, so it + ** must happen before OE_Replace. Technically, OE_Abort and OE_Rollback + ** could happen in any order, but they are grouped up front for + ** convenience. + ** + ** 2018-08-14: Ticket https://www.sqlite.org/src/info/908f001483982c43 + ** The order of constraints used to have OE_Update as (2) and OE_Abort + ** and so forth as (1). But apparently PostgreSQL checks the OE_Update + ** constraint before any others, so it had to be moved. + ** + ** Constraint checking code is generated in this order: + ** (A) The rowid constraint + ** (B) Unique index constraints that do not have OE_Replace as their + ** default conflict resolution strategy + ** (C) Unique index that do use OE_Replace by default. + ** + ** The ordering of (2) and (3) is accomplished by making sure the linked + ** list of indexes attached to a table puts all OE_Replace indexes last + ** in the list. See sqlite3CreateIndex() for where that happens. + */ + + if( pUpsert ){ + if( pUpsert->pUpsertTarget==0 ){ + /* An ON CONFLICT DO NOTHING clause, without a constraint-target. + ** Make all unique constraint resolution be OE_Ignore */ + assert( pUpsert->pUpsertSet==0 ); + overrideError = OE_Ignore; + pUpsert = 0; + }else if( (pUpIdx = pUpsert->pUpsertIdx)!=0 ){ + /* If the constraint-target uniqueness check must be run first. + ** Jump to that uniqueness check now */ + upsertJump = sqlite3VdbeAddOp0(v, OP_Goto); + VdbeComment((v, "UPSERT constraint goes first")); + } + } + + /* Determine if it is possible that triggers (either explicitly coded + ** triggers or FK resolution actions) might run as a result of deletes + ** that happen when OE_Replace conflict resolution occurs. (Call these + ** "replace triggers".) If any replace triggers run, we will need to + ** recheck all of the uniqueness constraints after they have all run. + ** But on the recheck, the resolution is OE_Abort instead of OE_Replace. + ** + ** If replace triggers are a possibility, then + ** + ** (1) Allocate register regTrigCnt and initialize it to zero. + ** That register will count the number of replace triggers that + ** fire. Constraint recheck only occurs if the number is positive. + ** (2) Initialize pTrigger to the list of all DELETE triggers on pTab. + ** (3) Initialize addrRecheck and lblRecheckOk + ** + ** The uniqueness rechecking code will create a series of tests to run + ** in a second pass. The addrRecheck and lblRecheckOk variables are + ** used to link together these tests which are separated from each other + ** in the generate bytecode. + */ + if( (db->flags & (SQLITE_RecTriggers|SQLITE_ForeignKeys))==0 ){ + /* There are not DELETE triggers nor FK constraints. No constraint + ** rechecks are needed. */ + pTrigger = 0; + regTrigCnt = 0; + }else{ + if( db->flags&SQLITE_RecTriggers ){ + pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0); + regTrigCnt = pTrigger!=0 || sqlite3FkRequired(pParse, pTab, 0, 0); + }else{ + pTrigger = 0; + regTrigCnt = sqlite3FkRequired(pParse, pTab, 0, 0); + } + if( regTrigCnt ){ + /* Replace triggers might exist. Allocate the counter and + ** initialize it to zero. */ + regTrigCnt = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regTrigCnt); + VdbeComment((v, "trigger count")); + lblRecheckOk = sqlite3VdbeMakeLabel(pParse); + addrRecheck = lblRecheckOk; + } + } + + /* If rowid is changing, make sure the new rowid does not previously + ** exist in the table. + */ + if( pkChng && pPk==0 ){ + int addrRowidOk = sqlite3VdbeMakeLabel(pParse); + + /* Figure out what action to take in case of a rowid collision */ + onError = pTab->keyConf; + if( overrideError!=OE_Default ){ + onError = overrideError; + }else if( onError==OE_Default ){ + onError = OE_Abort; + } + + /* figure out whether or not upsert applies in this case */ + if( pUpsert && pUpsert->pUpsertIdx==0 ){ + if( pUpsert->pUpsertSet==0 ){ + onError = OE_Ignore; /* DO NOTHING is the same as INSERT OR IGNORE */ + }else{ + onError = OE_Update; /* DO UPDATE */ + } + } + + /* If the response to a rowid conflict is REPLACE but the response + ** to some other UNIQUE constraint is FAIL or IGNORE, then we need + ** to defer the running of the rowid conflict checking until after + ** the UNIQUE constraints have run. + */ + if( onError==OE_Replace /* IPK rule is REPLACE */ + && onError!=overrideError /* Rules for other contraints are different */ + && pTab->pIndex /* There exist other constraints */ + ){ + ipkTop = sqlite3VdbeAddOp0(v, OP_Goto)+1; + VdbeComment((v, "defer IPK REPLACE until last")); + } + + if( isUpdate ){ + /* pkChng!=0 does not mean that the rowid has changed, only that + ** it might have changed. Skip the conflict logic below if the rowid + ** is unchanged. */ + sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRowidOk, regOldData); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + VdbeCoverage(v); + } + + /* Check to see if the new rowid already exists in the table. Skip + ** the following conflict logic if it does not. */ + VdbeNoopComment((v, "uniqueness check for ROWID")); + sqlite3VdbeVerifyAbortable(v, onError); + sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRowidOk, regNewData); + VdbeCoverage(v); + + switch( onError ){ + default: { + onError = OE_Abort; + /* no break */ deliberate_fall_through + } + case OE_Rollback: + case OE_Abort: + case OE_Fail: { + testcase( onError==OE_Rollback ); + testcase( onError==OE_Abort ); + testcase( onError==OE_Fail ); + sqlite3RowidConstraint(pParse, onError, pTab); + break; + } + case OE_Replace: { + /* If there are DELETE triggers on this table and the + ** recursive-triggers flag is set, call GenerateRowDelete() to + ** remove the conflicting row from the table. This will fire + ** the triggers and remove both the table and index b-tree entries. + ** + ** Otherwise, if there are no triggers or the recursive-triggers + ** flag is not set, but the table has one or more indexes, call + ** GenerateRowIndexDelete(). This removes the index b-tree entries + ** only. The table b-tree entry will be replaced by the new entry + ** when it is inserted. + ** + ** If either GenerateRowDelete() or GenerateRowIndexDelete() is called, + ** also invoke MultiWrite() to indicate that this VDBE may require + ** statement rollback (if the statement is aborted after the delete + ** takes place). Earlier versions called sqlite3MultiWrite() regardless, + ** but being more selective here allows statements like: + ** + ** REPLACE INTO t(rowid) VALUES($newrowid) + ** + ** to run without a statement journal if there are no indexes on the + ** table. + */ + if( regTrigCnt ){ + sqlite3MultiWrite(pParse); + sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur, + regNewData, 1, 0, OE_Replace, 1, -1); + sqlite3VdbeAddOp2(v, OP_AddImm, regTrigCnt, 1); /* incr trigger cnt */ + nReplaceTrig++; + }else{ +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + assert( HasRowid(pTab) ); + /* This OP_Delete opcode fires the pre-update-hook only. It does + ** not modify the b-tree. It is more efficient to let the coming + ** OP_Insert replace the existing entry than it is to delete the + ** existing entry and then insert a new one. */ + sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, OPFLAG_ISNOOP); + sqlite3VdbeAppendP4(v, pTab, P4_TABLE); +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + if( pTab->pIndex ){ + sqlite3MultiWrite(pParse); + sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,-1); + } + } + seenReplace = 1; + break; + } +#ifndef SQLITE_OMIT_UPSERT + case OE_Update: { + sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, 0, iDataCur); + /* no break */ deliberate_fall_through + } +#endif + case OE_Ignore: { + testcase( onError==OE_Ignore ); + sqlite3VdbeGoto(v, ignoreDest); + break; + } + } + sqlite3VdbeResolveLabel(v, addrRowidOk); + if( ipkTop ){ + ipkBottom = sqlite3VdbeAddOp0(v, OP_Goto); + sqlite3VdbeJumpHere(v, ipkTop-1); + } + } + + /* Test all UNIQUE constraints by creating entries for each UNIQUE + ** index and making sure that duplicate entries do not already exist. + ** Compute the revised record entries for indices as we go. + ** + ** This loop also handles the case of the PRIMARY KEY index for a + ** WITHOUT ROWID table. + */ + for(ix=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, ix++){ + int regIdx; /* Range of registers hold conent for pIdx */ + int regR; /* Range of registers holding conflicting PK */ + int iThisCur; /* Cursor for this UNIQUE index */ + int addrUniqueOk; /* Jump here if the UNIQUE constraint is satisfied */ + int addrConflictCk; /* First opcode in the conflict check logic */ + + if( aRegIdx[ix]==0 ) continue; /* Skip indices that do not change */ + if( pUpIdx==pIdx ){ + addrUniqueOk = upsertJump+1; + upsertBypass = sqlite3VdbeGoto(v, 0); + VdbeComment((v, "Skip upsert subroutine")); + sqlite3VdbeJumpHere(v, upsertJump); + }else{ + addrUniqueOk = sqlite3VdbeMakeLabel(pParse); + } + if( bAffinityDone==0 && (pUpIdx==0 || pUpIdx==pIdx) ){ + sqlite3TableAffinity(v, pTab, regNewData+1); + bAffinityDone = 1; + } + VdbeNoopComment((v, "prep index %s", pIdx->zName)); + iThisCur = iIdxCur+ix; + + + /* Skip partial indices for which the WHERE clause is not true */ + if( pIdx->pPartIdxWhere ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, aRegIdx[ix]); + pParse->iSelfTab = -(regNewData+1); + sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, addrUniqueOk, + SQLITE_JUMPIFNULL); + pParse->iSelfTab = 0; + } + + /* Create a record for this index entry as it should appear after + ** the insert or update. Store that record in the aRegIdx[ix] register + */ + regIdx = aRegIdx[ix]+1; + for(i=0; inColumn; i++){ + int iField = pIdx->aiColumn[i]; + int x; + if( iField==XN_EXPR ){ + pParse->iSelfTab = -(regNewData+1); + sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i); + pParse->iSelfTab = 0; + VdbeComment((v, "%s column %d", pIdx->zName, i)); + }else if( iField==XN_ROWID || iField==pTab->iPKey ){ + x = regNewData; + sqlite3VdbeAddOp2(v, OP_IntCopy, x, regIdx+i); + VdbeComment((v, "rowid")); + }else{ + testcase( sqlite3TableColumnToStorage(pTab, iField)!=iField ); + x = sqlite3TableColumnToStorage(pTab, iField) + regNewData + 1; + sqlite3VdbeAddOp2(v, OP_SCopy, x, regIdx+i); + VdbeComment((v, "%s", pTab->aCol[iField].zName)); + } + } + sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]); + VdbeComment((v, "for %s", pIdx->zName)); +#ifdef SQLITE_ENABLE_NULL_TRIM + if( pIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){ + sqlite3SetMakeRecordP5(v, pIdx->pTable); + } +#endif + sqlite3VdbeReleaseRegisters(pParse, regIdx, pIdx->nColumn, 0, 0); + + /* In an UPDATE operation, if this index is the PRIMARY KEY index + ** of a WITHOUT ROWID table and there has been no change the + ** primary key, then no collision is possible. The collision detection + ** logic below can all be skipped. */ + if( isUpdate && pPk==pIdx && pkChng==0 ){ + sqlite3VdbeResolveLabel(v, addrUniqueOk); + continue; + } + + /* Find out what action to take in case there is a uniqueness conflict */ + onError = pIdx->onError; + if( onError==OE_None ){ + sqlite3VdbeResolveLabel(v, addrUniqueOk); + continue; /* pIdx is not a UNIQUE index */ + } + if( overrideError!=OE_Default ){ + onError = overrideError; + }else if( onError==OE_Default ){ + onError = OE_Abort; + } + + /* Figure out if the upsert clause applies to this index */ + if( pUpIdx==pIdx ){ + if( pUpsert->pUpsertSet==0 ){ + onError = OE_Ignore; /* DO NOTHING is the same as INSERT OR IGNORE */ + }else{ + onError = OE_Update; /* DO UPDATE */ + } + } + + /* Collision detection may be omitted if all of the following are true: + ** (1) The conflict resolution algorithm is REPLACE + ** (2) The table is a WITHOUT ROWID table + ** (3) There are no secondary indexes on the table + ** (4) No delete triggers need to be fired if there is a conflict + ** (5) No FK constraint counters need to be updated if a conflict occurs. + ** + ** This is not possible for ENABLE_PREUPDATE_HOOK builds, as the row + ** must be explicitly deleted in order to ensure any pre-update hook + ** is invoked. */ +#ifndef SQLITE_ENABLE_PREUPDATE_HOOK + if( (ix==0 && pIdx->pNext==0) /* Condition 3 */ + && pPk==pIdx /* Condition 2 */ + && onError==OE_Replace /* Condition 1 */ + && ( 0==(db->flags&SQLITE_RecTriggers) || /* Condition 4 */ + 0==sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0)) + && ( 0==(db->flags&SQLITE_ForeignKeys) || /* Condition 5 */ + (0==pTab->pFKey && 0==sqlite3FkReferences(pTab))) + ){ + sqlite3VdbeResolveLabel(v, addrUniqueOk); + continue; + } +#endif /* ifndef SQLITE_ENABLE_PREUPDATE_HOOK */ + + /* Check to see if the new index entry will be unique */ + sqlite3VdbeVerifyAbortable(v, onError); + addrConflictCk = + sqlite3VdbeAddOp4Int(v, OP_NoConflict, iThisCur, addrUniqueOk, + regIdx, pIdx->nKeyCol); VdbeCoverage(v); + + /* Generate code to handle collisions */ + regR = (pIdx==pPk) ? regIdx : sqlite3GetTempRange(pParse, nPkField); + if( isUpdate || onError==OE_Replace ){ + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp2(v, OP_IdxRowid, iThisCur, regR); + /* Conflict only if the rowid of the existing index entry + ** is different from old-rowid */ + if( isUpdate ){ + sqlite3VdbeAddOp3(v, OP_Eq, regR, addrUniqueOk, regOldData); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + VdbeCoverage(v); + } + }else{ + int x; + /* Extract the PRIMARY KEY from the end of the index entry and + ** store it in registers regR..regR+nPk-1 */ + if( pIdx!=pPk ){ + for(i=0; inKeyCol; i++){ + assert( pPk->aiColumn[i]>=0 ); + x = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]); + sqlite3VdbeAddOp3(v, OP_Column, iThisCur, x, regR+i); + VdbeComment((v, "%s.%s", pTab->zName, + pTab->aCol[pPk->aiColumn[i]].zName)); + } + } + if( isUpdate ){ + /* If currently processing the PRIMARY KEY of a WITHOUT ROWID + ** table, only conflict if the new PRIMARY KEY values are actually + ** different from the old. + ** + ** For a UNIQUE index, only conflict if the PRIMARY KEY values + ** of the matched index row are different from the original PRIMARY + ** KEY values of this row before the update. */ + int addrJump = sqlite3VdbeCurrentAddr(v)+pPk->nKeyCol; + int op = OP_Ne; + int regCmp = (IsPrimaryKeyIndex(pIdx) ? regIdx : regR); + + for(i=0; inKeyCol; i++){ + char *p4 = (char*)sqlite3LocateCollSeq(pParse, pPk->azColl[i]); + x = pPk->aiColumn[i]; + assert( x>=0 ); + if( i==(pPk->nKeyCol-1) ){ + addrJump = addrUniqueOk; + op = OP_Eq; + } + x = sqlite3TableColumnToStorage(pTab, x); + sqlite3VdbeAddOp4(v, op, + regOldData+1+x, addrJump, regCmp+i, p4, P4_COLLSEQ + ); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + VdbeCoverageIf(v, op==OP_Eq); + VdbeCoverageIf(v, op==OP_Ne); + } + } + } + } + + /* Generate code that executes if the new index entry is not unique */ + assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail + || onError==OE_Ignore || onError==OE_Replace || onError==OE_Update ); + switch( onError ){ + case OE_Rollback: + case OE_Abort: + case OE_Fail: { + testcase( onError==OE_Rollback ); + testcase( onError==OE_Abort ); + testcase( onError==OE_Fail ); + sqlite3UniqueConstraint(pParse, onError, pIdx); + break; + } +#ifndef SQLITE_OMIT_UPSERT + case OE_Update: { + sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, pIdx, iIdxCur+ix); + /* no break */ deliberate_fall_through + } +#endif + case OE_Ignore: { + testcase( onError==OE_Ignore ); + sqlite3VdbeGoto(v, ignoreDest); + break; + } + default: { + int nConflictCk; /* Number of opcodes in conflict check logic */ + + assert( onError==OE_Replace ); + nConflictCk = sqlite3VdbeCurrentAddr(v) - addrConflictCk; + assert( nConflictCk>0 ); + testcase( nConflictCk>1 ); + if( regTrigCnt ){ + sqlite3MultiWrite(pParse); + nReplaceTrig++; + } + if( pTrigger && isUpdate ){ + sqlite3VdbeAddOp1(v, OP_CursorLock, iDataCur); + } + sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur, + regR, nPkField, 0, OE_Replace, + (pIdx==pPk ? ONEPASS_SINGLE : ONEPASS_OFF), iThisCur); + if( pTrigger && isUpdate ){ + sqlite3VdbeAddOp1(v, OP_CursorUnlock, iDataCur); + } + if( regTrigCnt ){ + int addrBypass; /* Jump destination to bypass recheck logic */ + + sqlite3VdbeAddOp2(v, OP_AddImm, regTrigCnt, 1); /* incr trigger cnt */ + addrBypass = sqlite3VdbeAddOp0(v, OP_Goto); /* Bypass recheck */ + VdbeComment((v, "bypass recheck")); + + /* Here we insert code that will be invoked after all constraint + ** checks have run, if and only if one or more replace triggers + ** fired. */ + sqlite3VdbeResolveLabel(v, lblRecheckOk); + lblRecheckOk = sqlite3VdbeMakeLabel(pParse); + if( pIdx->pPartIdxWhere ){ + /* Bypass the recheck if this partial index is not defined + ** for the current row */ + sqlite3VdbeAddOp2(v, OP_IsNull, regIdx-1, lblRecheckOk); + VdbeCoverage(v); + } + /* Copy the constraint check code from above, except change + ** the constraint-ok jump destination to be the address of + ** the next retest block */ + while( nConflictCk>0 ){ + VdbeOp x; /* Conflict check opcode to copy */ + /* The sqlite3VdbeAddOp4() call might reallocate the opcode array. + ** Hence, make a complete copy of the opcode, rather than using + ** a pointer to the opcode. */ + x = *sqlite3VdbeGetOp(v, addrConflictCk); + if( x.opcode!=OP_IdxRowid ){ + int p2; /* New P2 value for copied conflict check opcode */ + const char *zP4; + if( sqlite3OpcodeProperty[x.opcode]&OPFLG_JUMP ){ + p2 = lblRecheckOk; + }else{ + p2 = x.p2; + } + zP4 = x.p4type==P4_INT32 ? SQLITE_INT_TO_PTR(x.p4.i) : x.p4.z; + sqlite3VdbeAddOp4(v, x.opcode, x.p1, p2, x.p3, zP4, x.p4type); + sqlite3VdbeChangeP5(v, x.p5); + VdbeCoverageIf(v, p2!=x.p2); + } + nConflictCk--; + addrConflictCk++; + } + /* If the retest fails, issue an abort */ + sqlite3UniqueConstraint(pParse, OE_Abort, pIdx); + + sqlite3VdbeJumpHere(v, addrBypass); /* Terminate the recheck bypass */ + } + seenReplace = 1; + break; + } + } + if( pUpIdx==pIdx ){ + sqlite3VdbeGoto(v, upsertJump+1); + sqlite3VdbeJumpHere(v, upsertBypass); + }else{ + sqlite3VdbeResolveLabel(v, addrUniqueOk); + } + if( regR!=regIdx ) sqlite3ReleaseTempRange(pParse, regR, nPkField); + } + + /* If the IPK constraint is a REPLACE, run it last */ + if( ipkTop ){ + sqlite3VdbeGoto(v, ipkTop); + VdbeComment((v, "Do IPK REPLACE")); + sqlite3VdbeJumpHere(v, ipkBottom); + } + + /* Recheck all uniqueness constraints after replace triggers have run */ + testcase( regTrigCnt!=0 && nReplaceTrig==0 ); + assert( regTrigCnt!=0 || nReplaceTrig==0 ); + if( nReplaceTrig ){ + sqlite3VdbeAddOp2(v, OP_IfNot, regTrigCnt, lblRecheckOk);VdbeCoverage(v); + if( !pPk ){ + if( isUpdate ){ + sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRecheck, regOldData); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + VdbeCoverage(v); + } + sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRecheck, regNewData); + VdbeCoverage(v); + sqlite3RowidConstraint(pParse, OE_Abort, pTab); + }else{ + sqlite3VdbeGoto(v, addrRecheck); + } + sqlite3VdbeResolveLabel(v, lblRecheckOk); + } + + /* Generate the table record */ + if( HasRowid(pTab) ){ + int regRec = aRegIdx[ix]; + sqlite3VdbeAddOp3(v, OP_MakeRecord, regNewData+1, pTab->nNVCol, regRec); + sqlite3SetMakeRecordP5(v, pTab); + if( !bAffinityDone ){ + sqlite3TableAffinity(v, pTab, 0); + } + } + + *pbMayReplace = seenReplace; + VdbeModuleComment((v, "END: GenCnstCks(%d)", seenReplace)); +} + +#ifdef SQLITE_ENABLE_NULL_TRIM +/* +** Change the P5 operand on the last opcode (which should be an OP_MakeRecord) +** to be the number of columns in table pTab that must not be NULL-trimmed. +** +** Or if no columns of pTab may be NULL-trimmed, leave P5 at zero. +*/ +SQLITE_PRIVATE void sqlite3SetMakeRecordP5(Vdbe *v, Table *pTab){ + u16 i; + + /* Records with omitted columns are only allowed for schema format + ** version 2 and later (SQLite version 3.1.4, 2005-02-20). */ + if( pTab->pSchema->file_format<2 ) return; + + for(i=pTab->nCol-1; i>0; i--){ + if( pTab->aCol[i].pDflt!=0 ) break; + if( pTab->aCol[i].colFlags & COLFLAG_PRIMKEY ) break; + } + sqlite3VdbeChangeP5(v, i+1); +} +#endif + +/* +** This routine generates code to finish the INSERT or UPDATE operation +** that was started by a prior call to sqlite3GenerateConstraintChecks. +** A consecutive range of registers starting at regNewData contains the +** rowid and the content to be inserted. +** +** The arguments to this routine should be the same as the first six +** arguments to sqlite3GenerateConstraintChecks. +*/ +SQLITE_PRIVATE void sqlite3CompleteInsertion( + Parse *pParse, /* The parser context */ + Table *pTab, /* the table into which we are inserting */ + int iDataCur, /* Cursor of the canonical data source */ + int iIdxCur, /* First index cursor */ + int regNewData, /* Range of content */ + int *aRegIdx, /* Register used by each index. 0 for unused indices */ + int update_flags, /* True for UPDATE, False for INSERT */ + int appendBias, /* True if this is likely to be an append */ + int useSeekResult /* True to set the USESEEKRESULT flag on OP_[Idx]Insert */ +){ + Vdbe *v; /* Prepared statements under construction */ + Index *pIdx; /* An index being inserted or updated */ + u8 pik_flags; /* flag values passed to the btree insert */ + int i; /* Loop counter */ + + assert( update_flags==0 + || update_flags==OPFLAG_ISUPDATE + || update_flags==(OPFLAG_ISUPDATE|OPFLAG_SAVEPOSITION) + ); + + v = pParse->pVdbe; + assert( v!=0 ); + assert( pTab->pSelect==0 ); /* This table is not a VIEW */ + for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ + /* All REPLACE indexes are at the end of the list */ + assert( pIdx->onError!=OE_Replace + || pIdx->pNext==0 + || pIdx->pNext->onError==OE_Replace ); + if( aRegIdx[i]==0 ) continue; + if( pIdx->pPartIdxWhere ){ + sqlite3VdbeAddOp2(v, OP_IsNull, aRegIdx[i], sqlite3VdbeCurrentAddr(v)+2); + VdbeCoverage(v); + } + pik_flags = (useSeekResult ? OPFLAG_USESEEKRESULT : 0); + if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){ + assert( pParse->nested==0 ); + pik_flags |= OPFLAG_NCHANGE; + pik_flags |= (update_flags & OPFLAG_SAVEPOSITION); +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + if( update_flags==0 ){ + int r = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp2(v, OP_Integer, 0, r); + sqlite3VdbeAddOp4(v, OP_Insert, + iIdxCur+i, aRegIdx[i], r, (char*)pTab, P4_TABLE + ); + sqlite3VdbeChangeP5(v, OPFLAG_ISNOOP); + sqlite3ReleaseTempReg(pParse, r); + } +#endif + } + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iIdxCur+i, aRegIdx[i], + aRegIdx[i]+1, + pIdx->uniqNotNull ? pIdx->nKeyCol: pIdx->nColumn); + sqlite3VdbeChangeP5(v, pik_flags); + } + if( !HasRowid(pTab) ) return; + if( pParse->nested ){ + pik_flags = 0; + }else{ + pik_flags = OPFLAG_NCHANGE; + pik_flags |= (update_flags?update_flags:OPFLAG_LASTROWID); + } + if( appendBias ){ + pik_flags |= OPFLAG_APPEND; + } + if( useSeekResult ){ + pik_flags |= OPFLAG_USESEEKRESULT; + } + sqlite3VdbeAddOp3(v, OP_Insert, iDataCur, aRegIdx[i], regNewData); + if( !pParse->nested ){ + sqlite3VdbeAppendP4(v, pTab, P4_TABLE); + } + sqlite3VdbeChangeP5(v, pik_flags); +} + +/* +** Allocate cursors for the pTab table and all its indices and generate +** code to open and initialized those cursors. +** +** The cursor for the object that contains the complete data (normally +** the table itself, but the PRIMARY KEY index in the case of a WITHOUT +** ROWID table) is returned in *piDataCur. The first index cursor is +** returned in *piIdxCur. The number of indices is returned. +** +** Use iBase as the first cursor (either the *piDataCur for rowid tables +** or the first index for WITHOUT ROWID tables) if it is non-negative. +** If iBase is negative, then allocate the next available cursor. +** +** For a rowid table, *piDataCur will be exactly one less than *piIdxCur. +** For a WITHOUT ROWID table, *piDataCur will be somewhere in the range +** of *piIdxCurs, depending on where the PRIMARY KEY index appears on the +** pTab->pIndex list. +** +** If pTab is a virtual table, then this routine is a no-op and the +** *piDataCur and *piIdxCur values are left uninitialized. +*/ +SQLITE_PRIVATE int sqlite3OpenTableAndIndices( + Parse *pParse, /* Parsing context */ + Table *pTab, /* Table to be opened */ + int op, /* OP_OpenRead or OP_OpenWrite */ + u8 p5, /* P5 value for OP_Open* opcodes (except on WITHOUT ROWID) */ + int iBase, /* Use this for the table cursor, if there is one */ + u8 *aToOpen, /* If not NULL: boolean for each table and index */ + int *piDataCur, /* Write the database source cursor number here */ + int *piIdxCur /* Write the first index cursor number here */ +){ + int i; + int iDb; + int iDataCur; + Index *pIdx; + Vdbe *v; + + assert( op==OP_OpenRead || op==OP_OpenWrite ); + assert( op==OP_OpenWrite || p5==0 ); + if( IsVirtual(pTab) ){ + /* This routine is a no-op for virtual tables. Leave the output + ** variables *piDataCur and *piIdxCur uninitialized so that valgrind + ** can detect if they are used by mistake in the caller. */ + return 0; + } + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + v = pParse->pVdbe; + assert( v!=0 ); + if( iBase<0 ) iBase = pParse->nTab; + iDataCur = iBase++; + if( piDataCur ) *piDataCur = iDataCur; + if( HasRowid(pTab) && (aToOpen==0 || aToOpen[0]) ){ + sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op); + }else{ + sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName); + } + if( piIdxCur ) *piIdxCur = iBase; + for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ + int iIdxCur = iBase++; + assert( pIdx->pSchema==pTab->pSchema ); + if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){ + if( piDataCur ) *piDataCur = iIdxCur; + p5 = 0; + } + if( aToOpen==0 || aToOpen[i+1] ){ + sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + sqlite3VdbeChangeP5(v, p5); + VdbeComment((v, "%s", pIdx->zName)); + } + } + if( iBase>pParse->nTab ) pParse->nTab = iBase; + return i; +} + + +#ifdef SQLITE_TEST +/* +** The following global variable is incremented whenever the +** transfer optimization is used. This is used for testing +** purposes only - to make sure the transfer optimization really +** is happening when it is supposed to. +*/ +SQLITE_API int sqlite3_xferopt_count; +#endif /* SQLITE_TEST */ + + +#ifndef SQLITE_OMIT_XFER_OPT +/* +** Check to see if index pSrc is compatible as a source of data +** for index pDest in an insert transfer optimization. The rules +** for a compatible index: +** +** * The index is over the same set of columns +** * The same DESC and ASC markings occurs on all columns +** * The same onError processing (OE_Abort, OE_Ignore, etc) +** * The same collating sequence on each column +** * The index has the exact same WHERE clause +*/ +static int xferCompatibleIndex(Index *pDest, Index *pSrc){ + int i; + assert( pDest && pSrc ); + assert( pDest->pTable!=pSrc->pTable ); + if( pDest->nKeyCol!=pSrc->nKeyCol || pDest->nColumn!=pSrc->nColumn ){ + return 0; /* Different number of columns */ + } + if( pDest->onError!=pSrc->onError ){ + return 0; /* Different conflict resolution strategies */ + } + for(i=0; inKeyCol; i++){ + if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){ + return 0; /* Different columns indexed */ + } + if( pSrc->aiColumn[i]==XN_EXPR ){ + assert( pSrc->aColExpr!=0 && pDest->aColExpr!=0 ); + if( sqlite3ExprCompare(0, pSrc->aColExpr->a[i].pExpr, + pDest->aColExpr->a[i].pExpr, -1)!=0 ){ + return 0; /* Different expressions in the index */ + } + } + if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){ + return 0; /* Different sort orders */ + } + if( sqlite3_stricmp(pSrc->azColl[i],pDest->azColl[i])!=0 ){ + return 0; /* Different collating sequences */ + } + } + if( sqlite3ExprCompare(0, pSrc->pPartIdxWhere, pDest->pPartIdxWhere, -1) ){ + return 0; /* Different WHERE clauses */ + } + + /* If no test above fails then the indices must be compatible */ + return 1; +} + +/* +** Attempt the transfer optimization on INSERTs of the form +** +** INSERT INTO tab1 SELECT * FROM tab2; +** +** The xfer optimization transfers raw records from tab2 over to tab1. +** Columns are not decoded and reassembled, which greatly improves +** performance. Raw index records are transferred in the same way. +** +** The xfer optimization is only attempted if tab1 and tab2 are compatible. +** There are lots of rules for determining compatibility - see comments +** embedded in the code for details. +** +** This routine returns TRUE if the optimization is guaranteed to be used. +** Sometimes the xfer optimization will only work if the destination table +** is empty - a factor that can only be determined at run-time. In that +** case, this routine generates code for the xfer optimization but also +** does a test to see if the destination table is empty and jumps over the +** xfer optimization code if the test fails. In that case, this routine +** returns FALSE so that the caller will know to go ahead and generate +** an unoptimized transfer. This routine also returns FALSE if there +** is no chance that the xfer optimization can be applied. +** +** This optimization is particularly useful at making VACUUM run faster. +*/ +static int xferOptimization( + Parse *pParse, /* Parser context */ + Table *pDest, /* The table we are inserting into */ + Select *pSelect, /* A SELECT statement to use as the data source */ + int onError, /* How to handle constraint errors */ + int iDbDest /* The database of pDest */ +){ + sqlite3 *db = pParse->db; + ExprList *pEList; /* The result set of the SELECT */ + Table *pSrc; /* The table in the FROM clause of SELECT */ + Index *pSrcIdx, *pDestIdx; /* Source and destination indices */ + struct SrcList_item *pItem; /* An element of pSelect->pSrc */ + int i; /* Loop counter */ + int iDbSrc; /* The database of pSrc */ + int iSrc, iDest; /* Cursors from source and destination */ + int addr1, addr2; /* Loop addresses */ + int emptyDestTest = 0; /* Address of test for empty pDest */ + int emptySrcTest = 0; /* Address of test for empty pSrc */ + Vdbe *v; /* The VDBE we are building */ + int regAutoinc; /* Memory register used by AUTOINC */ + int destHasUniqueIdx = 0; /* True if pDest has a UNIQUE index */ + int regData, regRowid; /* Registers holding data and rowid */ + + if( pSelect==0 ){ + return 0; /* Must be of the form INSERT INTO ... SELECT ... */ + } + if( pParse->pWith || pSelect->pWith ){ + /* Do not attempt to process this query if there are an WITH clauses + ** attached to it. Proceeding may generate a false "no such table: xxx" + ** error if pSelect reads from a CTE named "xxx". */ + return 0; + } + if( sqlite3TriggerList(pParse, pDest) ){ + return 0; /* tab1 must not have triggers */ + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pDest) ){ + return 0; /* tab1 must not be a virtual table */ + } +#endif + if( onError==OE_Default ){ + if( pDest->iPKey>=0 ) onError = pDest->keyConf; + if( onError==OE_Default ) onError = OE_Abort; + } + assert(pSelect->pSrc); /* allocated even if there is no FROM clause */ + if( pSelect->pSrc->nSrc!=1 ){ + return 0; /* FROM clause must have exactly one term */ + } + if( pSelect->pSrc->a[0].pSelect ){ + return 0; /* FROM clause cannot contain a subquery */ + } + if( pSelect->pWhere ){ + return 0; /* SELECT may not have a WHERE clause */ + } + if( pSelect->pOrderBy ){ + return 0; /* SELECT may not have an ORDER BY clause */ + } + /* Do not need to test for a HAVING clause. If HAVING is present but + ** there is no ORDER BY, we will get an error. */ + if( pSelect->pGroupBy ){ + return 0; /* SELECT may not have a GROUP BY clause */ + } + if( pSelect->pLimit ){ + return 0; /* SELECT may not have a LIMIT clause */ + } + if( pSelect->pPrior ){ + return 0; /* SELECT may not be a compound query */ + } + if( pSelect->selFlags & SF_Distinct ){ + return 0; /* SELECT may not be DISTINCT */ + } + pEList = pSelect->pEList; + assert( pEList!=0 ); + if( pEList->nExpr!=1 ){ + return 0; /* The result set must have exactly one column */ + } + assert( pEList->a[0].pExpr ); + if( pEList->a[0].pExpr->op!=TK_ASTERISK ){ + return 0; /* The result set must be the special operator "*" */ + } + + /* At this point we have established that the statement is of the + ** correct syntactic form to participate in this optimization. Now + ** we have to check the semantics. + */ + pItem = pSelect->pSrc->a; + pSrc = sqlite3LocateTableItem(pParse, 0, pItem); + if( pSrc==0 ){ + return 0; /* FROM clause does not contain a real table */ + } + if( pSrc->tnum==pDest->tnum && pSrc->pSchema==pDest->pSchema ){ + testcase( pSrc!=pDest ); /* Possible due to bad sqlite_schema.rootpage */ + return 0; /* tab1 and tab2 may not be the same table */ + } + if( HasRowid(pDest)!=HasRowid(pSrc) ){ + return 0; /* source and destination must both be WITHOUT ROWID or not */ + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pSrc) ){ + return 0; /* tab2 must not be a virtual table */ + } +#endif + if( pSrc->pSelect ){ + return 0; /* tab2 may not be a view */ + } + if( pDest->nCol!=pSrc->nCol ){ + return 0; /* Number of columns must be the same in tab1 and tab2 */ + } + if( pDest->iPKey!=pSrc->iPKey ){ + return 0; /* Both tables must have the same INTEGER PRIMARY KEY */ + } + for(i=0; inCol; i++){ + Column *pDestCol = &pDest->aCol[i]; + Column *pSrcCol = &pSrc->aCol[i]; +#ifdef SQLITE_ENABLE_HIDDEN_COLUMNS + if( (db->mDbFlags & DBFLAG_Vacuum)==0 + && (pDestCol->colFlags | pSrcCol->colFlags) & COLFLAG_HIDDEN + ){ + return 0; /* Neither table may have __hidden__ columns */ + } +#endif +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + /* Even if tables t1 and t2 have identical schemas, if they contain + ** generated columns, then this statement is semantically incorrect: + ** + ** INSERT INTO t2 SELECT * FROM t1; + ** + ** The reason is that generated column values are returned by the + ** the SELECT statement on the right but the INSERT statement on the + ** left wants them to be omitted. + ** + ** Nevertheless, this is a useful notational shorthand to tell SQLite + ** to do a bulk transfer all of the content from t1 over to t2. + ** + ** We could, in theory, disable this (except for internal use by the + ** VACUUM command where it is actually needed). But why do that? It + ** seems harmless enough, and provides a useful service. + */ + if( (pDestCol->colFlags & COLFLAG_GENERATED) != + (pSrcCol->colFlags & COLFLAG_GENERATED) ){ + return 0; /* Both columns have the same generated-column type */ + } + /* But the transfer is only allowed if both the source and destination + ** tables have the exact same expressions for generated columns. + ** This requirement could be relaxed for VIRTUAL columns, I suppose. + */ + if( (pDestCol->colFlags & COLFLAG_GENERATED)!=0 ){ + if( sqlite3ExprCompare(0, pSrcCol->pDflt, pDestCol->pDflt, -1)!=0 ){ + testcase( pDestCol->colFlags & COLFLAG_VIRTUAL ); + testcase( pDestCol->colFlags & COLFLAG_STORED ); + return 0; /* Different generator expressions */ + } + } +#endif + if( pDestCol->affinity!=pSrcCol->affinity ){ + return 0; /* Affinity must be the same on all columns */ + } + if( sqlite3_stricmp(pDestCol->zColl, pSrcCol->zColl)!=0 ){ + return 0; /* Collating sequence must be the same on all columns */ + } + if( pDestCol->notNull && !pSrcCol->notNull ){ + return 0; /* tab2 must be NOT NULL if tab1 is */ + } + /* Default values for second and subsequent columns need to match. */ + if( (pDestCol->colFlags & COLFLAG_GENERATED)==0 && i>0 ){ + assert( pDestCol->pDflt==0 || pDestCol->pDflt->op==TK_SPAN ); + assert( pSrcCol->pDflt==0 || pSrcCol->pDflt->op==TK_SPAN ); + if( (pDestCol->pDflt==0)!=(pSrcCol->pDflt==0) + || (pDestCol->pDflt && strcmp(pDestCol->pDflt->u.zToken, + pSrcCol->pDflt->u.zToken)!=0) + ){ + return 0; /* Default values must be the same for all columns */ + } + } + } + for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){ + if( IsUniqueIndex(pDestIdx) ){ + destHasUniqueIdx = 1; + } + for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){ + if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break; + } + if( pSrcIdx==0 ){ + return 0; /* pDestIdx has no corresponding index in pSrc */ + } + if( pSrcIdx->tnum==pDestIdx->tnum && pSrc->pSchema==pDest->pSchema + && sqlite3FaultSim(411)==SQLITE_OK ){ + /* The sqlite3FaultSim() call allows this corruption test to be + ** bypassed during testing, in order to exercise other corruption tests + ** further downstream. */ + return 0; /* Corrupt schema - two indexes on the same btree */ + } + } +#ifndef SQLITE_OMIT_CHECK + if( pDest->pCheck && sqlite3ExprListCompare(pSrc->pCheck,pDest->pCheck,-1) ){ + return 0; /* Tables have different CHECK constraints. Ticket #2252 */ + } +#endif +#ifndef SQLITE_OMIT_FOREIGN_KEY + /* Disallow the transfer optimization if the destination table constains + ** any foreign key constraints. This is more restrictive than necessary. + ** But the main beneficiary of the transfer optimization is the VACUUM + ** command, and the VACUUM command disables foreign key constraints. So + ** the extra complication to make this rule less restrictive is probably + ** not worth the effort. Ticket [6284df89debdfa61db8073e062908af0c9b6118e] + */ + if( (db->flags & SQLITE_ForeignKeys)!=0 && pDest->pFKey!=0 ){ + return 0; + } +#endif + if( (db->flags & SQLITE_CountRows)!=0 ){ + return 0; /* xfer opt does not play well with PRAGMA count_changes */ + } + + /* If we get this far, it means that the xfer optimization is at + ** least a possibility, though it might only work if the destination + ** table (tab1) is initially empty. + */ +#ifdef SQLITE_TEST + sqlite3_xferopt_count++; +#endif + iDbSrc = sqlite3SchemaToIndex(db, pSrc->pSchema); + v = sqlite3GetVdbe(pParse); + sqlite3CodeVerifySchema(pParse, iDbSrc); + iSrc = pParse->nTab++; + iDest = pParse->nTab++; + regAutoinc = autoIncBegin(pParse, iDbDest, pDest); + regData = sqlite3GetTempReg(pParse); + regRowid = sqlite3GetTempReg(pParse); + sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite); + assert( HasRowid(pDest) || destHasUniqueIdx ); + if( (db->mDbFlags & DBFLAG_Vacuum)==0 && ( + (pDest->iPKey<0 && pDest->pIndex!=0) /* (1) */ + || destHasUniqueIdx /* (2) */ + || (onError!=OE_Abort && onError!=OE_Rollback) /* (3) */ + )){ + /* In some circumstances, we are able to run the xfer optimization + ** only if the destination table is initially empty. Unless the + ** DBFLAG_Vacuum flag is set, this block generates code to make + ** that determination. If DBFLAG_Vacuum is set, then the destination + ** table is always empty. + ** + ** Conditions under which the destination must be empty: + ** + ** (1) There is no INTEGER PRIMARY KEY but there are indices. + ** (If the destination is not initially empty, the rowid fields + ** of index entries might need to change.) + ** + ** (2) The destination has a unique index. (The xfer optimization + ** is unable to test uniqueness.) + ** + ** (3) onError is something other than OE_Abort and OE_Rollback. + */ + addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iDest, 0); VdbeCoverage(v); + emptyDestTest = sqlite3VdbeAddOp0(v, OP_Goto); + sqlite3VdbeJumpHere(v, addr1); + } + if( HasRowid(pSrc) ){ + u8 insFlags; + sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead); + emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v); + if( pDest->iPKey>=0 ){ + addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid); + sqlite3VdbeVerifyAbortable(v, onError); + addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid); + VdbeCoverage(v); + sqlite3RowidConstraint(pParse, onError, pDest); + sqlite3VdbeJumpHere(v, addr2); + autoIncStep(pParse, regAutoinc, regRowid); + }else if( pDest->pIndex==0 && !(db->mDbFlags & DBFLAG_VacuumInto) ){ + addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid); + }else{ + addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid); + assert( (pDest->tabFlags & TF_Autoincrement)==0 ); + } + if( db->mDbFlags & DBFLAG_Vacuum ){ + sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest); + insFlags = OPFLAG_APPEND|OPFLAG_USESEEKRESULT; + }else{ + insFlags = OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND; + } + sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1); + sqlite3VdbeAddOp4(v, OP_Insert, iDest, regData, regRowid, + (char*)pDest, P4_TABLE); + sqlite3VdbeChangeP5(v, insFlags); + sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0); + sqlite3VdbeAddOp2(v, OP_Close, iDest, 0); + }else{ + sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName); + sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName); + } + for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){ + u8 idxInsFlags = 0; + for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){ + if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break; + } + assert( pSrcIdx ); + sqlite3VdbeAddOp3(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc); + sqlite3VdbeSetP4KeyInfo(pParse, pSrcIdx); + VdbeComment((v, "%s", pSrcIdx->zName)); + sqlite3VdbeAddOp3(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest); + sqlite3VdbeSetP4KeyInfo(pParse, pDestIdx); + sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR); + VdbeComment((v, "%s", pDestIdx->zName)); + addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v); + if( db->mDbFlags & DBFLAG_Vacuum ){ + /* This INSERT command is part of a VACUUM operation, which guarantees + ** that the destination table is empty. If all indexed columns use + ** collation sequence BINARY, then it can also be assumed that the + ** index will be populated by inserting keys in strictly sorted + ** order. In this case, instead of seeking within the b-tree as part + ** of every OP_IdxInsert opcode, an OP_SeekEnd is added before the + ** OP_IdxInsert to seek to the point within the b-tree where each key + ** should be inserted. This is faster. + ** + ** If any of the indexed columns use a collation sequence other than + ** BINARY, this optimization is disabled. This is because the user + ** might change the definition of a collation sequence and then run + ** a VACUUM command. In that case keys may not be written in strictly + ** sorted order. */ + for(i=0; inColumn; i++){ + const char *zColl = pSrcIdx->azColl[i]; + if( sqlite3_stricmp(sqlite3StrBINARY, zColl) ) break; + } + if( i==pSrcIdx->nColumn ){ + idxInsFlags = OPFLAG_USESEEKRESULT; + sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest); + } + }else if( !HasRowid(pSrc) && pDestIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){ + idxInsFlags |= OPFLAG_NCHANGE; + } + sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1); + sqlite3VdbeAddOp2(v, OP_IdxInsert, iDest, regData); + sqlite3VdbeChangeP5(v, idxInsFlags|OPFLAG_APPEND); + sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0); + sqlite3VdbeAddOp2(v, OP_Close, iDest, 0); + } + if( emptySrcTest ) sqlite3VdbeJumpHere(v, emptySrcTest); + sqlite3ReleaseTempReg(pParse, regRowid); + sqlite3ReleaseTempReg(pParse, regData); + if( emptyDestTest ){ + sqlite3AutoincrementEnd(pParse); + sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0); + sqlite3VdbeJumpHere(v, emptyDestTest); + sqlite3VdbeAddOp2(v, OP_Close, iDest, 0); + return 0; + }else{ + return 1; + } +} +#endif /* SQLITE_OMIT_XFER_OPT */ + +/************** End of insert.c **********************************************/ +/************** Begin file legacy.c ******************************************/ +/* +** 2001 September 15 +** +** 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. +** +************************************************************************* +** Main file for the SQLite library. The routines in this file +** implement the programmer interface to the library. Routines in +** other files are for internal use by SQLite and should not be +** accessed by users of the library. +*/ + +/* #include "sqliteInt.h" */ + +/* +** Execute SQL code. Return one of the SQLITE_ success/failure +** codes. Also write an error message into memory obtained from +** malloc() and make *pzErrMsg point to that message. +** +** If the SQL is a query, then for each row in the query result +** the xCallback() function is called. pArg becomes the first +** argument to xCallback(). If xCallback=NULL then no callback +** is invoked, even for queries. +*/ +SQLITE_API int sqlite3_exec( + sqlite3 *db, /* The database on which the SQL executes */ + const char *zSql, /* The SQL to be executed */ + sqlite3_callback xCallback, /* Invoke this callback routine */ + void *pArg, /* First argument to xCallback() */ + char **pzErrMsg /* Write error messages here */ +){ + int rc = SQLITE_OK; /* Return code */ + const char *zLeftover; /* Tail of unprocessed SQL */ + sqlite3_stmt *pStmt = 0; /* The current SQL statement */ + char **azCols = 0; /* Names of result columns */ + int callbackIsInit; /* True if callback data is initialized */ + + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; + if( zSql==0 ) zSql = ""; + + sqlite3_mutex_enter(db->mutex); + sqlite3Error(db, SQLITE_OK); + while( rc==SQLITE_OK && zSql[0] ){ + int nCol = 0; + char **azVals = 0; + + pStmt = 0; + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover); + assert( rc==SQLITE_OK || pStmt==0 ); + if( rc!=SQLITE_OK ){ + continue; + } + if( !pStmt ){ + /* this happens for a comment or white-space */ + zSql = zLeftover; + continue; + } + callbackIsInit = 0; + + while( 1 ){ + int i; + rc = sqlite3_step(pStmt); + + /* Invoke the callback function if required */ + if( xCallback && (SQLITE_ROW==rc || + (SQLITE_DONE==rc && !callbackIsInit + && db->flags&SQLITE_NullCallback)) ){ + if( !callbackIsInit ){ + nCol = sqlite3_column_count(pStmt); + azCols = sqlite3DbMallocRaw(db, (2*nCol+1)*sizeof(const char*)); + if( azCols==0 ){ + goto exec_out; + } + for(i=0; ierrMask)==rc ); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/************** End of legacy.c **********************************************/ +/************** Begin file loadext.c *****************************************/ +/* +** 2006 June 7 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to dynamically load extensions into +** the SQLite library. +*/ + +#ifndef SQLITE_CORE + #define SQLITE_CORE 1 /* Disable the API redefinition in sqlite3ext.h */ +#endif +/************** Include sqlite3ext.h in the middle of loadext.c **************/ +/************** Begin file sqlite3ext.h **************************************/ +/* +** 2006 June 7 +** +** 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 header file defines the SQLite interface for use by +** shared libraries that want to be imported as extensions into +** an SQLite instance. Shared libraries that intend to be loaded +** as extensions by SQLite should #include this file instead of +** sqlite3.h. +*/ +#ifndef SQLITE3EXT_H +#define SQLITE3EXT_H +/* #include "sqlite3.h" */ + +/* +** The following structure holds pointers to all of the SQLite API +** routines. +** +** WARNING: In order to maintain backwards compatibility, add new +** interfaces to the end of this structure only. If you insert new +** interfaces in the middle of this structure, then older different +** versions of SQLite will not be able to load each other's shared +** libraries! +*/ +struct sqlite3_api_routines { + void * (*aggregate_context)(sqlite3_context*,int nBytes); + int (*aggregate_count)(sqlite3_context*); + int (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*)); + int (*bind_double)(sqlite3_stmt*,int,double); + int (*bind_int)(sqlite3_stmt*,int,int); + int (*bind_int64)(sqlite3_stmt*,int,sqlite_int64); + int (*bind_null)(sqlite3_stmt*,int); + int (*bind_parameter_count)(sqlite3_stmt*); + int (*bind_parameter_index)(sqlite3_stmt*,const char*zName); + const char * (*bind_parameter_name)(sqlite3_stmt*,int); + int (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*)); + int (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*)); + int (*bind_value)(sqlite3_stmt*,int,const sqlite3_value*); + int (*busy_handler)(sqlite3*,int(*)(void*,int),void*); + int (*busy_timeout)(sqlite3*,int ms); + int (*changes)(sqlite3*); + int (*close)(sqlite3*); + int (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*, + int eTextRep,const char*)); + int (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*, + int eTextRep,const void*)); + const void * (*column_blob)(sqlite3_stmt*,int iCol); + int (*column_bytes)(sqlite3_stmt*,int iCol); + int (*column_bytes16)(sqlite3_stmt*,int iCol); + int (*column_count)(sqlite3_stmt*pStmt); + const char * (*column_database_name)(sqlite3_stmt*,int); + const void * (*column_database_name16)(sqlite3_stmt*,int); + const char * (*column_decltype)(sqlite3_stmt*,int i); + const void * (*column_decltype16)(sqlite3_stmt*,int); + double (*column_double)(sqlite3_stmt*,int iCol); + int (*column_int)(sqlite3_stmt*,int iCol); + sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol); + const char * (*column_name)(sqlite3_stmt*,int); + const void * (*column_name16)(sqlite3_stmt*,int); + const char * (*column_origin_name)(sqlite3_stmt*,int); + const void * (*column_origin_name16)(sqlite3_stmt*,int); + const char * (*column_table_name)(sqlite3_stmt*,int); + const void * (*column_table_name16)(sqlite3_stmt*,int); + const unsigned char * (*column_text)(sqlite3_stmt*,int iCol); + const void * (*column_text16)(sqlite3_stmt*,int iCol); + int (*column_type)(sqlite3_stmt*,int iCol); + sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol); + void * (*commit_hook)(sqlite3*,int(*)(void*),void*); + int (*complete)(const char*sql); + int (*complete16)(const void*sql); + int (*create_collation)(sqlite3*,const char*,int,void*, + int(*)(void*,int,const void*,int,const void*)); + int (*create_collation16)(sqlite3*,const void*,int,void*, + int(*)(void*,int,const void*,int,const void*)); + int (*create_function)(sqlite3*,const char*,int,int,void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*)); + int (*create_function16)(sqlite3*,const void*,int,int,void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*)); + int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*); + int (*data_count)(sqlite3_stmt*pStmt); + sqlite3 * (*db_handle)(sqlite3_stmt*); + int (*declare_vtab)(sqlite3*,const char*); + int (*enable_shared_cache)(int); + int (*errcode)(sqlite3*db); + const char * (*errmsg)(sqlite3*); + const void * (*errmsg16)(sqlite3*); + int (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**); + int (*expired)(sqlite3_stmt*); + int (*finalize)(sqlite3_stmt*pStmt); + void (*free)(void*); + void (*free_table)(char**result); + int (*get_autocommit)(sqlite3*); + void * (*get_auxdata)(sqlite3_context*,int); + int (*get_table)(sqlite3*,const char*,char***,int*,int*,char**); + int (*global_recover)(void); + void (*interruptx)(sqlite3*); + sqlite_int64 (*last_insert_rowid)(sqlite3*); + const char * (*libversion)(void); + int (*libversion_number)(void); + void *(*malloc)(int); + char * (*mprintf)(const char*,...); + int (*open)(const char*,sqlite3**); + int (*open16)(const void*,sqlite3**); + int (*prepare)(sqlite3*,const char*,int,sqlite3_stmt**,const char**); + int (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**); + void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*); + void (*progress_handler)(sqlite3*,int,int(*)(void*),void*); + void *(*realloc)(void*,int); + int (*reset)(sqlite3_stmt*pStmt); + void (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_double)(sqlite3_context*,double); + void (*result_error)(sqlite3_context*,const char*,int); + void (*result_error16)(sqlite3_context*,const void*,int); + void (*result_int)(sqlite3_context*,int); + void (*result_int64)(sqlite3_context*,sqlite_int64); + void (*result_null)(sqlite3_context*); + void (*result_text)(sqlite3_context*,const char*,int,void(*)(void*)); + void (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_value)(sqlite3_context*,sqlite3_value*); + void * (*rollback_hook)(sqlite3*,void(*)(void*),void*); + int (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*, + const char*,const char*),void*); + void (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*)); + char * (*xsnprintf)(int,char*,const char*,...); + int (*step)(sqlite3_stmt*); + int (*table_column_metadata)(sqlite3*,const char*,const char*,const char*, + char const**,char const**,int*,int*,int*); + void (*thread_cleanup)(void); + int (*total_changes)(sqlite3*); + void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*); + int (*transfer_bindings)(sqlite3_stmt*,sqlite3_stmt*); + void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*, + sqlite_int64),void*); + void * (*user_data)(sqlite3_context*); + const void * (*value_blob)(sqlite3_value*); + int (*value_bytes)(sqlite3_value*); + int (*value_bytes16)(sqlite3_value*); + double (*value_double)(sqlite3_value*); + int (*value_int)(sqlite3_value*); + sqlite_int64 (*value_int64)(sqlite3_value*); + int (*value_numeric_type)(sqlite3_value*); + const unsigned char * (*value_text)(sqlite3_value*); + const void * (*value_text16)(sqlite3_value*); + const void * (*value_text16be)(sqlite3_value*); + const void * (*value_text16le)(sqlite3_value*); + int (*value_type)(sqlite3_value*); + char *(*vmprintf)(const char*,va_list); + /* Added ??? */ + int (*overload_function)(sqlite3*, const char *zFuncName, int nArg); + /* Added by 3.3.13 */ + int (*prepare_v2)(sqlite3*,const char*,int,sqlite3_stmt**,const char**); + int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**); + int (*clear_bindings)(sqlite3_stmt*); + /* Added by 3.4.1 */ + int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*, + void (*xDestroy)(void *)); + /* Added by 3.5.0 */ + int (*bind_zeroblob)(sqlite3_stmt*,int,int); + int (*blob_bytes)(sqlite3_blob*); + int (*blob_close)(sqlite3_blob*); + int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64, + int,sqlite3_blob**); + int (*blob_read)(sqlite3_blob*,void*,int,int); + int (*blob_write)(sqlite3_blob*,const void*,int,int); + int (*create_collation_v2)(sqlite3*,const char*,int,void*, + int(*)(void*,int,const void*,int,const void*), + void(*)(void*)); + int (*file_control)(sqlite3*,const char*,int,void*); + sqlite3_int64 (*memory_highwater)(int); + sqlite3_int64 (*memory_used)(void); + sqlite3_mutex *(*mutex_alloc)(int); + void (*mutex_enter)(sqlite3_mutex*); + void (*mutex_free)(sqlite3_mutex*); + void (*mutex_leave)(sqlite3_mutex*); + int (*mutex_try)(sqlite3_mutex*); + int (*open_v2)(const char*,sqlite3**,int,const char*); + int (*release_memory)(int); + void (*result_error_nomem)(sqlite3_context*); + void (*result_error_toobig)(sqlite3_context*); + int (*sleep)(int); + void (*soft_heap_limit)(int); + sqlite3_vfs *(*vfs_find)(const char*); + int (*vfs_register)(sqlite3_vfs*,int); + int (*vfs_unregister)(sqlite3_vfs*); + int (*xthreadsafe)(void); + void (*result_zeroblob)(sqlite3_context*,int); + void (*result_error_code)(sqlite3_context*,int); + int (*test_control)(int, ...); + void (*randomness)(int,void*); + sqlite3 *(*context_db_handle)(sqlite3_context*); + int (*extended_result_codes)(sqlite3*,int); + int (*limit)(sqlite3*,int,int); + sqlite3_stmt *(*next_stmt)(sqlite3*,sqlite3_stmt*); + const char *(*sql)(sqlite3_stmt*); + int (*status)(int,int*,int*,int); + int (*backup_finish)(sqlite3_backup*); + sqlite3_backup *(*backup_init)(sqlite3*,const char*,sqlite3*,const char*); + int (*backup_pagecount)(sqlite3_backup*); + int (*backup_remaining)(sqlite3_backup*); + int (*backup_step)(sqlite3_backup*,int); + const char *(*compileoption_get)(int); + int (*compileoption_used)(const char*); + int (*create_function_v2)(sqlite3*,const char*,int,int,void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void(*xDestroy)(void*)); + int (*db_config)(sqlite3*,int,...); + sqlite3_mutex *(*db_mutex)(sqlite3*); + int (*db_status)(sqlite3*,int,int*,int*,int); + int (*extended_errcode)(sqlite3*); + void (*log)(int,const char*,...); + sqlite3_int64 (*soft_heap_limit64)(sqlite3_int64); + const char *(*sourceid)(void); + int (*stmt_status)(sqlite3_stmt*,int,int); + int (*strnicmp)(const char*,const char*,int); + int (*unlock_notify)(sqlite3*,void(*)(void**,int),void*); + int (*wal_autocheckpoint)(sqlite3*,int); + int (*wal_checkpoint)(sqlite3*,const char*); + void *(*wal_hook)(sqlite3*,int(*)(void*,sqlite3*,const char*,int),void*); + int (*blob_reopen)(sqlite3_blob*,sqlite3_int64); + int (*vtab_config)(sqlite3*,int op,...); + int (*vtab_on_conflict)(sqlite3*); + /* Version 3.7.16 and later */ + int (*close_v2)(sqlite3*); + const char *(*db_filename)(sqlite3*,const char*); + int (*db_readonly)(sqlite3*,const char*); + int (*db_release_memory)(sqlite3*); + const char *(*errstr)(int); + int (*stmt_busy)(sqlite3_stmt*); + int (*stmt_readonly)(sqlite3_stmt*); + int (*stricmp)(const char*,const char*); + int (*uri_boolean)(const char*,const char*,int); + sqlite3_int64 (*uri_int64)(const char*,const char*,sqlite3_int64); + const char *(*uri_parameter)(const char*,const char*); + char *(*xvsnprintf)(int,char*,const char*,va_list); + int (*wal_checkpoint_v2)(sqlite3*,const char*,int,int*,int*); + /* Version 3.8.7 and later */ + int (*auto_extension)(void(*)(void)); + int (*bind_blob64)(sqlite3_stmt*,int,const void*,sqlite3_uint64, + void(*)(void*)); + int (*bind_text64)(sqlite3_stmt*,int,const char*,sqlite3_uint64, + void(*)(void*),unsigned char); + int (*cancel_auto_extension)(void(*)(void)); + int (*load_extension)(sqlite3*,const char*,const char*,char**); + void *(*malloc64)(sqlite3_uint64); + sqlite3_uint64 (*msize)(void*); + void *(*realloc64)(void*,sqlite3_uint64); + void (*reset_auto_extension)(void); + void (*result_blob64)(sqlite3_context*,const void*,sqlite3_uint64, + void(*)(void*)); + void (*result_text64)(sqlite3_context*,const char*,sqlite3_uint64, + void(*)(void*), unsigned char); + int (*strglob)(const char*,const char*); + /* Version 3.8.11 and later */ + sqlite3_value *(*value_dup)(const sqlite3_value*); + void (*value_free)(sqlite3_value*); + int (*result_zeroblob64)(sqlite3_context*,sqlite3_uint64); + int (*bind_zeroblob64)(sqlite3_stmt*, int, sqlite3_uint64); + /* Version 3.9.0 and later */ + unsigned int (*value_subtype)(sqlite3_value*); + void (*result_subtype)(sqlite3_context*,unsigned int); + /* Version 3.10.0 and later */ + int (*status64)(int,sqlite3_int64*,sqlite3_int64*,int); + int (*strlike)(const char*,const char*,unsigned int); + int (*db_cacheflush)(sqlite3*); + /* Version 3.12.0 and later */ + int (*system_errno)(sqlite3*); + /* Version 3.14.0 and later */ + int (*trace_v2)(sqlite3*,unsigned,int(*)(unsigned,void*,void*,void*),void*); + char *(*expanded_sql)(sqlite3_stmt*); + /* Version 3.18.0 and later */ + void (*set_last_insert_rowid)(sqlite3*,sqlite3_int64); + /* Version 3.20.0 and later */ + int (*prepare_v3)(sqlite3*,const char*,int,unsigned int, + sqlite3_stmt**,const char**); + int (*prepare16_v3)(sqlite3*,const void*,int,unsigned int, + sqlite3_stmt**,const void**); + int (*bind_pointer)(sqlite3_stmt*,int,void*,const char*,void(*)(void*)); + void (*result_pointer)(sqlite3_context*,void*,const char*,void(*)(void*)); + void *(*value_pointer)(sqlite3_value*,const char*); + int (*vtab_nochange)(sqlite3_context*); + int (*value_nochange)(sqlite3_value*); + const char *(*vtab_collation)(sqlite3_index_info*,int); + /* Version 3.24.0 and later */ + int (*keyword_count)(void); + int (*keyword_name)(int,const char**,int*); + int (*keyword_check)(const char*,int); + sqlite3_str *(*str_new)(sqlite3*); + char *(*str_finish)(sqlite3_str*); + void (*str_appendf)(sqlite3_str*, const char *zFormat, ...); + void (*str_vappendf)(sqlite3_str*, const char *zFormat, va_list); + void (*str_append)(sqlite3_str*, const char *zIn, int N); + void (*str_appendall)(sqlite3_str*, const char *zIn); + void (*str_appendchar)(sqlite3_str*, int N, char C); + void (*str_reset)(sqlite3_str*); + int (*str_errcode)(sqlite3_str*); + int (*str_length)(sqlite3_str*); + char *(*str_value)(sqlite3_str*); + /* Version 3.25.0 and later */ + int (*create_window_function)(sqlite3*,const char*,int,int,void*, + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void (*xValue)(sqlite3_context*), + void (*xInv)(sqlite3_context*,int,sqlite3_value**), + void(*xDestroy)(void*)); + /* Version 3.26.0 and later */ + const char *(*normalized_sql)(sqlite3_stmt*); + /* Version 3.28.0 and later */ + int (*stmt_isexplain)(sqlite3_stmt*); + int (*value_frombind)(sqlite3_value*); + /* Version 3.30.0 and later */ + int (*drop_modules)(sqlite3*,const char**); + /* Version 3.31.0 and later */ + sqlite3_int64 (*hard_heap_limit64)(sqlite3_int64); + const char *(*uri_key)(const char*,int); + const char *(*filename_database)(const char*); + const char *(*filename_journal)(const char*); + const char *(*filename_wal)(const char*); + /* Version 3.32.0 and later */ + char *(*create_filename)(const char*,const char*,const char*, + int,const char**); + void (*free_filename)(char*); + sqlite3_file *(*database_file_object)(const char*); + /* Version 3.34.0 and later */ + int (*txn_state)(sqlite3*,const char*); +}; + +/* +** This is the function signature used for all extension entry points. It +** is also defined in the file "loadext.c". +*/ +typedef int (*sqlite3_loadext_entry)( + sqlite3 *db, /* Handle to the database. */ + char **pzErrMsg, /* Used to set error string on failure. */ + const sqlite3_api_routines *pThunk /* Extension API function pointers. */ +); + +/* +** The following macros redefine the API routines so that they are +** redirected through the global sqlite3_api structure. +** +** This header file is also used by the loadext.c source file +** (part of the main SQLite library - not an extension) so that +** it can get access to the sqlite3_api_routines structure +** definition. But the main library does not want to redefine +** the API. So the redefinition macros are only valid if the +** SQLITE_CORE macros is undefined. +*/ +#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) +#define sqlite3_aggregate_context sqlite3_api->aggregate_context +#ifndef SQLITE_OMIT_DEPRECATED +#define sqlite3_aggregate_count sqlite3_api->aggregate_count +#endif +#define sqlite3_bind_blob sqlite3_api->bind_blob +#define sqlite3_bind_double sqlite3_api->bind_double +#define sqlite3_bind_int sqlite3_api->bind_int +#define sqlite3_bind_int64 sqlite3_api->bind_int64 +#define sqlite3_bind_null sqlite3_api->bind_null +#define sqlite3_bind_parameter_count sqlite3_api->bind_parameter_count +#define sqlite3_bind_parameter_index sqlite3_api->bind_parameter_index +#define sqlite3_bind_parameter_name sqlite3_api->bind_parameter_name +#define sqlite3_bind_text sqlite3_api->bind_text +#define sqlite3_bind_text16 sqlite3_api->bind_text16 +#define sqlite3_bind_value sqlite3_api->bind_value +#define sqlite3_busy_handler sqlite3_api->busy_handler +#define sqlite3_busy_timeout sqlite3_api->busy_timeout +#define sqlite3_changes sqlite3_api->changes +#define sqlite3_close sqlite3_api->close +#define sqlite3_collation_needed sqlite3_api->collation_needed +#define sqlite3_collation_needed16 sqlite3_api->collation_needed16 +#define sqlite3_column_blob sqlite3_api->column_blob +#define sqlite3_column_bytes sqlite3_api->column_bytes +#define sqlite3_column_bytes16 sqlite3_api->column_bytes16 +#define sqlite3_column_count sqlite3_api->column_count +#define sqlite3_column_database_name sqlite3_api->column_database_name +#define sqlite3_column_database_name16 sqlite3_api->column_database_name16 +#define sqlite3_column_decltype sqlite3_api->column_decltype +#define sqlite3_column_decltype16 sqlite3_api->column_decltype16 +#define sqlite3_column_double sqlite3_api->column_double +#define sqlite3_column_int sqlite3_api->column_int +#define sqlite3_column_int64 sqlite3_api->column_int64 +#define sqlite3_column_name sqlite3_api->column_name +#define sqlite3_column_name16 sqlite3_api->column_name16 +#define sqlite3_column_origin_name sqlite3_api->column_origin_name +#define sqlite3_column_origin_name16 sqlite3_api->column_origin_name16 +#define sqlite3_column_table_name sqlite3_api->column_table_name +#define sqlite3_column_table_name16 sqlite3_api->column_table_name16 +#define sqlite3_column_text sqlite3_api->column_text +#define sqlite3_column_text16 sqlite3_api->column_text16 +#define sqlite3_column_type sqlite3_api->column_type +#define sqlite3_column_value sqlite3_api->column_value +#define sqlite3_commit_hook sqlite3_api->commit_hook +#define sqlite3_complete sqlite3_api->complete +#define sqlite3_complete16 sqlite3_api->complete16 +#define sqlite3_create_collation sqlite3_api->create_collation +#define sqlite3_create_collation16 sqlite3_api->create_collation16 +#define sqlite3_create_function sqlite3_api->create_function +#define sqlite3_create_function16 sqlite3_api->create_function16 +#define sqlite3_create_module sqlite3_api->create_module +#define sqlite3_create_module_v2 sqlite3_api->create_module_v2 +#define sqlite3_data_count sqlite3_api->data_count +#define sqlite3_db_handle sqlite3_api->db_handle +#define sqlite3_declare_vtab sqlite3_api->declare_vtab +#define sqlite3_enable_shared_cache sqlite3_api->enable_shared_cache +#define sqlite3_errcode sqlite3_api->errcode +#define sqlite3_errmsg sqlite3_api->errmsg +#define sqlite3_errmsg16 sqlite3_api->errmsg16 +#define sqlite3_exec sqlite3_api->exec +#ifndef SQLITE_OMIT_DEPRECATED +#define sqlite3_expired sqlite3_api->expired +#endif +#define sqlite3_finalize sqlite3_api->finalize +#define sqlite3_free sqlite3_api->free +#define sqlite3_free_table sqlite3_api->free_table +#define sqlite3_get_autocommit sqlite3_api->get_autocommit +#define sqlite3_get_auxdata sqlite3_api->get_auxdata +#define sqlite3_get_table sqlite3_api->get_table +#ifndef SQLITE_OMIT_DEPRECATED +#define sqlite3_global_recover sqlite3_api->global_recover +#endif +#define sqlite3_interrupt sqlite3_api->interruptx +#define sqlite3_last_insert_rowid sqlite3_api->last_insert_rowid +#define sqlite3_libversion sqlite3_api->libversion +#define sqlite3_libversion_number sqlite3_api->libversion_number +#define sqlite3_malloc sqlite3_api->malloc +#define sqlite3_mprintf sqlite3_api->mprintf +#define sqlite3_open sqlite3_api->open +#define sqlite3_open16 sqlite3_api->open16 +#define sqlite3_prepare sqlite3_api->prepare +#define sqlite3_prepare16 sqlite3_api->prepare16 +#define sqlite3_prepare_v2 sqlite3_api->prepare_v2 +#define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2 +#define sqlite3_profile sqlite3_api->profile +#define sqlite3_progress_handler sqlite3_api->progress_handler +#define sqlite3_realloc sqlite3_api->realloc +#define sqlite3_reset sqlite3_api->reset +#define sqlite3_result_blob sqlite3_api->result_blob +#define sqlite3_result_double sqlite3_api->result_double +#define sqlite3_result_error sqlite3_api->result_error +#define sqlite3_result_error16 sqlite3_api->result_error16 +#define sqlite3_result_int sqlite3_api->result_int +#define sqlite3_result_int64 sqlite3_api->result_int64 +#define sqlite3_result_null sqlite3_api->result_null +#define sqlite3_result_text sqlite3_api->result_text +#define sqlite3_result_text16 sqlite3_api->result_text16 +#define sqlite3_result_text16be sqlite3_api->result_text16be +#define sqlite3_result_text16le sqlite3_api->result_text16le +#define sqlite3_result_value sqlite3_api->result_value +#define sqlite3_rollback_hook sqlite3_api->rollback_hook +#define sqlite3_set_authorizer sqlite3_api->set_authorizer +#define sqlite3_set_auxdata sqlite3_api->set_auxdata +#define sqlite3_snprintf sqlite3_api->xsnprintf +#define sqlite3_step sqlite3_api->step +#define sqlite3_table_column_metadata sqlite3_api->table_column_metadata +#define sqlite3_thread_cleanup sqlite3_api->thread_cleanup +#define sqlite3_total_changes sqlite3_api->total_changes +#define sqlite3_trace sqlite3_api->trace +#ifndef SQLITE_OMIT_DEPRECATED +#define sqlite3_transfer_bindings sqlite3_api->transfer_bindings +#endif +#define sqlite3_update_hook sqlite3_api->update_hook +#define sqlite3_user_data sqlite3_api->user_data +#define sqlite3_value_blob sqlite3_api->value_blob +#define sqlite3_value_bytes sqlite3_api->value_bytes +#define sqlite3_value_bytes16 sqlite3_api->value_bytes16 +#define sqlite3_value_double sqlite3_api->value_double +#define sqlite3_value_int sqlite3_api->value_int +#define sqlite3_value_int64 sqlite3_api->value_int64 +#define sqlite3_value_numeric_type sqlite3_api->value_numeric_type +#define sqlite3_value_text sqlite3_api->value_text +#define sqlite3_value_text16 sqlite3_api->value_text16 +#define sqlite3_value_text16be sqlite3_api->value_text16be +#define sqlite3_value_text16le sqlite3_api->value_text16le +#define sqlite3_value_type sqlite3_api->value_type +#define sqlite3_vmprintf sqlite3_api->vmprintf +#define sqlite3_vsnprintf sqlite3_api->xvsnprintf +#define sqlite3_overload_function sqlite3_api->overload_function +#define sqlite3_prepare_v2 sqlite3_api->prepare_v2 +#define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2 +#define sqlite3_clear_bindings sqlite3_api->clear_bindings +#define sqlite3_bind_zeroblob sqlite3_api->bind_zeroblob +#define sqlite3_blob_bytes sqlite3_api->blob_bytes +#define sqlite3_blob_close sqlite3_api->blob_close +#define sqlite3_blob_open sqlite3_api->blob_open +#define sqlite3_blob_read sqlite3_api->blob_read +#define sqlite3_blob_write sqlite3_api->blob_write +#define sqlite3_create_collation_v2 sqlite3_api->create_collation_v2 +#define sqlite3_file_control sqlite3_api->file_control +#define sqlite3_memory_highwater sqlite3_api->memory_highwater +#define sqlite3_memory_used sqlite3_api->memory_used +#define sqlite3_mutex_alloc sqlite3_api->mutex_alloc +#define sqlite3_mutex_enter sqlite3_api->mutex_enter +#define sqlite3_mutex_free sqlite3_api->mutex_free +#define sqlite3_mutex_leave sqlite3_api->mutex_leave +#define sqlite3_mutex_try sqlite3_api->mutex_try +#define sqlite3_open_v2 sqlite3_api->open_v2 +#define sqlite3_release_memory sqlite3_api->release_memory +#define sqlite3_result_error_nomem sqlite3_api->result_error_nomem +#define sqlite3_result_error_toobig sqlite3_api->result_error_toobig +#define sqlite3_sleep sqlite3_api->sleep +#define sqlite3_soft_heap_limit sqlite3_api->soft_heap_limit +#define sqlite3_vfs_find sqlite3_api->vfs_find +#define sqlite3_vfs_register sqlite3_api->vfs_register +#define sqlite3_vfs_unregister sqlite3_api->vfs_unregister +#define sqlite3_threadsafe sqlite3_api->xthreadsafe +#define sqlite3_result_zeroblob sqlite3_api->result_zeroblob +#define sqlite3_result_error_code sqlite3_api->result_error_code +#define sqlite3_test_control sqlite3_api->test_control +#define sqlite3_randomness sqlite3_api->randomness +#define sqlite3_context_db_handle sqlite3_api->context_db_handle +#define sqlite3_extended_result_codes sqlite3_api->extended_result_codes +#define sqlite3_limit sqlite3_api->limit +#define sqlite3_next_stmt sqlite3_api->next_stmt +#define sqlite3_sql sqlite3_api->sql +#define sqlite3_status sqlite3_api->status +#define sqlite3_backup_finish sqlite3_api->backup_finish +#define sqlite3_backup_init sqlite3_api->backup_init +#define sqlite3_backup_pagecount sqlite3_api->backup_pagecount +#define sqlite3_backup_remaining sqlite3_api->backup_remaining +#define sqlite3_backup_step sqlite3_api->backup_step +#define sqlite3_compileoption_get sqlite3_api->compileoption_get +#define sqlite3_compileoption_used sqlite3_api->compileoption_used +#define sqlite3_create_function_v2 sqlite3_api->create_function_v2 +#define sqlite3_db_config sqlite3_api->db_config +#define sqlite3_db_mutex sqlite3_api->db_mutex +#define sqlite3_db_status sqlite3_api->db_status +#define sqlite3_extended_errcode sqlite3_api->extended_errcode +#define sqlite3_log sqlite3_api->log +#define sqlite3_soft_heap_limit64 sqlite3_api->soft_heap_limit64 +#define sqlite3_sourceid sqlite3_api->sourceid +#define sqlite3_stmt_status sqlite3_api->stmt_status +#define sqlite3_strnicmp sqlite3_api->strnicmp +#define sqlite3_unlock_notify sqlite3_api->unlock_notify +#define sqlite3_wal_autocheckpoint sqlite3_api->wal_autocheckpoint +#define sqlite3_wal_checkpoint sqlite3_api->wal_checkpoint +#define sqlite3_wal_hook sqlite3_api->wal_hook +#define sqlite3_blob_reopen sqlite3_api->blob_reopen +#define sqlite3_vtab_config sqlite3_api->vtab_config +#define sqlite3_vtab_on_conflict sqlite3_api->vtab_on_conflict +/* Version 3.7.16 and later */ +#define sqlite3_close_v2 sqlite3_api->close_v2 +#define sqlite3_db_filename sqlite3_api->db_filename +#define sqlite3_db_readonly sqlite3_api->db_readonly +#define sqlite3_db_release_memory sqlite3_api->db_release_memory +#define sqlite3_errstr sqlite3_api->errstr +#define sqlite3_stmt_busy sqlite3_api->stmt_busy +#define sqlite3_stmt_readonly sqlite3_api->stmt_readonly +#define sqlite3_stricmp sqlite3_api->stricmp +#define sqlite3_uri_boolean sqlite3_api->uri_boolean +#define sqlite3_uri_int64 sqlite3_api->uri_int64 +#define sqlite3_uri_parameter sqlite3_api->uri_parameter +#define sqlite3_uri_vsnprintf sqlite3_api->xvsnprintf +#define sqlite3_wal_checkpoint_v2 sqlite3_api->wal_checkpoint_v2 +/* Version 3.8.7 and later */ +#define sqlite3_auto_extension sqlite3_api->auto_extension +#define sqlite3_bind_blob64 sqlite3_api->bind_blob64 +#define sqlite3_bind_text64 sqlite3_api->bind_text64 +#define sqlite3_cancel_auto_extension sqlite3_api->cancel_auto_extension +#define sqlite3_load_extension sqlite3_api->load_extension +#define sqlite3_malloc64 sqlite3_api->malloc64 +#define sqlite3_msize sqlite3_api->msize +#define sqlite3_realloc64 sqlite3_api->realloc64 +#define sqlite3_reset_auto_extension sqlite3_api->reset_auto_extension +#define sqlite3_result_blob64 sqlite3_api->result_blob64 +#define sqlite3_result_text64 sqlite3_api->result_text64 +#define sqlite3_strglob sqlite3_api->strglob +/* Version 3.8.11 and later */ +#define sqlite3_value_dup sqlite3_api->value_dup +#define sqlite3_value_free sqlite3_api->value_free +#define sqlite3_result_zeroblob64 sqlite3_api->result_zeroblob64 +#define sqlite3_bind_zeroblob64 sqlite3_api->bind_zeroblob64 +/* Version 3.9.0 and later */ +#define sqlite3_value_subtype sqlite3_api->value_subtype +#define sqlite3_result_subtype sqlite3_api->result_subtype +/* Version 3.10.0 and later */ +#define sqlite3_status64 sqlite3_api->status64 +#define sqlite3_strlike sqlite3_api->strlike +#define sqlite3_db_cacheflush sqlite3_api->db_cacheflush +/* Version 3.12.0 and later */ +#define sqlite3_system_errno sqlite3_api->system_errno +/* Version 3.14.0 and later */ +#define sqlite3_trace_v2 sqlite3_api->trace_v2 +#define sqlite3_expanded_sql sqlite3_api->expanded_sql +/* Version 3.18.0 and later */ +#define sqlite3_set_last_insert_rowid sqlite3_api->set_last_insert_rowid +/* Version 3.20.0 and later */ +#define sqlite3_prepare_v3 sqlite3_api->prepare_v3 +#define sqlite3_prepare16_v3 sqlite3_api->prepare16_v3 +#define sqlite3_bind_pointer sqlite3_api->bind_pointer +#define sqlite3_result_pointer sqlite3_api->result_pointer +#define sqlite3_value_pointer sqlite3_api->value_pointer +/* Version 3.22.0 and later */ +#define sqlite3_vtab_nochange sqlite3_api->vtab_nochange +#define sqlite3_value_nochange sqlite3_api->value_nochange +#define sqlite3_vtab_collation sqlite3_api->vtab_collation +/* Version 3.24.0 and later */ +#define sqlite3_keyword_count sqlite3_api->keyword_count +#define sqlite3_keyword_name sqlite3_api->keyword_name +#define sqlite3_keyword_check sqlite3_api->keyword_check +#define sqlite3_str_new sqlite3_api->str_new +#define sqlite3_str_finish sqlite3_api->str_finish +#define sqlite3_str_appendf sqlite3_api->str_appendf +#define sqlite3_str_vappendf sqlite3_api->str_vappendf +#define sqlite3_str_append sqlite3_api->str_append +#define sqlite3_str_appendall sqlite3_api->str_appendall +#define sqlite3_str_appendchar sqlite3_api->str_appendchar +#define sqlite3_str_reset sqlite3_api->str_reset +#define sqlite3_str_errcode sqlite3_api->str_errcode +#define sqlite3_str_length sqlite3_api->str_length +#define sqlite3_str_value sqlite3_api->str_value +/* Version 3.25.0 and later */ +#define sqlite3_create_window_function sqlite3_api->create_window_function +/* Version 3.26.0 and later */ +#define sqlite3_normalized_sql sqlite3_api->normalized_sql +/* Version 3.28.0 and later */ +#define sqlite3_stmt_isexplain sqlite3_api->stmt_isexplain +#define sqlite3_value_frombind sqlite3_api->value_frombind +/* Version 3.30.0 and later */ +#define sqlite3_drop_modules sqlite3_api->drop_modules +/* Version 3.31.0 and later */ +#define sqlite3_hard_heap_limit64 sqlite3_api->hard_heap_limit64 +#define sqlite3_uri_key sqlite3_api->uri_key +#define sqlite3_filename_database sqlite3_api->filename_database +#define sqlite3_filename_journal sqlite3_api->filename_journal +#define sqlite3_filename_wal sqlite3_api->filename_wal +/* Version 3.32.0 and later */ +#define sqlite3_create_filename sqlite3_api->create_filename +#define sqlite3_free_filename sqlite3_api->free_filename +#define sqlite3_database_file_object sqlite3_api->database_file_object +/* Version 3.34.0 and later */ +#define sqlite3_txn_state sqlite3_api->txn_state +#endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */ + +#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) + /* This case when the file really is being compiled as a loadable + ** extension */ +# define SQLITE_EXTENSION_INIT1 const sqlite3_api_routines *sqlite3_api=0; +# define SQLITE_EXTENSION_INIT2(v) sqlite3_api=v; +# define SQLITE_EXTENSION_INIT3 \ + extern const sqlite3_api_routines *sqlite3_api; +#else + /* This case when the file is being statically linked into the + ** application */ +# define SQLITE_EXTENSION_INIT1 /*no-op*/ +# define SQLITE_EXTENSION_INIT2(v) (void)v; /* unused parameter */ +# define SQLITE_EXTENSION_INIT3 /*no-op*/ +#endif + +#endif /* SQLITE3EXT_H */ + +/************** End of sqlite3ext.h ******************************************/ +/************** Continuing where we left off in loadext.c ********************/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_LOAD_EXTENSION +/* +** Some API routines are omitted when various features are +** excluded from a build of SQLite. Substitute a NULL pointer +** for any missing APIs. +*/ +#ifndef SQLITE_ENABLE_COLUMN_METADATA +# define sqlite3_column_database_name 0 +# define sqlite3_column_database_name16 0 +# define sqlite3_column_table_name 0 +# define sqlite3_column_table_name16 0 +# define sqlite3_column_origin_name 0 +# define sqlite3_column_origin_name16 0 +#endif + +#ifdef SQLITE_OMIT_AUTHORIZATION +# define sqlite3_set_authorizer 0 +#endif + +#ifdef SQLITE_OMIT_UTF16 +# define sqlite3_bind_text16 0 +# define sqlite3_collation_needed16 0 +# define sqlite3_column_decltype16 0 +# define sqlite3_column_name16 0 +# define sqlite3_column_text16 0 +# define sqlite3_complete16 0 +# define sqlite3_create_collation16 0 +# define sqlite3_create_function16 0 +# define sqlite3_errmsg16 0 +# define sqlite3_open16 0 +# define sqlite3_prepare16 0 +# define sqlite3_prepare16_v2 0 +# define sqlite3_prepare16_v3 0 +# define sqlite3_result_error16 0 +# define sqlite3_result_text16 0 +# define sqlite3_result_text16be 0 +# define sqlite3_result_text16le 0 +# define sqlite3_value_text16 0 +# define sqlite3_value_text16be 0 +# define sqlite3_value_text16le 0 +# define sqlite3_column_database_name16 0 +# define sqlite3_column_table_name16 0 +# define sqlite3_column_origin_name16 0 +#endif + +#ifdef SQLITE_OMIT_COMPLETE +# define sqlite3_complete 0 +# define sqlite3_complete16 0 +#endif + +#ifdef SQLITE_OMIT_DECLTYPE +# define sqlite3_column_decltype16 0 +# define sqlite3_column_decltype 0 +#endif + +#ifdef SQLITE_OMIT_PROGRESS_CALLBACK +# define sqlite3_progress_handler 0 +#endif + +#ifdef SQLITE_OMIT_VIRTUALTABLE +# define sqlite3_create_module 0 +# define sqlite3_create_module_v2 0 +# define sqlite3_declare_vtab 0 +# define sqlite3_vtab_config 0 +# define sqlite3_vtab_on_conflict 0 +# define sqlite3_vtab_collation 0 +#endif + +#ifdef SQLITE_OMIT_SHARED_CACHE +# define sqlite3_enable_shared_cache 0 +#endif + +#if defined(SQLITE_OMIT_TRACE) || defined(SQLITE_OMIT_DEPRECATED) +# define sqlite3_profile 0 +# define sqlite3_trace 0 +#endif + +#ifdef SQLITE_OMIT_GET_TABLE +# define sqlite3_free_table 0 +# define sqlite3_get_table 0 +#endif + +#ifdef SQLITE_OMIT_INCRBLOB +#define sqlite3_bind_zeroblob 0 +#define sqlite3_blob_bytes 0 +#define sqlite3_blob_close 0 +#define sqlite3_blob_open 0 +#define sqlite3_blob_read 0 +#define sqlite3_blob_write 0 +#define sqlite3_blob_reopen 0 +#endif + +#if defined(SQLITE_OMIT_TRACE) +# define sqlite3_trace_v2 0 +#endif + +/* +** The following structure contains pointers to all SQLite API routines. +** A pointer to this structure is passed into extensions when they are +** loaded so that the extension can make calls back into the SQLite +** library. +** +** When adding new APIs, add them to the bottom of this structure +** in order to preserve backwards compatibility. +** +** Extensions that use newer APIs should first call the +** sqlite3_libversion_number() to make sure that the API they +** intend to use is supported by the library. Extensions should +** also check to make sure that the pointer to the function is +** not NULL before calling it. +*/ +static const sqlite3_api_routines sqlite3Apis = { + sqlite3_aggregate_context, +#ifndef SQLITE_OMIT_DEPRECATED + sqlite3_aggregate_count, +#else + 0, +#endif + sqlite3_bind_blob, + sqlite3_bind_double, + sqlite3_bind_int, + sqlite3_bind_int64, + sqlite3_bind_null, + sqlite3_bind_parameter_count, + sqlite3_bind_parameter_index, + sqlite3_bind_parameter_name, + sqlite3_bind_text, + sqlite3_bind_text16, + sqlite3_bind_value, + sqlite3_busy_handler, + sqlite3_busy_timeout, + sqlite3_changes, + sqlite3_close, + sqlite3_collation_needed, + sqlite3_collation_needed16, + sqlite3_column_blob, + sqlite3_column_bytes, + sqlite3_column_bytes16, + sqlite3_column_count, + sqlite3_column_database_name, + sqlite3_column_database_name16, + sqlite3_column_decltype, + sqlite3_column_decltype16, + sqlite3_column_double, + sqlite3_column_int, + sqlite3_column_int64, + sqlite3_column_name, + sqlite3_column_name16, + sqlite3_column_origin_name, + sqlite3_column_origin_name16, + sqlite3_column_table_name, + sqlite3_column_table_name16, + sqlite3_column_text, + sqlite3_column_text16, + sqlite3_column_type, + sqlite3_column_value, + sqlite3_commit_hook, + sqlite3_complete, + sqlite3_complete16, + sqlite3_create_collation, + sqlite3_create_collation16, + sqlite3_create_function, + sqlite3_create_function16, + sqlite3_create_module, + sqlite3_data_count, + sqlite3_db_handle, + sqlite3_declare_vtab, + sqlite3_enable_shared_cache, + sqlite3_errcode, + sqlite3_errmsg, + sqlite3_errmsg16, + sqlite3_exec, +#ifndef SQLITE_OMIT_DEPRECATED + sqlite3_expired, +#else + 0, +#endif + sqlite3_finalize, + sqlite3_free, + sqlite3_free_table, + sqlite3_get_autocommit, + sqlite3_get_auxdata, + sqlite3_get_table, + 0, /* Was sqlite3_global_recover(), but that function is deprecated */ + sqlite3_interrupt, + sqlite3_last_insert_rowid, + sqlite3_libversion, + sqlite3_libversion_number, + sqlite3_malloc, + sqlite3_mprintf, + sqlite3_open, + sqlite3_open16, + sqlite3_prepare, + sqlite3_prepare16, + sqlite3_profile, + sqlite3_progress_handler, + sqlite3_realloc, + sqlite3_reset, + sqlite3_result_blob, + sqlite3_result_double, + sqlite3_result_error, + sqlite3_result_error16, + sqlite3_result_int, + sqlite3_result_int64, + sqlite3_result_null, + sqlite3_result_text, + sqlite3_result_text16, + sqlite3_result_text16be, + sqlite3_result_text16le, + sqlite3_result_value, + sqlite3_rollback_hook, + sqlite3_set_authorizer, + sqlite3_set_auxdata, + sqlite3_snprintf, + sqlite3_step, + sqlite3_table_column_metadata, +#ifndef SQLITE_OMIT_DEPRECATED + sqlite3_thread_cleanup, +#else + 0, +#endif + sqlite3_total_changes, + sqlite3_trace, +#ifndef SQLITE_OMIT_DEPRECATED + sqlite3_transfer_bindings, +#else + 0, +#endif + sqlite3_update_hook, + sqlite3_user_data, + sqlite3_value_blob, + sqlite3_value_bytes, + sqlite3_value_bytes16, + sqlite3_value_double, + sqlite3_value_int, + sqlite3_value_int64, + sqlite3_value_numeric_type, + sqlite3_value_text, + sqlite3_value_text16, + sqlite3_value_text16be, + sqlite3_value_text16le, + sqlite3_value_type, + sqlite3_vmprintf, + /* + ** The original API set ends here. All extensions can call any + ** of the APIs above provided that the pointer is not NULL. But + ** before calling APIs that follow, extension should check the + ** sqlite3_libversion_number() to make sure they are dealing with + ** a library that is new enough to support that API. + ************************************************************************* + */ + sqlite3_overload_function, + + /* + ** Added after 3.3.13 + */ + sqlite3_prepare_v2, + sqlite3_prepare16_v2, + sqlite3_clear_bindings, + + /* + ** Added for 3.4.1 + */ + sqlite3_create_module_v2, + + /* + ** Added for 3.5.0 + */ + sqlite3_bind_zeroblob, + sqlite3_blob_bytes, + sqlite3_blob_close, + sqlite3_blob_open, + sqlite3_blob_read, + sqlite3_blob_write, + sqlite3_create_collation_v2, + sqlite3_file_control, + sqlite3_memory_highwater, + sqlite3_memory_used, +#ifdef SQLITE_MUTEX_OMIT + 0, + 0, + 0, + 0, + 0, +#else + sqlite3_mutex_alloc, + sqlite3_mutex_enter, + sqlite3_mutex_free, + sqlite3_mutex_leave, + sqlite3_mutex_try, +#endif + sqlite3_open_v2, + sqlite3_release_memory, + sqlite3_result_error_nomem, + sqlite3_result_error_toobig, + sqlite3_sleep, + sqlite3_soft_heap_limit, + sqlite3_vfs_find, + sqlite3_vfs_register, + sqlite3_vfs_unregister, + + /* + ** Added for 3.5.8 + */ + sqlite3_threadsafe, + sqlite3_result_zeroblob, + sqlite3_result_error_code, + sqlite3_test_control, + sqlite3_randomness, + sqlite3_context_db_handle, + + /* + ** Added for 3.6.0 + */ + sqlite3_extended_result_codes, + sqlite3_limit, + sqlite3_next_stmt, + sqlite3_sql, + sqlite3_status, + + /* + ** Added for 3.7.4 + */ + sqlite3_backup_finish, + sqlite3_backup_init, + sqlite3_backup_pagecount, + sqlite3_backup_remaining, + sqlite3_backup_step, +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS + sqlite3_compileoption_get, + sqlite3_compileoption_used, +#else + 0, + 0, +#endif + sqlite3_create_function_v2, + sqlite3_db_config, + sqlite3_db_mutex, + sqlite3_db_status, + sqlite3_extended_errcode, + sqlite3_log, + sqlite3_soft_heap_limit64, + sqlite3_sourceid, + sqlite3_stmt_status, + sqlite3_strnicmp, +#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY + sqlite3_unlock_notify, +#else + 0, +#endif +#ifndef SQLITE_OMIT_WAL + sqlite3_wal_autocheckpoint, + sqlite3_wal_checkpoint, + sqlite3_wal_hook, +#else + 0, + 0, + 0, +#endif + sqlite3_blob_reopen, + sqlite3_vtab_config, + sqlite3_vtab_on_conflict, + sqlite3_close_v2, + sqlite3_db_filename, + sqlite3_db_readonly, + sqlite3_db_release_memory, + sqlite3_errstr, + sqlite3_stmt_busy, + sqlite3_stmt_readonly, + sqlite3_stricmp, + sqlite3_uri_boolean, + sqlite3_uri_int64, + sqlite3_uri_parameter, + sqlite3_vsnprintf, + sqlite3_wal_checkpoint_v2, + /* Version 3.8.7 and later */ + sqlite3_auto_extension, + sqlite3_bind_blob64, + sqlite3_bind_text64, + sqlite3_cancel_auto_extension, + sqlite3_load_extension, + sqlite3_malloc64, + sqlite3_msize, + sqlite3_realloc64, + sqlite3_reset_auto_extension, + sqlite3_result_blob64, + sqlite3_result_text64, + sqlite3_strglob, + /* Version 3.8.11 and later */ + (sqlite3_value*(*)(const sqlite3_value*))sqlite3_value_dup, + sqlite3_value_free, + sqlite3_result_zeroblob64, + sqlite3_bind_zeroblob64, + /* Version 3.9.0 and later */ + sqlite3_value_subtype, + sqlite3_result_subtype, + /* Version 3.10.0 and later */ + sqlite3_status64, + sqlite3_strlike, + sqlite3_db_cacheflush, + /* Version 3.12.0 and later */ + sqlite3_system_errno, + /* Version 3.14.0 and later */ + sqlite3_trace_v2, + sqlite3_expanded_sql, + /* Version 3.18.0 and later */ + sqlite3_set_last_insert_rowid, + /* Version 3.20.0 and later */ + sqlite3_prepare_v3, + sqlite3_prepare16_v3, + sqlite3_bind_pointer, + sqlite3_result_pointer, + sqlite3_value_pointer, + /* Version 3.22.0 and later */ + sqlite3_vtab_nochange, + sqlite3_value_nochange, + sqlite3_vtab_collation, + /* Version 3.24.0 and later */ + sqlite3_keyword_count, + sqlite3_keyword_name, + sqlite3_keyword_check, + sqlite3_str_new, + sqlite3_str_finish, + sqlite3_str_appendf, + sqlite3_str_vappendf, + sqlite3_str_append, + sqlite3_str_appendall, + sqlite3_str_appendchar, + sqlite3_str_reset, + sqlite3_str_errcode, + sqlite3_str_length, + sqlite3_str_value, + /* Version 3.25.0 and later */ + sqlite3_create_window_function, + /* Version 3.26.0 and later */ +#ifdef SQLITE_ENABLE_NORMALIZE + sqlite3_normalized_sql, +#else + 0, +#endif + /* Version 3.28.0 and later */ + sqlite3_stmt_isexplain, + sqlite3_value_frombind, + /* Version 3.30.0 and later */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + sqlite3_drop_modules, +#else + 0, +#endif + /* Version 3.31.0 and later */ + sqlite3_hard_heap_limit64, + sqlite3_uri_key, + sqlite3_filename_database, + sqlite3_filename_journal, + sqlite3_filename_wal, + /* Version 3.32.0 and later */ + sqlite3_create_filename, + sqlite3_free_filename, + sqlite3_database_file_object, + /* Version 3.34.0 and later */ + sqlite3_txn_state, +}; + +/* True if x is the directory separator character +*/ +#if SQLITE_OS_WIN +# define DirSep(X) ((X)=='/'||(X)=='\\') +#else +# define DirSep(X) ((X)=='/') +#endif + +/* +** Attempt to load an SQLite extension library contained in the file +** zFile. The entry point is zProc. zProc may be 0 in which case a +** default entry point name (sqlite3_extension_init) is used. Use +** of the default name is recommended. +** +** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong. +** +** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with +** error message text. The calling function should free this memory +** by calling sqlite3DbFree(db, ). +*/ +static int sqlite3LoadExtension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +){ + sqlite3_vfs *pVfs = db->pVfs; + void *handle; + sqlite3_loadext_entry xInit; + char *zErrmsg = 0; + const char *zEntry; + char *zAltEntry = 0; + void **aHandle; + u64 nMsg = 300 + sqlite3Strlen30(zFile); + int ii; + int rc; + + /* Shared library endings to try if zFile cannot be loaded as written */ + static const char *azEndings[] = { +#if SQLITE_OS_WIN + "dll" +#elif defined(__APPLE__) + "dylib" +#else + "so" +#endif + }; + + + if( pzErrMsg ) *pzErrMsg = 0; + + /* Ticket #1863. To avoid a creating security problems for older + ** applications that relink against newer versions of SQLite, the + ** ability to run load_extension is turned off by default. One + ** must call either sqlite3_enable_load_extension(db) or + ** sqlite3_db_config(db, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 1, 0) + ** to turn on extension loading. + */ + if( (db->flags & SQLITE_LoadExtension)==0 ){ + if( pzErrMsg ){ + *pzErrMsg = sqlite3_mprintf("not authorized"); + } + return SQLITE_ERROR; + } + + zEntry = zProc ? zProc : "sqlite3_extension_init"; + + handle = sqlite3OsDlOpen(pVfs, zFile); +#if SQLITE_OS_UNIX || SQLITE_OS_WIN + for(ii=0; ii sqlite3_example_init + ** C:/lib/mathfuncs.dll ==> sqlite3_mathfuncs_init + */ + if( xInit==0 && zProc==0 ){ + int iFile, iEntry, c; + int ncFile = sqlite3Strlen30(zFile); + zAltEntry = sqlite3_malloc64(ncFile+30); + if( zAltEntry==0 ){ + sqlite3OsDlClose(pVfs, handle); + return SQLITE_NOMEM_BKPT; + } + memcpy(zAltEntry, "sqlite3_", 8); + for(iFile=ncFile-1; iFile>=0 && !DirSep(zFile[iFile]); iFile--){} + iFile++; + if( sqlite3_strnicmp(zFile+iFile, "lib", 3)==0 ) iFile += 3; + for(iEntry=8; (c = zFile[iFile])!=0 && c!='.'; iFile++){ + if( sqlite3Isalpha(c) ){ + zAltEntry[iEntry++] = (char)sqlite3UpperToLower[(unsigned)c]; + } + } + memcpy(zAltEntry+iEntry, "_init", 6); + zEntry = zAltEntry; + xInit = (sqlite3_loadext_entry)sqlite3OsDlSym(pVfs, handle, zEntry); + } + if( xInit==0 ){ + if( pzErrMsg ){ + nMsg += sqlite3Strlen30(zEntry); + *pzErrMsg = zErrmsg = sqlite3_malloc64(nMsg); + if( zErrmsg ){ + sqlite3_snprintf(nMsg, zErrmsg, + "no entry point [%s] in shared library [%s]", zEntry, zFile); + sqlite3OsDlError(pVfs, nMsg-1, zErrmsg); + } + } + sqlite3OsDlClose(pVfs, handle); + sqlite3_free(zAltEntry); + return SQLITE_ERROR; + } + sqlite3_free(zAltEntry); + rc = xInit(db, &zErrmsg, &sqlite3Apis); + if( rc ){ + if( rc==SQLITE_OK_LOAD_PERMANENTLY ) return SQLITE_OK; + if( pzErrMsg ){ + *pzErrMsg = sqlite3_mprintf("error during initialization: %s", zErrmsg); + } + sqlite3_free(zErrmsg); + sqlite3OsDlClose(pVfs, handle); + return SQLITE_ERROR; + } + + /* Append the new shared library handle to the db->aExtension array. */ + aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1)); + if( aHandle==0 ){ + return SQLITE_NOMEM_BKPT; + } + if( db->nExtension>0 ){ + memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension); + } + sqlite3DbFree(db, db->aExtension); + db->aExtension = aHandle; + + db->aExtension[db->nExtension++] = handle; + return SQLITE_OK; +} +SQLITE_API int sqlite3_load_extension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +){ + int rc; + sqlite3_mutex_enter(db->mutex); + rc = sqlite3LoadExtension(db, zFile, zProc, pzErrMsg); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Call this routine when the database connection is closing in order +** to clean up loaded extensions +*/ +SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3 *db){ + int i; + assert( sqlite3_mutex_held(db->mutex) ); + for(i=0; inExtension; i++){ + sqlite3OsDlClose(db->pVfs, db->aExtension[i]); + } + sqlite3DbFree(db, db->aExtension); +} + +/* +** Enable or disable extension loading. Extension loading is disabled by +** default so as not to open security holes in older applications. +*/ +SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff){ + sqlite3_mutex_enter(db->mutex); + if( onoff ){ + db->flags |= SQLITE_LoadExtension|SQLITE_LoadExtFunc; + }else{ + db->flags &= ~(u64)(SQLITE_LoadExtension|SQLITE_LoadExtFunc); + } + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +#endif /* !defined(SQLITE_OMIT_LOAD_EXTENSION) */ + +/* +** The following object holds the list of automatically loaded +** extensions. +** +** This list is shared across threads. The SQLITE_MUTEX_STATIC_MAIN +** mutex must be held while accessing this list. +*/ +typedef struct sqlite3AutoExtList sqlite3AutoExtList; +static SQLITE_WSD struct sqlite3AutoExtList { + u32 nExt; /* Number of entries in aExt[] */ + void (**aExt)(void); /* Pointers to the extension init functions */ +} sqlite3Autoext = { 0, 0 }; + +/* The "wsdAutoext" macro will resolve to the autoextension +** state vector. If writable static data is unsupported on the target, +** we have to locate the state vector at run-time. In the more common +** case where writable static data is supported, wsdStat can refer directly +** to the "sqlite3Autoext" state vector declared above. +*/ +#ifdef SQLITE_OMIT_WSD +# define wsdAutoextInit \ + sqlite3AutoExtList *x = &GLOBAL(sqlite3AutoExtList,sqlite3Autoext) +# define wsdAutoext x[0] +#else +# define wsdAutoextInit +# define wsdAutoext sqlite3Autoext +#endif + + +/* +** Register a statically linked extension that is automatically +** loaded by every new database connection. +*/ +SQLITE_API int sqlite3_auto_extension( + void (*xInit)(void) +){ + int rc = SQLITE_OK; +#ifndef SQLITE_OMIT_AUTOINIT + rc = sqlite3_initialize(); + if( rc ){ + return rc; + }else +#endif + { + u32 i; +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); +#endif + wsdAutoextInit; + sqlite3_mutex_enter(mutex); + for(i=0; i=0; i--){ + if( wsdAutoext.aExt[i]==xInit ){ + wsdAutoext.nExt--; + wsdAutoext.aExt[i] = wsdAutoext.aExt[wsdAutoext.nExt]; + n++; + break; + } + } + sqlite3_mutex_leave(mutex); + return n; +} + +/* +** Reset the automatic extension loading mechanism. +*/ +SQLITE_API void sqlite3_reset_auto_extension(void){ +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize()==SQLITE_OK ) +#endif + { +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); +#endif + wsdAutoextInit; + sqlite3_mutex_enter(mutex); + sqlite3_free(wsdAutoext.aExt); + wsdAutoext.aExt = 0; + wsdAutoext.nExt = 0; + sqlite3_mutex_leave(mutex); + } +} + +/* +** Load all automatic extensions. +** +** If anything goes wrong, set an error in the database connection. +*/ +SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3 *db){ + u32 i; + int go = 1; + int rc; + sqlite3_loadext_entry xInit; + + wsdAutoextInit; + if( wsdAutoext.nExt==0 ){ + /* Common case: early out without every having to acquire a mutex */ + return; + } + for(i=0; go; i++){ + char *zErrmsg; +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); +#endif +#ifdef SQLITE_OMIT_LOAD_EXTENSION + const sqlite3_api_routines *pThunk = 0; +#else + const sqlite3_api_routines *pThunk = &sqlite3Apis; +#endif + sqlite3_mutex_enter(mutex); + if( i>=wsdAutoext.nExt ){ + xInit = 0; + go = 0; + }else{ + xInit = (sqlite3_loadext_entry)wsdAutoext.aExt[i]; + } + sqlite3_mutex_leave(mutex); + zErrmsg = 0; + if( xInit && (rc = xInit(db, &zErrmsg, pThunk))!=0 ){ + sqlite3ErrorWithMsg(db, rc, + "automatic extension loading failed: %s", zErrmsg); + go = 0; + } + sqlite3_free(zErrmsg); + } +} + +/************** End of loadext.c *********************************************/ +/************** Begin file pragma.c ******************************************/ +/* +** 2003 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the PRAGMA command. +*/ +/* #include "sqliteInt.h" */ + +#if !defined(SQLITE_ENABLE_LOCKING_STYLE) +# if defined(__APPLE__) +# define SQLITE_ENABLE_LOCKING_STYLE 1 +# else +# define SQLITE_ENABLE_LOCKING_STYLE 0 +# endif +#endif + +/*************************************************************************** +** The "pragma.h" include file is an automatically generated file that +** that includes the PragType_XXXX macro definitions and the aPragmaName[] +** object. This ensures that the aPragmaName[] table is arranged in +** lexicographical order to facility a binary search of the pragma name. +** Do not edit pragma.h directly. Edit and rerun the script in at +** ../tool/mkpragmatab.tcl. */ +/************** Include pragma.h in the middle of pragma.c *******************/ +/************** Begin file pragma.h ******************************************/ +/* DO NOT EDIT! +** This file is automatically generated by the script at +** ../tool/mkpragmatab.tcl. To update the set of pragmas, edit +** that script and rerun it. +*/ + +/* The various pragma types */ +#define PragTyp_ACTIVATE_EXTENSIONS 0 +#define PragTyp_ANALYSIS_LIMIT 1 +#define PragTyp_HEADER_VALUE 2 +#define PragTyp_AUTO_VACUUM 3 +#define PragTyp_FLAG 4 +#define PragTyp_BUSY_TIMEOUT 5 +#define PragTyp_CACHE_SIZE 6 +#define PragTyp_CACHE_SPILL 7 +#define PragTyp_CASE_SENSITIVE_LIKE 8 +#define PragTyp_COLLATION_LIST 9 +#define PragTyp_COMPILE_OPTIONS 10 +#define PragTyp_DATA_STORE_DIRECTORY 11 +#define PragTyp_DATABASE_LIST 12 +#define PragTyp_DEFAULT_CACHE_SIZE 13 +#define PragTyp_ENCODING 14 +#define PragTyp_FOREIGN_KEY_CHECK 15 +#define PragTyp_FOREIGN_KEY_LIST 16 +#define PragTyp_FUNCTION_LIST 17 +#define PragTyp_HARD_HEAP_LIMIT 18 +#define PragTyp_INCREMENTAL_VACUUM 19 +#define PragTyp_INDEX_INFO 20 +#define PragTyp_INDEX_LIST 21 +#define PragTyp_INTEGRITY_CHECK 22 +#define PragTyp_JOURNAL_MODE 23 +#define PragTyp_JOURNAL_SIZE_LIMIT 24 +#define PragTyp_LOCK_PROXY_FILE 25 +#define PragTyp_LOCKING_MODE 26 +#define PragTyp_PAGE_COUNT 27 +#define PragTyp_MMAP_SIZE 28 +#define PragTyp_MODULE_LIST 29 +#define PragTyp_OPTIMIZE 30 +#define PragTyp_PAGE_SIZE 31 +#define PragTyp_PRAGMA_LIST 32 +#define PragTyp_SECURE_DELETE 33 +#define PragTyp_SHRINK_MEMORY 34 +#define PragTyp_SOFT_HEAP_LIMIT 35 +#define PragTyp_SYNCHRONOUS 36 +#define PragTyp_TABLE_INFO 37 +#define PragTyp_TEMP_STORE 38 +#define PragTyp_TEMP_STORE_DIRECTORY 39 +#define PragTyp_THREADS 40 +#define PragTyp_WAL_AUTOCHECKPOINT 41 +#define PragTyp_WAL_CHECKPOINT 42 +#define PragTyp_LOCK_STATUS 43 +#define PragTyp_STATS 44 + +/* Property flags associated with various pragma. */ +#define PragFlg_NeedSchema 0x01 /* Force schema load before running */ +#define PragFlg_NoColumns 0x02 /* OP_ResultRow called with zero columns */ +#define PragFlg_NoColumns1 0x04 /* zero columns if RHS argument is present */ +#define PragFlg_ReadOnly 0x08 /* Read-only HEADER_VALUE */ +#define PragFlg_Result0 0x10 /* Acts as query when no argument */ +#define PragFlg_Result1 0x20 /* Acts as query when has one argument */ +#define PragFlg_SchemaOpt 0x40 /* Schema restricts name search if present */ +#define PragFlg_SchemaReq 0x80 /* Schema required - "main" is default */ + +/* Names of columns for pragmas that return multi-column result +** or that return single-column results where the name of the +** result column is different from the name of the pragma +*/ +static const char *const pragCName[] = { + /* 0 */ "id", /* Used by: foreign_key_list */ + /* 1 */ "seq", + /* 2 */ "table", + /* 3 */ "from", + /* 4 */ "to", + /* 5 */ "on_update", + /* 6 */ "on_delete", + /* 7 */ "match", + /* 8 */ "cid", /* Used by: table_xinfo */ + /* 9 */ "name", + /* 10 */ "type", + /* 11 */ "notnull", + /* 12 */ "dflt_value", + /* 13 */ "pk", + /* 14 */ "hidden", + /* table_info reuses 8 */ + /* 15 */ "seqno", /* Used by: index_xinfo */ + /* 16 */ "cid", + /* 17 */ "name", + /* 18 */ "desc", + /* 19 */ "coll", + /* 20 */ "key", + /* 21 */ "name", /* Used by: function_list */ + /* 22 */ "builtin", + /* 23 */ "type", + /* 24 */ "enc", + /* 25 */ "narg", + /* 26 */ "flags", + /* 27 */ "tbl", /* Used by: stats */ + /* 28 */ "idx", + /* 29 */ "wdth", + /* 30 */ "hght", + /* 31 */ "flgs", + /* 32 */ "seq", /* Used by: index_list */ + /* 33 */ "name", + /* 34 */ "unique", + /* 35 */ "origin", + /* 36 */ "partial", + /* 37 */ "table", /* Used by: foreign_key_check */ + /* 38 */ "rowid", + /* 39 */ "parent", + /* 40 */ "fkid", + /* index_info reuses 15 */ + /* 41 */ "seq", /* Used by: database_list */ + /* 42 */ "name", + /* 43 */ "file", + /* 44 */ "busy", /* Used by: wal_checkpoint */ + /* 45 */ "log", + /* 46 */ "checkpointed", + /* collation_list reuses 32 */ + /* 47 */ "database", /* Used by: lock_status */ + /* 48 */ "status", + /* 49 */ "cache_size", /* Used by: default_cache_size */ + /* module_list pragma_list reuses 9 */ + /* 50 */ "timeout", /* Used by: busy_timeout */ +}; + +/* Definitions of all built-in pragmas */ +typedef struct PragmaName { + const char *const zName; /* Name of pragma */ + u8 ePragTyp; /* PragTyp_XXX value */ + u8 mPragFlg; /* Zero or more PragFlg_XXX values */ + u8 iPragCName; /* Start of column names in pragCName[] */ + u8 nPragCName; /* Num of col names. 0 means use pragma name */ + u64 iArg; /* Extra argument */ +} PragmaName; +static const PragmaName aPragmaName[] = { +#if defined(SQLITE_ENABLE_CEROD) + {/* zName: */ "activate_extensions", + /* ePragTyp: */ PragTyp_ACTIVATE_EXTENSIONS, + /* ePragFlg: */ 0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif + {/* zName: */ "analysis_limit", + /* ePragTyp: */ PragTyp_ANALYSIS_LIMIT, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS) + {/* zName: */ "application_id", + /* ePragTyp: */ PragTyp_HEADER_VALUE, + /* ePragFlg: */ PragFlg_NoColumns1|PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ BTREE_APPLICATION_ID }, +#endif +#if !defined(SQLITE_OMIT_AUTOVACUUM) + {/* zName: */ "auto_vacuum", + /* ePragTyp: */ PragTyp_AUTO_VACUUM, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if !defined(SQLITE_OMIT_AUTOMATIC_INDEX) + {/* zName: */ "automatic_index", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_AutoIndex }, +#endif +#endif + {/* zName: */ "busy_timeout", + /* ePragTyp: */ PragTyp_BUSY_TIMEOUT, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 50, 1, + /* iArg: */ 0 }, +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + {/* zName: */ "cache_size", + /* ePragTyp: */ PragTyp_CACHE_SIZE, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "cache_spill", + /* ePragTyp: */ PragTyp_CACHE_SPILL, + /* ePragFlg: */ PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_CASE_SENSITIVE_LIKE_PRAGMA) + {/* zName: */ "case_sensitive_like", + /* ePragTyp: */ PragTyp_CASE_SENSITIVE_LIKE, + /* ePragFlg: */ PragFlg_NoColumns, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif + {/* zName: */ "cell_size_check", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_CellSizeCk }, +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "checkpoint_fullfsync", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_CkptFullFSync }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) + {/* zName: */ "collation_list", + /* ePragTyp: */ PragTyp_COLLATION_LIST, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 32, 2, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_COMPILEOPTION_DIAGS) + {/* zName: */ "compile_options", + /* ePragTyp: */ PragTyp_COMPILE_OPTIONS, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "count_changes", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_CountRows }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_OS_WIN + {/* zName: */ "data_store_directory", + /* ePragTyp: */ PragTyp_DATA_STORE_DIRECTORY, + /* ePragFlg: */ PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS) + {/* zName: */ "data_version", + /* ePragTyp: */ PragTyp_HEADER_VALUE, + /* ePragFlg: */ PragFlg_ReadOnly|PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ BTREE_DATA_VERSION }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) + {/* zName: */ "database_list", + /* ePragTyp: */ PragTyp_DATABASE_LIST, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0, + /* ColNames: */ 41, 3, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED) + {/* zName: */ "default_cache_size", + /* ePragTyp: */ PragTyp_DEFAULT_CACHE_SIZE, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1, + /* ColNames: */ 49, 1, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) + {/* zName: */ "defer_foreign_keys", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_DeferFKs }, +#endif +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "empty_result_callbacks", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_NullCallback }, +#endif +#if !defined(SQLITE_OMIT_UTF16) + {/* zName: */ "encoding", + /* ePragTyp: */ PragTyp_ENCODING, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) + {/* zName: */ "foreign_key_check", + /* ePragTyp: */ PragTyp_FOREIGN_KEY_CHECK, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 37, 4, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FOREIGN_KEY) + {/* zName: */ "foreign_key_list", + /* ePragTyp: */ PragTyp_FOREIGN_KEY_LIST, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 0, 8, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) + {/* zName: */ "foreign_keys", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_ForeignKeys }, +#endif +#endif +#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS) + {/* zName: */ "freelist_count", + /* ePragTyp: */ PragTyp_HEADER_VALUE, + /* ePragFlg: */ PragFlg_ReadOnly|PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ BTREE_FREE_PAGE_COUNT }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "full_column_names", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_FullColNames }, + {/* zName: */ "fullfsync", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_FullFSync }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) +#if !defined(SQLITE_OMIT_INTROSPECTION_PRAGMAS) + {/* zName: */ "function_list", + /* ePragTyp: */ PragTyp_FUNCTION_LIST, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 21, 6, + /* iArg: */ 0 }, +#endif +#endif + {/* zName: */ "hard_heap_limit", + /* ePragTyp: */ PragTyp_HARD_HEAP_LIMIT, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if !defined(SQLITE_OMIT_CHECK) + {/* zName: */ "ignore_check_constraints", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_IgnoreChecks }, +#endif +#endif +#if !defined(SQLITE_OMIT_AUTOVACUUM) + {/* zName: */ "incremental_vacuum", + /* ePragTyp: */ PragTyp_INCREMENTAL_VACUUM, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_NoColumns, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) + {/* zName: */ "index_info", + /* ePragTyp: */ PragTyp_INDEX_INFO, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 15, 3, + /* iArg: */ 0 }, + {/* zName: */ "index_list", + /* ePragTyp: */ PragTyp_INDEX_LIST, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 32, 5, + /* iArg: */ 0 }, + {/* zName: */ "index_xinfo", + /* ePragTyp: */ PragTyp_INDEX_INFO, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 15, 6, + /* iArg: */ 1 }, +#endif +#if !defined(SQLITE_OMIT_INTEGRITY_CHECK) + {/* zName: */ "integrity_check", + /* ePragTyp: */ PragTyp_INTEGRITY_CHECK, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + {/* zName: */ "journal_mode", + /* ePragTyp: */ PragTyp_JOURNAL_MODE, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, + {/* zName: */ "journal_size_limit", + /* ePragTyp: */ PragTyp_JOURNAL_SIZE_LIMIT, + /* ePragFlg: */ PragFlg_Result0|PragFlg_SchemaReq, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "legacy_alter_table", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_LegacyAlter }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_ENABLE_LOCKING_STYLE + {/* zName: */ "lock_proxy_file", + /* ePragTyp: */ PragTyp_LOCK_PROXY_FILE, + /* ePragFlg: */ PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + {/* zName: */ "lock_status", + /* ePragTyp: */ PragTyp_LOCK_STATUS, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 47, 2, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + {/* zName: */ "locking_mode", + /* ePragTyp: */ PragTyp_LOCKING_MODE, + /* ePragFlg: */ PragFlg_Result0|PragFlg_SchemaReq, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, + {/* zName: */ "max_page_count", + /* ePragTyp: */ PragTyp_PAGE_COUNT, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, + {/* zName: */ "mmap_size", + /* ePragTyp: */ PragTyp_MMAP_SIZE, + /* ePragFlg: */ 0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) +#if !defined(SQLITE_OMIT_VIRTUALTABLE) +#if !defined(SQLITE_OMIT_INTROSPECTION_PRAGMAS) + {/* zName: */ "module_list", + /* ePragTyp: */ PragTyp_MODULE_LIST, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 9, 1, + /* iArg: */ 0 }, +#endif +#endif +#endif + {/* zName: */ "optimize", + /* ePragTyp: */ PragTyp_OPTIMIZE, + /* ePragFlg: */ PragFlg_Result1|PragFlg_NeedSchema, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + {/* zName: */ "page_count", + /* ePragTyp: */ PragTyp_PAGE_COUNT, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, + {/* zName: */ "page_size", + /* ePragTyp: */ PragTyp_PAGE_SIZE, + /* ePragFlg: */ PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if defined(SQLITE_DEBUG) + {/* zName: */ "parser_trace", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_ParserTrace }, +#endif +#endif +#if !defined(SQLITE_OMIT_INTROSPECTION_PRAGMAS) + {/* zName: */ "pragma_list", + /* ePragTyp: */ PragTyp_PRAGMA_LIST, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 9, 1, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "query_only", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_QueryOnly }, +#endif +#if !defined(SQLITE_OMIT_INTEGRITY_CHECK) + {/* zName: */ "quick_check", + /* ePragTyp: */ PragTyp_INTEGRITY_CHECK, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "read_uncommitted", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_ReadUncommit }, + {/* zName: */ "recursive_triggers", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_RecTriggers }, + {/* zName: */ "reverse_unordered_selects", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_ReverseOrder }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS) + {/* zName: */ "schema_version", + /* ePragTyp: */ PragTyp_HEADER_VALUE, + /* ePragFlg: */ PragFlg_NoColumns1|PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ BTREE_SCHEMA_VERSION }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + {/* zName: */ "secure_delete", + /* ePragTyp: */ PragTyp_SECURE_DELETE, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "short_column_names", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_ShortColNames }, +#endif + {/* zName: */ "shrink_memory", + /* ePragTyp: */ PragTyp_SHRINK_MEMORY, + /* ePragFlg: */ PragFlg_NoColumns, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, + {/* zName: */ "soft_heap_limit", + /* ePragTyp: */ PragTyp_SOFT_HEAP_LIMIT, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if defined(SQLITE_DEBUG) + {/* zName: */ "sql_trace", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_SqlTrace }, +#endif +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) && defined(SQLITE_DEBUG) + {/* zName: */ "stats", + /* ePragTyp: */ PragTyp_STATS, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq, + /* ColNames: */ 27, 5, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + {/* zName: */ "synchronous", + /* ePragTyp: */ PragTyp_SYNCHRONOUS, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) + {/* zName: */ "table_info", + /* ePragTyp: */ PragTyp_TABLE_INFO, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 8, 6, + /* iArg: */ 0 }, + {/* zName: */ "table_xinfo", + /* ePragTyp: */ PragTyp_TABLE_INFO, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 8, 7, + /* iArg: */ 1 }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + {/* zName: */ "temp_store", + /* ePragTyp: */ PragTyp_TEMP_STORE, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, + {/* zName: */ "temp_store_directory", + /* ePragTyp: */ PragTyp_TEMP_STORE_DIRECTORY, + /* ePragFlg: */ PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif + {/* zName: */ "threads", + /* ePragTyp: */ PragTyp_THREADS, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "trusted_schema", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_TrustedSchema }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS) + {/* zName: */ "user_version", + /* ePragTyp: */ PragTyp_HEADER_VALUE, + /* ePragFlg: */ PragFlg_NoColumns1|PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ BTREE_USER_VERSION }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if defined(SQLITE_DEBUG) + {/* zName: */ "vdbe_addoptrace", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_VdbeAddopTrace }, + {/* zName: */ "vdbe_debug", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_SqlTrace|SQLITE_VdbeListing|SQLITE_VdbeTrace }, + {/* zName: */ "vdbe_eqp", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_VdbeEQP }, + {/* zName: */ "vdbe_listing", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_VdbeListing }, + {/* zName: */ "vdbe_trace", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_VdbeTrace }, +#endif +#endif +#if !defined(SQLITE_OMIT_WAL) + {/* zName: */ "wal_autocheckpoint", + /* ePragTyp: */ PragTyp_WAL_AUTOCHECKPOINT, + /* ePragFlg: */ 0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, + {/* zName: */ "wal_checkpoint", + /* ePragTyp: */ PragTyp_WAL_CHECKPOINT, + /* ePragFlg: */ PragFlg_NeedSchema, + /* ColNames: */ 44, 3, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "writable_schema", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_WriteSchema|SQLITE_NoSchemaError }, +#endif +}; +/* Number of pragmas: 67 on by default, 77 total. */ + +/************** End of pragma.h **********************************************/ +/************** Continuing where we left off in pragma.c *********************/ + +/* +** Interpret the given string as a safety level. Return 0 for OFF, +** 1 for ON or NORMAL, 2 for FULL, and 3 for EXTRA. Return 1 for an empty or +** unrecognized string argument. The FULL and EXTRA option is disallowed +** if the omitFull parameter it 1. +** +** Note that the values returned are one less that the values that +** should be passed into sqlite3BtreeSetSafetyLevel(). The is done +** to support legacy SQL code. The safety level used to be boolean +** and older scripts may have used numbers 0 for OFF and 1 for ON. +*/ +static u8 getSafetyLevel(const char *z, int omitFull, u8 dflt){ + /* 123456789 123456789 123 */ + static const char zText[] = "onoffalseyestruextrafull"; + static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 15, 20}; + static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 5, 4}; + static const u8 iValue[] = {1, 0, 0, 0, 1, 1, 3, 2}; + /* on no off false yes true extra full */ + int i, n; + if( sqlite3Isdigit(*z) ){ + return (u8)sqlite3Atoi(z); + } + n = sqlite3Strlen30(z); + for(i=0; i=0&&i<=2)?i:0); +} +#endif /* ifndef SQLITE_OMIT_AUTOVACUUM */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* +** Interpret the given string as a temp db location. Return 1 for file +** backed temporary databases, 2 for the Red-Black tree in memory database +** and 0 to use the compile-time default. +*/ +static int getTempStore(const char *z){ + if( z[0]>='0' && z[0]<='2' ){ + return z[0] - '0'; + }else if( sqlite3StrICmp(z, "file")==0 ){ + return 1; + }else if( sqlite3StrICmp(z, "memory")==0 ){ + return 2; + }else{ + return 0; + } +} +#endif /* SQLITE_PAGER_PRAGMAS */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* +** Invalidate temp storage, either when the temp storage is changed +** from default, or when 'file' and the temp_store_directory has changed +*/ +static int invalidateTempStorage(Parse *pParse){ + sqlite3 *db = pParse->db; + if( db->aDb[1].pBt!=0 ){ + if( !db->autoCommit + || sqlite3BtreeTxnState(db->aDb[1].pBt)!=SQLITE_TXN_NONE + ){ + sqlite3ErrorMsg(pParse, "temporary storage cannot be changed " + "from within a transaction"); + return SQLITE_ERROR; + } + sqlite3BtreeClose(db->aDb[1].pBt); + db->aDb[1].pBt = 0; + sqlite3ResetAllSchemasOfConnection(db); + } + return SQLITE_OK; +} +#endif /* SQLITE_PAGER_PRAGMAS */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* +** If the TEMP database is open, close it and mark the database schema +** as needing reloading. This must be done when using the SQLITE_TEMP_STORE +** or DEFAULT_TEMP_STORE pragmas. +*/ +static int changeTempStorage(Parse *pParse, const char *zStorageType){ + int ts = getTempStore(zStorageType); + sqlite3 *db = pParse->db; + if( db->temp_store==ts ) return SQLITE_OK; + if( invalidateTempStorage( pParse ) != SQLITE_OK ){ + return SQLITE_ERROR; + } + db->temp_store = (u8)ts; + return SQLITE_OK; +} +#endif /* SQLITE_PAGER_PRAGMAS */ + +/* +** Set result column names for a pragma. +*/ +static void setPragmaResultColumnNames( + Vdbe *v, /* The query under construction */ + const PragmaName *pPragma /* The pragma */ +){ + u8 n = pPragma->nPragCName; + sqlite3VdbeSetNumCols(v, n==0 ? 1 : n); + if( n==0 ){ + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, pPragma->zName, SQLITE_STATIC); + }else{ + int i, j; + for(i=0, j=pPragma->iPragCName; iautoCommit ){ + Db *pDb = db->aDb; + int n = db->nDb; + assert( SQLITE_FullFSync==PAGER_FULLFSYNC ); + assert( SQLITE_CkptFullFSync==PAGER_CKPT_FULLFSYNC ); + assert( SQLITE_CacheSpill==PAGER_CACHESPILL ); + assert( (PAGER_FULLFSYNC | PAGER_CKPT_FULLFSYNC | PAGER_CACHESPILL) + == PAGER_FLAGS_MASK ); + assert( (pDb->safety_level & PAGER_SYNCHRONOUS_MASK)==pDb->safety_level ); + while( (n--) > 0 ){ + if( pDb->pBt ){ + sqlite3BtreeSetPagerFlags(pDb->pBt, + pDb->safety_level | (db->flags & PAGER_FLAGS_MASK) ); + } + pDb++; + } + } +} +#else +# define setAllPagerFlags(X) /* no-op */ +#endif + + +/* +** Return a human-readable name for a constraint resolution action. +*/ +#ifndef SQLITE_OMIT_FOREIGN_KEY +static const char *actionName(u8 action){ + const char *zName; + switch( action ){ + case OE_SetNull: zName = "SET NULL"; break; + case OE_SetDflt: zName = "SET DEFAULT"; break; + case OE_Cascade: zName = "CASCADE"; break; + case OE_Restrict: zName = "RESTRICT"; break; + default: zName = "NO ACTION"; + assert( action==OE_None ); break; + } + return zName; +} +#endif + + +/* +** Parameter eMode must be one of the PAGER_JOURNALMODE_XXX constants +** defined in pager.h. This function returns the associated lowercase +** journal-mode name. +*/ +SQLITE_PRIVATE const char *sqlite3JournalModename(int eMode){ + static char * const azModeName[] = { + "delete", "persist", "off", "truncate", "memory" +#ifndef SQLITE_OMIT_WAL + , "wal" +#endif + }; + assert( PAGER_JOURNALMODE_DELETE==0 ); + assert( PAGER_JOURNALMODE_PERSIST==1 ); + assert( PAGER_JOURNALMODE_OFF==2 ); + assert( PAGER_JOURNALMODE_TRUNCATE==3 ); + assert( PAGER_JOURNALMODE_MEMORY==4 ); + assert( PAGER_JOURNALMODE_WAL==5 ); + assert( eMode>=0 && eMode<=ArraySize(azModeName) ); + + if( eMode==ArraySize(azModeName) ) return 0; + return azModeName[eMode]; +} + +/* +** Locate a pragma in the aPragmaName[] array. +*/ +static const PragmaName *pragmaLocate(const char *zName){ + int upr, lwr, mid = 0, rc; + lwr = 0; + upr = ArraySize(aPragmaName)-1; + while( lwr<=upr ){ + mid = (lwr+upr)/2; + rc = sqlite3_stricmp(zName, aPragmaName[mid].zName); + if( rc==0 ) break; + if( rc<0 ){ + upr = mid - 1; + }else{ + lwr = mid + 1; + } + } + return lwr>upr ? 0 : &aPragmaName[mid]; +} + +/* +** Create zero or more entries in the output for the SQL functions +** defined by FuncDef p. +*/ +static void pragmaFunclistLine( + Vdbe *v, /* The prepared statement being created */ + FuncDef *p, /* A particular function definition */ + int isBuiltin, /* True if this is a built-in function */ + int showInternFuncs /* True if showing internal functions */ +){ + for(; p; p=p->pNext){ + const char *zType; + static const u32 mask = + SQLITE_DETERMINISTIC | + SQLITE_DIRECTONLY | + SQLITE_SUBTYPE | + SQLITE_INNOCUOUS | + SQLITE_FUNC_INTERNAL + ; + static const char *azEnc[] = { 0, "utf8", "utf16le", "utf16be" }; + + assert( SQLITE_FUNC_ENCMASK==0x3 ); + assert( strcmp(azEnc[SQLITE_UTF8],"utf8")==0 ); + assert( strcmp(azEnc[SQLITE_UTF16LE],"utf16le")==0 ); + assert( strcmp(azEnc[SQLITE_UTF16BE],"utf16be")==0 ); + + if( p->xSFunc==0 ) continue; + if( (p->funcFlags & SQLITE_FUNC_INTERNAL)!=0 + && showInternFuncs==0 + ){ + continue; + } + if( p->xValue!=0 ){ + zType = "w"; + }else if( p->xFinalize!=0 ){ + zType = "a"; + }else{ + zType = "s"; + } + sqlite3VdbeMultiLoad(v, 1, "sissii", + p->zName, isBuiltin, + zType, azEnc[p->funcFlags&SQLITE_FUNC_ENCMASK], + p->nArg, + (p->funcFlags & mask) ^ SQLITE_INNOCUOUS + ); + } +} + + +/* +** Helper subroutine for PRAGMA integrity_check: +** +** Generate code to output a single-column result row with a value of the +** string held in register 3. Decrement the result count in register 1 +** and halt if the maximum number of result rows have been issued. +*/ +static int integrityCheckResultRow(Vdbe *v){ + int addr; + sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1); + addr = sqlite3VdbeAddOp3(v, OP_IfPos, 1, sqlite3VdbeCurrentAddr(v)+2, 1); + VdbeCoverage(v); + sqlite3VdbeAddOp0(v, OP_Halt); + return addr; +} + +/* +** Process a pragma statement. +** +** Pragmas are of this form: +** +** PRAGMA [schema.]id [= value] +** +** The identifier might also be a string. The value is a string, and +** identifier, or a number. If minusFlag is true, then the value is +** a number that was preceded by a minus sign. +** +** If the left side is "database.id" then pId1 is the database name +** and pId2 is the id. If the left side is just "id" then pId1 is the +** id and pId2 is any empty string. +*/ +SQLITE_PRIVATE void sqlite3Pragma( + Parse *pParse, + Token *pId1, /* First part of [schema.]id field */ + Token *pId2, /* Second part of [schema.]id field, or NULL */ + Token *pValue, /* Token for , or NULL */ + int minusFlag /* True if a '-' sign preceded */ +){ + char *zLeft = 0; /* Nul-terminated UTF-8 string */ + char *zRight = 0; /* Nul-terminated UTF-8 string , or NULL */ + const char *zDb = 0; /* The database name */ + Token *pId; /* Pointer to token */ + char *aFcntl[4]; /* Argument to SQLITE_FCNTL_PRAGMA */ + int iDb; /* Database index for */ + int rc; /* return value form SQLITE_FCNTL_PRAGMA */ + sqlite3 *db = pParse->db; /* The database connection */ + Db *pDb; /* The specific database being pragmaed */ + Vdbe *v = sqlite3GetVdbe(pParse); /* Prepared statement */ + const PragmaName *pPragma; /* The pragma */ + + if( v==0 ) return; + sqlite3VdbeRunOnlyOnce(v); + pParse->nMem = 2; + + /* Interpret the [schema.] part of the pragma statement. iDb is the + ** index of the database this pragma is being applied to in db.aDb[]. */ + iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId); + if( iDb<0 ) return; + pDb = &db->aDb[iDb]; + + /* If the temp database has been explicitly named as part of the + ** pragma, make sure it is open. + */ + if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){ + return; + } + + zLeft = sqlite3NameFromToken(db, pId); + if( !zLeft ) return; + if( minusFlag ){ + zRight = sqlite3MPrintf(db, "-%T", pValue); + }else{ + zRight = sqlite3NameFromToken(db, pValue); + } + + assert( pId2 ); + zDb = pId2->n>0 ? pDb->zDbSName : 0; + if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){ + goto pragma_out; + } + + /* Send an SQLITE_FCNTL_PRAGMA file-control to the underlying VFS + ** connection. If it returns SQLITE_OK, then assume that the VFS + ** handled the pragma and generate a no-op prepared statement. + ** + ** IMPLEMENTATION-OF: R-12238-55120 Whenever a PRAGMA statement is parsed, + ** an SQLITE_FCNTL_PRAGMA file control is sent to the open sqlite3_file + ** object corresponding to the database file to which the pragma + ** statement refers. + ** + ** IMPLEMENTATION-OF: R-29875-31678 The argument to the SQLITE_FCNTL_PRAGMA + ** file control is an array of pointers to strings (char**) in which the + ** second element of the array is the name of the pragma and the third + ** element is the argument to the pragma or NULL if the pragma has no + ** argument. + */ + aFcntl[0] = 0; + aFcntl[1] = zLeft; + aFcntl[2] = zRight; + aFcntl[3] = 0; + db->busyHandler.nBusy = 0; + rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_PRAGMA, (void*)aFcntl); + if( rc==SQLITE_OK ){ + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, aFcntl[0], SQLITE_TRANSIENT); + returnSingleText(v, aFcntl[0]); + sqlite3_free(aFcntl[0]); + goto pragma_out; + } + if( rc!=SQLITE_NOTFOUND ){ + if( aFcntl[0] ){ + sqlite3ErrorMsg(pParse, "%s", aFcntl[0]); + sqlite3_free(aFcntl[0]); + } + pParse->nErr++; + pParse->rc = rc; + goto pragma_out; + } + + /* Locate the pragma in the lookup table */ + pPragma = pragmaLocate(zLeft); + if( pPragma==0 ) goto pragma_out; + + /* Make sure the database schema is loaded if the pragma requires that */ + if( (pPragma->mPragFlg & PragFlg_NeedSchema)!=0 ){ + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + } + + /* Register the result column names for pragmas that return results */ + if( (pPragma->mPragFlg & PragFlg_NoColumns)==0 + && ((pPragma->mPragFlg & PragFlg_NoColumns1)==0 || zRight==0) + ){ + setPragmaResultColumnNames(v, pPragma); + } + + /* Jump to the appropriate pragma handler */ + switch( pPragma->ePragTyp ){ + +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED) + /* + ** PRAGMA [schema.]default_cache_size + ** PRAGMA [schema.]default_cache_size=N + ** + ** The first form reports the current persistent setting for the + ** page cache size. The value returned is the maximum number of + ** pages in the page cache. The second form sets both the current + ** page cache size value and the persistent page cache size value + ** stored in the database file. + ** + ** Older versions of SQLite would set the default cache size to a + ** negative number to indicate synchronous=OFF. These days, synchronous + ** is always on by default regardless of the sign of the default cache + ** size. But continue to take the absolute value of the default cache + ** size of historical compatibility. + */ + case PragTyp_DEFAULT_CACHE_SIZE: { + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList getCacheSize[] = { + { OP_Transaction, 0, 0, 0}, /* 0 */ + { OP_ReadCookie, 0, 1, BTREE_DEFAULT_CACHE_SIZE}, /* 1 */ + { OP_IfPos, 1, 8, 0}, + { OP_Integer, 0, 2, 0}, + { OP_Subtract, 1, 2, 1}, + { OP_IfPos, 1, 8, 0}, + { OP_Integer, 0, 1, 0}, /* 6 */ + { OP_Noop, 0, 0, 0}, + { OP_ResultRow, 1, 1, 0}, + }; + VdbeOp *aOp; + sqlite3VdbeUsesBtree(v, iDb); + if( !zRight ){ + pParse->nMem += 2; + sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(getCacheSize)); + aOp = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize, iLn); + if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break; + aOp[0].p1 = iDb; + aOp[1].p1 = iDb; + aOp[6].p1 = SQLITE_DEFAULT_CACHE_SIZE; + }else{ + int size = sqlite3AbsInt32(sqlite3Atoi(zRight)); + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, size); + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pDb->pSchema->cache_size = size; + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); + } + break; + } +#endif /* !SQLITE_OMIT_PAGER_PRAGMAS && !SQLITE_OMIT_DEPRECATED */ + +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + /* + ** PRAGMA [schema.]page_size + ** PRAGMA [schema.]page_size=N + ** + ** The first form reports the current setting for the + ** database page size in bytes. The second form sets the + ** database page size value. The value can only be set if + ** the database has not yet been created. + */ + case PragTyp_PAGE_SIZE: { + Btree *pBt = pDb->pBt; + assert( pBt!=0 ); + if( !zRight ){ + int size = ALWAYS(pBt) ? sqlite3BtreeGetPageSize(pBt) : 0; + returnSingleInt(v, size); + }else{ + /* Malloc may fail when setting the page-size, as there is an internal + ** buffer that the pager module resizes using sqlite3_realloc(). + */ + db->nextPagesize = sqlite3Atoi(zRight); + if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize,0,0) ){ + sqlite3OomFault(db); + } + } + break; + } + + /* + ** PRAGMA [schema.]secure_delete + ** PRAGMA [schema.]secure_delete=ON/OFF/FAST + ** + ** The first form reports the current setting for the + ** secure_delete flag. The second form changes the secure_delete + ** flag setting and reports the new value. + */ + case PragTyp_SECURE_DELETE: { + Btree *pBt = pDb->pBt; + int b = -1; + assert( pBt!=0 ); + if( zRight ){ + if( sqlite3_stricmp(zRight, "fast")==0 ){ + b = 2; + }else{ + b = sqlite3GetBoolean(zRight, 0); + } + } + if( pId2->n==0 && b>=0 ){ + int ii; + for(ii=0; iinDb; ii++){ + sqlite3BtreeSecureDelete(db->aDb[ii].pBt, b); + } + } + b = sqlite3BtreeSecureDelete(pBt, b); + returnSingleInt(v, b); + break; + } + + /* + ** PRAGMA [schema.]max_page_count + ** PRAGMA [schema.]max_page_count=N + ** + ** The first form reports the current setting for the + ** maximum number of pages in the database file. The + ** second form attempts to change this setting. Both + ** forms return the current setting. + ** + ** The absolute value of N is used. This is undocumented and might + ** change. The only purpose is to provide an easy way to test + ** the sqlite3AbsInt32() function. + ** + ** PRAGMA [schema.]page_count + ** + ** Return the number of pages in the specified database. + */ + case PragTyp_PAGE_COUNT: { + int iReg; + i64 x = 0; + sqlite3CodeVerifySchema(pParse, iDb); + iReg = ++pParse->nMem; + if( sqlite3Tolower(zLeft[0])=='p' ){ + sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg); + }else{ + if( zRight && sqlite3DecOrHexToI64(zRight,&x)==0 ){ + if( x<0 ) x = 0; + else if( x>0xfffffffe ) x = 0xfffffffe; + }else{ + x = 0; + } + sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg, (int)x); + } + sqlite3VdbeAddOp2(v, OP_ResultRow, iReg, 1); + break; + } + + /* + ** PRAGMA [schema.]locking_mode + ** PRAGMA [schema.]locking_mode = (normal|exclusive) + */ + case PragTyp_LOCKING_MODE: { + const char *zRet = "normal"; + int eMode = getLockingMode(zRight); + + if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){ + /* Simple "PRAGMA locking_mode;" statement. This is a query for + ** the current default locking mode (which may be different to + ** the locking-mode of the main database). + */ + eMode = db->dfltLockMode; + }else{ + Pager *pPager; + if( pId2->n==0 ){ + /* This indicates that no database name was specified as part + ** of the PRAGMA command. In this case the locking-mode must be + ** set on all attached databases, as well as the main db file. + ** + ** Also, the sqlite3.dfltLockMode variable is set so that + ** any subsequently attached databases also use the specified + ** locking mode. + */ + int ii; + assert(pDb==&db->aDb[0]); + for(ii=2; iinDb; ii++){ + pPager = sqlite3BtreePager(db->aDb[ii].pBt); + sqlite3PagerLockingMode(pPager, eMode); + } + db->dfltLockMode = (u8)eMode; + } + pPager = sqlite3BtreePager(pDb->pBt); + eMode = sqlite3PagerLockingMode(pPager, eMode); + } + + assert( eMode==PAGER_LOCKINGMODE_NORMAL + || eMode==PAGER_LOCKINGMODE_EXCLUSIVE ); + if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){ + zRet = "exclusive"; + } + returnSingleText(v, zRet); + break; + } + + /* + ** PRAGMA [schema.]journal_mode + ** PRAGMA [schema.]journal_mode = + ** (delete|persist|off|truncate|memory|wal|off) + */ + case PragTyp_JOURNAL_MODE: { + int eMode; /* One of the PAGER_JOURNALMODE_XXX symbols */ + int ii; /* Loop counter */ + + if( zRight==0 ){ + /* If there is no "=MODE" part of the pragma, do a query for the + ** current mode */ + eMode = PAGER_JOURNALMODE_QUERY; + }else{ + const char *zMode; + int n = sqlite3Strlen30(zRight); + for(eMode=0; (zMode = sqlite3JournalModename(eMode))!=0; eMode++){ + if( sqlite3StrNICmp(zRight, zMode, n)==0 ) break; + } + if( !zMode ){ + /* If the "=MODE" part does not match any known journal mode, + ** then do a query */ + eMode = PAGER_JOURNALMODE_QUERY; + } + if( eMode==PAGER_JOURNALMODE_OFF && (db->flags & SQLITE_Defensive)!=0 ){ + /* Do not allow journal-mode "OFF" in defensive since the database + ** can become corrupted using ordinary SQL when the journal is off */ + eMode = PAGER_JOURNALMODE_QUERY; + } + } + if( eMode==PAGER_JOURNALMODE_QUERY && pId2->n==0 ){ + /* Convert "PRAGMA journal_mode" into "PRAGMA main.journal_mode" */ + iDb = 0; + pId2->n = 1; + } + for(ii=db->nDb-1; ii>=0; ii--){ + if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){ + sqlite3VdbeUsesBtree(v, ii); + sqlite3VdbeAddOp3(v, OP_JournalMode, ii, 1, eMode); + } + } + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); + break; + } + + /* + ** PRAGMA [schema.]journal_size_limit + ** PRAGMA [schema.]journal_size_limit=N + ** + ** Get or set the size limit on rollback journal files. + */ + case PragTyp_JOURNAL_SIZE_LIMIT: { + Pager *pPager = sqlite3BtreePager(pDb->pBt); + i64 iLimit = -2; + if( zRight ){ + sqlite3DecOrHexToI64(zRight, &iLimit); + if( iLimit<-1 ) iLimit = -1; + } + iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit); + returnSingleInt(v, iLimit); + break; + } + +#endif /* SQLITE_OMIT_PAGER_PRAGMAS */ + + /* + ** PRAGMA [schema.]auto_vacuum + ** PRAGMA [schema.]auto_vacuum=N + ** + ** Get or set the value of the database 'auto-vacuum' parameter. + ** The value is one of: 0 NONE 1 FULL 2 INCREMENTAL + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + case PragTyp_AUTO_VACUUM: { + Btree *pBt = pDb->pBt; + assert( pBt!=0 ); + if( !zRight ){ + returnSingleInt(v, sqlite3BtreeGetAutoVacuum(pBt)); + }else{ + int eAuto = getAutoVacuum(zRight); + assert( eAuto>=0 && eAuto<=2 ); + db->nextAutovac = (u8)eAuto; + /* Call SetAutoVacuum() to set initialize the internal auto and + ** incr-vacuum flags. This is required in case this connection + ** creates the database file. It is important that it is created + ** as an auto-vacuum capable db. + */ + rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto); + if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){ + /* When setting the auto_vacuum mode to either "full" or + ** "incremental", write the value of meta[6] in the database + ** file. Before writing to meta[6], check that meta[3] indicates + ** that this really is an auto-vacuum capable database. + */ + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList setMeta6[] = { + { OP_Transaction, 0, 1, 0}, /* 0 */ + { OP_ReadCookie, 0, 1, BTREE_LARGEST_ROOT_PAGE}, + { OP_If, 1, 0, 0}, /* 2 */ + { OP_Halt, SQLITE_OK, OE_Abort, 0}, /* 3 */ + { OP_SetCookie, 0, BTREE_INCR_VACUUM, 0}, /* 4 */ + }; + VdbeOp *aOp; + int iAddr = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(setMeta6)); + aOp = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6, iLn); + if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break; + aOp[0].p1 = iDb; + aOp[1].p1 = iDb; + aOp[2].p2 = iAddr+4; + aOp[4].p1 = iDb; + aOp[4].p3 = eAuto - 1; + sqlite3VdbeUsesBtree(v, iDb); + } + } + break; + } +#endif + + /* + ** PRAGMA [schema.]incremental_vacuum(N) + ** + ** Do N steps of incremental vacuuming on a database. + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + case PragTyp_INCREMENTAL_VACUUM: { + int iLimit, addr; + if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){ + iLimit = 0x7fffffff; + } + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1); + addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb); VdbeCoverage(v); + sqlite3VdbeAddOp1(v, OP_ResultRow, 1); + sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); + sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr); + break; + } +#endif + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS + /* + ** PRAGMA [schema.]cache_size + ** PRAGMA [schema.]cache_size=N + ** + ** The first form reports the current local setting for the + ** page cache size. The second form sets the local + ** page cache size value. If N is positive then that is the + ** number of pages in the cache. If N is negative, then the + ** number of pages is adjusted so that the cache uses -N kibibytes + ** of memory. + */ + case PragTyp_CACHE_SIZE: { + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( !zRight ){ + returnSingleInt(v, pDb->pSchema->cache_size); + }else{ + int size = sqlite3Atoi(zRight); + pDb->pSchema->cache_size = size; + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); + } + break; + } + + /* + ** PRAGMA [schema.]cache_spill + ** PRAGMA cache_spill=BOOLEAN + ** PRAGMA [schema.]cache_spill=N + ** + ** The first form reports the current local setting for the + ** page cache spill size. The second form turns cache spill on + ** or off. When turnning cache spill on, the size is set to the + ** current cache_size. The third form sets a spill size that + ** may be different form the cache size. + ** If N is positive then that is the + ** number of pages in the cache. If N is negative, then the + ** number of pages is adjusted so that the cache uses -N kibibytes + ** of memory. + ** + ** If the number of cache_spill pages is less then the number of + ** cache_size pages, no spilling occurs until the page count exceeds + ** the number of cache_size pages. + ** + ** The cache_spill=BOOLEAN setting applies to all attached schemas, + ** not just the schema specified. + */ + case PragTyp_CACHE_SPILL: { + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( !zRight ){ + returnSingleInt(v, + (db->flags & SQLITE_CacheSpill)==0 ? 0 : + sqlite3BtreeSetSpillSize(pDb->pBt,0)); + }else{ + int size = 1; + if( sqlite3GetInt32(zRight, &size) ){ + sqlite3BtreeSetSpillSize(pDb->pBt, size); + } + if( sqlite3GetBoolean(zRight, size!=0) ){ + db->flags |= SQLITE_CacheSpill; + }else{ + db->flags &= ~(u64)SQLITE_CacheSpill; + } + setAllPagerFlags(db); + } + break; + } + + /* + ** PRAGMA [schema.]mmap_size(N) + ** + ** Used to set mapping size limit. The mapping size limit is + ** used to limit the aggregate size of all memory mapped regions of the + ** database file. If this parameter is set to zero, then memory mapping + ** is not used at all. If N is negative, then the default memory map + ** limit determined by sqlite3_config(SQLITE_CONFIG_MMAP_SIZE) is set. + ** The parameter N is measured in bytes. + ** + ** This value is advisory. The underlying VFS is free to memory map + ** as little or as much as it wants. Except, if N is set to 0 then the + ** upper layers will never invoke the xFetch interfaces to the VFS. + */ + case PragTyp_MMAP_SIZE: { + sqlite3_int64 sz; +#if SQLITE_MAX_MMAP_SIZE>0 + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( zRight ){ + int ii; + sqlite3DecOrHexToI64(zRight, &sz); + if( sz<0 ) sz = sqlite3GlobalConfig.szMmap; + if( pId2->n==0 ) db->szMmap = sz; + for(ii=db->nDb-1; ii>=0; ii--){ + if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){ + sqlite3BtreeSetMmapLimit(db->aDb[ii].pBt, sz); + } + } + } + sz = -1; + rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_MMAP_SIZE, &sz); +#else + sz = 0; + rc = SQLITE_OK; +#endif + if( rc==SQLITE_OK ){ + returnSingleInt(v, sz); + }else if( rc!=SQLITE_NOTFOUND ){ + pParse->nErr++; + pParse->rc = rc; + } + break; + } + + /* + ** PRAGMA temp_store + ** PRAGMA temp_store = "default"|"memory"|"file" + ** + ** Return or set the local value of the temp_store flag. Changing + ** the local value does not make changes to the disk file and the default + ** value will be restored the next time the database is opened. + ** + ** Note that it is possible for the library compile-time options to + ** override this setting + */ + case PragTyp_TEMP_STORE: { + if( !zRight ){ + returnSingleInt(v, db->temp_store); + }else{ + changeTempStorage(pParse, zRight); + } + break; + } + + /* + ** PRAGMA temp_store_directory + ** PRAGMA temp_store_directory = ""|"directory_name" + ** + ** Return or set the local value of the temp_store_directory flag. Changing + ** the value sets a specific directory to be used for temporary files. + ** Setting to a null string reverts to the default temporary directory search. + ** If temporary directory is changed, then invalidateTempStorage. + ** + */ + case PragTyp_TEMP_STORE_DIRECTORY: { + if( !zRight ){ + returnSingleText(v, sqlite3_temp_directory); + }else{ +#ifndef SQLITE_OMIT_WSD + if( zRight[0] ){ + int res; + rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res); + if( rc!=SQLITE_OK || res==0 ){ + sqlite3ErrorMsg(pParse, "not a writable directory"); + goto pragma_out; + } + } + if( SQLITE_TEMP_STORE==0 + || (SQLITE_TEMP_STORE==1 && db->temp_store<=1) + || (SQLITE_TEMP_STORE==2 && db->temp_store==1) + ){ + invalidateTempStorage(pParse); + } + sqlite3_free(sqlite3_temp_directory); + if( zRight[0] ){ + sqlite3_temp_directory = sqlite3_mprintf("%s", zRight); + }else{ + sqlite3_temp_directory = 0; + } +#endif /* SQLITE_OMIT_WSD */ + } + break; + } + +#if SQLITE_OS_WIN + /* + ** PRAGMA data_store_directory + ** PRAGMA data_store_directory = ""|"directory_name" + ** + ** Return or set the local value of the data_store_directory flag. Changing + ** the value sets a specific directory to be used for database files that + ** were specified with a relative pathname. Setting to a null string reverts + ** to the default database directory, which for database files specified with + ** a relative path will probably be based on the current directory for the + ** process. Database file specified with an absolute path are not impacted + ** by this setting, regardless of its value. + ** + */ + case PragTyp_DATA_STORE_DIRECTORY: { + if( !zRight ){ + returnSingleText(v, sqlite3_data_directory); + }else{ +#ifndef SQLITE_OMIT_WSD + if( zRight[0] ){ + int res; + rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res); + if( rc!=SQLITE_OK || res==0 ){ + sqlite3ErrorMsg(pParse, "not a writable directory"); + goto pragma_out; + } + } + sqlite3_free(sqlite3_data_directory); + if( zRight[0] ){ + sqlite3_data_directory = sqlite3_mprintf("%s", zRight); + }else{ + sqlite3_data_directory = 0; + } +#endif /* SQLITE_OMIT_WSD */ + } + break; + } +#endif + +#if SQLITE_ENABLE_LOCKING_STYLE + /* + ** PRAGMA [schema.]lock_proxy_file + ** PRAGMA [schema.]lock_proxy_file = ":auto:"|"lock_file_path" + ** + ** Return or set the value of the lock_proxy_file flag. Changing + ** the value sets a specific file to be used for database access locks. + ** + */ + case PragTyp_LOCK_PROXY_FILE: { + if( !zRight ){ + Pager *pPager = sqlite3BtreePager(pDb->pBt); + char *proxy_file_path = NULL; + sqlite3_file *pFile = sqlite3PagerFile(pPager); + sqlite3OsFileControlHint(pFile, SQLITE_GET_LOCKPROXYFILE, + &proxy_file_path); + returnSingleText(v, proxy_file_path); + }else{ + Pager *pPager = sqlite3BtreePager(pDb->pBt); + sqlite3_file *pFile = sqlite3PagerFile(pPager); + int res; + if( zRight[0] ){ + res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE, + zRight); + } else { + res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE, + NULL); + } + if( res!=SQLITE_OK ){ + sqlite3ErrorMsg(pParse, "failed to set lock proxy file"); + goto pragma_out; + } + } + break; + } +#endif /* SQLITE_ENABLE_LOCKING_STYLE */ + + /* + ** PRAGMA [schema.]synchronous + ** PRAGMA [schema.]synchronous=OFF|ON|NORMAL|FULL|EXTRA + ** + ** Return or set the local value of the synchronous flag. Changing + ** the local value does not make changes to the disk file and the + ** default value will be restored the next time the database is + ** opened. + */ + case PragTyp_SYNCHRONOUS: { + if( !zRight ){ + returnSingleInt(v, pDb->safety_level-1); + }else{ + if( !db->autoCommit ){ + sqlite3ErrorMsg(pParse, + "Safety level may not be changed inside a transaction"); + }else if( iDb!=1 ){ + int iLevel = (getSafetyLevel(zRight,0,1)+1) & PAGER_SYNCHRONOUS_MASK; + if( iLevel==0 ) iLevel = 1; + pDb->safety_level = iLevel; + pDb->bSyncSet = 1; + setAllPagerFlags(db); + } + } + break; + } +#endif /* SQLITE_OMIT_PAGER_PRAGMAS */ + +#ifndef SQLITE_OMIT_FLAG_PRAGMAS + case PragTyp_FLAG: { + if( zRight==0 ){ + setPragmaResultColumnNames(v, pPragma); + returnSingleInt(v, (db->flags & pPragma->iArg)!=0 ); + }else{ + u64 mask = pPragma->iArg; /* Mask of bits to set or clear. */ + if( db->autoCommit==0 ){ + /* Foreign key support may not be enabled or disabled while not + ** in auto-commit mode. */ + mask &= ~(SQLITE_ForeignKeys); + } +#if SQLITE_USER_AUTHENTICATION + if( db->auth.authLevel==UAUTH_User ){ + /* Do not allow non-admin users to modify the schema arbitrarily */ + mask &= ~(SQLITE_WriteSchema); + } +#endif + + if( sqlite3GetBoolean(zRight, 0) ){ + db->flags |= mask; + }else{ + db->flags &= ~mask; + if( mask==SQLITE_DeferFKs ) db->nDeferredImmCons = 0; + } + + /* Many of the flag-pragmas modify the code generated by the SQL + ** compiler (eg. count_changes). So add an opcode to expire all + ** compiled SQL statements after modifying a pragma value. + */ + sqlite3VdbeAddOp0(v, OP_Expire); + setAllPagerFlags(db); + } + break; + } +#endif /* SQLITE_OMIT_FLAG_PRAGMAS */ + +#ifndef SQLITE_OMIT_SCHEMA_PRAGMAS + /* + ** PRAGMA table_info(
    ) + ** + ** Return a single row for each column of the named table. The columns of + ** the returned data set are: + ** + ** cid: Column id (numbered from left to right, starting at 0) + ** name: Column name + ** type: Column declaration type. + ** notnull: True if 'NOT NULL' is part of column declaration + ** dflt_value: The default value for the column, if any. + ** pk: Non-zero for PK fields. + */ + case PragTyp_TABLE_INFO: if( zRight ){ + Table *pTab; + sqlite3CodeVerifyNamedSchema(pParse, zDb); + pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb); + if( pTab ){ + int i, k; + int nHidden = 0; + Column *pCol; + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + pParse->nMem = 7; + sqlite3ViewGetColumnNames(pParse, pTab); + for(i=0, pCol=pTab->aCol; inCol; i++, pCol++){ + int isHidden = 0; + if( pCol->colFlags & COLFLAG_NOINSERT ){ + if( pPragma->iArg==0 ){ + nHidden++; + continue; + } + if( pCol->colFlags & COLFLAG_VIRTUAL ){ + isHidden = 2; /* GENERATED ALWAYS AS ... VIRTUAL */ + }else if( pCol->colFlags & COLFLAG_STORED ){ + isHidden = 3; /* GENERATED ALWAYS AS ... STORED */ + }else{ assert( pCol->colFlags & COLFLAG_HIDDEN ); + isHidden = 1; /* HIDDEN */ + } + } + if( (pCol->colFlags & COLFLAG_PRIMKEY)==0 ){ + k = 0; + }else if( pPk==0 ){ + k = 1; + }else{ + for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){} + } + assert( pCol->pDflt==0 || pCol->pDflt->op==TK_SPAN || isHidden>=2 ); + sqlite3VdbeMultiLoad(v, 1, pPragma->iArg ? "issisii" : "issisi", + i-nHidden, + pCol->zName, + sqlite3ColumnType(pCol,""), + pCol->notNull ? 1 : 0, + pCol->pDflt && isHidden<2 ? pCol->pDflt->u.zToken : 0, + k, + isHidden); + } + } + } + break; + +#ifdef SQLITE_DEBUG + case PragTyp_STATS: { + Index *pIdx; + HashElem *i; + pParse->nMem = 5; + sqlite3CodeVerifySchema(pParse, iDb); + for(i=sqliteHashFirst(&pDb->pSchema->tblHash); i; i=sqliteHashNext(i)){ + Table *pTab = sqliteHashData(i); + sqlite3VdbeMultiLoad(v, 1, "ssiii", + pTab->zName, + 0, + pTab->szTabRow, + pTab->nRowLogEst, + pTab->tabFlags); + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + sqlite3VdbeMultiLoad(v, 2, "siiiX", + pIdx->zName, + pIdx->szIdxRow, + pIdx->aiRowLogEst[0], + pIdx->hasStat1); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 5); + } + } + } + break; +#endif + + case PragTyp_INDEX_INFO: if( zRight ){ + Index *pIdx; + Table *pTab; + pIdx = sqlite3FindIndex(db, zRight, zDb); + if( pIdx==0 ){ + /* If there is no index named zRight, check to see if there is a + ** WITHOUT ROWID table named zRight, and if there is, show the + ** structure of the PRIMARY KEY index for that table. */ + pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb); + if( pTab && !HasRowid(pTab) ){ + pIdx = sqlite3PrimaryKeyIndex(pTab); + } + } + if( pIdx ){ + int iIdxDb = sqlite3SchemaToIndex(db, pIdx->pSchema); + int i; + int mx; + if( pPragma->iArg ){ + /* PRAGMA index_xinfo (newer version with more rows and columns) */ + mx = pIdx->nColumn; + pParse->nMem = 6; + }else{ + /* PRAGMA index_info (legacy version) */ + mx = pIdx->nKeyCol; + pParse->nMem = 3; + } + pTab = pIdx->pTable; + sqlite3CodeVerifySchema(pParse, iIdxDb); + assert( pParse->nMem<=pPragma->nPragCName ); + for(i=0; iaiColumn[i]; + sqlite3VdbeMultiLoad(v, 1, "iisX", i, cnum, + cnum<0 ? 0 : pTab->aCol[cnum].zName); + if( pPragma->iArg ){ + sqlite3VdbeMultiLoad(v, 4, "isiX", + pIdx->aSortOrder[i], + pIdx->azColl[i], + inKeyCol); + } + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, pParse->nMem); + } + } + } + break; + + case PragTyp_INDEX_LIST: if( zRight ){ + Index *pIdx; + Table *pTab; + int i; + pTab = sqlite3FindTable(db, zRight, zDb); + if( pTab ){ + int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema); + pParse->nMem = 5; + sqlite3CodeVerifySchema(pParse, iTabDb); + for(pIdx=pTab->pIndex, i=0; pIdx; pIdx=pIdx->pNext, i++){ + const char *azOrigin[] = { "c", "u", "pk" }; + sqlite3VdbeMultiLoad(v, 1, "isisi", + i, + pIdx->zName, + IsUniqueIndex(pIdx), + azOrigin[pIdx->idxType], + pIdx->pPartIdxWhere!=0); + } + } + } + break; + + case PragTyp_DATABASE_LIST: { + int i; + pParse->nMem = 3; + for(i=0; inDb; i++){ + if( db->aDb[i].pBt==0 ) continue; + assert( db->aDb[i].zDbSName!=0 ); + sqlite3VdbeMultiLoad(v, 1, "iss", + i, + db->aDb[i].zDbSName, + sqlite3BtreeGetFilename(db->aDb[i].pBt)); + } + } + break; + + case PragTyp_COLLATION_LIST: { + int i = 0; + HashElem *p; + pParse->nMem = 2; + for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){ + CollSeq *pColl = (CollSeq *)sqliteHashData(p); + sqlite3VdbeMultiLoad(v, 1, "is", i++, pColl->zName); + } + } + break; + +#ifndef SQLITE_OMIT_INTROSPECTION_PRAGMAS + case PragTyp_FUNCTION_LIST: { + int i; + HashElem *j; + FuncDef *p; + int showInternFunc = (db->mDbFlags & DBFLAG_InternalFunc)!=0; + pParse->nMem = 6; + for(i=0; iu.pHash ){ + pragmaFunclistLine(v, p, 1, showInternFunc); + } + } + for(j=sqliteHashFirst(&db->aFunc); j; j=sqliteHashNext(j)){ + p = (FuncDef*)sqliteHashData(j); + pragmaFunclistLine(v, p, 0, showInternFunc); + } + } + break; + +#ifndef SQLITE_OMIT_VIRTUALTABLE + case PragTyp_MODULE_LIST: { + HashElem *j; + pParse->nMem = 1; + for(j=sqliteHashFirst(&db->aModule); j; j=sqliteHashNext(j)){ + Module *pMod = (Module*)sqliteHashData(j); + sqlite3VdbeMultiLoad(v, 1, "s", pMod->zName); + } + } + break; +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + + case PragTyp_PRAGMA_LIST: { + int i; + for(i=0; ipFKey; + if( pFK ){ + int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema); + int i = 0; + pParse->nMem = 8; + sqlite3CodeVerifySchema(pParse, iTabDb); + while(pFK){ + int j; + for(j=0; jnCol; j++){ + sqlite3VdbeMultiLoad(v, 1, "iissssss", + i, + j, + pFK->zTo, + pTab->aCol[pFK->aCol[j].iFrom].zName, + pFK->aCol[j].zCol, + actionName(pFK->aAction[1]), /* ON UPDATE */ + actionName(pFK->aAction[0]), /* ON DELETE */ + "NONE"); + } + ++i; + pFK = pFK->pNextFrom; + } + } + } + } + break; +#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ + +#ifndef SQLITE_OMIT_FOREIGN_KEY +#ifndef SQLITE_OMIT_TRIGGER + case PragTyp_FOREIGN_KEY_CHECK: { + FKey *pFK; /* A foreign key constraint */ + Table *pTab; /* Child table contain "REFERENCES" keyword */ + Table *pParent; /* Parent table that child points to */ + Index *pIdx; /* Index in the parent table */ + int i; /* Loop counter: Foreign key number for pTab */ + int j; /* Loop counter: Field of the foreign key */ + HashElem *k; /* Loop counter: Next table in schema */ + int x; /* result variable */ + int regResult; /* 3 registers to hold a result row */ + int regKey; /* Register to hold key for checking the FK */ + int regRow; /* Registers to hold a row from pTab */ + int addrTop; /* Top of a loop checking foreign keys */ + int addrOk; /* Jump here if the key is OK */ + int *aiCols; /* child to parent column mapping */ + + regResult = pParse->nMem+1; + pParse->nMem += 4; + regKey = ++pParse->nMem; + regRow = ++pParse->nMem; + k = sqliteHashFirst(&db->aDb[iDb].pSchema->tblHash); + while( k ){ + if( zRight ){ + pTab = sqlite3LocateTable(pParse, 0, zRight, zDb); + k = 0; + }else{ + pTab = (Table*)sqliteHashData(k); + k = sqliteHashNext(k); + } + if( pTab==0 || pTab->pFKey==0 ) continue; + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + zDb = db->aDb[iDb].zDbSName; + sqlite3CodeVerifySchema(pParse, iDb); + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow; + sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead); + sqlite3VdbeLoadString(v, regResult, pTab->zName); + for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){ + pParent = sqlite3FindTable(db, pFK->zTo, zDb); + if( pParent==0 ) continue; + pIdx = 0; + sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName); + x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, 0); + if( x==0 ){ + if( pIdx==0 ){ + sqlite3OpenTable(pParse, i, iDb, pParent, OP_OpenRead); + }else{ + sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + } + }else{ + k = 0; + break; + } + } + assert( pParse->nErr>0 || pFK==0 ); + if( pFK ) break; + if( pParse->nTabnTab = i; + addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, 0); VdbeCoverage(v); + for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){ + pParent = sqlite3FindTable(db, pFK->zTo, zDb); + pIdx = 0; + aiCols = 0; + if( pParent ){ + x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, &aiCols); + assert( x==0 || db->mallocFailed ); + } + addrOk = sqlite3VdbeMakeLabel(pParse); + + /* Generate code to read the child key values into registers + ** regRow..regRow+n. If any of the child key values are NULL, this + ** row cannot cause an FK violation. Jump directly to addrOk in + ** this case. */ + for(j=0; jnCol; j++){ + int iCol = aiCols ? aiCols[j] : pFK->aCol[j].iFrom; + sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, iCol, regRow+j); + sqlite3VdbeAddOp2(v, OP_IsNull, regRow+j, addrOk); VdbeCoverage(v); + } + + /* Generate code to query the parent index for a matching parent + ** key. If a match is found, jump to addrOk. */ + if( pIdx ){ + sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, pFK->nCol, regKey, + sqlite3IndexAffinityStr(db,pIdx), pFK->nCol); + sqlite3VdbeAddOp4Int(v, OP_Found, i, addrOk, regKey, 0); + VdbeCoverage(v); + }else if( pParent ){ + int jmp = sqlite3VdbeCurrentAddr(v)+2; + sqlite3VdbeAddOp3(v, OP_SeekRowid, i, jmp, regRow); VdbeCoverage(v); + sqlite3VdbeGoto(v, addrOk); + assert( pFK->nCol==1 || db->mallocFailed ); + } + + /* Generate code to report an FK violation to the caller. */ + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp2(v, OP_Rowid, 0, regResult+1); + }else{ + sqlite3VdbeAddOp2(v, OP_Null, 0, regResult+1); + } + sqlite3VdbeMultiLoad(v, regResult+2, "siX", pFK->zTo, i-1); + sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, 4); + sqlite3VdbeResolveLabel(v, addrOk); + sqlite3DbFree(db, aiCols); + } + sqlite3VdbeAddOp2(v, OP_Next, 0, addrTop+1); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addrTop); + } + } + break; +#endif /* !defined(SQLITE_OMIT_TRIGGER) */ +#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ + +#ifndef SQLITE_OMIT_CASE_SENSITIVE_LIKE_PRAGMA + /* Reinstall the LIKE and GLOB functions. The variant of LIKE + ** used will be case sensitive or not depending on the RHS. + */ + case PragTyp_CASE_SENSITIVE_LIKE: { + if( zRight ){ + sqlite3RegisterLikeFunctions(db, sqlite3GetBoolean(zRight, 0)); + } + } + break; +#endif /* SQLITE_OMIT_CASE_SENSITIVE_LIKE_PRAGMA */ + +#ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX +# define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100 +#endif + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK + /* PRAGMA integrity_check + ** PRAGMA integrity_check(N) + ** PRAGMA quick_check + ** PRAGMA quick_check(N) + ** + ** Verify the integrity of the database. + ** + ** The "quick_check" is reduced version of + ** integrity_check designed to detect most database corruption + ** without the overhead of cross-checking indexes. Quick_check + ** is linear time wherease integrity_check is O(NlogN). + ** + ** The maximum nubmer of errors is 100 by default. A different default + ** can be specified using a numeric parameter N. + ** + ** Or, the parameter N can be the name of a table. In that case, only + ** the one table named is verified. The freelist is only verified if + ** the named table is "sqlite_schema" (or one of its aliases). + ** + ** All schemas are checked by default. To check just a single + ** schema, use the form: + ** + ** PRAGMA schema.integrity_check; + */ + case PragTyp_INTEGRITY_CHECK: { + int i, j, addr, mxErr; + Table *pObjTab = 0; /* Check only this one table, if not NULL */ + + int isQuick = (sqlite3Tolower(zLeft[0])=='q'); + + /* If the PRAGMA command was of the form "PRAGMA .integrity_check", + ** then iDb is set to the index of the database identified by . + ** In this case, the integrity of database iDb only is verified by + ** the VDBE created below. + ** + ** Otherwise, if the command was simply "PRAGMA integrity_check" (or + ** "PRAGMA quick_check"), then iDb is set to 0. In this case, set iDb + ** to -1 here, to indicate that the VDBE should verify the integrity + ** of all attached databases. */ + assert( iDb>=0 ); + assert( iDb==0 || pId2->z ); + if( pId2->z==0 ) iDb = -1; + + /* Initialize the VDBE program */ + pParse->nMem = 6; + + /* Set the maximum error count */ + mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX; + if( zRight ){ + if( sqlite3GetInt32(zRight, &mxErr) ){ + if( mxErr<=0 ){ + mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX; + } + }else{ + pObjTab = sqlite3LocateTable(pParse, 0, zRight, + iDb>=0 ? db->aDb[iDb].zDbSName : 0); + } + } + sqlite3VdbeAddOp2(v, OP_Integer, mxErr-1, 1); /* reg[1] holds errors left */ + + /* Do an integrity check on each database file */ + for(i=0; inDb; i++){ + HashElem *x; /* For looping over tables in the schema */ + Hash *pTbls; /* Set of all tables in the schema */ + int *aRoot; /* Array of root page numbers of all btrees */ + int cnt = 0; /* Number of entries in aRoot[] */ + int mxIdx = 0; /* Maximum number of indexes for any table */ + + if( OMIT_TEMPDB && i==1 ) continue; + if( iDb>=0 && i!=iDb ) continue; + + sqlite3CodeVerifySchema(pParse, i); + + /* Do an integrity check of the B-Tree + ** + ** Begin by finding the root pages numbers + ** for all tables and indices in the database. + */ + assert( sqlite3SchemaMutexHeld(db, i, 0) ); + pTbls = &db->aDb[i].pSchema->tblHash; + for(cnt=0, x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){ + Table *pTab = sqliteHashData(x); /* Current table */ + Index *pIdx; /* An index on pTab */ + int nIdx; /* Number of indexes on pTab */ + if( pObjTab && pObjTab!=pTab ) continue; + if( HasRowid(pTab) ) cnt++; + for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ cnt++; } + if( nIdx>mxIdx ) mxIdx = nIdx; + } + if( cnt==0 ) continue; + if( pObjTab ) cnt++; + aRoot = sqlite3DbMallocRawNN(db, sizeof(int)*(cnt+1)); + if( aRoot==0 ) break; + cnt = 0; + if( pObjTab ) aRoot[++cnt] = 0; + for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){ + Table *pTab = sqliteHashData(x); + Index *pIdx; + if( pObjTab && pObjTab!=pTab ) continue; + if( HasRowid(pTab) ) aRoot[++cnt] = pTab->tnum; + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + aRoot[++cnt] = pIdx->tnum; + } + } + aRoot[0] = cnt; + + /* Make sure sufficient number of registers have been allocated */ + pParse->nMem = MAX( pParse->nMem, 8+mxIdx ); + sqlite3ClearTempRegCache(pParse); + + /* Do the b-tree integrity checks */ + sqlite3VdbeAddOp4(v, OP_IntegrityCk, 2, cnt, 1, (char*)aRoot,P4_INTARRAY); + sqlite3VdbeChangeP5(v, (u8)i); + addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2); VdbeCoverage(v); + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, + sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zDbSName), + P4_DYNAMIC); + sqlite3VdbeAddOp3(v, OP_Concat, 2, 3, 3); + integrityCheckResultRow(v); + sqlite3VdbeJumpHere(v, addr); + + /* Make sure all the indices are constructed correctly. + */ + for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){ + Table *pTab = sqliteHashData(x); + Index *pIdx, *pPk; + Index *pPrior = 0; + int loopTop; + int iDataCur, iIdxCur; + int r1 = -1; + + if( pTab->tnum<1 ) continue; /* Skip VIEWs or VIRTUAL TABLEs */ + if( pObjTab && pObjTab!=pTab ) continue; + pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab); + sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead, 0, + 1, 0, &iDataCur, &iIdxCur); + /* reg[7] counts the number of entries in the table. + ** reg[8+i] counts the number of entries in the i-th index + */ + sqlite3VdbeAddOp2(v, OP_Integer, 0, 7); + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + sqlite3VdbeAddOp2(v, OP_Integer, 0, 8+j); /* index entries counter */ + } + assert( pParse->nMem>=8+j ); + assert( sqlite3NoTempsInRange(pParse,1,7+j) ); + sqlite3VdbeAddOp2(v, OP_Rewind, iDataCur, 0); VdbeCoverage(v); + loopTop = sqlite3VdbeAddOp2(v, OP_AddImm, 7, 1); + if( !isQuick ){ + /* Sanity check on record header decoding */ + sqlite3VdbeAddOp3(v, OP_Column, iDataCur, pTab->nNVCol-1,3); + sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG); + } + /* Verify that all NOT NULL columns really are NOT NULL */ + for(j=0; jnCol; j++){ + char *zErr; + int jmp2; + if( j==pTab->iPKey ) continue; + if( pTab->aCol[j].notNull==0 ) continue; + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3); + if( sqlite3VdbeGetOp(v,-1)->opcode==OP_Column ){ + sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG); + } + jmp2 = sqlite3VdbeAddOp1(v, OP_NotNull, 3); VdbeCoverage(v); + zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName, + pTab->aCol[j].zName); + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC); + integrityCheckResultRow(v); + sqlite3VdbeJumpHere(v, jmp2); + } + /* Verify CHECK constraints */ + if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){ + ExprList *pCheck = sqlite3ExprListDup(db, pTab->pCheck, 0); + if( db->mallocFailed==0 ){ + int addrCkFault = sqlite3VdbeMakeLabel(pParse); + int addrCkOk = sqlite3VdbeMakeLabel(pParse); + char *zErr; + int k; + pParse->iSelfTab = iDataCur + 1; + for(k=pCheck->nExpr-1; k>0; k--){ + sqlite3ExprIfFalse(pParse, pCheck->a[k].pExpr, addrCkFault, 0); + } + sqlite3ExprIfTrue(pParse, pCheck->a[0].pExpr, addrCkOk, + SQLITE_JUMPIFNULL); + sqlite3VdbeResolveLabel(v, addrCkFault); + pParse->iSelfTab = 0; + zErr = sqlite3MPrintf(db, "CHECK constraint failed in %s", + pTab->zName); + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC); + integrityCheckResultRow(v); + sqlite3VdbeResolveLabel(v, addrCkOk); + } + sqlite3ExprListDelete(db, pCheck); + } + if( !isQuick ){ /* Omit the remaining tests for quick_check */ + /* Validate index entries for the current row */ + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + int jmp2, jmp3, jmp4, jmp5; + int ckUniq = sqlite3VdbeMakeLabel(pParse); + if( pPk==pIdx ) continue; + r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 0, &jmp3, + pPrior, r1); + pPrior = pIdx; + sqlite3VdbeAddOp2(v, OP_AddImm, 8+j, 1);/* increment entry count */ + /* Verify that an index entry exists for the current table row */ + jmp2 = sqlite3VdbeAddOp4Int(v, OP_Found, iIdxCur+j, ckUniq, r1, + pIdx->nColumn); VdbeCoverage(v); + sqlite3VdbeLoadString(v, 3, "row "); + sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3); + sqlite3VdbeLoadString(v, 4, " missing from index "); + sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3); + jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName); + sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3); + jmp4 = integrityCheckResultRow(v); + sqlite3VdbeJumpHere(v, jmp2); + /* For UNIQUE indexes, verify that only one entry exists with the + ** current key. The entry is unique if (1) any column is NULL + ** or (2) the next entry has a different key */ + if( IsUniqueIndex(pIdx) ){ + int uniqOk = sqlite3VdbeMakeLabel(pParse); + int jmp6; + int kk; + for(kk=0; kknKeyCol; kk++){ + int iCol = pIdx->aiColumn[kk]; + assert( iCol!=XN_ROWID && iColnCol ); + if( iCol>=0 && pTab->aCol[iCol].notNull ) continue; + sqlite3VdbeAddOp2(v, OP_IsNull, r1+kk, uniqOk); + VdbeCoverage(v); + } + jmp6 = sqlite3VdbeAddOp1(v, OP_Next, iIdxCur+j); VdbeCoverage(v); + sqlite3VdbeGoto(v, uniqOk); + sqlite3VdbeJumpHere(v, jmp6); + sqlite3VdbeAddOp4Int(v, OP_IdxGT, iIdxCur+j, uniqOk, r1, + pIdx->nKeyCol); VdbeCoverage(v); + sqlite3VdbeLoadString(v, 3, "non-unique entry in index "); + sqlite3VdbeGoto(v, jmp5); + sqlite3VdbeResolveLabel(v, uniqOk); + } + sqlite3VdbeJumpHere(v, jmp4); + sqlite3ResolvePartIdxLabel(pParse, jmp3); + } + } + sqlite3VdbeAddOp2(v, OP_Next, iDataCur, loopTop); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, loopTop-1); + if( !isQuick ){ + sqlite3VdbeLoadString(v, 2, "wrong # of entries in index "); + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + if( pPk==pIdx ) continue; + sqlite3VdbeAddOp2(v, OP_Count, iIdxCur+j, 3); + addr = sqlite3VdbeAddOp3(v, OP_Eq, 8+j, 0, 3); VdbeCoverage(v); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + sqlite3VdbeLoadString(v, 4, pIdx->zName); + sqlite3VdbeAddOp3(v, OP_Concat, 4, 2, 3); + integrityCheckResultRow(v); + sqlite3VdbeJumpHere(v, addr); + } + } + } + } + { + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList endCode[] = { + { OP_AddImm, 1, 0, 0}, /* 0 */ + { OP_IfNotZero, 1, 4, 0}, /* 1 */ + { OP_String8, 0, 3, 0}, /* 2 */ + { OP_ResultRow, 3, 1, 0}, /* 3 */ + { OP_Halt, 0, 0, 0}, /* 4 */ + { OP_String8, 0, 3, 0}, /* 5 */ + { OP_Goto, 0, 3, 0}, /* 6 */ + }; + VdbeOp *aOp; + + aOp = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode, iLn); + if( aOp ){ + aOp[0].p2 = 1-mxErr; + aOp[2].p4type = P4_STATIC; + aOp[2].p4.z = "ok"; + aOp[5].p4type = P4_STATIC; + aOp[5].p4.z = (char*)sqlite3ErrStr(SQLITE_CORRUPT); + } + sqlite3VdbeChangeP3(v, 0, sqlite3VdbeCurrentAddr(v)-2); + } + } + break; +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +#ifndef SQLITE_OMIT_UTF16 + /* + ** PRAGMA encoding + ** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be" + ** + ** In its first form, this pragma returns the encoding of the main + ** database. If the database is not initialized, it is initialized now. + ** + ** The second form of this pragma is a no-op if the main database file + ** has not already been initialized. In this case it sets the default + ** encoding that will be used for the main database file if a new file + ** is created. If an existing main database file is opened, then the + ** default text encoding for the existing database is used. + ** + ** In all cases new databases created using the ATTACH command are + ** created to use the same default text encoding as the main database. If + ** the main database has not been initialized and/or created when ATTACH + ** is executed, this is done before the ATTACH operation. + ** + ** In the second form this pragma sets the text encoding to be used in + ** new database files created using this database handle. It is only + ** useful if invoked immediately after the main database i + */ + case PragTyp_ENCODING: { + static const struct EncName { + char *zName; + u8 enc; + } encnames[] = { + { "UTF8", SQLITE_UTF8 }, + { "UTF-8", SQLITE_UTF8 }, /* Must be element [1] */ + { "UTF-16le", SQLITE_UTF16LE }, /* Must be element [2] */ + { "UTF-16be", SQLITE_UTF16BE }, /* Must be element [3] */ + { "UTF16le", SQLITE_UTF16LE }, + { "UTF16be", SQLITE_UTF16BE }, + { "UTF-16", 0 }, /* SQLITE_UTF16NATIVE */ + { "UTF16", 0 }, /* SQLITE_UTF16NATIVE */ + { 0, 0 } + }; + const struct EncName *pEnc; + if( !zRight ){ /* "PRAGMA encoding" */ + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + assert( encnames[SQLITE_UTF8].enc==SQLITE_UTF8 ); + assert( encnames[SQLITE_UTF16LE].enc==SQLITE_UTF16LE ); + assert( encnames[SQLITE_UTF16BE].enc==SQLITE_UTF16BE ); + returnSingleText(v, encnames[ENC(pParse->db)].zName); + }else{ /* "PRAGMA encoding = XXX" */ + /* Only change the value of sqlite.enc if the database handle is not + ** initialized. If the main database exists, the new sqlite.enc value + ** will be overwritten when the schema is next loaded. If it does not + ** already exists, it will be created to use the new encoding value. + */ + if( (db->mDbFlags & DBFLAG_EncodingFixed)==0 ){ + for(pEnc=&encnames[0]; pEnc->zName; pEnc++){ + if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){ + u8 enc = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE; + SCHEMA_ENC(db) = enc; + sqlite3SetTextEncoding(db, enc); + break; + } + } + if( !pEnc->zName ){ + sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight); + } + } + } + } + break; +#endif /* SQLITE_OMIT_UTF16 */ + +#ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS + /* + ** PRAGMA [schema.]schema_version + ** PRAGMA [schema.]schema_version = + ** + ** PRAGMA [schema.]user_version + ** PRAGMA [schema.]user_version = + ** + ** PRAGMA [schema.]freelist_count + ** + ** PRAGMA [schema.]data_version + ** + ** PRAGMA [schema.]application_id + ** PRAGMA [schema.]application_id = + ** + ** The pragma's schema_version and user_version are used to set or get + ** the value of the schema-version and user-version, respectively. Both + ** the schema-version and the user-version are 32-bit signed integers + ** stored in the database header. + ** + ** The schema-cookie is usually only manipulated internally by SQLite. It + ** is incremented by SQLite whenever the database schema is modified (by + ** creating or dropping a table or index). The schema version is used by + ** SQLite each time a query is executed to ensure that the internal cache + ** of the schema used when compiling the SQL query matches the schema of + ** the database against which the compiled query is actually executed. + ** Subverting this mechanism by using "PRAGMA schema_version" to modify + ** the schema-version is potentially dangerous and may lead to program + ** crashes or database corruption. Use with caution! + ** + ** The user-version is not used internally by SQLite. It may be used by + ** applications for any purpose. + */ + case PragTyp_HEADER_VALUE: { + int iCookie = pPragma->iArg; /* Which cookie to read or write */ + sqlite3VdbeUsesBtree(v, iDb); + if( zRight && (pPragma->mPragFlg & PragFlg_ReadOnly)==0 ){ + /* Write the specified cookie value */ + static const VdbeOpList setCookie[] = { + { OP_Transaction, 0, 1, 0}, /* 0 */ + { OP_SetCookie, 0, 0, 0}, /* 1 */ + }; + VdbeOp *aOp; + sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(setCookie)); + aOp = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie, 0); + if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break; + aOp[0].p1 = iDb; + aOp[1].p1 = iDb; + aOp[1].p2 = iCookie; + aOp[1].p3 = sqlite3Atoi(zRight); + aOp[1].p5 = 1; + }else{ + /* Read the specified cookie value */ + static const VdbeOpList readCookie[] = { + { OP_Transaction, 0, 0, 0}, /* 0 */ + { OP_ReadCookie, 0, 1, 0}, /* 1 */ + { OP_ResultRow, 1, 1, 0} + }; + VdbeOp *aOp; + sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(readCookie)); + aOp = sqlite3VdbeAddOpList(v, ArraySize(readCookie),readCookie,0); + if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break; + aOp[0].p1 = iDb; + aOp[1].p1 = iDb; + aOp[1].p3 = iCookie; + sqlite3VdbeReusable(v); + } + } + break; +#endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */ + +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS + /* + ** PRAGMA compile_options + ** + ** Return the names of all compile-time options used in this build, + ** one option per row. + */ + case PragTyp_COMPILE_OPTIONS: { + int i = 0; + const char *zOpt; + pParse->nMem = 1; + while( (zOpt = sqlite3_compileoption_get(i++))!=0 ){ + sqlite3VdbeLoadString(v, 1, zOpt); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); + } + sqlite3VdbeReusable(v); + } + break; +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ + +#ifndef SQLITE_OMIT_WAL + /* + ** PRAGMA [schema.]wal_checkpoint = passive|full|restart|truncate + ** + ** Checkpoint the database. + */ + case PragTyp_WAL_CHECKPOINT: { + int iBt = (pId2->z?iDb:SQLITE_MAX_ATTACHED); + int eMode = SQLITE_CHECKPOINT_PASSIVE; + if( zRight ){ + if( sqlite3StrICmp(zRight, "full")==0 ){ + eMode = SQLITE_CHECKPOINT_FULL; + }else if( sqlite3StrICmp(zRight, "restart")==0 ){ + eMode = SQLITE_CHECKPOINT_RESTART; + }else if( sqlite3StrICmp(zRight, "truncate")==0 ){ + eMode = SQLITE_CHECKPOINT_TRUNCATE; + } + } + pParse->nMem = 3; + sqlite3VdbeAddOp3(v, OP_Checkpoint, iBt, eMode, 1); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3); + } + break; + + /* + ** PRAGMA wal_autocheckpoint + ** PRAGMA wal_autocheckpoint = N + ** + ** Configure a database connection to automatically checkpoint a database + ** after accumulating N frames in the log. Or query for the current value + ** of N. + */ + case PragTyp_WAL_AUTOCHECKPOINT: { + if( zRight ){ + sqlite3_wal_autocheckpoint(db, sqlite3Atoi(zRight)); + } + returnSingleInt(v, + db->xWalCallback==sqlite3WalDefaultHook ? + SQLITE_PTR_TO_INT(db->pWalArg) : 0); + } + break; +#endif + + /* + ** PRAGMA shrink_memory + ** + ** IMPLEMENTATION-OF: R-23445-46109 This pragma causes the database + ** connection on which it is invoked to free up as much memory as it + ** can, by calling sqlite3_db_release_memory(). + */ + case PragTyp_SHRINK_MEMORY: { + sqlite3_db_release_memory(db); + break; + } + + /* + ** PRAGMA optimize + ** PRAGMA optimize(MASK) + ** PRAGMA schema.optimize + ** PRAGMA schema.optimize(MASK) + ** + ** Attempt to optimize the database. All schemas are optimized in the first + ** two forms, and only the specified schema is optimized in the latter two. + ** + ** The details of optimizations performed by this pragma are expected + ** to change and improve over time. Applications should anticipate that + ** this pragma will perform new optimizations in future releases. + ** + ** The optional argument is a bitmask of optimizations to perform: + ** + ** 0x0001 Debugging mode. Do not actually perform any optimizations + ** but instead return one line of text for each optimization + ** that would have been done. Off by default. + ** + ** 0x0002 Run ANALYZE on tables that might benefit. On by default. + ** See below for additional information. + ** + ** 0x0004 (Not yet implemented) Record usage and performance + ** information from the current session in the + ** database file so that it will be available to "optimize" + ** pragmas run by future database connections. + ** + ** 0x0008 (Not yet implemented) Create indexes that might have + ** been helpful to recent queries + ** + ** The default MASK is and always shall be 0xfffe. 0xfffe means perform all + ** of the optimizations listed above except Debug Mode, including new + ** optimizations that have not yet been invented. If new optimizations are + ** ever added that should be off by default, those off-by-default + ** optimizations will have bitmasks of 0x10000 or larger. + ** + ** DETERMINATION OF WHEN TO RUN ANALYZE + ** + ** In the current implementation, a table is analyzed if only if all of + ** the following are true: + ** + ** (1) MASK bit 0x02 is set. + ** + ** (2) The query planner used sqlite_stat1-style statistics for one or + ** more indexes of the table at some point during the lifetime of + ** the current connection. + ** + ** (3) One or more indexes of the table are currently unanalyzed OR + ** the number of rows in the table has increased by 25 times or more + ** since the last time ANALYZE was run. + ** + ** The rules for when tables are analyzed are likely to change in + ** future releases. + */ + case PragTyp_OPTIMIZE: { + int iDbLast; /* Loop termination point for the schema loop */ + int iTabCur; /* Cursor for a table whose size needs checking */ + HashElem *k; /* Loop over tables of a schema */ + Schema *pSchema; /* The current schema */ + Table *pTab; /* A table in the schema */ + Index *pIdx; /* An index of the table */ + LogEst szThreshold; /* Size threshold above which reanalysis is needd */ + char *zSubSql; /* SQL statement for the OP_SqlExec opcode */ + u32 opMask; /* Mask of operations to perform */ + + if( zRight ){ + opMask = (u32)sqlite3Atoi(zRight); + if( (opMask & 0x02)==0 ) break; + }else{ + opMask = 0xfffe; + } + iTabCur = pParse->nTab++; + for(iDbLast = zDb?iDb:db->nDb-1; iDb<=iDbLast; iDb++){ + if( iDb==1 ) continue; + sqlite3CodeVerifySchema(pParse, iDb); + pSchema = db->aDb[iDb].pSchema; + for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){ + pTab = (Table*)sqliteHashData(k); + + /* If table pTab has not been used in a way that would benefit from + ** having analysis statistics during the current session, then skip it. + ** This also has the effect of skipping virtual tables and views */ + if( (pTab->tabFlags & TF_StatsUsed)==0 ) continue; + + /* Reanalyze if the table is 25 times larger than the last analysis */ + szThreshold = pTab->nRowLogEst + 46; assert( sqlite3LogEst(25)==46 ); + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + if( !pIdx->hasStat1 ){ + szThreshold = 0; /* Always analyze if any index lacks statistics */ + break; + } + } + if( szThreshold ){ + sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead); + sqlite3VdbeAddOp3(v, OP_IfSmaller, iTabCur, + sqlite3VdbeCurrentAddr(v)+2+(opMask&1), szThreshold); + VdbeCoverage(v); + } + zSubSql = sqlite3MPrintf(db, "ANALYZE \"%w\".\"%w\"", + db->aDb[iDb].zDbSName, pTab->zName); + if( opMask & 0x01 ){ + int r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp4(v, OP_String8, 0, r1, 0, zSubSql, P4_DYNAMIC); + sqlite3VdbeAddOp2(v, OP_ResultRow, r1, 1); + }else{ + sqlite3VdbeAddOp4(v, OP_SqlExec, 0, 0, 0, zSubSql, P4_DYNAMIC); + } + } + } + sqlite3VdbeAddOp0(v, OP_Expire); + break; + } + + /* + ** PRAGMA busy_timeout + ** PRAGMA busy_timeout = N + ** + ** Call sqlite3_busy_timeout(db, N). Return the current timeout value + ** if one is set. If no busy handler or a different busy handler is set + ** then 0 is returned. Setting the busy_timeout to 0 or negative + ** disables the timeout. + */ + /*case PragTyp_BUSY_TIMEOUT*/ default: { + assert( pPragma->ePragTyp==PragTyp_BUSY_TIMEOUT ); + if( zRight ){ + sqlite3_busy_timeout(db, sqlite3Atoi(zRight)); + } + returnSingleInt(v, db->busyTimeout); + break; + } + + /* + ** PRAGMA soft_heap_limit + ** PRAGMA soft_heap_limit = N + ** + ** IMPLEMENTATION-OF: R-26343-45930 This pragma invokes the + ** sqlite3_soft_heap_limit64() interface with the argument N, if N is + ** specified and is a non-negative integer. + ** IMPLEMENTATION-OF: R-64451-07163 The soft_heap_limit pragma always + ** returns the same integer that would be returned by the + ** sqlite3_soft_heap_limit64(-1) C-language function. + */ + case PragTyp_SOFT_HEAP_LIMIT: { + sqlite3_int64 N; + if( zRight && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK ){ + sqlite3_soft_heap_limit64(N); + } + returnSingleInt(v, sqlite3_soft_heap_limit64(-1)); + break; + } + + /* + ** PRAGMA hard_heap_limit + ** PRAGMA hard_heap_limit = N + ** + ** Invoke sqlite3_hard_heap_limit64() to query or set the hard heap + ** limit. The hard heap limit can be activated or lowered by this + ** pragma, but not raised or deactivated. Only the + ** sqlite3_hard_heap_limit64() C-language API can raise or deactivate + ** the hard heap limit. This allows an application to set a heap limit + ** constraint that cannot be relaxed by an untrusted SQL script. + */ + case PragTyp_HARD_HEAP_LIMIT: { + sqlite3_int64 N; + if( zRight && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK ){ + sqlite3_int64 iPrior = sqlite3_hard_heap_limit64(-1); + if( N>0 && (iPrior==0 || iPrior>N) ) sqlite3_hard_heap_limit64(N); + } + returnSingleInt(v, sqlite3_hard_heap_limit64(-1)); + break; + } + + /* + ** PRAGMA threads + ** PRAGMA threads = N + ** + ** Configure the maximum number of worker threads. Return the new + ** maximum, which might be less than requested. + */ + case PragTyp_THREADS: { + sqlite3_int64 N; + if( zRight + && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK + && N>=0 + ){ + sqlite3_limit(db, SQLITE_LIMIT_WORKER_THREADS, (int)(N&0x7fffffff)); + } + returnSingleInt(v, sqlite3_limit(db, SQLITE_LIMIT_WORKER_THREADS, -1)); + break; + } + + /* + ** PRAGMA analysis_limit + ** PRAGMA analysis_limit = N + ** + ** Configure the maximum number of rows that ANALYZE will examine + ** in each index that it looks at. Return the new limit. + */ + case PragTyp_ANALYSIS_LIMIT: { + sqlite3_int64 N; + if( zRight + && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK + && N>=0 + ){ + db->nAnalysisLimit = (int)(N&0x7fffffff); + } + returnSingleInt(v, db->nAnalysisLimit); + break; + } + +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + /* + ** Report the current state of file logs for all databases + */ + case PragTyp_LOCK_STATUS: { + static const char *const azLockName[] = { + "unlocked", "shared", "reserved", "pending", "exclusive" + }; + int i; + pParse->nMem = 2; + for(i=0; inDb; i++){ + Btree *pBt; + const char *zState = "unknown"; + int j; + if( db->aDb[i].zDbSName==0 ) continue; + pBt = db->aDb[i].pBt; + if( pBt==0 || sqlite3BtreePager(pBt)==0 ){ + zState = "closed"; + }else if( sqlite3_file_control(db, i ? db->aDb[i].zDbSName : 0, + SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){ + zState = azLockName[j]; + } + sqlite3VdbeMultiLoad(v, 1, "ss", db->aDb[i].zDbSName, zState); + } + break; + } +#endif + +#if defined(SQLITE_ENABLE_CEROD) + case PragTyp_ACTIVATE_EXTENSIONS: if( zRight ){ + if( sqlite3StrNICmp(zRight, "cerod-", 6)==0 ){ + sqlite3_activate_cerod(&zRight[6]); + } + } + break; +#endif + + } /* End of the PRAGMA switch */ + + /* The following block is a no-op unless SQLITE_DEBUG is defined. Its only + ** purpose is to execute assert() statements to verify that if the + ** PragFlg_NoColumns1 flag is set and the caller specified an argument + ** to the PRAGMA, the implementation has not added any OP_ResultRow + ** instructions to the VM. */ + if( (pPragma->mPragFlg & PragFlg_NoColumns1) && zRight ){ + sqlite3VdbeVerifyNoResultRow(v); + } + +pragma_out: + sqlite3DbFree(db, zLeft); + sqlite3DbFree(db, zRight); +} +#ifndef SQLITE_OMIT_VIRTUALTABLE +/***************************************************************************** +** Implementation of an eponymous virtual table that runs a pragma. +** +*/ +typedef struct PragmaVtab PragmaVtab; +typedef struct PragmaVtabCursor PragmaVtabCursor; +struct PragmaVtab { + sqlite3_vtab base; /* Base class. Must be first */ + sqlite3 *db; /* The database connection to which it belongs */ + const PragmaName *pName; /* Name of the pragma */ + u8 nHidden; /* Number of hidden columns */ + u8 iHidden; /* Index of the first hidden column */ +}; +struct PragmaVtabCursor { + sqlite3_vtab_cursor base; /* Base class. Must be first */ + sqlite3_stmt *pPragma; /* The pragma statement to run */ + sqlite_int64 iRowid; /* Current rowid */ + char *azArg[2]; /* Value of the argument and schema */ +}; + +/* +** Pragma virtual table module xConnect method. +*/ +static int pragmaVtabConnect( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + const PragmaName *pPragma = (const PragmaName*)pAux; + PragmaVtab *pTab = 0; + int rc; + int i, j; + char cSep = '('; + StrAccum acc; + char zBuf[200]; + + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(argv); + sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); + sqlite3_str_appendall(&acc, "CREATE TABLE x"); + for(i=0, j=pPragma->iPragCName; inPragCName; i++, j++){ + sqlite3_str_appendf(&acc, "%c\"%s\"", cSep, pragCName[j]); + cSep = ','; + } + if( i==0 ){ + sqlite3_str_appendf(&acc, "(\"%s\"", pPragma->zName); + i++; + } + j = 0; + if( pPragma->mPragFlg & PragFlg_Result1 ){ + sqlite3_str_appendall(&acc, ",arg HIDDEN"); + j++; + } + if( pPragma->mPragFlg & (PragFlg_SchemaOpt|PragFlg_SchemaReq) ){ + sqlite3_str_appendall(&acc, ",schema HIDDEN"); + j++; + } + sqlite3_str_append(&acc, ")", 1); + sqlite3StrAccumFinish(&acc); + assert( strlen(zBuf) < sizeof(zBuf)-1 ); + rc = sqlite3_declare_vtab(db, zBuf); + if( rc==SQLITE_OK ){ + pTab = (PragmaVtab*)sqlite3_malloc(sizeof(PragmaVtab)); + if( pTab==0 ){ + rc = SQLITE_NOMEM; + }else{ + memset(pTab, 0, sizeof(PragmaVtab)); + pTab->pName = pPragma; + pTab->db = db; + pTab->iHidden = i; + pTab->nHidden = j; + } + }else{ + *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + } + + *ppVtab = (sqlite3_vtab*)pTab; + return rc; +} + +/* +** Pragma virtual table module xDisconnect method. +*/ +static int pragmaVtabDisconnect(sqlite3_vtab *pVtab){ + PragmaVtab *pTab = (PragmaVtab*)pVtab; + sqlite3_free(pTab); + return SQLITE_OK; +} + +/* Figure out the best index to use to search a pragma virtual table. +** +** There are not really any index choices. But we want to encourage the +** query planner to give == constraints on as many hidden parameters as +** possible, and especially on the first hidden parameter. So return a +** high cost if hidden parameters are unconstrained. +*/ +static int pragmaVtabBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){ + PragmaVtab *pTab = (PragmaVtab*)tab; + const struct sqlite3_index_constraint *pConstraint; + int i, j; + int seen[2]; + + pIdxInfo->estimatedCost = (double)1; + if( pTab->nHidden==0 ){ return SQLITE_OK; } + pConstraint = pIdxInfo->aConstraint; + seen[0] = 0; + seen[1] = 0; + for(i=0; inConstraint; i++, pConstraint++){ + if( pConstraint->usable==0 ) continue; + if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue; + if( pConstraint->iColumn < pTab->iHidden ) continue; + j = pConstraint->iColumn - pTab->iHidden; + assert( j < 2 ); + seen[j] = i+1; + } + if( seen[0]==0 ){ + pIdxInfo->estimatedCost = (double)2147483647; + pIdxInfo->estimatedRows = 2147483647; + return SQLITE_OK; + } + j = seen[0]-1; + pIdxInfo->aConstraintUsage[j].argvIndex = 1; + pIdxInfo->aConstraintUsage[j].omit = 1; + if( seen[1]==0 ) return SQLITE_OK; + pIdxInfo->estimatedCost = (double)20; + pIdxInfo->estimatedRows = 20; + j = seen[1]-1; + pIdxInfo->aConstraintUsage[j].argvIndex = 2; + pIdxInfo->aConstraintUsage[j].omit = 1; + return SQLITE_OK; +} + +/* Create a new cursor for the pragma virtual table */ +static int pragmaVtabOpen(sqlite3_vtab *pVtab, sqlite3_vtab_cursor **ppCursor){ + PragmaVtabCursor *pCsr; + pCsr = (PragmaVtabCursor*)sqlite3_malloc(sizeof(*pCsr)); + if( pCsr==0 ) return SQLITE_NOMEM; + memset(pCsr, 0, sizeof(PragmaVtabCursor)); + pCsr->base.pVtab = pVtab; + *ppCursor = &pCsr->base; + return SQLITE_OK; +} + +/* Clear all content from pragma virtual table cursor. */ +static void pragmaVtabCursorClear(PragmaVtabCursor *pCsr){ + int i; + sqlite3_finalize(pCsr->pPragma); + pCsr->pPragma = 0; + for(i=0; iazArg); i++){ + sqlite3_free(pCsr->azArg[i]); + pCsr->azArg[i] = 0; + } +} + +/* Close a pragma virtual table cursor */ +static int pragmaVtabClose(sqlite3_vtab_cursor *cur){ + PragmaVtabCursor *pCsr = (PragmaVtabCursor*)cur; + pragmaVtabCursorClear(pCsr); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +/* Advance the pragma virtual table cursor to the next row */ +static int pragmaVtabNext(sqlite3_vtab_cursor *pVtabCursor){ + PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor; + int rc = SQLITE_OK; + + /* Increment the xRowid value */ + pCsr->iRowid++; + assert( pCsr->pPragma ); + if( SQLITE_ROW!=sqlite3_step(pCsr->pPragma) ){ + rc = sqlite3_finalize(pCsr->pPragma); + pCsr->pPragma = 0; + pragmaVtabCursorClear(pCsr); + } + return rc; +} + +/* +** Pragma virtual table module xFilter method. +*/ +static int pragmaVtabFilter( + sqlite3_vtab_cursor *pVtabCursor, + int idxNum, const char *idxStr, + int argc, sqlite3_value **argv +){ + PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor; + PragmaVtab *pTab = (PragmaVtab*)(pVtabCursor->pVtab); + int rc; + int i, j; + StrAccum acc; + char *zSql; + + UNUSED_PARAMETER(idxNum); + UNUSED_PARAMETER(idxStr); + pragmaVtabCursorClear(pCsr); + j = (pTab->pName->mPragFlg & PragFlg_Result1)!=0 ? 0 : 1; + for(i=0; iazArg) ); + assert( pCsr->azArg[j]==0 ); + if( zText ){ + pCsr->azArg[j] = sqlite3_mprintf("%s", zText); + if( pCsr->azArg[j]==0 ){ + return SQLITE_NOMEM; + } + } + } + sqlite3StrAccumInit(&acc, 0, 0, 0, pTab->db->aLimit[SQLITE_LIMIT_SQL_LENGTH]); + sqlite3_str_appendall(&acc, "PRAGMA "); + if( pCsr->azArg[1] ){ + sqlite3_str_appendf(&acc, "%Q.", pCsr->azArg[1]); + } + sqlite3_str_appendall(&acc, pTab->pName->zName); + if( pCsr->azArg[0] ){ + sqlite3_str_appendf(&acc, "=%Q", pCsr->azArg[0]); + } + zSql = sqlite3StrAccumFinish(&acc); + if( zSql==0 ) return SQLITE_NOMEM; + rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pPragma, 0); + sqlite3_free(zSql); + if( rc!=SQLITE_OK ){ + pTab->base.zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pTab->db)); + return rc; + } + return pragmaVtabNext(pVtabCursor); +} + +/* +** Pragma virtual table module xEof method. +*/ +static int pragmaVtabEof(sqlite3_vtab_cursor *pVtabCursor){ + PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor; + return (pCsr->pPragma==0); +} + +/* The xColumn method simply returns the corresponding column from +** the PRAGMA. +*/ +static int pragmaVtabColumn( + sqlite3_vtab_cursor *pVtabCursor, + sqlite3_context *ctx, + int i +){ + PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor; + PragmaVtab *pTab = (PragmaVtab*)(pVtabCursor->pVtab); + if( iiHidden ){ + sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pPragma, i)); + }else{ + sqlite3_result_text(ctx, pCsr->azArg[i-pTab->iHidden],-1,SQLITE_TRANSIENT); + } + return SQLITE_OK; +} + +/* +** Pragma virtual table module xRowid method. +*/ +static int pragmaVtabRowid(sqlite3_vtab_cursor *pVtabCursor, sqlite_int64 *p){ + PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor; + *p = pCsr->iRowid; + return SQLITE_OK; +} + +/* The pragma virtual table object */ +static const sqlite3_module pragmaVtabModule = { + 0, /* iVersion */ + 0, /* xCreate - create a table */ + pragmaVtabConnect, /* xConnect - connect to an existing table */ + pragmaVtabBestIndex, /* xBestIndex - Determine search strategy */ + pragmaVtabDisconnect, /* xDisconnect - Disconnect from a table */ + 0, /* xDestroy - Drop a table */ + pragmaVtabOpen, /* xOpen - open a cursor */ + pragmaVtabClose, /* xClose - close a cursor */ + pragmaVtabFilter, /* xFilter - configure scan constraints */ + pragmaVtabNext, /* xNext - advance a cursor */ + pragmaVtabEof, /* xEof */ + pragmaVtabColumn, /* xColumn - read data */ + pragmaVtabRowid, /* xRowid - read data */ + 0, /* xUpdate - write data */ + 0, /* xBegin - begin transaction */ + 0, /* xSync - sync transaction */ + 0, /* xCommit - commit transaction */ + 0, /* xRollback - rollback transaction */ + 0, /* xFindFunction - function overloading */ + 0, /* xRename - rename the table */ + 0, /* xSavepoint */ + 0, /* xRelease */ + 0, /* xRollbackTo */ + 0 /* xShadowName */ +}; + +/* +** Check to see if zTabName is really the name of a pragma. If it is, +** then register an eponymous virtual table for that pragma and return +** a pointer to the Module object for the new virtual table. +*/ +SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3 *db, const char *zName){ + const PragmaName *pName; + assert( sqlite3_strnicmp(zName, "pragma_", 7)==0 ); + pName = pragmaLocate(zName+7); + if( pName==0 ) return 0; + if( (pName->mPragFlg & (PragFlg_Result0|PragFlg_Result1))==0 ) return 0; + assert( sqlite3HashFind(&db->aModule, zName)==0 ); + return sqlite3VtabCreateModule(db, zName, &pragmaVtabModule, (void*)pName, 0); +} + +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#endif /* SQLITE_OMIT_PRAGMA */ + +/************** End of pragma.c **********************************************/ +/************** Begin file prepare.c *****************************************/ +/* +** 2005 May 25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the implementation of the sqlite3_prepare() +** interface, and routines that contribute to loading the database schema +** from disk. +*/ +/* #include "sqliteInt.h" */ + +/* +** Fill the InitData structure with an error message that indicates +** that the database is corrupt. +*/ +static void corruptSchema( + InitData *pData, /* Initialization context */ + const char *zObj, /* Object being parsed at the point of error */ + const char *zExtra /* Error information */ +){ + sqlite3 *db = pData->db; + if( db->mallocFailed ){ + pData->rc = SQLITE_NOMEM_BKPT; + }else if( pData->pzErrMsg[0]!=0 ){ + /* A error message has already been generated. Do not overwrite it */ + }else if( pData->mInitFlags & INITFLAG_AlterTable ){ + *pData->pzErrMsg = sqlite3DbStrDup(db, zExtra); + pData->rc = SQLITE_ERROR; + }else if( db->flags & SQLITE_WriteSchema ){ + pData->rc = SQLITE_CORRUPT_BKPT; + }else{ + char *z; + if( zObj==0 ) zObj = "?"; + z = sqlite3MPrintf(db, "malformed database schema (%s)", zObj); + if( zExtra && zExtra[0] ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra); + *pData->pzErrMsg = z; + pData->rc = SQLITE_CORRUPT_BKPT; + } +} + +/* +** Check to see if any sibling index (another index on the same table) +** of pIndex has the same root page number, and if it does, return true. +** This would indicate a corrupt schema. +*/ +SQLITE_PRIVATE int sqlite3IndexHasDuplicateRootPage(Index *pIndex){ + Index *p; + for(p=pIndex->pTable->pIndex; p; p=p->pNext){ + if( p->tnum==pIndex->tnum && p!=pIndex ) return 1; + } + return 0; +} + +/* forward declaration */ +static int sqlite3Prepare( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ + Vdbe *pReprepare, /* VM being reprepared */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +); + + +/* +** This is the callback routine for the code that initializes the +** database. See sqlite3Init() below for additional information. +** This routine is also called from the OP_ParseSchema opcode of the VDBE. +** +** Each callback contains the following information: +** +** argv[0] = type of object: "table", "index", "trigger", or "view". +** argv[1] = name of thing being created +** argv[2] = associated table if an index or trigger +** argv[3] = root page number for table or index. 0 for trigger or view. +** argv[4] = SQL text for the CREATE statement. +** +*/ +SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){ + InitData *pData = (InitData*)pInit; + sqlite3 *db = pData->db; + int iDb = pData->iDb; + + assert( argc==5 ); + UNUSED_PARAMETER2(NotUsed, argc); + assert( sqlite3_mutex_held(db->mutex) ); + db->mDbFlags |= DBFLAG_EncodingFixed; + pData->nInitRow++; + if( db->mallocFailed ){ + corruptSchema(pData, argv[1], 0); + return 1; + } + + assert( iDb>=0 && iDbnDb ); + if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */ + if( argv[3]==0 ){ + corruptSchema(pData, argv[1], 0); + }else if( sqlite3_strnicmp(argv[4],"create ",7)==0 ){ + /* Call the parser to process a CREATE TABLE, INDEX or VIEW. + ** But because db->init.busy is set to 1, no VDBE code is generated + ** or executed. All the parser does is build the internal data + ** structures that describe the table, index, or view. + */ + int rc; + u8 saved_iDb = db->init.iDb; + sqlite3_stmt *pStmt; + TESTONLY(int rcp); /* Return code from sqlite3_prepare() */ + + assert( db->init.busy ); + db->init.iDb = iDb; + if( sqlite3GetUInt32(argv[3], &db->init.newTnum)==0 + || (db->init.newTnum>pData->mxPage && pData->mxPage>0) + ){ + if( sqlite3Config.bExtraSchemaChecks ){ + corruptSchema(pData, argv[1], "invalid rootpage"); + } + } + db->init.orphanTrigger = 0; + db->init.azInit = argv; + pStmt = 0; + TESTONLY(rcp = ) sqlite3Prepare(db, argv[4], -1, 0, 0, &pStmt, 0); + rc = db->errCode; + assert( (rc&0xFF)==(rcp&0xFF) ); + db->init.iDb = saved_iDb; + /* assert( saved_iDb==0 || (db->mDbFlags & DBFLAG_Vacuum)!=0 ); */ + if( SQLITE_OK!=rc ){ + if( db->init.orphanTrigger ){ + assert( iDb==1 ); + }else{ + if( rc > pData->rc ) pData->rc = rc; + if( rc==SQLITE_NOMEM ){ + sqlite3OomFault(db); + }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){ + corruptSchema(pData, argv[1], sqlite3_errmsg(db)); + } + } + } + sqlite3_finalize(pStmt); + }else if( argv[1]==0 || (argv[4]!=0 && argv[4][0]!=0) ){ + corruptSchema(pData, argv[1], 0); + }else{ + /* If the SQL column is blank it means this is an index that + ** was created to be the PRIMARY KEY or to fulfill a UNIQUE + ** constraint for a CREATE TABLE. The index should have already + ** been created when we processed the CREATE TABLE. All we have + ** to do here is record the root page number for that index. + */ + Index *pIndex; + pIndex = sqlite3FindIndex(db, argv[1], db->aDb[iDb].zDbSName); + if( pIndex==0 ){ + corruptSchema(pData, argv[1], "orphan index"); + }else + if( sqlite3GetUInt32(argv[3],&pIndex->tnum)==0 + || pIndex->tnum<2 + || pIndex->tnum>pData->mxPage + || sqlite3IndexHasDuplicateRootPage(pIndex) + ){ + if( sqlite3Config.bExtraSchemaChecks ){ + corruptSchema(pData, argv[1], "invalid rootpage"); + } + } + } + return 0; +} + +/* +** Attempt to read the database schema and initialize internal +** data structures for a single database file. The index of the +** database file is given by iDb. iDb==0 is used for the main +** database. iDb==1 should never be used. iDb>=2 is used for +** auxiliary databases. Return one of the SQLITE_ error codes to +** indicate success or failure. +*/ +SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){ + int rc; + int i; +#ifndef SQLITE_OMIT_DEPRECATED + int size; +#endif + Db *pDb; + char const *azArg[6]; + int meta[5]; + InitData initData; + const char *zSchemaTabName; + int openedTransaction = 0; + int mask = ((db->mDbFlags & DBFLAG_EncodingFixed) | ~DBFLAG_EncodingFixed); + + assert( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0 ); + assert( iDb>=0 && iDbnDb ); + assert( db->aDb[iDb].pSchema ); + assert( sqlite3_mutex_held(db->mutex) ); + assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) ); + + db->init.busy = 1; + + /* Construct the in-memory representation schema tables (sqlite_schema or + ** sqlite_temp_schema) by invoking the parser directly. The appropriate + ** table name will be inserted automatically by the parser so we can just + ** use the abbreviation "x" here. The parser will also automatically tag + ** the schema table as read-only. */ + azArg[0] = "table"; + azArg[1] = zSchemaTabName = SCHEMA_TABLE(iDb); + azArg[2] = azArg[1]; + azArg[3] = "1"; + azArg[4] = "CREATE TABLE x(type text,name text,tbl_name text," + "rootpage int,sql text)"; + azArg[5] = 0; + initData.db = db; + initData.iDb = iDb; + initData.rc = SQLITE_OK; + initData.pzErrMsg = pzErrMsg; + initData.mInitFlags = mFlags; + initData.nInitRow = 0; + initData.mxPage = 0; + sqlite3InitCallback(&initData, 5, (char **)azArg, 0); + db->mDbFlags &= mask; + if( initData.rc ){ + rc = initData.rc; + goto error_out; + } + + /* Create a cursor to hold the database open + */ + pDb = &db->aDb[iDb]; + if( pDb->pBt==0 ){ + assert( iDb==1 ); + DbSetProperty(db, 1, DB_SchemaLoaded); + rc = SQLITE_OK; + goto error_out; + } + + /* If there is not already a read-only (or read-write) transaction opened + ** on the b-tree database, open one now. If a transaction is opened, it + ** will be closed before this function returns. */ + sqlite3BtreeEnter(pDb->pBt); + if( sqlite3BtreeTxnState(pDb->pBt)==SQLITE_TXN_NONE ){ + rc = sqlite3BtreeBeginTrans(pDb->pBt, 0, 0); + if( rc!=SQLITE_OK ){ + sqlite3SetString(pzErrMsg, db, sqlite3ErrStr(rc)); + goto initone_error_out; + } + openedTransaction = 1; + } + + /* Get the database meta information. + ** + ** Meta values are as follows: + ** meta[0] Schema cookie. Changes with each schema change. + ** meta[1] File format of schema layer. + ** meta[2] Size of the page cache. + ** meta[3] Largest rootpage (auto/incr_vacuum mode) + ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE + ** meta[5] User version + ** meta[6] Incremental vacuum mode + ** meta[7] unused + ** meta[8] unused + ** meta[9] unused + ** + ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to + ** the possible values of meta[4]. + */ + for(i=0; ipBt, i+1, (u32 *)&meta[i]); + } + if( (db->flags & SQLITE_ResetDatabase)!=0 ){ + memset(meta, 0, sizeof(meta)); + } + pDb->pSchema->schema_cookie = meta[BTREE_SCHEMA_VERSION-1]; + + /* If opening a non-empty database, check the text encoding. For the + ** main database, set sqlite3.enc to the encoding of the main database. + ** For an attached db, it is an error if the encoding is not the same + ** as sqlite3.enc. + */ + if( meta[BTREE_TEXT_ENCODING-1] ){ /* text encoding */ + if( iDb==0 && (db->mDbFlags & DBFLAG_EncodingFixed)==0 ){ + u8 encoding; +#ifndef SQLITE_OMIT_UTF16 + /* If opening the main database, set ENC(db). */ + encoding = (u8)meta[BTREE_TEXT_ENCODING-1] & 3; + if( encoding==0 ) encoding = SQLITE_UTF8; +#else + encoding = SQLITE_UTF8; +#endif + sqlite3SetTextEncoding(db, encoding); + }else{ + /* If opening an attached database, the encoding much match ENC(db) */ + if( (meta[BTREE_TEXT_ENCODING-1] & 3)!=ENC(db) ){ + sqlite3SetString(pzErrMsg, db, "attached databases must use the same" + " text encoding as main database"); + rc = SQLITE_ERROR; + goto initone_error_out; + } + } + } + pDb->pSchema->enc = ENC(db); + + if( pDb->pSchema->cache_size==0 ){ +#ifndef SQLITE_OMIT_DEPRECATED + size = sqlite3AbsInt32(meta[BTREE_DEFAULT_CACHE_SIZE-1]); + if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; } + pDb->pSchema->cache_size = size; +#else + pDb->pSchema->cache_size = SQLITE_DEFAULT_CACHE_SIZE; +#endif + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); + } + + /* + ** file_format==1 Version 3.0.0. + ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN + ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults + ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants + */ + pDb->pSchema->file_format = (u8)meta[BTREE_FILE_FORMAT-1]; + if( pDb->pSchema->file_format==0 ){ + pDb->pSchema->file_format = 1; + } + if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){ + sqlite3SetString(pzErrMsg, db, "unsupported file format"); + rc = SQLITE_ERROR; + goto initone_error_out; + } + + /* Ticket #2804: When we open a database in the newer file format, + ** clear the legacy_file_format pragma flag so that a VACUUM will + ** not downgrade the database and thus invalidate any descending + ** indices that the user might have created. + */ + if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){ + db->flags &= ~(u64)SQLITE_LegacyFileFmt; + } + + /* Read the schema information out of the schema tables + */ + assert( db->init.busy ); + initData.mxPage = sqlite3BtreeLastPage(pDb->pBt); + { + char *zSql; + zSql = sqlite3MPrintf(db, + "SELECT*FROM\"%w\".%s ORDER BY rowid", + db->aDb[iDb].zDbSName, zSchemaTabName); +#ifndef SQLITE_OMIT_AUTHORIZATION + { + sqlite3_xauth xAuth; + xAuth = db->xAuth; + db->xAuth = 0; +#endif + rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0); +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = xAuth; + } +#endif + if( rc==SQLITE_OK ) rc = initData.rc; + sqlite3DbFree(db, zSql); +#ifndef SQLITE_OMIT_ANALYZE + if( rc==SQLITE_OK ){ + sqlite3AnalysisLoad(db, iDb); + } +#endif + } + if( db->mallocFailed ){ + rc = SQLITE_NOMEM_BKPT; + sqlite3ResetAllSchemasOfConnection(db); + } + if( rc==SQLITE_OK || (db->flags&SQLITE_NoSchemaError)){ + /* Black magic: If the SQLITE_NoSchemaError flag is set, then consider + ** the schema loaded, even if errors occurred. In this situation the + ** current sqlite3_prepare() operation will fail, but the following one + ** will attempt to compile the supplied statement against whatever subset + ** of the schema was loaded before the error occurred. The primary + ** purpose of this is to allow access to the sqlite_schema table + ** even when its contents have been corrupted. + */ + DbSetProperty(db, iDb, DB_SchemaLoaded); + rc = SQLITE_OK; + } + + /* Jump here for an error that occurs after successfully allocating + ** curMain and calling sqlite3BtreeEnter(). For an error that occurs + ** before that point, jump to error_out. + */ +initone_error_out: + if( openedTransaction ){ + sqlite3BtreeCommit(pDb->pBt); + } + sqlite3BtreeLeave(pDb->pBt); + +error_out: + if( rc ){ + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ + sqlite3OomFault(db); + } + sqlite3ResetOneSchema(db, iDb); + } + db->init.busy = 0; + return rc; +} + +/* +** Initialize all database files - the main database file, the file +** used to store temporary tables, and any additional database files +** created using ATTACH statements. Return a success code. If an +** error occurs, write an error message into *pzErrMsg. +** +** After a database is initialized, the DB_SchemaLoaded bit is set +** bit is set in the flags field of the Db structure. +*/ +SQLITE_PRIVATE int sqlite3Init(sqlite3 *db, char **pzErrMsg){ + int i, rc; + int commit_internal = !(db->mDbFlags&DBFLAG_SchemaChange); + + assert( sqlite3_mutex_held(db->mutex) ); + assert( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) ); + assert( db->init.busy==0 ); + ENC(db) = SCHEMA_ENC(db); + assert( db->nDb>0 ); + /* Do the main schema first */ + if( !DbHasProperty(db, 0, DB_SchemaLoaded) ){ + rc = sqlite3InitOne(db, 0, pzErrMsg, 0); + if( rc ) return rc; + } + /* All other schemas after the main schema. The "temp" schema must be last */ + for(i=db->nDb-1; i>0; i--){ + assert( i==1 || sqlite3BtreeHoldsMutex(db->aDb[i].pBt) ); + if( !DbHasProperty(db, i, DB_SchemaLoaded) ){ + rc = sqlite3InitOne(db, i, pzErrMsg, 0); + if( rc ) return rc; + } + } + if( commit_internal ){ + sqlite3CommitInternalChanges(db); + } + return SQLITE_OK; +} + +/* +** This routine is a no-op if the database schema is already initialized. +** Otherwise, the schema is loaded. An error code is returned. +*/ +SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse){ + int rc = SQLITE_OK; + sqlite3 *db = pParse->db; + assert( sqlite3_mutex_held(db->mutex) ); + if( !db->init.busy ){ + rc = sqlite3Init(db, &pParse->zErrMsg); + if( rc!=SQLITE_OK ){ + pParse->rc = rc; + pParse->nErr++; + }else if( db->noSharedCache ){ + db->mDbFlags |= DBFLAG_SchemaKnownOk; + } + } + return rc; +} + + +/* +** Check schema cookies in all databases. If any cookie is out +** of date set pParse->rc to SQLITE_SCHEMA. If all schema cookies +** make no changes to pParse->rc. +*/ +static void schemaIsValid(Parse *pParse){ + sqlite3 *db = pParse->db; + int iDb; + int rc; + int cookie; + + assert( pParse->checkSchema ); + assert( sqlite3_mutex_held(db->mutex) ); + for(iDb=0; iDbnDb; iDb++){ + int openedTransaction = 0; /* True if a transaction is opened */ + Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */ + if( pBt==0 ) continue; + + /* If there is not already a read-only (or read-write) transaction opened + ** on the b-tree database, open one now. If a transaction is opened, it + ** will be closed immediately after reading the meta-value. */ + if( sqlite3BtreeTxnState(pBt)==SQLITE_TXN_NONE ){ + rc = sqlite3BtreeBeginTrans(pBt, 0, 0); + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ + sqlite3OomFault(db); + } + if( rc!=SQLITE_OK ) return; + openedTransaction = 1; + } + + /* Read the schema cookie from the database. If it does not match the + ** value stored as part of the in-memory schema representation, + ** set Parse.rc to SQLITE_SCHEMA. */ + sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie); + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){ + sqlite3ResetOneSchema(db, iDb); + pParse->rc = SQLITE_SCHEMA; + } + + /* Close the transaction, if one was opened. */ + if( openedTransaction ){ + sqlite3BtreeCommit(pBt); + } + } +} + +/* +** Convert a schema pointer into the iDb index that indicates +** which database file in db->aDb[] the schema refers to. +** +** If the same database is attached more than once, the first +** attached database is returned. +*/ +SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){ + int i = -32768; + + /* If pSchema is NULL, then return -32768. This happens when code in + ** expr.c is trying to resolve a reference to a transient table (i.e. one + ** created by a sub-select). In this case the return value of this + ** function should never be used. + ** + ** We return -32768 instead of the more usual -1 simply because using + ** -32768 as the incorrect index into db->aDb[] is much + ** more likely to cause a segfault than -1 (of course there are assert() + ** statements too, but it never hurts to play the odds) and + ** -32768 will still fit into a 16-bit signed integer. + */ + assert( sqlite3_mutex_held(db->mutex) ); + if( pSchema ){ + for(i=0; 1; i++){ + assert( inDb ); + if( db->aDb[i].pSchema==pSchema ){ + break; + } + } + assert( i>=0 && inDb ); + } + return i; +} + +/* +** Deallocate a single AggInfo object +*/ +static void agginfoFree(sqlite3 *db, AggInfo *p){ + sqlite3DbFree(db, p->aCol); + sqlite3DbFree(db, p->aFunc); + sqlite3DbFree(db, p); +} + +/* +** Free all memory allocations in the pParse object +*/ +SQLITE_PRIVATE void sqlite3ParserReset(Parse *pParse){ + sqlite3 *db = pParse->db; + AggInfo *pThis = pParse->pAggList; + while( pThis ){ + AggInfo *pNext = pThis->pNext; + agginfoFree(db, pThis); + pThis = pNext; + } + sqlite3DbFree(db, pParse->aLabel); + sqlite3ExprListDelete(db, pParse->pConstExpr); + if( db ){ + assert( db->lookaside.bDisable >= pParse->disableLookaside ); + db->lookaside.bDisable -= pParse->disableLookaside; + db->lookaside.sz = db->lookaside.bDisable ? 0 : db->lookaside.szTrue; + } + pParse->disableLookaside = 0; +} + +/* +** Compile the UTF-8 encoded SQL statement zSql into a statement handle. +*/ +static int sqlite3Prepare( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ + Vdbe *pReprepare, /* VM being reprepared */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + char *zErrMsg = 0; /* Error message */ + int rc = SQLITE_OK; /* Result code */ + int i; /* Loop counter */ + Parse sParse; /* Parsing context */ + + memset(&sParse, 0, PARSE_HDR_SZ); + memset(PARSE_TAIL(&sParse), 0, PARSE_TAIL_SZ); + sParse.pReprepare = pReprepare; + assert( ppStmt && *ppStmt==0 ); + /* assert( !db->mallocFailed ); // not true with SQLITE_USE_ALLOCA */ + assert( sqlite3_mutex_held(db->mutex) ); + + /* For a long-term use prepared statement avoid the use of + ** lookaside memory. + */ + if( prepFlags & SQLITE_PREPARE_PERSISTENT ){ + sParse.disableLookaside++; + DisableLookaside; + } + sParse.disableVtab = (prepFlags & SQLITE_PREPARE_NO_VTAB)!=0; + + /* Check to verify that it is possible to get a read lock on all + ** database schemas. The inability to get a read lock indicates that + ** some other database connection is holding a write-lock, which in + ** turn means that the other connection has made uncommitted changes + ** to the schema. + ** + ** Were we to proceed and prepare the statement against the uncommitted + ** schema changes and if those schema changes are subsequently rolled + ** back and different changes are made in their place, then when this + ** prepared statement goes to run the schema cookie would fail to detect + ** the schema change. Disaster would follow. + ** + ** This thread is currently holding mutexes on all Btrees (because + ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it + ** is not possible for another thread to start a new schema change + ** while this routine is running. Hence, we do not need to hold + ** locks on the schema, we just need to make sure nobody else is + ** holding them. + ** + ** Note that setting READ_UNCOMMITTED overrides most lock detection, + ** but it does *not* override schema lock detection, so this all still + ** works even if READ_UNCOMMITTED is set. + */ + if( !db->noSharedCache ){ + for(i=0; inDb; i++) { + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + assert( sqlite3BtreeHoldsMutex(pBt) ); + rc = sqlite3BtreeSchemaLocked(pBt); + if( rc ){ + const char *zDb = db->aDb[i].zDbSName; + sqlite3ErrorWithMsg(db, rc, "database schema is locked: %s", zDb); + testcase( db->flags & SQLITE_ReadUncommit ); + goto end_prepare; + } + } + } + } + + sqlite3VtabUnlockList(db); + + sParse.db = db; + if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){ + char *zSqlCopy; + int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH]; + testcase( nBytes==mxLen ); + testcase( nBytes==mxLen+1 ); + if( nBytes>mxLen ){ + sqlite3ErrorWithMsg(db, SQLITE_TOOBIG, "statement too long"); + rc = sqlite3ApiExit(db, SQLITE_TOOBIG); + goto end_prepare; + } + zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes); + if( zSqlCopy ){ + sqlite3RunParser(&sParse, zSqlCopy, &zErrMsg); + sParse.zTail = &zSql[sParse.zTail-zSqlCopy]; + sqlite3DbFree(db, zSqlCopy); + }else{ + sParse.zTail = &zSql[nBytes]; + } + }else{ + sqlite3RunParser(&sParse, zSql, &zErrMsg); + } + assert( 0==sParse.nQueryLoop ); + + if( sParse.rc==SQLITE_DONE ){ + sParse.rc = SQLITE_OK; + } + if( sParse.checkSchema ){ + schemaIsValid(&sParse); + } + if( pzTail ){ + *pzTail = sParse.zTail; + } + + if( db->init.busy==0 ){ + sqlite3VdbeSetSql(sParse.pVdbe, zSql, (int)(sParse.zTail-zSql), prepFlags); + } + if( db->mallocFailed ){ + sParse.rc = SQLITE_NOMEM_BKPT; + } + rc = sParse.rc; + if( rc!=SQLITE_OK ){ + if( sParse.pVdbe ) sqlite3VdbeFinalize(sParse.pVdbe); + assert(!(*ppStmt)); + }else{ + *ppStmt = (sqlite3_stmt*)sParse.pVdbe; + } + + if( zErrMsg ){ + sqlite3ErrorWithMsg(db, rc, "%s", zErrMsg); + sqlite3DbFree(db, zErrMsg); + }else{ + sqlite3Error(db, rc); + } + + /* Delete any TriggerPrg structures allocated while parsing this statement. */ + while( sParse.pTriggerPrg ){ + TriggerPrg *pT = sParse.pTriggerPrg; + sParse.pTriggerPrg = pT->pNext; + sqlite3DbFree(db, pT); + } + +end_prepare: + + sqlite3ParserReset(&sParse); + return rc; +} +static int sqlite3LockAndPrepare( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ + Vdbe *pOld, /* VM being reprepared */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + int rc; + int cnt = 0; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( ppStmt==0 ) return SQLITE_MISUSE_BKPT; +#endif + *ppStmt = 0; + if( !sqlite3SafetyCheckOk(db)||zSql==0 ){ + return SQLITE_MISUSE_BKPT; + } + sqlite3_mutex_enter(db->mutex); + sqlite3BtreeEnterAll(db); + do{ + /* Make multiple attempts to compile the SQL, until it either succeeds + ** or encounters a permanent error. A schema problem after one schema + ** reset is considered a permanent error. */ + rc = sqlite3Prepare(db, zSql, nBytes, prepFlags, pOld, ppStmt, pzTail); + assert( rc==SQLITE_OK || *ppStmt==0 ); + }while( rc==SQLITE_ERROR_RETRY + || (rc==SQLITE_SCHEMA && (sqlite3ResetOneSchema(db,-1), cnt++)==0) ); + sqlite3BtreeLeaveAll(db); + rc = sqlite3ApiExit(db, rc); + assert( (rc&db->errMask)==rc ); + db->busyHandler.nBusy = 0; + sqlite3_mutex_leave(db->mutex); + return rc; +} + + +/* +** Rerun the compilation of a statement after a schema change. +** +** If the statement is successfully recompiled, return SQLITE_OK. Otherwise, +** if the statement cannot be recompiled because another connection has +** locked the sqlite3_schema table, return SQLITE_LOCKED. If any other error +** occurs, return SQLITE_SCHEMA. +*/ +SQLITE_PRIVATE int sqlite3Reprepare(Vdbe *p){ + int rc; + sqlite3_stmt *pNew; + const char *zSql; + sqlite3 *db; + u8 prepFlags; + + assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) ); + zSql = sqlite3_sql((sqlite3_stmt *)p); + assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */ + db = sqlite3VdbeDb(p); + assert( sqlite3_mutex_held(db->mutex) ); + prepFlags = sqlite3VdbePrepareFlags(p); + rc = sqlite3LockAndPrepare(db, zSql, -1, prepFlags, p, &pNew, 0); + if( rc ){ + if( rc==SQLITE_NOMEM ){ + sqlite3OomFault(db); + } + assert( pNew==0 ); + return rc; + }else{ + assert( pNew!=0 ); + } + sqlite3VdbeSwap((Vdbe*)pNew, p); + sqlite3TransferBindings(pNew, (sqlite3_stmt*)p); + sqlite3VdbeResetStepResult((Vdbe*)pNew); + sqlite3VdbeFinalize((Vdbe*)pNew); + return SQLITE_OK; +} + + +/* +** Two versions of the official API. Legacy and new use. In the legacy +** version, the original SQL text is not saved in the prepared statement +** and so if a schema change occurs, SQLITE_SCHEMA is returned by +** sqlite3_step(). In the new version, the original SQL text is retained +** and the statement is automatically recompiled if an schema change +** occurs. +*/ +SQLITE_API int sqlite3_prepare( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + int rc; + rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ + return rc; +} +SQLITE_API int sqlite3_prepare_v2( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + int rc; + /* EVIDENCE-OF: R-37923-12173 The sqlite3_prepare_v2() interface works + ** exactly the same as sqlite3_prepare_v3() with a zero prepFlags + ** parameter. + ** + ** Proof in that the 5th parameter to sqlite3LockAndPrepare is 0 */ + rc = sqlite3LockAndPrepare(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,0, + ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); + return rc; +} +SQLITE_API int sqlite3_prepare_v3( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + int rc; + /* EVIDENCE-OF: R-56861-42673 sqlite3_prepare_v3() differs from + ** sqlite3_prepare_v2() only in having the extra prepFlags parameter, + ** which is a bit array consisting of zero or more of the + ** SQLITE_PREPARE_* flags. + ** + ** Proof by comparison to the implementation of sqlite3_prepare_v2() + ** directly above. */ + rc = sqlite3LockAndPrepare(db,zSql,nBytes, + SQLITE_PREPARE_SAVESQL|(prepFlags&SQLITE_PREPARE_MASK), + 0,ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); + return rc; +} + + +#ifndef SQLITE_OMIT_UTF16 +/* +** Compile the UTF-16 encoded SQL statement zSql into a statement handle. +*/ +static int sqlite3Prepare16( + sqlite3 *db, /* Database handle. */ + const void *zSql, /* UTF-16 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const void **pzTail /* OUT: End of parsed string */ +){ + /* This function currently works by first transforming the UTF-16 + ** encoded string to UTF-8, then invoking sqlite3_prepare(). The + ** tricky bit is figuring out the pointer to return in *pzTail. + */ + char *zSql8; + const char *zTail8 = 0; + int rc = SQLITE_OK; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( ppStmt==0 ) return SQLITE_MISUSE_BKPT; +#endif + *ppStmt = 0; + if( !sqlite3SafetyCheckOk(db)||zSql==0 ){ + return SQLITE_MISUSE_BKPT; + } + if( nBytes>=0 ){ + int sz; + const char *z = (const char*)zSql; + for(sz=0; szmutex); + zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE); + if( zSql8 ){ + rc = sqlite3LockAndPrepare(db, zSql8, -1, prepFlags, 0, ppStmt, &zTail8); + } + + if( zTail8 && pzTail ){ + /* If sqlite3_prepare returns a tail pointer, we calculate the + ** equivalent pointer into the UTF-16 string by counting the unicode + ** characters between zSql8 and zTail8, and then returning a pointer + ** the same number of characters into the UTF-16 string. + */ + int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8)); + *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed); + } + sqlite3DbFree(db, zSql8); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Two versions of the official API. Legacy and new use. In the legacy +** version, the original SQL text is not saved in the prepared statement +** and so if a schema change occurs, SQLITE_SCHEMA is returned by +** sqlite3_step(). In the new version, the original SQL text is retained +** and the statement is automatically recompiled if an schema change +** occurs. +*/ +SQLITE_API int sqlite3_prepare16( + sqlite3 *db, /* Database handle. */ + const void *zSql, /* UTF-16 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const void **pzTail /* OUT: End of parsed string */ +){ + int rc; + rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ + return rc; +} +SQLITE_API int sqlite3_prepare16_v2( + sqlite3 *db, /* Database handle. */ + const void *zSql, /* UTF-16 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const void **pzTail /* OUT: End of parsed string */ +){ + int rc; + rc = sqlite3Prepare16(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ + return rc; +} +SQLITE_API int sqlite3_prepare16_v3( + sqlite3 *db, /* Database handle. */ + const void *zSql, /* UTF-16 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const void **pzTail /* OUT: End of parsed string */ +){ + int rc; + rc = sqlite3Prepare16(db,zSql,nBytes, + SQLITE_PREPARE_SAVESQL|(prepFlags&SQLITE_PREPARE_MASK), + ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ + return rc; +} + +#endif /* SQLITE_OMIT_UTF16 */ + +/************** End of prepare.c *********************************************/ +/************** Begin file select.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** to handle SELECT statements in SQLite. +*/ +/* #include "sqliteInt.h" */ + +/* +** An instance of the following object is used to record information about +** how to process the DISTINCT keyword, to simplify passing that information +** into the selectInnerLoop() routine. +*/ +typedef struct DistinctCtx DistinctCtx; +struct DistinctCtx { + u8 isTnct; /* True if the DISTINCT keyword is present */ + u8 eTnctType; /* One of the WHERE_DISTINCT_* operators */ + int tabTnct; /* Ephemeral table used for DISTINCT processing */ + int addrTnct; /* Address of OP_OpenEphemeral opcode for tabTnct */ +}; + +/* +** An instance of the following object is used to record information about +** the ORDER BY (or GROUP BY) clause of query is being coded. +** +** The aDefer[] array is used by the sorter-references optimization. For +** example, assuming there is no index that can be used for the ORDER BY, +** for the query: +** +** SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10; +** +** it may be more efficient to add just the "a" values to the sorter, and +** retrieve the associated "bigblob" values directly from table t1 as the +** 10 smallest "a" values are extracted from the sorter. +** +** When the sorter-reference optimization is used, there is one entry in the +** aDefer[] array for each database table that may be read as values are +** extracted from the sorter. +*/ +typedef struct SortCtx SortCtx; +struct SortCtx { + ExprList *pOrderBy; /* The ORDER BY (or GROUP BY clause) */ + int nOBSat; /* Number of ORDER BY terms satisfied by indices */ + int iECursor; /* Cursor number for the sorter */ + int regReturn; /* Register holding block-output return address */ + int labelBkOut; /* Start label for the block-output subroutine */ + int addrSortIndex; /* Address of the OP_SorterOpen or OP_OpenEphemeral */ + int labelDone; /* Jump here when done, ex: LIMIT reached */ + int labelOBLopt; /* Jump here when sorter is full */ + u8 sortFlags; /* Zero or more SORTFLAG_* bits */ +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + u8 nDefer; /* Number of valid entries in aDefer[] */ + struct DeferredCsr { + Table *pTab; /* Table definition */ + int iCsr; /* Cursor number for table */ + int nKey; /* Number of PK columns for table pTab (>=1) */ + } aDefer[4]; +#endif + struct RowLoadInfo *pDeferredRowLoad; /* Deferred row loading info or NULL */ +}; +#define SORTFLAG_UseSorter 0x01 /* Use SorterOpen instead of OpenEphemeral */ + +/* +** Delete all the content of a Select structure. Deallocate the structure +** itself depending on the value of bFree +** +** If bFree==1, call sqlite3DbFree() on the p object. +** If bFree==0, Leave the first Select object unfreed +*/ +static void clearSelect(sqlite3 *db, Select *p, int bFree){ + while( p ){ + Select *pPrior = p->pPrior; + sqlite3ExprListDelete(db, p->pEList); + sqlite3SrcListDelete(db, p->pSrc); + sqlite3ExprDelete(db, p->pWhere); + sqlite3ExprListDelete(db, p->pGroupBy); + sqlite3ExprDelete(db, p->pHaving); + sqlite3ExprListDelete(db, p->pOrderBy); + sqlite3ExprDelete(db, p->pLimit); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( OK_IF_ALWAYS_TRUE(p->pWinDefn) ){ + sqlite3WindowListDelete(db, p->pWinDefn); + } +#endif + if( OK_IF_ALWAYS_TRUE(p->pWith) ) sqlite3WithDelete(db, p->pWith); + if( bFree ) sqlite3DbFreeNN(db, p); + p = pPrior; + bFree = 1; + } +} + +/* +** Initialize a SelectDest structure. +*/ +SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){ + pDest->eDest = (u8)eDest; + pDest->iSDParm = iParm; + pDest->iSDParm2 = 0; + pDest->zAffSdst = 0; + pDest->iSdst = 0; + pDest->nSdst = 0; +} + + +/* +** Allocate a new Select structure and return a pointer to that +** structure. +*/ +SQLITE_PRIVATE Select *sqlite3SelectNew( + Parse *pParse, /* Parsing context */ + ExprList *pEList, /* which columns to include in the result */ + SrcList *pSrc, /* the FROM clause -- which tables to scan */ + Expr *pWhere, /* the WHERE clause */ + ExprList *pGroupBy, /* the GROUP BY clause */ + Expr *pHaving, /* the HAVING clause */ + ExprList *pOrderBy, /* the ORDER BY clause */ + u32 selFlags, /* Flag parameters, such as SF_Distinct */ + Expr *pLimit /* LIMIT value. NULL means not used */ +){ + Select *pNew, *pAllocated; + Select standin; + pAllocated = pNew = sqlite3DbMallocRawNN(pParse->db, sizeof(*pNew) ); + if( pNew==0 ){ + assert( pParse->db->mallocFailed ); + pNew = &standin; + } + if( pEList==0 ){ + pEList = sqlite3ExprListAppend(pParse, 0, + sqlite3Expr(pParse->db,TK_ASTERISK,0)); + } + pNew->pEList = pEList; + pNew->op = TK_SELECT; + pNew->selFlags = selFlags; + pNew->iLimit = 0; + pNew->iOffset = 0; + pNew->selId = ++pParse->nSelect; + pNew->addrOpenEphm[0] = -1; + pNew->addrOpenEphm[1] = -1; + pNew->nSelectRow = 0; + if( pSrc==0 ) pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*pSrc)); + pNew->pSrc = pSrc; + pNew->pWhere = pWhere; + pNew->pGroupBy = pGroupBy; + pNew->pHaving = pHaving; + pNew->pOrderBy = pOrderBy; + pNew->pPrior = 0; + pNew->pNext = 0; + pNew->pLimit = pLimit; + pNew->pWith = 0; +#ifndef SQLITE_OMIT_WINDOWFUNC + pNew->pWin = 0; + pNew->pWinDefn = 0; +#endif + if( pParse->db->mallocFailed ) { + clearSelect(pParse->db, pNew, pNew!=&standin); + pAllocated = 0; + }else{ + assert( pNew->pSrc!=0 || pParse->nErr>0 ); + } + return pAllocated; +} + + +/* +** Delete the given Select structure and all of its substructures. +*/ +SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3 *db, Select *p){ + if( OK_IF_ALWAYS_TRUE(p) ) clearSelect(db, p, 1); +} + +/* +** Return a pointer to the right-most SELECT statement in a compound. +*/ +static Select *findRightmost(Select *p){ + while( p->pNext ) p = p->pNext; + return p; +} + +/* +** Given 1 to 3 identifiers preceding the JOIN keyword, determine the +** type of join. Return an integer constant that expresses that type +** in terms of the following bit values: +** +** JT_INNER +** JT_CROSS +** JT_OUTER +** JT_NATURAL +** JT_LEFT +** JT_RIGHT +** +** A full outer join is the combination of JT_LEFT and JT_RIGHT. +** +** If an illegal or unsupported join type is seen, then still return +** a join type, but put an error in the pParse structure. +*/ +SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){ + int jointype = 0; + Token *apAll[3]; + Token *p; + /* 0123456789 123456789 123456789 123 */ + static const char zKeyText[] = "naturaleftouterightfullinnercross"; + static const struct { + u8 i; /* Beginning of keyword text in zKeyText[] */ + u8 nChar; /* Length of the keyword in characters */ + u8 code; /* Join type mask */ + } aKeyword[] = { + /* natural */ { 0, 7, JT_NATURAL }, + /* left */ { 6, 4, JT_LEFT|JT_OUTER }, + /* outer */ { 10, 5, JT_OUTER }, + /* right */ { 14, 5, JT_RIGHT|JT_OUTER }, + /* full */ { 19, 4, JT_LEFT|JT_RIGHT|JT_OUTER }, + /* inner */ { 23, 5, JT_INNER }, + /* cross */ { 28, 5, JT_INNER|JT_CROSS }, + }; + int i, j; + apAll[0] = pA; + apAll[1] = pB; + apAll[2] = pC; + for(i=0; i<3 && apAll[i]; i++){ + p = apAll[i]; + for(j=0; jn==aKeyword[j].nChar + && sqlite3StrNICmp((char*)p->z, &zKeyText[aKeyword[j].i], p->n)==0 ){ + jointype |= aKeyword[j].code; + break; + } + } + testcase( j==0 || j==1 || j==2 || j==3 || j==4 || j==5 || j==6 ); + if( j>=ArraySize(aKeyword) ){ + jointype |= JT_ERROR; + break; + } + } + if( + (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) || + (jointype & JT_ERROR)!=0 + ){ + const char *zSp = " "; + assert( pB!=0 ); + if( pC==0 ){ zSp++; } + sqlite3ErrorMsg(pParse, "unknown or unsupported join type: " + "%T %T%s%T", pA, pB, zSp, pC); + jointype = JT_INNER; + }else if( (jointype & JT_OUTER)!=0 + && (jointype & (JT_LEFT|JT_RIGHT))!=JT_LEFT ){ + sqlite3ErrorMsg(pParse, + "RIGHT and FULL OUTER JOINs are not currently supported"); + jointype = JT_INNER; + } + return jointype; +} + +/* +** Return the index of a column in a table. Return -1 if the column +** is not contained in the table. +*/ +static int columnIndex(Table *pTab, const char *zCol){ + int i; + u8 h = sqlite3StrIHash(zCol); + Column *pCol; + for(pCol=pTab->aCol, i=0; inCol; pCol++, i++){ + if( pCol->hName==h && sqlite3StrICmp(pCol->zName, zCol)==0 ) return i; + } + return -1; +} + +/* +** Search the first N tables in pSrc, from left to right, looking for a +** table that has a column named zCol. +** +** When found, set *piTab and *piCol to the table index and column index +** of the matching column and return TRUE. +** +** If not found, return FALSE. +*/ +static int tableAndColumnIndex( + SrcList *pSrc, /* Array of tables to search */ + int N, /* Number of tables in pSrc->a[] to search */ + const char *zCol, /* Name of the column we are looking for */ + int *piTab, /* Write index of pSrc->a[] here */ + int *piCol, /* Write index of pSrc->a[*piTab].pTab->aCol[] here */ + int bIgnoreHidden /* True to ignore hidden columns */ +){ + int i; /* For looping over tables in pSrc */ + int iCol; /* Index of column matching zCol */ + + assert( (piTab==0)==(piCol==0) ); /* Both or neither are NULL */ + for(i=0; ia[i].pTab, zCol); + if( iCol>=0 + && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0) + ){ + if( piTab ){ + *piTab = i; + *piCol = iCol; + } + return 1; + } + } + return 0; +} + +/* +** This function is used to add terms implied by JOIN syntax to the +** WHERE clause expression of a SELECT statement. The new term, which +** is ANDed with the existing WHERE clause, is of the form: +** +** (tab1.col1 = tab2.col2) +** +** where tab1 is the iSrc'th table in SrcList pSrc and tab2 is the +** (iSrc+1)'th. Column col1 is column iColLeft of tab1, and col2 is +** column iColRight of tab2. +*/ +static void addWhereTerm( + Parse *pParse, /* Parsing context */ + SrcList *pSrc, /* List of tables in FROM clause */ + int iLeft, /* Index of first table to join in pSrc */ + int iColLeft, /* Index of column in first table */ + int iRight, /* Index of second table in pSrc */ + int iColRight, /* Index of column in second table */ + int isOuterJoin, /* True if this is an OUTER join */ + Expr **ppWhere /* IN/OUT: The WHERE clause to add to */ +){ + sqlite3 *db = pParse->db; + Expr *pE1; + Expr *pE2; + Expr *pEq; + + assert( iLeftnSrc>iRight ); + assert( pSrc->a[iLeft].pTab ); + assert( pSrc->a[iRight].pTab ); + + pE1 = sqlite3CreateColumnExpr(db, pSrc, iLeft, iColLeft); + pE2 = sqlite3CreateColumnExpr(db, pSrc, iRight, iColRight); + + pEq = sqlite3PExpr(pParse, TK_EQ, pE1, pE2); + if( pEq && isOuterJoin ){ + ExprSetProperty(pEq, EP_FromJoin); + assert( !ExprHasProperty(pEq, EP_TokenOnly|EP_Reduced) ); + ExprSetVVAProperty(pEq, EP_NoReduce); + pEq->iRightJoinTable = (i16)pE2->iTable; + } + *ppWhere = sqlite3ExprAnd(pParse, *ppWhere, pEq); +} + +/* +** Set the EP_FromJoin property on all terms of the given expression. +** And set the Expr.iRightJoinTable to iTable for every term in the +** expression. +** +** The EP_FromJoin property is used on terms of an expression to tell +** the LEFT OUTER JOIN processing logic that this term is part of the +** join restriction specified in the ON or USING clause and not a part +** of the more general WHERE clause. These terms are moved over to the +** WHERE clause during join processing but we need to remember that they +** originated in the ON or USING clause. +** +** The Expr.iRightJoinTable tells the WHERE clause processing that the +** expression depends on table iRightJoinTable even if that table is not +** explicitly mentioned in the expression. That information is needed +** for cases like this: +** +** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5 +** +** The where clause needs to defer the handling of the t1.x=5 +** term until after the t2 loop of the join. In that way, a +** NULL t2 row will be inserted whenever t1.x!=5. If we do not +** defer the handling of t1.x=5, it will be processed immediately +** after the t1 loop and rows with t1.x!=5 will never appear in +** the output, which is incorrect. +*/ +SQLITE_PRIVATE void sqlite3SetJoinExpr(Expr *p, int iTable){ + while( p ){ + ExprSetProperty(p, EP_FromJoin); + assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) ); + ExprSetVVAProperty(p, EP_NoReduce); + p->iRightJoinTable = (i16)iTable; + if( p->op==TK_FUNCTION && p->x.pList ){ + int i; + for(i=0; ix.pList->nExpr; i++){ + sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable); + } + } + sqlite3SetJoinExpr(p->pLeft, iTable); + p = p->pRight; + } +} + +/* Undo the work of sqlite3SetJoinExpr(). In the expression p, convert every +** term that is marked with EP_FromJoin and iRightJoinTable==iTable into +** an ordinary term that omits the EP_FromJoin mark. +** +** This happens when a LEFT JOIN is simplified into an ordinary JOIN. +*/ +static void unsetJoinExpr(Expr *p, int iTable){ + while( p ){ + if( ExprHasProperty(p, EP_FromJoin) + && (iTable<0 || p->iRightJoinTable==iTable) ){ + ExprClearProperty(p, EP_FromJoin); + } + if( p->op==TK_FUNCTION && p->x.pList ){ + int i; + for(i=0; ix.pList->nExpr; i++){ + unsetJoinExpr(p->x.pList->a[i].pExpr, iTable); + } + } + unsetJoinExpr(p->pLeft, iTable); + p = p->pRight; + } +} + +/* +** This routine processes the join information for a SELECT statement. +** ON and USING clauses are converted into extra terms of the WHERE clause. +** NATURAL joins also create extra WHERE clause terms. +** +** The terms of a FROM clause are contained in the Select.pSrc structure. +** The left most table is the first entry in Select.pSrc. The right-most +** table is the last entry. The join operator is held in the entry to +** the left. Thus entry 0 contains the join operator for the join between +** entries 0 and 1. Any ON or USING clauses associated with the join are +** also attached to the left entry. +** +** This routine returns the number of errors encountered. +*/ +static int sqliteProcessJoin(Parse *pParse, Select *p){ + SrcList *pSrc; /* All tables in the FROM clause */ + int i, j; /* Loop counters */ + struct SrcList_item *pLeft; /* Left table being joined */ + struct SrcList_item *pRight; /* Right table being joined */ + + pSrc = p->pSrc; + pLeft = &pSrc->a[0]; + pRight = &pLeft[1]; + for(i=0; inSrc-1; i++, pRight++, pLeft++){ + Table *pRightTab = pRight->pTab; + int isOuter; + + if( NEVER(pLeft->pTab==0 || pRightTab==0) ) continue; + isOuter = (pRight->fg.jointype & JT_OUTER)!=0; + + /* When the NATURAL keyword is present, add WHERE clause terms for + ** every column that the two tables have in common. + */ + if( pRight->fg.jointype & JT_NATURAL ){ + if( pRight->pOn || pRight->pUsing ){ + sqlite3ErrorMsg(pParse, "a NATURAL join may not have " + "an ON or USING clause", 0); + return 1; + } + for(j=0; jnCol; j++){ + char *zName; /* Name of column in the right table */ + int iLeft; /* Matching left table */ + int iLeftCol; /* Matching column in the left table */ + + if( IsHiddenColumn(&pRightTab->aCol[j]) ) continue; + zName = pRightTab->aCol[j].zName; + if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 1) ){ + addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, j, + isOuter, &p->pWhere); + } + } + } + + /* Disallow both ON and USING clauses in the same join + */ + if( pRight->pOn && pRight->pUsing ){ + sqlite3ErrorMsg(pParse, "cannot have both ON and USING " + "clauses in the same join"); + return 1; + } + + /* Add the ON clause to the end of the WHERE clause, connected by + ** an AND operator. + */ + if( pRight->pOn ){ + if( isOuter ) sqlite3SetJoinExpr(pRight->pOn, pRight->iCursor); + p->pWhere = sqlite3ExprAnd(pParse, p->pWhere, pRight->pOn); + pRight->pOn = 0; + } + + /* Create extra terms on the WHERE clause for each column named + ** in the USING clause. Example: If the two tables to be joined are + ** A and B and the USING clause names X, Y, and Z, then add this + ** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z + ** Report an error if any column mentioned in the USING clause is + ** not contained in both tables to be joined. + */ + if( pRight->pUsing ){ + IdList *pList = pRight->pUsing; + for(j=0; jnId; j++){ + char *zName; /* Name of the term in the USING clause */ + int iLeft; /* Table on the left with matching column name */ + int iLeftCol; /* Column number of matching column on the left */ + int iRightCol; /* Column number of matching column on the right */ + + zName = pList->a[j].zName; + iRightCol = columnIndex(pRightTab, zName); + if( iRightCol<0 + || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 0) + ){ + sqlite3ErrorMsg(pParse, "cannot join using column %s - column " + "not present in both tables", zName); + return 1; + } + addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, iRightCol, + isOuter, &p->pWhere); + } + } + } + return 0; +} + +/* +** An instance of this object holds information (beyond pParse and pSelect) +** needed to load the next result row that is to be added to the sorter. +*/ +typedef struct RowLoadInfo RowLoadInfo; +struct RowLoadInfo { + int regResult; /* Store results in array of registers here */ + u8 ecelFlags; /* Flag argument to ExprCodeExprList() */ +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + ExprList *pExtra; /* Extra columns needed by sorter refs */ + int regExtraResult; /* Where to load the extra columns */ +#endif +}; + +/* +** This routine does the work of loading query data into an array of +** registers so that it can be added to the sorter. +*/ +static void innerLoopLoadRow( + Parse *pParse, /* Statement under construction */ + Select *pSelect, /* The query being coded */ + RowLoadInfo *pInfo /* Info needed to complete the row load */ +){ + sqlite3ExprCodeExprList(pParse, pSelect->pEList, pInfo->regResult, + 0, pInfo->ecelFlags); +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + if( pInfo->pExtra ){ + sqlite3ExprCodeExprList(pParse, pInfo->pExtra, pInfo->regExtraResult, 0, 0); + sqlite3ExprListDelete(pParse->db, pInfo->pExtra); + } +#endif +} + +/* +** Code the OP_MakeRecord instruction that generates the entry to be +** added into the sorter. +** +** Return the register in which the result is stored. +*/ +static int makeSorterRecord( + Parse *pParse, + SortCtx *pSort, + Select *pSelect, + int regBase, + int nBase +){ + int nOBSat = pSort->nOBSat; + Vdbe *v = pParse->pVdbe; + int regOut = ++pParse->nMem; + if( pSort->pDeferredRowLoad ){ + innerLoopLoadRow(pParse, pSelect, pSort->pDeferredRowLoad); + } + sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase+nOBSat, nBase-nOBSat, regOut); + return regOut; +} + +/* +** Generate code that will push the record in registers regData +** through regData+nData-1 onto the sorter. +*/ +static void pushOntoSorter( + Parse *pParse, /* Parser context */ + SortCtx *pSort, /* Information about the ORDER BY clause */ + Select *pSelect, /* The whole SELECT statement */ + int regData, /* First register holding data to be sorted */ + int regOrigData, /* First register holding data before packing */ + int nData, /* Number of elements in the regData data array */ + int nPrefixReg /* No. of reg prior to regData available for use */ +){ + Vdbe *v = pParse->pVdbe; /* Stmt under construction */ + int bSeq = ((pSort->sortFlags & SORTFLAG_UseSorter)==0); + int nExpr = pSort->pOrderBy->nExpr; /* No. of ORDER BY terms */ + int nBase = nExpr + bSeq + nData; /* Fields in sorter record */ + int regBase; /* Regs for sorter record */ + int regRecord = 0; /* Assembled sorter record */ + int nOBSat = pSort->nOBSat; /* ORDER BY terms to skip */ + int op; /* Opcode to add sorter record to sorter */ + int iLimit; /* LIMIT counter */ + int iSkip = 0; /* End of the sorter insert loop */ + + assert( bSeq==0 || bSeq==1 ); + + /* Three cases: + ** (1) The data to be sorted has already been packed into a Record + ** by a prior OP_MakeRecord. In this case nData==1 and regData + ** will be completely unrelated to regOrigData. + ** (2) All output columns are included in the sort record. In that + ** case regData==regOrigData. + ** (3) Some output columns are omitted from the sort record due to + ** the SQLITE_ENABLE_SORTER_REFERENCE optimization, or due to the + ** SQLITE_ECEL_OMITREF optimization, or due to the + ** SortCtx.pDeferredRowLoad optimiation. In any of these cases + ** regOrigData is 0 to prevent this routine from trying to copy + ** values that might not yet exist. + */ + assert( nData==1 || regData==regOrigData || regOrigData==0 ); + + if( nPrefixReg ){ + assert( nPrefixReg==nExpr+bSeq ); + regBase = regData - nPrefixReg; + }else{ + regBase = pParse->nMem + 1; + pParse->nMem += nBase; + } + assert( pSelect->iOffset==0 || pSelect->iLimit!=0 ); + iLimit = pSelect->iOffset ? pSelect->iOffset+1 : pSelect->iLimit; + pSort->labelDone = sqlite3VdbeMakeLabel(pParse); + sqlite3ExprCodeExprList(pParse, pSort->pOrderBy, regBase, regOrigData, + SQLITE_ECEL_DUP | (regOrigData? SQLITE_ECEL_REF : 0)); + if( bSeq ){ + sqlite3VdbeAddOp2(v, OP_Sequence, pSort->iECursor, regBase+nExpr); + } + if( nPrefixReg==0 && nData>0 ){ + sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+bSeq, nData); + } + if( nOBSat>0 ){ + int regPrevKey; /* The first nOBSat columns of the previous row */ + int addrFirst; /* Address of the OP_IfNot opcode */ + int addrJmp; /* Address of the OP_Jump opcode */ + VdbeOp *pOp; /* Opcode that opens the sorter */ + int nKey; /* Number of sorting key columns, including OP_Sequence */ + KeyInfo *pKI; /* Original KeyInfo on the sorter table */ + + regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase); + regPrevKey = pParse->nMem+1; + pParse->nMem += pSort->nOBSat; + nKey = nExpr - pSort->nOBSat + bSeq; + if( bSeq ){ + addrFirst = sqlite3VdbeAddOp1(v, OP_IfNot, regBase+nExpr); + }else{ + addrFirst = sqlite3VdbeAddOp1(v, OP_SequenceTest, pSort->iECursor); + } + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_Compare, regPrevKey, regBase, pSort->nOBSat); + pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex); + if( pParse->db->mallocFailed ) return; + pOp->p2 = nKey + nData; + pKI = pOp->p4.pKeyInfo; + memset(pKI->aSortFlags, 0, pKI->nKeyField); /* Makes OP_Jump testable */ + sqlite3VdbeChangeP4(v, -1, (char*)pKI, P4_KEYINFO); + testcase( pKI->nAllField > pKI->nKeyField+2 ); + pOp->p4.pKeyInfo = sqlite3KeyInfoFromExprList(pParse,pSort->pOrderBy,nOBSat, + pKI->nAllField-pKI->nKeyField-1); + pOp = 0; /* Ensure pOp not used after sqltie3VdbeAddOp3() */ + addrJmp = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp3(v, OP_Jump, addrJmp+1, 0, addrJmp+1); VdbeCoverage(v); + pSort->labelBkOut = sqlite3VdbeMakeLabel(pParse); + pSort->regReturn = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut); + sqlite3VdbeAddOp1(v, OP_ResetSorter, pSort->iECursor); + if( iLimit ){ + sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, pSort->labelDone); + VdbeCoverage(v); + } + sqlite3VdbeJumpHere(v, addrFirst); + sqlite3ExprCodeMove(pParse, regBase, regPrevKey, pSort->nOBSat); + sqlite3VdbeJumpHere(v, addrJmp); + } + if( iLimit ){ + /* At this point the values for the new sorter entry are stored + ** in an array of registers. They need to be composed into a record + ** and inserted into the sorter if either (a) there are currently + ** less than LIMIT+OFFSET items or (b) the new record is smaller than + ** the largest record currently in the sorter. If (b) is true and there + ** are already LIMIT+OFFSET items in the sorter, delete the largest + ** entry before inserting the new one. This way there are never more + ** than LIMIT+OFFSET items in the sorter. + ** + ** If the new record does not need to be inserted into the sorter, + ** jump to the next iteration of the loop. If the pSort->labelOBLopt + ** value is not zero, then it is a label of where to jump. Otherwise, + ** just bypass the row insert logic. See the header comment on the + ** sqlite3WhereOrderByLimitOptLabel() function for additional info. + */ + int iCsr = pSort->iECursor; + sqlite3VdbeAddOp2(v, OP_IfNotZero, iLimit, sqlite3VdbeCurrentAddr(v)+4); + VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Last, iCsr, 0); + iSkip = sqlite3VdbeAddOp4Int(v, OP_IdxLE, + iCsr, 0, regBase+nOBSat, nExpr-nOBSat); + VdbeCoverage(v); + sqlite3VdbeAddOp1(v, OP_Delete, iCsr); + } + if( regRecord==0 ){ + regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase); + } + if( pSort->sortFlags & SORTFLAG_UseSorter ){ + op = OP_SorterInsert; + }else{ + op = OP_IdxInsert; + } + sqlite3VdbeAddOp4Int(v, op, pSort->iECursor, regRecord, + regBase+nOBSat, nBase-nOBSat); + if( iSkip ){ + sqlite3VdbeChangeP2(v, iSkip, + pSort->labelOBLopt ? pSort->labelOBLopt : sqlite3VdbeCurrentAddr(v)); + } +} + +/* +** Add code to implement the OFFSET +*/ +static void codeOffset( + Vdbe *v, /* Generate code into this VM */ + int iOffset, /* Register holding the offset counter */ + int iContinue /* Jump here to skip the current record */ +){ + if( iOffset>0 ){ + sqlite3VdbeAddOp3(v, OP_IfPos, iOffset, iContinue, 1); VdbeCoverage(v); + VdbeComment((v, "OFFSET")); + } +} + +/* +** Add code that will check to make sure the N registers starting at iMem +** form a distinct entry. iTab is a sorting index that holds previously +** seen combinations of the N values. A new entry is made in iTab +** if the current N values are new. +** +** A jump to addrRepeat is made and the N+1 values are popped from the +** stack if the top N elements are not distinct. +*/ +static void codeDistinct( + Parse *pParse, /* Parsing and code generating context */ + int iTab, /* A sorting index used to test for distinctness */ + int addrRepeat, /* Jump to here if not distinct */ + int N, /* Number of elements */ + int iMem /* First element */ +){ + Vdbe *v; + int r1; + + v = pParse->pVdbe; + r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r1, iMem, N); + sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + sqlite3ReleaseTempReg(pParse, r1); +} + +#ifdef SQLITE_ENABLE_SORTER_REFERENCES +/* +** This function is called as part of inner-loop generation for a SELECT +** statement with an ORDER BY that is not optimized by an index. It +** determines the expressions, if any, that the sorter-reference +** optimization should be used for. The sorter-reference optimization +** is used for SELECT queries like: +** +** SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10 +** +** If the optimization is used for expression "bigblob", then instead of +** storing values read from that column in the sorter records, the PK of +** the row from table t1 is stored instead. Then, as records are extracted from +** the sorter to return to the user, the required value of bigblob is +** retrieved directly from table t1. If the values are very large, this +** can be more efficient than storing them directly in the sorter records. +** +** The ExprList_item.bSorterRef flag is set for each expression in pEList +** for which the sorter-reference optimization should be enabled. +** Additionally, the pSort->aDefer[] array is populated with entries +** for all cursors required to evaluate all selected expressions. Finally. +** output variable (*ppExtra) is set to an expression list containing +** expressions for all extra PK values that should be stored in the +** sorter records. +*/ +static void selectExprDefer( + Parse *pParse, /* Leave any error here */ + SortCtx *pSort, /* Sorter context */ + ExprList *pEList, /* Expressions destined for sorter */ + ExprList **ppExtra /* Expressions to append to sorter record */ +){ + int i; + int nDefer = 0; + ExprList *pExtra = 0; + for(i=0; inExpr; i++){ + struct ExprList_item *pItem = &pEList->a[i]; + if( pItem->u.x.iOrderByCol==0 ){ + Expr *pExpr = pItem->pExpr; + Table *pTab = pExpr->y.pTab; + if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 && pTab && !IsVirtual(pTab) + && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF) + ){ + int j; + for(j=0; jaDefer[j].iCsr==pExpr->iTable ) break; + } + if( j==nDefer ){ + if( nDefer==ArraySize(pSort->aDefer) ){ + continue; + }else{ + int nKey = 1; + int k; + Index *pPk = 0; + if( !HasRowid(pTab) ){ + pPk = sqlite3PrimaryKeyIndex(pTab); + nKey = pPk->nKeyCol; + } + for(k=0; kiTable = pExpr->iTable; + pNew->y.pTab = pExpr->y.pTab; + pNew->iColumn = pPk ? pPk->aiColumn[k] : -1; + pExtra = sqlite3ExprListAppend(pParse, pExtra, pNew); + } + } + pSort->aDefer[nDefer].pTab = pExpr->y.pTab; + pSort->aDefer[nDefer].iCsr = pExpr->iTable; + pSort->aDefer[nDefer].nKey = nKey; + nDefer++; + } + } + pItem->bSorterRef = 1; + } + } + } + pSort->nDefer = (u8)nDefer; + *ppExtra = pExtra; +} +#endif + +/* +** This routine generates the code for the inside of the inner loop +** of a SELECT. +** +** If srcTab is negative, then the p->pEList expressions +** are evaluated in order to get the data for this row. If srcTab is +** zero or more, then data is pulled from srcTab and p->pEList is used only +** to get the number of columns and the collation sequence for each column. +*/ +static void selectInnerLoop( + Parse *pParse, /* The parser context */ + Select *p, /* The complete select statement being coded */ + int srcTab, /* Pull data from this table if non-negative */ + SortCtx *pSort, /* If not NULL, info on how to process ORDER BY */ + DistinctCtx *pDistinct, /* If not NULL, info on how to process DISTINCT */ + SelectDest *pDest, /* How to dispose of the results */ + int iContinue, /* Jump here to continue with next row */ + int iBreak /* Jump here to break out of the inner loop */ +){ + Vdbe *v = pParse->pVdbe; + int i; + int hasDistinct; /* True if the DISTINCT keyword is present */ + int eDest = pDest->eDest; /* How to dispose of results */ + int iParm = pDest->iSDParm; /* First argument to disposal method */ + int nResultCol; /* Number of result columns */ + int nPrefixReg = 0; /* Number of extra registers before regResult */ + RowLoadInfo sRowLoadInfo; /* Info for deferred row loading */ + + /* Usually, regResult is the first cell in an array of memory cells + ** containing the current result row. In this case regOrig is set to the + ** same value. However, if the results are being sent to the sorter, the + ** values for any expressions that are also part of the sort-key are omitted + ** from this array. In this case regOrig is set to zero. */ + int regResult; /* Start of memory holding current results */ + int regOrig; /* Start of memory holding full result (or 0) */ + + assert( v ); + assert( p->pEList!=0 ); + hasDistinct = pDistinct ? pDistinct->eTnctType : WHERE_DISTINCT_NOOP; + if( pSort && pSort->pOrderBy==0 ) pSort = 0; + if( pSort==0 && !hasDistinct ){ + assert( iContinue!=0 ); + codeOffset(v, p->iOffset, iContinue); + } + + /* Pull the requested columns. + */ + nResultCol = p->pEList->nExpr; + + if( pDest->iSdst==0 ){ + if( pSort ){ + nPrefixReg = pSort->pOrderBy->nExpr; + if( !(pSort->sortFlags & SORTFLAG_UseSorter) ) nPrefixReg++; + pParse->nMem += nPrefixReg; + } + pDest->iSdst = pParse->nMem+1; + pParse->nMem += nResultCol; + }else if( pDest->iSdst+nResultCol > pParse->nMem ){ + /* This is an error condition that can result, for example, when a SELECT + ** on the right-hand side of an INSERT contains more result columns than + ** there are columns in the table on the left. The error will be caught + ** and reported later. But we need to make sure enough memory is allocated + ** to avoid other spurious errors in the meantime. */ + pParse->nMem += nResultCol; + } + pDest->nSdst = nResultCol; + regOrig = regResult = pDest->iSdst; + if( srcTab>=0 ){ + for(i=0; ipEList->a[i].zEName)); + } + }else if( eDest!=SRT_Exists ){ +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + ExprList *pExtra = 0; +#endif + /* If the destination is an EXISTS(...) expression, the actual + ** values returned by the SELECT are not required. + */ + u8 ecelFlags; /* "ecel" is an abbreviation of "ExprCodeExprList" */ + ExprList *pEList; + if( eDest==SRT_Mem || eDest==SRT_Output || eDest==SRT_Coroutine ){ + ecelFlags = SQLITE_ECEL_DUP; + }else{ + ecelFlags = 0; + } + if( pSort && hasDistinct==0 && eDest!=SRT_EphemTab && eDest!=SRT_Table ){ + /* For each expression in p->pEList that is a copy of an expression in + ** the ORDER BY clause (pSort->pOrderBy), set the associated + ** iOrderByCol value to one more than the index of the ORDER BY + ** expression within the sort-key that pushOntoSorter() will generate. + ** This allows the p->pEList field to be omitted from the sorted record, + ** saving space and CPU cycles. */ + ecelFlags |= (SQLITE_ECEL_OMITREF|SQLITE_ECEL_REF); + + for(i=pSort->nOBSat; ipOrderBy->nExpr; i++){ + int j; + if( (j = pSort->pOrderBy->a[i].u.x.iOrderByCol)>0 ){ + p->pEList->a[j-1].u.x.iOrderByCol = i+1-pSort->nOBSat; + } + } +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + selectExprDefer(pParse, pSort, p->pEList, &pExtra); + if( pExtra && pParse->db->mallocFailed==0 ){ + /* If there are any extra PK columns to add to the sorter records, + ** allocate extra memory cells and adjust the OpenEphemeral + ** instruction to account for the larger records. This is only + ** required if there are one or more WITHOUT ROWID tables with + ** composite primary keys in the SortCtx.aDefer[] array. */ + VdbeOp *pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex); + pOp->p2 += (pExtra->nExpr - pSort->nDefer); + pOp->p4.pKeyInfo->nAllField += (pExtra->nExpr - pSort->nDefer); + pParse->nMem += pExtra->nExpr; + } +#endif + + /* Adjust nResultCol to account for columns that are omitted + ** from the sorter by the optimizations in this branch */ + pEList = p->pEList; + for(i=0; inExpr; i++){ + if( pEList->a[i].u.x.iOrderByCol>0 +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + || pEList->a[i].bSorterRef +#endif + ){ + nResultCol--; + regOrig = 0; + } + } + + testcase( regOrig ); + testcase( eDest==SRT_Set ); + testcase( eDest==SRT_Mem ); + testcase( eDest==SRT_Coroutine ); + testcase( eDest==SRT_Output ); + assert( eDest==SRT_Set || eDest==SRT_Mem + || eDest==SRT_Coroutine || eDest==SRT_Output + || eDest==SRT_Upfrom ); + } + sRowLoadInfo.regResult = regResult; + sRowLoadInfo.ecelFlags = ecelFlags; +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + sRowLoadInfo.pExtra = pExtra; + sRowLoadInfo.regExtraResult = regResult + nResultCol; + if( pExtra ) nResultCol += pExtra->nExpr; +#endif + if( p->iLimit + && (ecelFlags & SQLITE_ECEL_OMITREF)!=0 + && nPrefixReg>0 + ){ + assert( pSort!=0 ); + assert( hasDistinct==0 ); + pSort->pDeferredRowLoad = &sRowLoadInfo; + regOrig = 0; + }else{ + innerLoopLoadRow(pParse, p, &sRowLoadInfo); + } + } + + /* If the DISTINCT keyword was present on the SELECT statement + ** and this row has been seen before, then do not make this row + ** part of the result. + */ + if( hasDistinct ){ + switch( pDistinct->eTnctType ){ + case WHERE_DISTINCT_ORDERED: { + VdbeOp *pOp; /* No longer required OpenEphemeral instr. */ + int iJump; /* Jump destination */ + int regPrev; /* Previous row content */ + + /* Allocate space for the previous row */ + regPrev = pParse->nMem+1; + pParse->nMem += nResultCol; + + /* Change the OP_OpenEphemeral coded earlier to an OP_Null + ** sets the MEM_Cleared bit on the first register of the + ** previous value. This will cause the OP_Ne below to always + ** fail on the first iteration of the loop even if the first + ** row is all NULLs. + */ + sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct); + pOp = sqlite3VdbeGetOp(v, pDistinct->addrTnct); + pOp->opcode = OP_Null; + pOp->p1 = 1; + pOp->p2 = regPrev; + pOp = 0; /* Ensure pOp is not used after sqlite3VdbeAddOp() */ + + iJump = sqlite3VdbeCurrentAddr(v) + nResultCol; + for(i=0; ipEList->a[i].pExpr); + if( idb->mallocFailed ); + sqlite3VdbeAddOp3(v, OP_Copy, regResult, regPrev, nResultCol-1); + break; + } + + case WHERE_DISTINCT_UNIQUE: { + sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct); + break; + } + + default: { + assert( pDistinct->eTnctType==WHERE_DISTINCT_UNORDERED ); + codeDistinct(pParse, pDistinct->tabTnct, iContinue, nResultCol, + regResult); + break; + } + } + if( pSort==0 ){ + codeOffset(v, p->iOffset, iContinue); + } + } + + switch( eDest ){ + /* In this mode, write each query result to the key of the temporary + ** table iParm. + */ +#ifndef SQLITE_OMIT_COMPOUND_SELECT + case SRT_Union: { + int r1; + r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol); + sqlite3ReleaseTempReg(pParse, r1); + break; + } + + /* Construct a record from the query result, but instead of + ** saving that record, use it as a key to delete elements from + ** the temporary table iParm. + */ + case SRT_Except: { + sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nResultCol); + break; + } +#endif /* SQLITE_OMIT_COMPOUND_SELECT */ + + /* Store the result as data using a unique key. + */ + case SRT_Fifo: + case SRT_DistFifo: + case SRT_Table: + case SRT_EphemTab: { + int r1 = sqlite3GetTempRange(pParse, nPrefixReg+1); + testcase( eDest==SRT_Table ); + testcase( eDest==SRT_EphemTab ); + testcase( eDest==SRT_Fifo ); + testcase( eDest==SRT_DistFifo ); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1+nPrefixReg); +#ifndef SQLITE_OMIT_CTE + if( eDest==SRT_DistFifo ){ + /* If the destination is DistFifo, then cursor (iParm+1) is open + ** on an ephemeral index. If the current row is already present + ** in the index, do not write it to the output. If not, add the + ** current row to the index and proceed with writing it to the + ** output table as well. */ + int addr = sqlite3VdbeCurrentAddr(v) + 4; + sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, addr, r1, 0); + VdbeCoverage(v); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm+1, r1,regResult,nResultCol); + assert( pSort==0 ); + } +#endif + if( pSort ){ + assert( regResult==regOrig ); + pushOntoSorter(pParse, pSort, p, r1+nPrefixReg, regOrig, 1, nPrefixReg); + }else{ + int r2 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2); + sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + sqlite3ReleaseTempReg(pParse, r2); + } + sqlite3ReleaseTempRange(pParse, r1, nPrefixReg+1); + break; + } + + case SRT_Upfrom: { + if( pSort ){ + pushOntoSorter( + pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg); + }else{ + int i2 = pDest->iSDParm2; + int r1 = sqlite3GetTempReg(pParse); + + /* If the UPDATE FROM join is an aggregate that matches no rows, it + ** might still be trying to return one row, because that is what + ** aggregates do. Don't record that empty row in the output table. */ + sqlite3VdbeAddOp2(v, OP_IsNull, regResult, iBreak); VdbeCoverage(v); + + sqlite3VdbeAddOp3(v, OP_MakeRecord, + regResult+(i2<0), nResultCol-(i2<0), r1); + if( i2<0 ){ + sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, regResult); + }else{ + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, i2); + } + } + break; + } + +#ifndef SQLITE_OMIT_SUBQUERY + /* If we are creating a set for an "expr IN (SELECT ...)" construct, + ** then there should be a single item on the stack. Write this + ** item into the set table with bogus data. + */ + case SRT_Set: { + if( pSort ){ + /* At first glance you would think we could optimize out the + ** ORDER BY in this case since the order of entries in the set + ** does not matter. But there might be a LIMIT clause, in which + ** case the order does matter */ + pushOntoSorter( + pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg); + }else{ + int r1 = sqlite3GetTempReg(pParse); + assert( sqlite3Strlen30(pDest->zAffSdst)==nResultCol ); + sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, nResultCol, + r1, pDest->zAffSdst, nResultCol); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol); + sqlite3ReleaseTempReg(pParse, r1); + } + break; + } + + + /* If any row exist in the result set, record that fact and abort. + */ + case SRT_Exists: { + sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm); + /* The LIMIT clause will terminate the loop for us */ + break; + } + + /* If this is a scalar select that is part of an expression, then + ** store the results in the appropriate memory cell or array of + ** memory cells and break out of the scan loop. + */ + case SRT_Mem: { + if( pSort ){ + assert( nResultCol<=pDest->nSdst ); + pushOntoSorter( + pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg); + }else{ + assert( nResultCol==pDest->nSdst ); + assert( regResult==iParm ); + /* The LIMIT clause will jump out of the loop for us */ + } + break; + } +#endif /* #ifndef SQLITE_OMIT_SUBQUERY */ + + case SRT_Coroutine: /* Send data to a co-routine */ + case SRT_Output: { /* Return the results */ + testcase( eDest==SRT_Coroutine ); + testcase( eDest==SRT_Output ); + if( pSort ){ + pushOntoSorter(pParse, pSort, p, regResult, regOrig, nResultCol, + nPrefixReg); + }else if( eDest==SRT_Coroutine ){ + sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm); + }else{ + sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nResultCol); + } + break; + } + +#ifndef SQLITE_OMIT_CTE + /* Write the results into a priority queue that is order according to + ** pDest->pOrderBy (in pSO). pDest->iSDParm (in iParm) is the cursor for an + ** index with pSO->nExpr+2 columns. Build a key using pSO for the first + ** pSO->nExpr columns, then make sure all keys are unique by adding a + ** final OP_Sequence column. The last column is the record as a blob. + */ + case SRT_DistQueue: + case SRT_Queue: { + int nKey; + int r1, r2, r3; + int addrTest = 0; + ExprList *pSO; + pSO = pDest->pOrderBy; + assert( pSO ); + nKey = pSO->nExpr; + r1 = sqlite3GetTempReg(pParse); + r2 = sqlite3GetTempRange(pParse, nKey+2); + r3 = r2+nKey+1; + if( eDest==SRT_DistQueue ){ + /* If the destination is DistQueue, then cursor (iParm+1) is open + ** on a second ephemeral index that holds all values every previously + ** added to the queue. */ + addrTest = sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, 0, + regResult, nResultCol); + VdbeCoverage(v); + } + sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r3); + if( eDest==SRT_DistQueue ){ + sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm+1, r3); + sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + } + for(i=0; ia[i].u.x.iOrderByCol - 1, + r2+i); + } + sqlite3VdbeAddOp2(v, OP_Sequence, iParm, r2+nKey); + sqlite3VdbeAddOp3(v, OP_MakeRecord, r2, nKey+2, r1); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, r2, nKey+2); + if( addrTest ) sqlite3VdbeJumpHere(v, addrTest); + sqlite3ReleaseTempReg(pParse, r1); + sqlite3ReleaseTempRange(pParse, r2, nKey+2); + break; + } +#endif /* SQLITE_OMIT_CTE */ + + + +#if !defined(SQLITE_OMIT_TRIGGER) + /* Discard the results. This is used for SELECT statements inside + ** the body of a TRIGGER. The purpose of such selects is to call + ** user-defined functions that have side effects. We do not care + ** about the actual results of the select. + */ + default: { + assert( eDest==SRT_Discard ); + break; + } +#endif + } + + /* Jump to the end of the loop if the LIMIT is reached. Except, if + ** there is a sorter, in which case the sorter has already limited + ** the output for us. + */ + if( pSort==0 && p->iLimit ){ + sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v); + } +} + +/* +** Allocate a KeyInfo object sufficient for an index of N key columns and +** X extra columns. +*/ +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){ + int nExtra = (N+X)*(sizeof(CollSeq*)+1) - sizeof(CollSeq*); + KeyInfo *p = sqlite3DbMallocRawNN(db, sizeof(KeyInfo) + nExtra); + if( p ){ + p->aSortFlags = (u8*)&p->aColl[N+X]; + p->nKeyField = (u16)N; + p->nAllField = (u16)(N+X); + p->enc = ENC(db); + p->db = db; + p->nRef = 1; + memset(&p[1], 0, nExtra); + }else{ + sqlite3OomFault(db); + } + return p; +} + +/* +** Deallocate a KeyInfo object +*/ +SQLITE_PRIVATE void sqlite3KeyInfoUnref(KeyInfo *p){ + if( p ){ + assert( p->nRef>0 ); + p->nRef--; + if( p->nRef==0 ) sqlite3DbFreeNN(p->db, p); + } +} + +/* +** Make a new pointer to a KeyInfo object +*/ +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoRef(KeyInfo *p){ + if( p ){ + assert( p->nRef>0 ); + p->nRef++; + } + return p; +} + +#ifdef SQLITE_DEBUG +/* +** Return TRUE if a KeyInfo object can be change. The KeyInfo object +** can only be changed if this is just a single reference to the object. +** +** This routine is used only inside of assert() statements. +*/ +SQLITE_PRIVATE int sqlite3KeyInfoIsWriteable(KeyInfo *p){ return p->nRef==1; } +#endif /* SQLITE_DEBUG */ + +/* +** Given an expression list, generate a KeyInfo structure that records +** the collating sequence for each expression in that expression list. +** +** If the ExprList is an ORDER BY or GROUP BY clause then the resulting +** KeyInfo structure is appropriate for initializing a virtual index to +** implement that clause. If the ExprList is the result set of a SELECT +** then the KeyInfo structure is appropriate for initializing a virtual +** index to implement a DISTINCT test. +** +** Space to hold the KeyInfo structure is obtained from malloc. The calling +** function is responsible for seeing that this structure is eventually +** freed. +*/ +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoFromExprList( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* Form the KeyInfo object from this ExprList */ + int iStart, /* Begin with this column of pList */ + int nExtra /* Add this many extra columns to the end */ +){ + int nExpr; + KeyInfo *pInfo; + struct ExprList_item *pItem; + sqlite3 *db = pParse->db; + int i; + + nExpr = pList->nExpr; + pInfo = sqlite3KeyInfoAlloc(db, nExpr-iStart, nExtra+1); + if( pInfo ){ + assert( sqlite3KeyInfoIsWriteable(pInfo) ); + for(i=iStart, pItem=pList->a+iStart; iaColl[i-iStart] = sqlite3ExprNNCollSeq(pParse, pItem->pExpr); + pInfo->aSortFlags[i-iStart] = pItem->sortFlags; + } + } + return pInfo; +} + +/* +** Name of the connection operator, used for error messages. +*/ +static const char *selectOpName(int id){ + char *z; + switch( id ){ + case TK_ALL: z = "UNION ALL"; break; + case TK_INTERSECT: z = "INTERSECT"; break; + case TK_EXCEPT: z = "EXCEPT"; break; + default: z = "UNION"; break; + } + return z; +} + +#ifndef SQLITE_OMIT_EXPLAIN +/* +** Unless an "EXPLAIN QUERY PLAN" command is being processed, this function +** is a no-op. Otherwise, it adds a single row of output to the EQP result, +** where the caption is of the form: +** +** "USE TEMP B-TREE FOR xxx" +** +** where xxx is one of "DISTINCT", "ORDER BY" or "GROUP BY". Exactly which +** is determined by the zUsage argument. +*/ +static void explainTempTable(Parse *pParse, const char *zUsage){ + ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s", zUsage)); +} + +/* +** Assign expression b to lvalue a. A second, no-op, version of this macro +** is provided when SQLITE_OMIT_EXPLAIN is defined. This allows the code +** in sqlite3Select() to assign values to structure member variables that +** only exist if SQLITE_OMIT_EXPLAIN is not defined without polluting the +** code with #ifndef directives. +*/ +# define explainSetInteger(a, b) a = b + +#else +/* No-op versions of the explainXXX() functions and macros. */ +# define explainTempTable(y,z) +# define explainSetInteger(y,z) +#endif + + +/* +** If the inner loop was generated using a non-null pOrderBy argument, +** then the results were placed in a sorter. After the loop is terminated +** we need to run the sorter and output the results. The following +** routine generates the code needed to do that. +*/ +static void generateSortTail( + Parse *pParse, /* Parsing context */ + Select *p, /* The SELECT statement */ + SortCtx *pSort, /* Information on the ORDER BY clause */ + int nColumn, /* Number of columns of data */ + SelectDest *pDest /* Write the sorted results here */ +){ + Vdbe *v = pParse->pVdbe; /* The prepared statement */ + int addrBreak = pSort->labelDone; /* Jump here to exit loop */ + int addrContinue = sqlite3VdbeMakeLabel(pParse);/* Jump here for next cycle */ + int addr; /* Top of output loop. Jump for Next. */ + int addrOnce = 0; + int iTab; + ExprList *pOrderBy = pSort->pOrderBy; + int eDest = pDest->eDest; + int iParm = pDest->iSDParm; + int regRow; + int regRowid; + int iCol; + int nKey; /* Number of key columns in sorter record */ + int iSortTab; /* Sorter cursor to read from */ + int i; + int bSeq; /* True if sorter record includes seq. no. */ + int nRefKey = 0; + struct ExprList_item *aOutEx = p->pEList->a; + + assert( addrBreak<0 ); + if( pSort->labelBkOut ){ + sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut); + sqlite3VdbeGoto(v, addrBreak); + sqlite3VdbeResolveLabel(v, pSort->labelBkOut); + } + +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + /* Open any cursors needed for sorter-reference expressions */ + for(i=0; inDefer; i++){ + Table *pTab = pSort->aDefer[i].pTab; + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead); + nRefKey = MAX(nRefKey, pSort->aDefer[i].nKey); + } +#endif + + iTab = pSort->iECursor; + if( eDest==SRT_Output || eDest==SRT_Coroutine || eDest==SRT_Mem ){ + regRowid = 0; + regRow = pDest->iSdst; + }else{ + regRowid = sqlite3GetTempReg(pParse); + if( eDest==SRT_EphemTab || eDest==SRT_Table ){ + regRow = sqlite3GetTempReg(pParse); + nColumn = 0; + }else{ + regRow = sqlite3GetTempRange(pParse, nColumn); + } + } + nKey = pOrderBy->nExpr - pSort->nOBSat; + if( pSort->sortFlags & SORTFLAG_UseSorter ){ + int regSortOut = ++pParse->nMem; + iSortTab = pParse->nTab++; + if( pSort->labelBkOut ){ + addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + } + sqlite3VdbeAddOp3(v, OP_OpenPseudo, iSortTab, regSortOut, + nKey+1+nColumn+nRefKey); + if( addrOnce ) sqlite3VdbeJumpHere(v, addrOnce); + addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak); + VdbeCoverage(v); + codeOffset(v, p->iOffset, addrContinue); + sqlite3VdbeAddOp3(v, OP_SorterData, iTab, regSortOut, iSortTab); + bSeq = 0; + }else{ + addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, addrBreak); VdbeCoverage(v); + codeOffset(v, p->iOffset, addrContinue); + iSortTab = iTab; + bSeq = 1; + } + for(i=0, iCol=nKey+bSeq-1; inDefer ){ + int iKey = iCol+1; + int regKey = sqlite3GetTempRange(pParse, nRefKey); + + for(i=0; inDefer; i++){ + int iCsr = pSort->aDefer[i].iCsr; + Table *pTab = pSort->aDefer[i].pTab; + int nKey = pSort->aDefer[i].nKey; + + sqlite3VdbeAddOp1(v, OP_NullRow, iCsr); + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey); + sqlite3VdbeAddOp3(v, OP_SeekRowid, iCsr, + sqlite3VdbeCurrentAddr(v)+1, regKey); + }else{ + int k; + int iJmp; + assert( sqlite3PrimaryKeyIndex(pTab)->nKeyCol==nKey ); + for(k=0; k=0; i--){ +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + if( aOutEx[i].bSorterRef ){ + sqlite3ExprCode(pParse, aOutEx[i].pExpr, regRow+i); + }else +#endif + { + int iRead; + if( aOutEx[i].u.x.iOrderByCol ){ + iRead = aOutEx[i].u.x.iOrderByCol-1; + }else{ + iRead = iCol--; + } + sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iRead, regRow+i); + VdbeComment((v, "%s", aOutEx[i].zEName)); + } + } + switch( eDest ){ + case SRT_Table: + case SRT_EphemTab: { + sqlite3VdbeAddOp3(v, OP_Column, iSortTab, nKey+bSeq, regRow); + sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid); + sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case SRT_Set: { + assert( nColumn==sqlite3Strlen30(pDest->zAffSdst) ); + sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, nColumn, regRowid, + pDest->zAffSdst, nColumn); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, regRowid, regRow, nColumn); + break; + } + case SRT_Mem: { + /* The LIMIT clause will terminate the loop for us */ + break; + } +#endif + case SRT_Upfrom: { + int i2 = pDest->iSDParm2; + int r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_MakeRecord,regRow+(i2<0),nColumn-(i2<0),r1); + if( i2<0 ){ + sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, regRow); + }else{ + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regRow, i2); + } + break; + } + default: { + assert( eDest==SRT_Output || eDest==SRT_Coroutine ); + testcase( eDest==SRT_Output ); + testcase( eDest==SRT_Coroutine ); + if( eDest==SRT_Output ){ + sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iSdst, nColumn); + }else{ + sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm); + } + break; + } + } + if( regRowid ){ + if( eDest==SRT_Set ){ + sqlite3ReleaseTempRange(pParse, regRow, nColumn); + }else{ + sqlite3ReleaseTempReg(pParse, regRow); + } + sqlite3ReleaseTempReg(pParse, regRowid); + } + /* The bottom of the loop + */ + sqlite3VdbeResolveLabel(v, addrContinue); + if( pSort->sortFlags & SORTFLAG_UseSorter ){ + sqlite3VdbeAddOp2(v, OP_SorterNext, iTab, addr); VdbeCoverage(v); + }else{ + sqlite3VdbeAddOp2(v, OP_Next, iTab, addr); VdbeCoverage(v); + } + if( pSort->regReturn ) sqlite3VdbeAddOp1(v, OP_Return, pSort->regReturn); + sqlite3VdbeResolveLabel(v, addrBreak); +} + +/* +** Return a pointer to a string containing the 'declaration type' of the +** expression pExpr. The string may be treated as static by the caller. +** +** Also try to estimate the size of the returned value and return that +** result in *pEstWidth. +** +** The declaration type is the exact datatype definition extracted from the +** original CREATE TABLE statement if the expression is a column. The +** declaration type for a ROWID field is INTEGER. Exactly when an expression +** is considered a column can be complex in the presence of subqueries. The +** result-set expression in all of the following SELECT statements is +** considered a column by this function. +** +** SELECT col FROM tbl; +** SELECT (SELECT col FROM tbl; +** SELECT (SELECT col FROM tbl); +** SELECT abc FROM (SELECT col AS abc FROM tbl); +** +** The declaration type for any expression other than a column is NULL. +** +** This routine has either 3 or 6 parameters depending on whether or not +** the SQLITE_ENABLE_COLUMN_METADATA compile-time option is used. +*/ +#ifdef SQLITE_ENABLE_COLUMN_METADATA +# define columnType(A,B,C,D,E) columnTypeImpl(A,B,C,D,E) +#else /* if !defined(SQLITE_ENABLE_COLUMN_METADATA) */ +# define columnType(A,B,C,D,E) columnTypeImpl(A,B) +#endif +static const char *columnTypeImpl( + NameContext *pNC, +#ifndef SQLITE_ENABLE_COLUMN_METADATA + Expr *pExpr +#else + Expr *pExpr, + const char **pzOrigDb, + const char **pzOrigTab, + const char **pzOrigCol +#endif +){ + char const *zType = 0; + int j; +#ifdef SQLITE_ENABLE_COLUMN_METADATA + char const *zOrigDb = 0; + char const *zOrigTab = 0; + char const *zOrigCol = 0; +#endif + + assert( pExpr!=0 ); + assert( pNC->pSrcList!=0 ); + switch( pExpr->op ){ + case TK_COLUMN: { + /* The expression is a column. Locate the table the column is being + ** extracted from in NameContext.pSrcList. This table may be real + ** database table or a subquery. + */ + Table *pTab = 0; /* Table structure column is extracted from */ + Select *pS = 0; /* Select the column is extracted from */ + int iCol = pExpr->iColumn; /* Index of column in pTab */ + while( pNC && !pTab ){ + SrcList *pTabList = pNC->pSrcList; + for(j=0;jnSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++); + if( jnSrc ){ + pTab = pTabList->a[j].pTab; + pS = pTabList->a[j].pSelect; + }else{ + pNC = pNC->pNext; + } + } + + if( pTab==0 ){ + /* At one time, code such as "SELECT new.x" within a trigger would + ** cause this condition to run. Since then, we have restructured how + ** trigger code is generated and so this condition is no longer + ** possible. However, it can still be true for statements like + ** the following: + ** + ** CREATE TABLE t1(col INTEGER); + ** SELECT (SELECT t1.col) FROM FROM t1; + ** + ** when columnType() is called on the expression "t1.col" in the + ** sub-select. In this case, set the column type to NULL, even + ** though it should really be "INTEGER". + ** + ** This is not a problem, as the column type of "t1.col" is never + ** used. When columnType() is called on the expression + ** "(SELECT t1.col)", the correct type is returned (see the TK_SELECT + ** branch below. */ + break; + } + + assert( pTab && pExpr->y.pTab==pTab ); + if( pS ){ + /* The "table" is actually a sub-select or a view in the FROM clause + ** of the SELECT statement. Return the declaration type and origin + ** data for the result-set column of the sub-select. + */ + if( iCol>=0 && iColpEList->nExpr ){ + /* If iCol is less than zero, then the expression requests the + ** rowid of the sub-select or view. This expression is legal (see + ** test case misc2.2.2) - it always evaluates to NULL. + */ + NameContext sNC; + Expr *p = pS->pEList->a[iCol].pExpr; + sNC.pSrcList = pS->pSrc; + sNC.pNext = pNC; + sNC.pParse = pNC->pParse; + zType = columnType(&sNC, p,&zOrigDb,&zOrigTab,&zOrigCol); + } + }else{ + /* A real table or a CTE table */ + assert( !pS ); +#ifdef SQLITE_ENABLE_COLUMN_METADATA + if( iCol<0 ) iCol = pTab->iPKey; + assert( iCol==XN_ROWID || (iCol>=0 && iColnCol) ); + if( iCol<0 ){ + zType = "INTEGER"; + zOrigCol = "rowid"; + }else{ + zOrigCol = pTab->aCol[iCol].zName; + zType = sqlite3ColumnType(&pTab->aCol[iCol],0); + } + zOrigTab = pTab->zName; + if( pNC->pParse && pTab->pSchema ){ + int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema); + zOrigDb = pNC->pParse->db->aDb[iDb].zDbSName; + } +#else + assert( iCol==XN_ROWID || (iCol>=0 && iColnCol) ); + if( iCol<0 ){ + zType = "INTEGER"; + }else{ + zType = sqlite3ColumnType(&pTab->aCol[iCol],0); + } +#endif + } + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_SELECT: { + /* The expression is a sub-select. Return the declaration type and + ** origin info for the single column in the result set of the SELECT + ** statement. + */ + NameContext sNC; + Select *pS = pExpr->x.pSelect; + Expr *p = pS->pEList->a[0].pExpr; + assert( ExprHasProperty(pExpr, EP_xIsSelect) ); + sNC.pSrcList = pS->pSrc; + sNC.pNext = pNC; + sNC.pParse = pNC->pParse; + zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol); + break; + } +#endif + } + +#ifdef SQLITE_ENABLE_COLUMN_METADATA + if( pzOrigDb ){ + assert( pzOrigTab && pzOrigCol ); + *pzOrigDb = zOrigDb; + *pzOrigTab = zOrigTab; + *pzOrigCol = zOrigCol; + } +#endif + return zType; +} + +/* +** Generate code that will tell the VDBE the declaration types of columns +** in the result set. +*/ +static void generateColumnTypes( + Parse *pParse, /* Parser context */ + SrcList *pTabList, /* List of tables */ + ExprList *pEList /* Expressions defining the result set */ +){ +#ifndef SQLITE_OMIT_DECLTYPE + Vdbe *v = pParse->pVdbe; + int i; + NameContext sNC; + sNC.pSrcList = pTabList; + sNC.pParse = pParse; + sNC.pNext = 0; + for(i=0; inExpr; i++){ + Expr *p = pEList->a[i].pExpr; + const char *zType; +#ifdef SQLITE_ENABLE_COLUMN_METADATA + const char *zOrigDb = 0; + const char *zOrigTab = 0; + const char *zOrigCol = 0; + zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol); + + /* The vdbe must make its own copy of the column-type and other + ** column specific strings, in case the schema is reset before this + ** virtual machine is deleted. + */ + sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, SQLITE_TRANSIENT); + sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, SQLITE_TRANSIENT); + sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, SQLITE_TRANSIENT); +#else + zType = columnType(&sNC, p, 0, 0, 0); +#endif + sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, SQLITE_TRANSIENT); + } +#endif /* !defined(SQLITE_OMIT_DECLTYPE) */ +} + + +/* +** Compute the column names for a SELECT statement. +** +** The only guarantee that SQLite makes about column names is that if the +** column has an AS clause assigning it a name, that will be the name used. +** That is the only documented guarantee. However, countless applications +** developed over the years have made baseless assumptions about column names +** and will break if those assumptions changes. Hence, use extreme caution +** when modifying this routine to avoid breaking legacy. +** +** See Also: sqlite3ColumnsFromExprList() +** +** The PRAGMA short_column_names and PRAGMA full_column_names settings are +** deprecated. The default setting is short=ON, full=OFF. 99.9% of all +** applications should operate this way. Nevertheless, we need to support the +** other modes for legacy: +** +** short=OFF, full=OFF: Column name is the text of the expression has it +** originally appears in the SELECT statement. In +** other words, the zSpan of the result expression. +** +** short=ON, full=OFF: (This is the default setting). If the result +** refers directly to a table column, then the +** result column name is just the table column +** name: COLUMN. Otherwise use zSpan. +** +** full=ON, short=ANY: If the result refers directly to a table column, +** then the result column name with the table name +** prefix, ex: TABLE.COLUMN. Otherwise use zSpan. +*/ +static void generateColumnNames( + Parse *pParse, /* Parser context */ + Select *pSelect /* Generate column names for this SELECT statement */ +){ + Vdbe *v = pParse->pVdbe; + int i; + Table *pTab; + SrcList *pTabList; + ExprList *pEList; + sqlite3 *db = pParse->db; + int fullName; /* TABLE.COLUMN if no AS clause and is a direct table ref */ + int srcName; /* COLUMN or TABLE.COLUMN if no AS clause and is direct */ + +#ifndef SQLITE_OMIT_EXPLAIN + /* If this is an EXPLAIN, skip this step */ + if( pParse->explain ){ + return; + } +#endif + + if( pParse->colNamesSet ) return; + /* Column names are determined by the left-most term of a compound select */ + while( pSelect->pPrior ) pSelect = pSelect->pPrior; + SELECTTRACE(1,pParse,pSelect,("generating column names\n")); + pTabList = pSelect->pSrc; + pEList = pSelect->pEList; + assert( v!=0 ); + assert( pTabList!=0 ); + pParse->colNamesSet = 1; + fullName = (db->flags & SQLITE_FullColNames)!=0; + srcName = (db->flags & SQLITE_ShortColNames)!=0 || fullName; + sqlite3VdbeSetNumCols(v, pEList->nExpr); + for(i=0; inExpr; i++){ + Expr *p = pEList->a[i].pExpr; + + assert( p!=0 ); + assert( p->op!=TK_AGG_COLUMN ); /* Agg processing has not run yet */ + assert( p->op!=TK_COLUMN || p->y.pTab!=0 ); /* Covering idx not yet coded */ + if( pEList->a[i].zEName && pEList->a[i].eEName==ENAME_NAME ){ + /* An AS clause always takes first priority */ + char *zName = pEList->a[i].zEName; + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT); + }else if( srcName && p->op==TK_COLUMN ){ + char *zCol; + int iCol = p->iColumn; + pTab = p->y.pTab; + assert( pTab!=0 ); + if( iCol<0 ) iCol = pTab->iPKey; + assert( iCol==-1 || (iCol>=0 && iColnCol) ); + if( iCol<0 ){ + zCol = "rowid"; + }else{ + zCol = pTab->aCol[iCol].zName; + } + if( fullName ){ + char *zName = 0; + zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol); + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC); + }else{ + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, SQLITE_TRANSIENT); + } + }else{ + const char *z = pEList->a[i].zEName; + z = z==0 ? sqlite3MPrintf(db, "column%d", i+1) : sqlite3DbStrDup(db, z); + sqlite3VdbeSetColName(v, i, COLNAME_NAME, z, SQLITE_DYNAMIC); + } + } + generateColumnTypes(pParse, pTabList, pEList); +} + +/* +** Given an expression list (which is really the list of expressions +** that form the result set of a SELECT statement) compute appropriate +** column names for a table that would hold the expression list. +** +** All column names will be unique. +** +** Only the column names are computed. Column.zType, Column.zColl, +** and other fields of Column are zeroed. +** +** Return SQLITE_OK on success. If a memory allocation error occurs, +** store NULL in *paCol and 0 in *pnCol and return SQLITE_NOMEM. +** +** The only guarantee that SQLite makes about column names is that if the +** column has an AS clause assigning it a name, that will be the name used. +** That is the only documented guarantee. However, countless applications +** developed over the years have made baseless assumptions about column names +** and will break if those assumptions changes. Hence, use extreme caution +** when modifying this routine to avoid breaking legacy. +** +** See Also: generateColumnNames() +*/ +SQLITE_PRIVATE int sqlite3ColumnsFromExprList( + Parse *pParse, /* Parsing context */ + ExprList *pEList, /* Expr list from which to derive column names */ + i16 *pnCol, /* Write the number of columns here */ + Column **paCol /* Write the new column list here */ +){ + sqlite3 *db = pParse->db; /* Database connection */ + int i, j; /* Loop counters */ + u32 cnt; /* Index added to make the name unique */ + Column *aCol, *pCol; /* For looping over result columns */ + int nCol; /* Number of columns in the result set */ + char *zName; /* Column name */ + int nName; /* Size of name in zName[] */ + Hash ht; /* Hash table of column names */ + Table *pTab; + + sqlite3HashInit(&ht); + if( pEList ){ + nCol = pEList->nExpr; + aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol); + testcase( aCol==0 ); + if( nCol>32767 ) nCol = 32767; + }else{ + nCol = 0; + aCol = 0; + } + assert( nCol==(i16)nCol ); + *pnCol = nCol; + *paCol = aCol; + + for(i=0, pCol=aCol; imallocFailed; i++, pCol++){ + /* Get an appropriate name for the column + */ + if( (zName = pEList->a[i].zEName)!=0 && pEList->a[i].eEName==ENAME_NAME ){ + /* If the column contains an "AS " phrase, use as the name */ + }else{ + Expr *pColExpr = sqlite3ExprSkipCollateAndLikely(pEList->a[i].pExpr); + while( ALWAYS(pColExpr!=0) && pColExpr->op==TK_DOT ){ + pColExpr = pColExpr->pRight; + assert( pColExpr!=0 ); + } + if( pColExpr->op==TK_COLUMN && (pTab = pColExpr->y.pTab)!=0 ){ + /* For columns use the column name name */ + int iCol = pColExpr->iColumn; + if( iCol<0 ) iCol = pTab->iPKey; + zName = iCol>=0 ? pTab->aCol[iCol].zName : "rowid"; + }else if( pColExpr->op==TK_ID ){ + assert( !ExprHasProperty(pColExpr, EP_IntValue) ); + zName = pColExpr->u.zToken; + }else{ + /* Use the original text of the column expression as its name */ + zName = pEList->a[i].zEName; + } + } + if( zName && !sqlite3IsTrueOrFalse(zName) ){ + zName = sqlite3DbStrDup(db, zName); + }else{ + zName = sqlite3MPrintf(db,"column%d",i+1); + } + + /* Make sure the column name is unique. If the name is not unique, + ** append an integer to the name so that it becomes unique. + */ + cnt = 0; + while( zName && sqlite3HashFind(&ht, zName)!=0 ){ + nName = sqlite3Strlen30(zName); + if( nName>0 ){ + for(j=nName-1; j>0 && sqlite3Isdigit(zName[j]); j--){} + if( zName[j]==':' ) nName = j; + } + zName = sqlite3MPrintf(db, "%.*z:%u", nName, zName, ++cnt); + if( cnt>3 ) sqlite3_randomness(sizeof(cnt), &cnt); + } + pCol->zName = zName; + pCol->hName = sqlite3StrIHash(zName); + sqlite3ColumnPropertiesFromName(0, pCol); + if( zName && sqlite3HashInsert(&ht, zName, pCol)==pCol ){ + sqlite3OomFault(db); + } + } + sqlite3HashClear(&ht); + if( db->mallocFailed ){ + for(j=0; jdb; + NameContext sNC; + Column *pCol; + CollSeq *pColl; + int i; + Expr *p; + struct ExprList_item *a; + + assert( pSelect!=0 ); + assert( (pSelect->selFlags & SF_Resolved)!=0 ); + assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed ); + if( db->mallocFailed ) return; + memset(&sNC, 0, sizeof(sNC)); + sNC.pSrcList = pSelect->pSrc; + a = pSelect->pEList->a; + for(i=0, pCol=pTab->aCol; inCol; i++, pCol++){ + const char *zType; + int n, m; + p = a[i].pExpr; + zType = columnType(&sNC, p, 0, 0, 0); + /* pCol->szEst = ... // Column size est for SELECT tables never used */ + pCol->affinity = sqlite3ExprAffinity(p); + if( zType ){ + m = sqlite3Strlen30(zType); + n = sqlite3Strlen30(pCol->zName); + pCol->zName = sqlite3DbReallocOrFree(db, pCol->zName, n+m+2); + if( pCol->zName ){ + memcpy(&pCol->zName[n+1], zType, m+1); + pCol->colFlags |= COLFLAG_HASTYPE; + } + } + if( pCol->affinity<=SQLITE_AFF_NONE ) pCol->affinity = aff; + pColl = sqlite3ExprCollSeq(pParse, p); + if( pColl && pCol->zColl==0 ){ + pCol->zColl = sqlite3DbStrDup(db, pColl->zName); + } + } + pTab->szTabRow = 1; /* Any non-zero value works */ +} + +/* +** Given a SELECT statement, generate a Table structure that describes +** the result set of that SELECT. +*/ +SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect, char aff){ + Table *pTab; + sqlite3 *db = pParse->db; + u64 savedFlags; + + savedFlags = db->flags; + db->flags &= ~(u64)SQLITE_FullColNames; + db->flags |= SQLITE_ShortColNames; + sqlite3SelectPrep(pParse, pSelect, 0); + db->flags = savedFlags; + if( pParse->nErr ) return 0; + while( pSelect->pPrior ) pSelect = pSelect->pPrior; + pTab = sqlite3DbMallocZero(db, sizeof(Table) ); + if( pTab==0 ){ + return 0; + } + pTab->nTabRef = 1; + pTab->zName = 0; + pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) ); + sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol); + sqlite3SelectAddColumnTypeAndCollation(pParse, pTab, pSelect, aff); + pTab->iPKey = -1; + if( db->mallocFailed ){ + sqlite3DeleteTable(db, pTab); + return 0; + } + return pTab; +} + +/* +** Get a VDBE for the given parser context. Create a new one if necessary. +** If an error occurs, return NULL and leave a message in pParse. +*/ +SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse *pParse){ + if( pParse->pVdbe ){ + return pParse->pVdbe; + } + if( pParse->pToplevel==0 + && OptimizationEnabled(pParse->db,SQLITE_FactorOutConst) + ){ + pParse->okConstFactor = 1; + } + return sqlite3VdbeCreate(pParse); +} + + +/* +** Compute the iLimit and iOffset fields of the SELECT based on the +** pLimit expressions. pLimit->pLeft and pLimit->pRight hold the expressions +** that appear in the original SQL statement after the LIMIT and OFFSET +** keywords. Or NULL if those keywords are omitted. iLimit and iOffset +** are the integer memory register numbers for counters used to compute +** the limit and offset. If there is no limit and/or offset, then +** iLimit and iOffset are negative. +** +** This routine changes the values of iLimit and iOffset only if +** a limit or offset is defined by pLimit->pLeft and pLimit->pRight. iLimit +** and iOffset should have been preset to appropriate default values (zero) +** prior to calling this routine. +** +** The iOffset register (if it exists) is initialized to the value +** of the OFFSET. The iLimit register is initialized to LIMIT. Register +** iOffset+1 is initialized to LIMIT+OFFSET. +** +** Only if pLimit->pLeft!=0 do the limit registers get +** redefined. The UNION ALL operator uses this property to force +** the reuse of the same limit and offset registers across multiple +** SELECT statements. +*/ +static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){ + Vdbe *v = 0; + int iLimit = 0; + int iOffset; + int n; + Expr *pLimit = p->pLimit; + + if( p->iLimit ) return; + + /* + ** "LIMIT -1" always shows all rows. There is some + ** controversy about what the correct behavior should be. + ** The current implementation interprets "LIMIT 0" to mean + ** no rows. + */ + if( pLimit ){ + assert( pLimit->op==TK_LIMIT ); + assert( pLimit->pLeft!=0 ); + p->iLimit = iLimit = ++pParse->nMem; + v = sqlite3GetVdbe(pParse); + assert( v!=0 ); + if( sqlite3ExprIsInteger(pLimit->pLeft, &n) ){ + sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit); + VdbeComment((v, "LIMIT counter")); + if( n==0 ){ + sqlite3VdbeGoto(v, iBreak); + }else if( n>=0 && p->nSelectRow>sqlite3LogEst((u64)n) ){ + p->nSelectRow = sqlite3LogEst((u64)n); + p->selFlags |= SF_FixedLimit; + } + }else{ + sqlite3ExprCode(pParse, pLimit->pLeft, iLimit); + sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit); VdbeCoverage(v); + VdbeComment((v, "LIMIT counter")); + sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, iBreak); VdbeCoverage(v); + } + if( pLimit->pRight ){ + p->iOffset = iOffset = ++pParse->nMem; + pParse->nMem++; /* Allocate an extra register for limit+offset */ + sqlite3ExprCode(pParse, pLimit->pRight, iOffset); + sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset); VdbeCoverage(v); + VdbeComment((v, "OFFSET counter")); + sqlite3VdbeAddOp3(v, OP_OffsetLimit, iLimit, iOffset+1, iOffset); + VdbeComment((v, "LIMIT+OFFSET")); + } + } +} + +#ifndef SQLITE_OMIT_COMPOUND_SELECT +/* +** Return the appropriate collating sequence for the iCol-th column of +** the result set for the compound-select statement "p". Return NULL if +** the column has no default collating sequence. +** +** The collating sequence for the compound select is taken from the +** left-most term of the select that has a collating sequence. +*/ +static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){ + CollSeq *pRet; + if( p->pPrior ){ + pRet = multiSelectCollSeq(pParse, p->pPrior, iCol); + }else{ + pRet = 0; + } + assert( iCol>=0 ); + /* iCol must be less than p->pEList->nExpr. Otherwise an error would + ** have been thrown during name resolution and we would not have gotten + ** this far */ + if( pRet==0 && ALWAYS(iColpEList->nExpr) ){ + pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr); + } + return pRet; +} + +/* +** The select statement passed as the second parameter is a compound SELECT +** with an ORDER BY clause. This function allocates and returns a KeyInfo +** structure suitable for implementing the ORDER BY. +** +** Space to hold the KeyInfo structure is obtained from malloc. The calling +** function is responsible for ensuring that this structure is eventually +** freed. +*/ +static KeyInfo *multiSelectOrderByKeyInfo(Parse *pParse, Select *p, int nExtra){ + ExprList *pOrderBy = p->pOrderBy; + int nOrderBy = p->pOrderBy->nExpr; + sqlite3 *db = pParse->db; + KeyInfo *pRet = sqlite3KeyInfoAlloc(db, nOrderBy+nExtra, 1); + if( pRet ){ + int i; + for(i=0; ia[i]; + Expr *pTerm = pItem->pExpr; + CollSeq *pColl; + + if( pTerm->flags & EP_Collate ){ + pColl = sqlite3ExprCollSeq(pParse, pTerm); + }else{ + pColl = multiSelectCollSeq(pParse, p, pItem->u.x.iOrderByCol-1); + if( pColl==0 ) pColl = db->pDfltColl; + pOrderBy->a[i].pExpr = + sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName); + } + assert( sqlite3KeyInfoIsWriteable(pRet) ); + pRet->aColl[i] = pColl; + pRet->aSortFlags[i] = pOrderBy->a[i].sortFlags; + } + } + + return pRet; +} + +#ifndef SQLITE_OMIT_CTE +/* +** This routine generates VDBE code to compute the content of a WITH RECURSIVE +** query of the form: +** +** AS ( UNION [ALL] ) +** \___________/ \_______________/ +** p->pPrior p +** +** +** There is exactly one reference to the recursive-table in the FROM clause +** of recursive-query, marked with the SrcList->a[].fg.isRecursive flag. +** +** The setup-query runs once to generate an initial set of rows that go +** into a Queue table. Rows are extracted from the Queue table one by +** one. Each row extracted from Queue is output to pDest. Then the single +** extracted row (now in the iCurrent table) becomes the content of the +** recursive-table for a recursive-query run. The output of the recursive-query +** is added back into the Queue table. Then another row is extracted from Queue +** and the iteration continues until the Queue table is empty. +** +** If the compound query operator is UNION then no duplicate rows are ever +** inserted into the Queue table. The iDistinct table keeps a copy of all rows +** that have ever been inserted into Queue and causes duplicates to be +** discarded. If the operator is UNION ALL, then duplicates are allowed. +** +** If the query has an ORDER BY, then entries in the Queue table are kept in +** ORDER BY order and the first entry is extracted for each cycle. Without +** an ORDER BY, the Queue table is just a FIFO. +** +** If a LIMIT clause is provided, then the iteration stops after LIMIT rows +** have been output to pDest. A LIMIT of zero means to output no rows and a +** negative LIMIT means to output all rows. If there is also an OFFSET clause +** with a positive value, then the first OFFSET outputs are discarded rather +** than being sent to pDest. The LIMIT count does not begin until after OFFSET +** rows have been skipped. +*/ +static void generateWithRecursiveQuery( + Parse *pParse, /* Parsing context */ + Select *p, /* The recursive SELECT to be coded */ + SelectDest *pDest /* What to do with query results */ +){ + SrcList *pSrc = p->pSrc; /* The FROM clause of the recursive query */ + int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */ + Vdbe *v = pParse->pVdbe; /* The prepared statement under construction */ + Select *pSetup = p->pPrior; /* The setup query */ + Select *pFirstRec; /* Left-most recursive term */ + int addrTop; /* Top of the loop */ + int addrCont, addrBreak; /* CONTINUE and BREAK addresses */ + int iCurrent = 0; /* The Current table */ + int regCurrent; /* Register holding Current table */ + int iQueue; /* The Queue table */ + int iDistinct = 0; /* To ensure unique results if UNION */ + int eDest = SRT_Fifo; /* How to write to Queue */ + SelectDest destQueue; /* SelectDest targetting the Queue table */ + int i; /* Loop counter */ + int rc; /* Result code */ + ExprList *pOrderBy; /* The ORDER BY clause */ + Expr *pLimit; /* Saved LIMIT and OFFSET */ + int regLimit, regOffset; /* Registers used by LIMIT and OFFSET */ + +#ifndef SQLITE_OMIT_WINDOWFUNC + if( p->pWin ){ + sqlite3ErrorMsg(pParse, "cannot use window functions in recursive queries"); + return; + } +#endif + + /* Obtain authorization to do a recursive query */ + if( sqlite3AuthCheck(pParse, SQLITE_RECURSIVE, 0, 0, 0) ) return; + + /* Process the LIMIT and OFFSET clauses, if they exist */ + addrBreak = sqlite3VdbeMakeLabel(pParse); + p->nSelectRow = 320; /* 4 billion rows */ + computeLimitRegisters(pParse, p, addrBreak); + pLimit = p->pLimit; + regLimit = p->iLimit; + regOffset = p->iOffset; + p->pLimit = 0; + p->iLimit = p->iOffset = 0; + pOrderBy = p->pOrderBy; + + /* Locate the cursor number of the Current table */ + for(i=0; ALWAYS(inSrc); i++){ + if( pSrc->a[i].fg.isRecursive ){ + iCurrent = pSrc->a[i].iCursor; + break; + } + } + + /* Allocate cursors numbers for Queue and Distinct. The cursor number for + ** the Distinct table must be exactly one greater than Queue in order + ** for the SRT_DistFifo and SRT_DistQueue destinations to work. */ + iQueue = pParse->nTab++; + if( p->op==TK_UNION ){ + eDest = pOrderBy ? SRT_DistQueue : SRT_DistFifo; + iDistinct = pParse->nTab++; + }else{ + eDest = pOrderBy ? SRT_Queue : SRT_Fifo; + } + sqlite3SelectDestInit(&destQueue, eDest, iQueue); + + /* Allocate cursors for Current, Queue, and Distinct. */ + regCurrent = ++pParse->nMem; + sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol); + if( pOrderBy ){ + KeyInfo *pKeyInfo = multiSelectOrderByKeyInfo(pParse, p, 1); + sqlite3VdbeAddOp4(v, OP_OpenEphemeral, iQueue, pOrderBy->nExpr+2, 0, + (char*)pKeyInfo, P4_KEYINFO); + destQueue.pOrderBy = pOrderBy; + }else{ + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol); + } + VdbeComment((v, "Queue table")); + if( iDistinct ){ + p->addrOpenEphm[0] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iDistinct, 0); + p->selFlags |= SF_UsesEphemeral; + } + + /* Detach the ORDER BY clause from the compound SELECT */ + p->pOrderBy = 0; + + /* Figure out how many elements of the compound SELECT are part of the + ** recursive query. Make sure no recursive elements use aggregate + ** functions. Mark the recursive elements as UNION ALL even if they + ** are really UNION because the distinctness will be enforced by the + ** iDistinct table. pFirstRec is left pointing to the left-most + ** recursive term of the CTE. + */ + pFirstRec = p; + for(pFirstRec=p; ALWAYS(pFirstRec!=0); pFirstRec=pFirstRec->pPrior){ + if( pFirstRec->selFlags & SF_Aggregate ){ + sqlite3ErrorMsg(pParse, "recursive aggregate queries not supported"); + goto end_of_recursive_query; + } + pFirstRec->op = TK_ALL; + if( (pFirstRec->pPrior->selFlags & SF_Recursive)==0 ) break; + } + + /* Store the results of the setup-query in Queue. */ + pSetup = pFirstRec->pPrior; + pSetup->pNext = 0; + ExplainQueryPlan((pParse, 1, "SETUP")); + rc = sqlite3Select(pParse, pSetup, &destQueue); + pSetup->pNext = p; + if( rc ) goto end_of_recursive_query; + + /* Find the next row in the Queue and output that row */ + addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iQueue, addrBreak); VdbeCoverage(v); + + /* Transfer the next row in Queue over to Current */ + sqlite3VdbeAddOp1(v, OP_NullRow, iCurrent); /* To reset column cache */ + if( pOrderBy ){ + sqlite3VdbeAddOp3(v, OP_Column, iQueue, pOrderBy->nExpr+1, regCurrent); + }else{ + sqlite3VdbeAddOp2(v, OP_RowData, iQueue, regCurrent); + } + sqlite3VdbeAddOp1(v, OP_Delete, iQueue); + + /* Output the single row in Current */ + addrCont = sqlite3VdbeMakeLabel(pParse); + codeOffset(v, regOffset, addrCont); + selectInnerLoop(pParse, p, iCurrent, + 0, 0, pDest, addrCont, addrBreak); + if( regLimit ){ + sqlite3VdbeAddOp2(v, OP_DecrJumpZero, regLimit, addrBreak); + VdbeCoverage(v); + } + sqlite3VdbeResolveLabel(v, addrCont); + + /* Execute the recursive SELECT taking the single row in Current as + ** the value for the recursive-table. Store the results in the Queue. + */ + pFirstRec->pPrior = 0; + ExplainQueryPlan((pParse, 1, "RECURSIVE STEP")); + sqlite3Select(pParse, p, &destQueue); + assert( pFirstRec->pPrior==0 ); + pFirstRec->pPrior = pSetup; + + /* Keep running the loop until the Queue is empty */ + sqlite3VdbeGoto(v, addrTop); + sqlite3VdbeResolveLabel(v, addrBreak); + +end_of_recursive_query: + sqlite3ExprListDelete(pParse->db, p->pOrderBy); + p->pOrderBy = pOrderBy; + p->pLimit = pLimit; + return; +} +#endif /* SQLITE_OMIT_CTE */ + +/* Forward references */ +static int multiSelectOrderBy( + Parse *pParse, /* Parsing context */ + Select *p, /* The right-most of SELECTs to be coded */ + SelectDest *pDest /* What to do with query results */ +); + +/* +** Handle the special case of a compound-select that originates from a +** VALUES clause. By handling this as a special case, we avoid deep +** recursion, and thus do not need to enforce the SQLITE_LIMIT_COMPOUND_SELECT +** on a VALUES clause. +** +** Because the Select object originates from a VALUES clause: +** (1) There is no LIMIT or OFFSET or else there is a LIMIT of exactly 1 +** (2) All terms are UNION ALL +** (3) There is no ORDER BY clause +** +** The "LIMIT of exactly 1" case of condition (1) comes about when a VALUES +** clause occurs within scalar expression (ex: "SELECT (VALUES(1),(2),(3))"). +** The sqlite3CodeSubselect will have added the LIMIT 1 clause in tht case. +** Since the limit is exactly 1, we only need to evalutes the left-most VALUES. +*/ +static int multiSelectValues( + Parse *pParse, /* Parsing context */ + Select *p, /* The right-most of SELECTs to be coded */ + SelectDest *pDest /* What to do with query results */ +){ + int nRow = 1; + int rc = 0; + int bShowAll = p->pLimit==0; + assert( p->selFlags & SF_MultiValue ); + do{ + assert( p->selFlags & SF_Values ); + assert( p->op==TK_ALL || (p->op==TK_SELECT && p->pPrior==0) ); + assert( p->pNext==0 || p->pEList->nExpr==p->pNext->pEList->nExpr ); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( p->pWin ) return -1; +#endif + if( p->pPrior==0 ) break; + assert( p->pPrior->pNext==p ); + p = p->pPrior; + nRow += bShowAll; + }while(1); + ExplainQueryPlan((pParse, 0, "SCAN %d CONSTANT ROW%s", nRow, + nRow==1 ? "" : "S")); + while( p ){ + selectInnerLoop(pParse, p, -1, 0, 0, pDest, 1, 1); + if( !bShowAll ) break; + p->nSelectRow = nRow; + p = p->pNext; + } + return rc; +} + +/* +** Return true if the SELECT statement which is known to be the recursive +** part of a recursive CTE still has its anchor terms attached. If the +** anchor terms have already been removed, then return false. +*/ +static int hasAnchor(Select *p){ + while( p && (p->selFlags & SF_Recursive)!=0 ){ p = p->pPrior; } + return p!=0; +} + +/* +** This routine is called to process a compound query form from +** two or more separate queries using UNION, UNION ALL, EXCEPT, or +** INTERSECT +** +** "p" points to the right-most of the two queries. the query on the +** left is p->pPrior. The left query could also be a compound query +** in which case this routine will be called recursively. +** +** The results of the total query are to be written into a destination +** of type eDest with parameter iParm. +** +** Example 1: Consider a three-way compound SQL statement. +** +** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3 +** +** This statement is parsed up as follows: +** +** SELECT c FROM t3 +** | +** `-----> SELECT b FROM t2 +** | +** `------> SELECT a FROM t1 +** +** The arrows in the diagram above represent the Select.pPrior pointer. +** So if this routine is called with p equal to the t3 query, then +** pPrior will be the t2 query. p->op will be TK_UNION in this case. +** +** Notice that because of the way SQLite parses compound SELECTs, the +** individual selects always group from left to right. +*/ +static int multiSelect( + Parse *pParse, /* Parsing context */ + Select *p, /* The right-most of SELECTs to be coded */ + SelectDest *pDest /* What to do with query results */ +){ + int rc = SQLITE_OK; /* Success code from a subroutine */ + Select *pPrior; /* Another SELECT immediately to our left */ + Vdbe *v; /* Generate code to this VDBE */ + SelectDest dest; /* Alternative data destination */ + Select *pDelete = 0; /* Chain of simple selects to delete */ + sqlite3 *db; /* Database connection */ + + /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only + ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT. + */ + assert( p && p->pPrior ); /* Calling function guarantees this much */ + assert( (p->selFlags & SF_Recursive)==0 || p->op==TK_ALL || p->op==TK_UNION ); + assert( p->selFlags & SF_Compound ); + db = pParse->db; + pPrior = p->pPrior; + dest = *pDest; + if( pPrior->pOrderBy || pPrior->pLimit ){ + sqlite3ErrorMsg(pParse,"%s clause should come after %s not before", + pPrior->pOrderBy!=0 ? "ORDER BY" : "LIMIT", selectOpName(p->op)); + rc = 1; + goto multi_select_end; + } + + v = sqlite3GetVdbe(pParse); + assert( v!=0 ); /* The VDBE already created by calling function */ + + /* Create the destination temporary table if necessary + */ + if( dest.eDest==SRT_EphemTab ){ + assert( p->pEList ); + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iSDParm, p->pEList->nExpr); + dest.eDest = SRT_Table; + } + + /* Special handling for a compound-select that originates as a VALUES clause. + */ + if( p->selFlags & SF_MultiValue ){ + rc = multiSelectValues(pParse, p, &dest); + if( rc>=0 ) goto multi_select_end; + rc = SQLITE_OK; + } + + /* Make sure all SELECTs in the statement have the same number of elements + ** in their result sets. + */ + assert( p->pEList && pPrior->pEList ); + assert( p->pEList->nExpr==pPrior->pEList->nExpr ); + +#ifndef SQLITE_OMIT_CTE + if( (p->selFlags & SF_Recursive)!=0 && hasAnchor(p) ){ + generateWithRecursiveQuery(pParse, p, &dest); + }else +#endif + + /* Compound SELECTs that have an ORDER BY clause are handled separately. + */ + if( p->pOrderBy ){ + return multiSelectOrderBy(pParse, p, pDest); + }else{ + +#ifndef SQLITE_OMIT_EXPLAIN + if( pPrior->pPrior==0 ){ + ExplainQueryPlan((pParse, 1, "COMPOUND QUERY")); + ExplainQueryPlan((pParse, 1, "LEFT-MOST SUBQUERY")); + } +#endif + + /* Generate code for the left and right SELECT statements. + */ + switch( p->op ){ + case TK_ALL: { + int addr = 0; + int nLimit; + assert( !pPrior->pLimit ); + pPrior->iLimit = p->iLimit; + pPrior->iOffset = p->iOffset; + pPrior->pLimit = p->pLimit; + rc = sqlite3Select(pParse, pPrior, &dest); + p->pLimit = 0; + if( rc ){ + goto multi_select_end; + } + p->pPrior = 0; + p->iLimit = pPrior->iLimit; + p->iOffset = pPrior->iOffset; + if( p->iLimit ){ + addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v); + VdbeComment((v, "Jump ahead if LIMIT reached")); + if( p->iOffset ){ + sqlite3VdbeAddOp3(v, OP_OffsetLimit, + p->iLimit, p->iOffset+1, p->iOffset); + } + } + ExplainQueryPlan((pParse, 1, "UNION ALL")); + rc = sqlite3Select(pParse, p, &dest); + testcase( rc!=SQLITE_OK ); + pDelete = p->pPrior; + p->pPrior = pPrior; + p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow); + if( pPrior->pLimit + && sqlite3ExprIsInteger(pPrior->pLimit->pLeft, &nLimit) + && nLimit>0 && p->nSelectRow > sqlite3LogEst((u64)nLimit) + ){ + p->nSelectRow = sqlite3LogEst((u64)nLimit); + } + if( addr ){ + sqlite3VdbeJumpHere(v, addr); + } + break; + } + case TK_EXCEPT: + case TK_UNION: { + int unionTab; /* Cursor number of the temp table holding result */ + u8 op = 0; /* One of the SRT_ operations to apply to self */ + int priorOp; /* The SRT_ operation to apply to prior selects */ + Expr *pLimit; /* Saved values of p->nLimit */ + int addr; + SelectDest uniondest; + + testcase( p->op==TK_EXCEPT ); + testcase( p->op==TK_UNION ); + priorOp = SRT_Union; + if( dest.eDest==priorOp ){ + /* We can reuse a temporary table generated by a SELECT to our + ** right. + */ + assert( p->pLimit==0 ); /* Not allowed on leftward elements */ + unionTab = dest.iSDParm; + }else{ + /* We will need to create our own temporary table to hold the + ** intermediate results. + */ + unionTab = pParse->nTab++; + assert( p->pOrderBy==0 ); + addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0); + assert( p->addrOpenEphm[0] == -1 ); + p->addrOpenEphm[0] = addr; + findRightmost(p)->selFlags |= SF_UsesEphemeral; + assert( p->pEList ); + } + + + /* Code the SELECT statements to our left + */ + assert( !pPrior->pOrderBy ); + sqlite3SelectDestInit(&uniondest, priorOp, unionTab); + rc = sqlite3Select(pParse, pPrior, &uniondest); + if( rc ){ + goto multi_select_end; + } + + /* Code the current SELECT statement + */ + if( p->op==TK_EXCEPT ){ + op = SRT_Except; + }else{ + assert( p->op==TK_UNION ); + op = SRT_Union; + } + p->pPrior = 0; + pLimit = p->pLimit; + p->pLimit = 0; + uniondest.eDest = op; + ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE", + selectOpName(p->op))); + rc = sqlite3Select(pParse, p, &uniondest); + testcase( rc!=SQLITE_OK ); + assert( p->pOrderBy==0 ); + pDelete = p->pPrior; + p->pPrior = pPrior; + p->pOrderBy = 0; + if( p->op==TK_UNION ){ + p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow); + } + sqlite3ExprDelete(db, p->pLimit); + p->pLimit = pLimit; + p->iLimit = 0; + p->iOffset = 0; + + /* Convert the data in the temporary table into whatever form + ** it is that we currently need. + */ + assert( unionTab==dest.iSDParm || dest.eDest!=priorOp ); + assert( p->pEList || db->mallocFailed ); + if( dest.eDest!=priorOp && db->mallocFailed==0 ){ + int iCont, iBreak, iStart; + iBreak = sqlite3VdbeMakeLabel(pParse); + iCont = sqlite3VdbeMakeLabel(pParse); + computeLimitRegisters(pParse, p, iBreak); + sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak); VdbeCoverage(v); + iStart = sqlite3VdbeCurrentAddr(v); + selectInnerLoop(pParse, p, unionTab, + 0, 0, &dest, iCont, iBreak); + sqlite3VdbeResolveLabel(v, iCont); + sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart); VdbeCoverage(v); + sqlite3VdbeResolveLabel(v, iBreak); + sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0); + } + break; + } + default: assert( p->op==TK_INTERSECT ); { + int tab1, tab2; + int iCont, iBreak, iStart; + Expr *pLimit; + int addr; + SelectDest intersectdest; + int r1; + + /* INTERSECT is different from the others since it requires + ** two temporary tables. Hence it has its own case. Begin + ** by allocating the tables we will need. + */ + tab1 = pParse->nTab++; + tab2 = pParse->nTab++; + assert( p->pOrderBy==0 ); + + addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0); + assert( p->addrOpenEphm[0] == -1 ); + p->addrOpenEphm[0] = addr; + findRightmost(p)->selFlags |= SF_UsesEphemeral; + assert( p->pEList ); + + /* Code the SELECTs to our left into temporary table "tab1". + */ + sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1); + rc = sqlite3Select(pParse, pPrior, &intersectdest); + if( rc ){ + goto multi_select_end; + } + + /* Code the current SELECT into temporary table "tab2" + */ + addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0); + assert( p->addrOpenEphm[1] == -1 ); + p->addrOpenEphm[1] = addr; + p->pPrior = 0; + pLimit = p->pLimit; + p->pLimit = 0; + intersectdest.iSDParm = tab2; + ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE", + selectOpName(p->op))); + rc = sqlite3Select(pParse, p, &intersectdest); + testcase( rc!=SQLITE_OK ); + pDelete = p->pPrior; + p->pPrior = pPrior; + if( p->nSelectRow>pPrior->nSelectRow ){ + p->nSelectRow = pPrior->nSelectRow; + } + sqlite3ExprDelete(db, p->pLimit); + p->pLimit = pLimit; + + /* Generate code to take the intersection of the two temporary + ** tables. + */ + if( rc ) break; + assert( p->pEList ); + iBreak = sqlite3VdbeMakeLabel(pParse); + iCont = sqlite3VdbeMakeLabel(pParse); + computeLimitRegisters(pParse, p, iBreak); + sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak); VdbeCoverage(v); + r1 = sqlite3GetTempReg(pParse); + iStart = sqlite3VdbeAddOp2(v, OP_RowData, tab1, r1); + sqlite3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0); + VdbeCoverage(v); + sqlite3ReleaseTempReg(pParse, r1); + selectInnerLoop(pParse, p, tab1, + 0, 0, &dest, iCont, iBreak); + sqlite3VdbeResolveLabel(v, iCont); + sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart); VdbeCoverage(v); + sqlite3VdbeResolveLabel(v, iBreak); + sqlite3VdbeAddOp2(v, OP_Close, tab2, 0); + sqlite3VdbeAddOp2(v, OP_Close, tab1, 0); + break; + } + } + + #ifndef SQLITE_OMIT_EXPLAIN + if( p->pNext==0 ){ + ExplainQueryPlanPop(pParse); + } + #endif + } + if( pParse->nErr ) goto multi_select_end; + + /* Compute collating sequences used by + ** temporary tables needed to implement the compound select. + ** Attach the KeyInfo structure to all temporary tables. + ** + ** This section is run by the right-most SELECT statement only. + ** SELECT statements to the left always skip this part. The right-most + ** SELECT might also skip this part if it has no ORDER BY clause and + ** no temp tables are required. + */ + if( p->selFlags & SF_UsesEphemeral ){ + int i; /* Loop counter */ + KeyInfo *pKeyInfo; /* Collating sequence for the result set */ + Select *pLoop; /* For looping through SELECT statements */ + CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */ + int nCol; /* Number of columns in result set */ + + assert( p->pNext==0 ); + nCol = p->pEList->nExpr; + pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1); + if( !pKeyInfo ){ + rc = SQLITE_NOMEM_BKPT; + goto multi_select_end; + } + for(i=0, apColl=pKeyInfo->aColl; ipDfltColl; + } + } + + for(pLoop=p; pLoop; pLoop=pLoop->pPrior){ + for(i=0; i<2; i++){ + int addr = pLoop->addrOpenEphm[i]; + if( addr<0 ){ + /* If [0] is unused then [1] is also unused. So we can + ** always safely abort as soon as the first unused slot is found */ + assert( pLoop->addrOpenEphm[1]<0 ); + break; + } + sqlite3VdbeChangeP2(v, addr, nCol); + sqlite3VdbeChangeP4(v, addr, (char*)sqlite3KeyInfoRef(pKeyInfo), + P4_KEYINFO); + pLoop->addrOpenEphm[i] = -1; + } + } + sqlite3KeyInfoUnref(pKeyInfo); + } + +multi_select_end: + pDest->iSdst = dest.iSdst; + pDest->nSdst = dest.nSdst; + sqlite3SelectDelete(db, pDelete); + return rc; +} +#endif /* SQLITE_OMIT_COMPOUND_SELECT */ + +/* +** Error message for when two or more terms of a compound select have different +** size result sets. +*/ +SQLITE_PRIVATE void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p){ + if( p->selFlags & SF_Values ){ + sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms"); + }else{ + sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s" + " do not have the same number of result columns", selectOpName(p->op)); + } +} + +/* +** Code an output subroutine for a coroutine implementation of a +** SELECT statment. +** +** The data to be output is contained in pIn->iSdst. There are +** pIn->nSdst columns to be output. pDest is where the output should +** be sent. +** +** regReturn is the number of the register holding the subroutine +** return address. +** +** If regPrev>0 then it is the first register in a vector that +** records the previous output. mem[regPrev] is a flag that is false +** if there has been no previous output. If regPrev>0 then code is +** generated to suppress duplicates. pKeyInfo is used for comparing +** keys. +** +** If the LIMIT found in p->iLimit is reached, jump immediately to +** iBreak. +*/ +static int generateOutputSubroutine( + Parse *pParse, /* Parsing context */ + Select *p, /* The SELECT statement */ + SelectDest *pIn, /* Coroutine supplying data */ + SelectDest *pDest, /* Where to send the data */ + int regReturn, /* The return address register */ + int regPrev, /* Previous result register. No uniqueness if 0 */ + KeyInfo *pKeyInfo, /* For comparing with previous entry */ + int iBreak /* Jump here if we hit the LIMIT */ +){ + Vdbe *v = pParse->pVdbe; + int iContinue; + int addr; + + addr = sqlite3VdbeCurrentAddr(v); + iContinue = sqlite3VdbeMakeLabel(pParse); + + /* Suppress duplicates for UNION, EXCEPT, and INTERSECT + */ + if( regPrev ){ + int addr1, addr2; + addr1 = sqlite3VdbeAddOp1(v, OP_IfNot, regPrev); VdbeCoverage(v); + addr2 = sqlite3VdbeAddOp4(v, OP_Compare, pIn->iSdst, regPrev+1, pIn->nSdst, + (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO); + sqlite3VdbeAddOp3(v, OP_Jump, addr2+2, iContinue, addr2+2); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp3(v, OP_Copy, pIn->iSdst, regPrev+1, pIn->nSdst-1); + sqlite3VdbeAddOp2(v, OP_Integer, 1, regPrev); + } + if( pParse->db->mallocFailed ) return 0; + + /* Suppress the first OFFSET entries if there is an OFFSET clause + */ + codeOffset(v, p->iOffset, iContinue); + + assert( pDest->eDest!=SRT_Exists ); + assert( pDest->eDest!=SRT_Table ); + switch( pDest->eDest ){ + /* Store the result as data using a unique key. + */ + case SRT_EphemTab: { + int r1 = sqlite3GetTempReg(pParse); + int r2 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst, r1); + sqlite3VdbeAddOp2(v, OP_NewRowid, pDest->iSDParm, r2); + sqlite3VdbeAddOp3(v, OP_Insert, pDest->iSDParm, r1, r2); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + sqlite3ReleaseTempReg(pParse, r2); + sqlite3ReleaseTempReg(pParse, r1); + break; + } + +#ifndef SQLITE_OMIT_SUBQUERY + /* If we are creating a set for an "expr IN (SELECT ...)". + */ + case SRT_Set: { + int r1; + testcase( pIn->nSdst>1 ); + r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst, + r1, pDest->zAffSdst, pIn->nSdst); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pDest->iSDParm, r1, + pIn->iSdst, pIn->nSdst); + sqlite3ReleaseTempReg(pParse, r1); + break; + } + + /* If this is a scalar select that is part of an expression, then + ** store the results in the appropriate memory cell and break out + ** of the scan loop. Note that the select might return multiple columns + ** if it is the RHS of a row-value IN operator. + */ + case SRT_Mem: { + if( pParse->nErr==0 ){ + testcase( pIn->nSdst>1 ); + sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSDParm, pIn->nSdst); + } + /* The LIMIT clause will jump out of the loop for us */ + break; + } +#endif /* #ifndef SQLITE_OMIT_SUBQUERY */ + + /* The results are stored in a sequence of registers + ** starting at pDest->iSdst. Then the co-routine yields. + */ + case SRT_Coroutine: { + if( pDest->iSdst==0 ){ + pDest->iSdst = sqlite3GetTempRange(pParse, pIn->nSdst); + pDest->nSdst = pIn->nSdst; + } + sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSdst, pIn->nSdst); + sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm); + break; + } + + /* If none of the above, then the result destination must be + ** SRT_Output. This routine is never called with any other + ** destination other than the ones handled above or SRT_Output. + ** + ** For SRT_Output, results are stored in a sequence of registers. + ** Then the OP_ResultRow opcode is used to cause sqlite3_step() to + ** return the next row of result. + */ + default: { + assert( pDest->eDest==SRT_Output ); + sqlite3VdbeAddOp2(v, OP_ResultRow, pIn->iSdst, pIn->nSdst); + break; + } + } + + /* Jump to the end of the loop if the LIMIT is reached. + */ + if( p->iLimit ){ + sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v); + } + + /* Generate the subroutine return + */ + sqlite3VdbeResolveLabel(v, iContinue); + sqlite3VdbeAddOp1(v, OP_Return, regReturn); + + return addr; +} + +/* +** Alternative compound select code generator for cases when there +** is an ORDER BY clause. +** +** We assume a query of the following form: +** +** ORDER BY +** +** is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea +** is to code both and with the ORDER BY clause as +** co-routines. Then run the co-routines in parallel and merge the results +** into the output. In addition to the two coroutines (called selectA and +** selectB) there are 7 subroutines: +** +** outA: Move the output of the selectA coroutine into the output +** of the compound query. +** +** outB: Move the output of the selectB coroutine into the output +** of the compound query. (Only generated for UNION and +** UNION ALL. EXCEPT and INSERTSECT never output a row that +** appears only in B.) +** +** AltB: Called when there is data from both coroutines and AB. +** +** EofA: Called when data is exhausted from selectA. +** +** EofB: Called when data is exhausted from selectB. +** +** The implementation of the latter five subroutines depend on which +** is used: +** +** +** UNION ALL UNION EXCEPT INTERSECT +** ------------- ----------------- -------------- ----------------- +** AltB: outA, nextA outA, nextA outA, nextA nextA +** +** AeqB: outA, nextA nextA nextA outA, nextA +** +** AgtB: outB, nextB outB, nextB nextB nextB +** +** EofA: outB, nextB outB, nextB halt halt +** +** EofB: outA, nextA outA, nextA outA, nextA halt +** +** In the AltB, AeqB, and AgtB subroutines, an EOF on A following nextA +** causes an immediate jump to EofA and an EOF on B following nextB causes +** an immediate jump to EofB. Within EofA and EofB, and EOF on entry or +** following nextX causes a jump to the end of the select processing. +** +** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled +** within the output subroutine. The regPrev register set holds the previously +** output value. A comparison is made against this value and the output +** is skipped if the next results would be the same as the previous. +** +** The implementation plan is to implement the two coroutines and seven +** subroutines first, then put the control logic at the bottom. Like this: +** +** goto Init +** coA: coroutine for left query (A) +** coB: coroutine for right query (B) +** outA: output one row of A +** outB: output one row of B (UNION and UNION ALL only) +** EofA: ... +** EofB: ... +** AltB: ... +** AeqB: ... +** AgtB: ... +** Init: initialize coroutine registers +** yield coA +** if eof(A) goto EofA +** yield coB +** if eof(B) goto EofB +** Cmpr: Compare A, B +** Jump AltB, AeqB, AgtB +** End: ... +** +** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not +** actually called using Gosub and they do not Return. EofA and EofB loop +** until all data is exhausted then jump to the "end" labe. AltB, AeqB, +** and AgtB jump to either L2 or to one of EofA or EofB. +*/ +#ifndef SQLITE_OMIT_COMPOUND_SELECT +static int multiSelectOrderBy( + Parse *pParse, /* Parsing context */ + Select *p, /* The right-most of SELECTs to be coded */ + SelectDest *pDest /* What to do with query results */ +){ + int i, j; /* Loop counters */ + Select *pPrior; /* Another SELECT immediately to our left */ + Vdbe *v; /* Generate code to this VDBE */ + SelectDest destA; /* Destination for coroutine A */ + SelectDest destB; /* Destination for coroutine B */ + int regAddrA; /* Address register for select-A coroutine */ + int regAddrB; /* Address register for select-B coroutine */ + int addrSelectA; /* Address of the select-A coroutine */ + int addrSelectB; /* Address of the select-B coroutine */ + int regOutA; /* Address register for the output-A subroutine */ + int regOutB; /* Address register for the output-B subroutine */ + int addrOutA; /* Address of the output-A subroutine */ + int addrOutB = 0; /* Address of the output-B subroutine */ + int addrEofA; /* Address of the select-A-exhausted subroutine */ + int addrEofA_noB; /* Alternate addrEofA if B is uninitialized */ + int addrEofB; /* Address of the select-B-exhausted subroutine */ + int addrAltB; /* Address of the AB subroutine */ + int regLimitA; /* Limit register for select-A */ + int regLimitB; /* Limit register for select-A */ + int regPrev; /* A range of registers to hold previous output */ + int savedLimit; /* Saved value of p->iLimit */ + int savedOffset; /* Saved value of p->iOffset */ + int labelCmpr; /* Label for the start of the merge algorithm */ + int labelEnd; /* Label for the end of the overall SELECT stmt */ + int addr1; /* Jump instructions that get retargetted */ + int op; /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */ + KeyInfo *pKeyDup = 0; /* Comparison information for duplicate removal */ + KeyInfo *pKeyMerge; /* Comparison information for merging rows */ + sqlite3 *db; /* Database connection */ + ExprList *pOrderBy; /* The ORDER BY clause */ + int nOrderBy; /* Number of terms in the ORDER BY clause */ + u32 *aPermute; /* Mapping from ORDER BY terms to result set columns */ + + assert( p->pOrderBy!=0 ); + assert( pKeyDup==0 ); /* "Managed" code needs this. Ticket #3382. */ + db = pParse->db; + v = pParse->pVdbe; + assert( v!=0 ); /* Already thrown the error if VDBE alloc failed */ + labelEnd = sqlite3VdbeMakeLabel(pParse); + labelCmpr = sqlite3VdbeMakeLabel(pParse); + + + /* Patch up the ORDER BY clause + */ + op = p->op; + pPrior = p->pPrior; + assert( pPrior->pOrderBy==0 ); + pOrderBy = p->pOrderBy; + assert( pOrderBy ); + nOrderBy = pOrderBy->nExpr; + + /* For operators other than UNION ALL we have to make sure that + ** the ORDER BY clause covers every term of the result set. Add + ** terms to the ORDER BY clause as necessary. + */ + if( op!=TK_ALL ){ + for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){ + struct ExprList_item *pItem; + for(j=0, pItem=pOrderBy->a; ju.x.iOrderByCol>0 ); + if( pItem->u.x.iOrderByCol==i ) break; + } + if( j==nOrderBy ){ + Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0); + if( pNew==0 ) return SQLITE_NOMEM_BKPT; + pNew->flags |= EP_IntValue; + pNew->u.iValue = i; + p->pOrderBy = pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew); + if( pOrderBy ) pOrderBy->a[nOrderBy++].u.x.iOrderByCol = (u16)i; + } + } + } + + /* Compute the comparison permutation and keyinfo that is used with + ** the permutation used to determine if the next + ** row of results comes from selectA or selectB. Also add explicit + ** collations to the ORDER BY clause terms so that when the subqueries + ** to the right and the left are evaluated, they use the correct + ** collation. + */ + aPermute = sqlite3DbMallocRawNN(db, sizeof(u32)*(nOrderBy + 1)); + if( aPermute ){ + struct ExprList_item *pItem; + aPermute[0] = nOrderBy; + for(i=1, pItem=pOrderBy->a; i<=nOrderBy; i++, pItem++){ + assert( pItem->u.x.iOrderByCol>0 ); + assert( pItem->u.x.iOrderByCol<=p->pEList->nExpr ); + aPermute[i] = pItem->u.x.iOrderByCol - 1; + } + pKeyMerge = multiSelectOrderByKeyInfo(pParse, p, 1); + }else{ + pKeyMerge = 0; + } + + /* Reattach the ORDER BY clause to the query. + */ + p->pOrderBy = pOrderBy; + pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0); + + /* Allocate a range of temporary registers and the KeyInfo needed + ** for the logic that removes duplicate result rows when the + ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL). + */ + if( op==TK_ALL ){ + regPrev = 0; + }else{ + int nExpr = p->pEList->nExpr; + assert( nOrderBy>=nExpr || db->mallocFailed ); + regPrev = pParse->nMem+1; + pParse->nMem += nExpr+1; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regPrev); + pKeyDup = sqlite3KeyInfoAlloc(db, nExpr, 1); + if( pKeyDup ){ + assert( sqlite3KeyInfoIsWriteable(pKeyDup) ); + for(i=0; iaColl[i] = multiSelectCollSeq(pParse, p, i); + pKeyDup->aSortFlags[i] = 0; + } + } + } + + /* Separate the left and the right query from one another + */ + p->pPrior = 0; + pPrior->pNext = 0; + sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER"); + if( pPrior->pPrior==0 ){ + sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER"); + } + + /* Compute the limit registers */ + computeLimitRegisters(pParse, p, labelEnd); + if( p->iLimit && op==TK_ALL ){ + regLimitA = ++pParse->nMem; + regLimitB = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit, + regLimitA); + sqlite3VdbeAddOp2(v, OP_Copy, regLimitA, regLimitB); + }else{ + regLimitA = regLimitB = 0; + } + sqlite3ExprDelete(db, p->pLimit); + p->pLimit = 0; + + regAddrA = ++pParse->nMem; + regAddrB = ++pParse->nMem; + regOutA = ++pParse->nMem; + regOutB = ++pParse->nMem; + sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA); + sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB); + + ExplainQueryPlan((pParse, 1, "MERGE (%s)", selectOpName(p->op))); + + /* Generate a coroutine to evaluate the SELECT statement to the + ** left of the compound operator - the "A" select. + */ + addrSelectA = sqlite3VdbeCurrentAddr(v) + 1; + addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrA, 0, addrSelectA); + VdbeComment((v, "left SELECT")); + pPrior->iLimit = regLimitA; + ExplainQueryPlan((pParse, 1, "LEFT")); + sqlite3Select(pParse, pPrior, &destA); + sqlite3VdbeEndCoroutine(v, regAddrA); + sqlite3VdbeJumpHere(v, addr1); + + /* Generate a coroutine to evaluate the SELECT statement on + ** the right - the "B" select + */ + addrSelectB = sqlite3VdbeCurrentAddr(v) + 1; + addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrB, 0, addrSelectB); + VdbeComment((v, "right SELECT")); + savedLimit = p->iLimit; + savedOffset = p->iOffset; + p->iLimit = regLimitB; + p->iOffset = 0; + ExplainQueryPlan((pParse, 1, "RIGHT")); + sqlite3Select(pParse, p, &destB); + p->iLimit = savedLimit; + p->iOffset = savedOffset; + sqlite3VdbeEndCoroutine(v, regAddrB); + + /* Generate a subroutine that outputs the current row of the A + ** select as the next output row of the compound select. + */ + VdbeNoopComment((v, "Output routine for A")); + addrOutA = generateOutputSubroutine(pParse, + p, &destA, pDest, regOutA, + regPrev, pKeyDup, labelEnd); + + /* Generate a subroutine that outputs the current row of the B + ** select as the next output row of the compound select. + */ + if( op==TK_ALL || op==TK_UNION ){ + VdbeNoopComment((v, "Output routine for B")); + addrOutB = generateOutputSubroutine(pParse, + p, &destB, pDest, regOutB, + regPrev, pKeyDup, labelEnd); + } + sqlite3KeyInfoUnref(pKeyDup); + + /* Generate a subroutine to run when the results from select A + ** are exhausted and only data in select B remains. + */ + if( op==TK_EXCEPT || op==TK_INTERSECT ){ + addrEofA_noB = addrEofA = labelEnd; + }else{ + VdbeNoopComment((v, "eof-A subroutine")); + addrEofA = sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB); + addrEofA_noB = sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, labelEnd); + VdbeCoverage(v); + sqlite3VdbeGoto(v, addrEofA); + p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow); + } + + /* Generate a subroutine to run when the results from select B + ** are exhausted and only data in select A remains. + */ + if( op==TK_INTERSECT ){ + addrEofB = addrEofA; + if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow; + }else{ + VdbeNoopComment((v, "eof-B subroutine")); + addrEofB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA); + sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, labelEnd); VdbeCoverage(v); + sqlite3VdbeGoto(v, addrEofB); + } + + /* Generate code to handle the case of AB + */ + VdbeNoopComment((v, "A-gt-B subroutine")); + addrAgtB = sqlite3VdbeCurrentAddr(v); + if( op==TK_ALL || op==TK_UNION ){ + sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB); + } + sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v); + sqlite3VdbeGoto(v, labelCmpr); + + /* This code runs once to initialize everything. + */ + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA_noB); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v); + + /* Implement the main merge loop + */ + sqlite3VdbeResolveLabel(v, labelCmpr); + sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY); + sqlite3VdbeAddOp4(v, OP_Compare, destA.iSdst, destB.iSdst, nOrderBy, + (char*)pKeyMerge, P4_KEYINFO); + sqlite3VdbeChangeP5(v, OPFLAG_PERMUTE); + sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB); VdbeCoverage(v); + + /* Jump to the this point in order to terminate the query. + */ + sqlite3VdbeResolveLabel(v, labelEnd); + + /* Reassembly the compound query so that it will be freed correctly + ** by the calling function */ + if( p->pPrior ){ + sqlite3SelectDelete(db, p->pPrior); + } + p->pPrior = pPrior; + pPrior->pNext = p; + + /*** TBD: Insert subroutine calls to close cursors on incomplete + **** subqueries ****/ + ExplainQueryPlanPop(pParse); + return pParse->nErr!=0; +} +#endif + +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) + +/* An instance of the SubstContext object describes an substitution edit +** to be performed on a parse tree. +** +** All references to columns in table iTable are to be replaced by corresponding +** expressions in pEList. +*/ +typedef struct SubstContext { + Parse *pParse; /* The parsing context */ + int iTable; /* Replace references to this table */ + int iNewTable; /* New table number */ + int isLeftJoin; /* Add TK_IF_NULL_ROW opcodes on each replacement */ + ExprList *pEList; /* Replacement expressions */ +} SubstContext; + +/* Forward Declarations */ +static void substExprList(SubstContext*, ExprList*); +static void substSelect(SubstContext*, Select*, int); + +/* +** Scan through the expression pExpr. Replace every reference to +** a column in table number iTable with a copy of the iColumn-th +** entry in pEList. (But leave references to the ROWID column +** unchanged.) +** +** This routine is part of the flattening procedure. A subquery +** whose result set is defined by pEList appears as entry in the +** FROM clause of a SELECT such that the VDBE cursor assigned to that +** FORM clause entry is iTable. This routine makes the necessary +** changes to pExpr so that it refers directly to the source table +** of the subquery rather the result set of the subquery. +*/ +static Expr *substExpr( + SubstContext *pSubst, /* Description of the substitution */ + Expr *pExpr /* Expr in which substitution occurs */ +){ + if( pExpr==0 ) return 0; + if( ExprHasProperty(pExpr, EP_FromJoin) + && pExpr->iRightJoinTable==pSubst->iTable + ){ + pExpr->iRightJoinTable = pSubst->iNewTable; + } + if( pExpr->op==TK_COLUMN + && pExpr->iTable==pSubst->iTable + && !ExprHasProperty(pExpr, EP_FixedCol) + ){ + if( pExpr->iColumn<0 ){ + pExpr->op = TK_NULL; + }else{ + Expr *pNew; + Expr *pCopy = pSubst->pEList->a[pExpr->iColumn].pExpr; + Expr ifNullRow; + assert( pSubst->pEList!=0 && pExpr->iColumnpEList->nExpr ); + assert( pExpr->pRight==0 ); + if( sqlite3ExprIsVector(pCopy) ){ + sqlite3VectorErrorMsg(pSubst->pParse, pCopy); + }else{ + sqlite3 *db = pSubst->pParse->db; + if( pSubst->isLeftJoin && pCopy->op!=TK_COLUMN ){ + memset(&ifNullRow, 0, sizeof(ifNullRow)); + ifNullRow.op = TK_IF_NULL_ROW; + ifNullRow.pLeft = pCopy; + ifNullRow.iTable = pSubst->iNewTable; + ifNullRow.flags = EP_IfNullRow; + pCopy = &ifNullRow; + } + testcase( ExprHasProperty(pCopy, EP_Subquery) ); + pNew = sqlite3ExprDup(db, pCopy, 0); + if( pNew && pSubst->isLeftJoin ){ + ExprSetProperty(pNew, EP_CanBeNull); + } + if( pNew && ExprHasProperty(pExpr,EP_FromJoin) ){ + sqlite3SetJoinExpr(pNew, pExpr->iRightJoinTable); + } + sqlite3ExprDelete(db, pExpr); + pExpr = pNew; + + /* Ensure that the expression now has an implicit collation sequence, + ** just as it did when it was a column of a view or sub-query. */ + if( pExpr ){ + if( pExpr->op!=TK_COLUMN && pExpr->op!=TK_COLLATE ){ + CollSeq *pColl = sqlite3ExprCollSeq(pSubst->pParse, pExpr); + pExpr = sqlite3ExprAddCollateString(pSubst->pParse, pExpr, + (pColl ? pColl->zName : "BINARY") + ); + } + ExprClearProperty(pExpr, EP_Collate); + } + } + } + }else{ + if( pExpr->op==TK_IF_NULL_ROW && pExpr->iTable==pSubst->iTable ){ + pExpr->iTable = pSubst->iNewTable; + } + pExpr->pLeft = substExpr(pSubst, pExpr->pLeft); + pExpr->pRight = substExpr(pSubst, pExpr->pRight); + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + substSelect(pSubst, pExpr->x.pSelect, 1); + }else{ + substExprList(pSubst, pExpr->x.pList); + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + Window *pWin = pExpr->y.pWin; + pWin->pFilter = substExpr(pSubst, pWin->pFilter); + substExprList(pSubst, pWin->pPartition); + substExprList(pSubst, pWin->pOrderBy); + } +#endif + } + return pExpr; +} +static void substExprList( + SubstContext *pSubst, /* Description of the substitution */ + ExprList *pList /* List to scan and in which to make substitutes */ +){ + int i; + if( pList==0 ) return; + for(i=0; inExpr; i++){ + pList->a[i].pExpr = substExpr(pSubst, pList->a[i].pExpr); + } +} +static void substSelect( + SubstContext *pSubst, /* Description of the substitution */ + Select *p, /* SELECT statement in which to make substitutions */ + int doPrior /* Do substitutes on p->pPrior too */ +){ + SrcList *pSrc; + struct SrcList_item *pItem; + int i; + if( !p ) return; + do{ + substExprList(pSubst, p->pEList); + substExprList(pSubst, p->pGroupBy); + substExprList(pSubst, p->pOrderBy); + p->pHaving = substExpr(pSubst, p->pHaving); + p->pWhere = substExpr(pSubst, p->pWhere); + pSrc = p->pSrc; + assert( pSrc!=0 ); + for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){ + substSelect(pSubst, pItem->pSelect, 1); + if( pItem->fg.isTabFunc ){ + substExprList(pSubst, pItem->u1.pFuncArg); + } + } + }while( doPrior && (p = p->pPrior)!=0 ); +} +#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ + +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) +/* +** pSelect is a SELECT statement and pSrcItem is one item in the FROM +** clause of that SELECT. +** +** This routine scans the entire SELECT statement and recomputes the +** pSrcItem->colUsed mask. +*/ +static int recomputeColumnsUsedExpr(Walker *pWalker, Expr *pExpr){ + struct SrcList_item *pItem; + if( pExpr->op!=TK_COLUMN ) return WRC_Continue; + pItem = pWalker->u.pSrcItem; + if( pItem->iCursor!=pExpr->iTable ) return WRC_Continue; + if( pExpr->iColumn<0 ) return WRC_Continue; + pItem->colUsed |= sqlite3ExprColUsed(pExpr); + return WRC_Continue; +} +static void recomputeColumnsUsed( + Select *pSelect, /* The complete SELECT statement */ + struct SrcList_item *pSrcItem /* Which FROM clause item to recompute */ +){ + Walker w; + if( NEVER(pSrcItem->pTab==0) ) return; + memset(&w, 0, sizeof(w)); + w.xExprCallback = recomputeColumnsUsedExpr; + w.xSelectCallback = sqlite3SelectWalkNoop; + w.u.pSrcItem = pSrcItem; + pSrcItem->colUsed = 0; + sqlite3WalkSelect(&w, pSelect); +} +#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ + +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) +/* +** This routine attempts to flatten subqueries as a performance optimization. +** This routine returns 1 if it makes changes and 0 if no flattening occurs. +** +** To understand the concept of flattening, consider the following +** query: +** +** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5 +** +** The default way of implementing this query is to execute the +** subquery first and store the results in a temporary table, then +** run the outer query on that temporary table. This requires two +** passes over the data. Furthermore, because the temporary table +** has no indices, the WHERE clause on the outer query cannot be +** optimized. +** +** This routine attempts to rewrite queries such as the above into +** a single flat select, like this: +** +** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5 +** +** The code generated for this simplification gives the same result +** but only has to scan the data once. And because indices might +** exist on the table t1, a complete scan of the data might be +** avoided. +** +** Flattening is subject to the following constraints: +** +** (**) We no longer attempt to flatten aggregate subqueries. Was: +** The subquery and the outer query cannot both be aggregates. +** +** (**) We no longer attempt to flatten aggregate subqueries. Was: +** (2) If the subquery is an aggregate then +** (2a) the outer query must not be a join and +** (2b) the outer query must not use subqueries +** other than the one FROM-clause subquery that is a candidate +** for flattening. (This is due to ticket [2f7170d73bf9abf80] +** from 2015-02-09.) +** +** (3) If the subquery is the right operand of a LEFT JOIN then +** (3a) the subquery may not be a join and +** (3b) the FROM clause of the subquery may not contain a virtual +** table and +** (3c) the outer query may not be an aggregate. +** (3d) the outer query may not be DISTINCT. +** +** (4) The subquery can not be DISTINCT. +** +** (**) At one point restrictions (4) and (5) defined a subset of DISTINCT +** sub-queries that were excluded from this optimization. Restriction +** (4) has since been expanded to exclude all DISTINCT subqueries. +** +** (**) We no longer attempt to flatten aggregate subqueries. Was: +** If the subquery is aggregate, the outer query may not be DISTINCT. +** +** (7) The subquery must have a FROM clause. TODO: For subqueries without +** A FROM clause, consider adding a FROM clause with the special +** table sqlite_once that consists of a single row containing a +** single NULL. +** +** (8) If the subquery uses LIMIT then the outer query may not be a join. +** +** (9) If the subquery uses LIMIT then the outer query may not be aggregate. +** +** (**) Restriction (10) was removed from the code on 2005-02-05 but we +** accidently carried the comment forward until 2014-09-15. Original +** constraint: "If the subquery is aggregate then the outer query +** may not use LIMIT." +** +** (11) The subquery and the outer query may not both have ORDER BY clauses. +** +** (**) Not implemented. Subsumed into restriction (3). Was previously +** a separate restriction deriving from ticket #350. +** +** (13) The subquery and outer query may not both use LIMIT. +** +** (14) The subquery may not use OFFSET. +** +** (15) If the outer query is part of a compound select, then the +** subquery may not use LIMIT. +** (See ticket #2339 and ticket [02a8e81d44]). +** +** (16) If the outer query is aggregate, then the subquery may not +** use ORDER BY. (Ticket #2942) This used to not matter +** until we introduced the group_concat() function. +** +** (17) If the subquery is a compound select, then +** (17a) all compound operators must be a UNION ALL, and +** (17b) no terms within the subquery compound may be aggregate +** or DISTINCT, and +** (17c) every term within the subquery compound must have a FROM clause +** (17d) the outer query may not be +** (17d1) aggregate, or +** (17d2) DISTINCT, or +** (17d3) a join. +** (17e) the subquery may not contain window functions +** +** The parent and sub-query may contain WHERE clauses. Subject to +** rules (11), (13) and (14), they may also contain ORDER BY, +** LIMIT and OFFSET clauses. The subquery cannot use any compound +** operator other than UNION ALL because all the other compound +** operators have an implied DISTINCT which is disallowed by +** restriction (4). +** +** Also, each component of the sub-query must return the same number +** of result columns. This is actually a requirement for any compound +** SELECT statement, but all the code here does is make sure that no +** such (illegal) sub-query is flattened. The caller will detect the +** syntax error and return a detailed message. +** +** (18) If the sub-query is a compound select, then all terms of the +** ORDER BY clause of the parent must be simple references to +** columns of the sub-query. +** +** (19) If the subquery uses LIMIT then the outer query may not +** have a WHERE clause. +** +** (20) If the sub-query is a compound select, then it must not use +** an ORDER BY clause. Ticket #3773. We could relax this constraint +** somewhat by saying that the terms of the ORDER BY clause must +** appear as unmodified result columns in the outer query. But we +** have other optimizations in mind to deal with that case. +** +** (21) If the subquery uses LIMIT then the outer query may not be +** DISTINCT. (See ticket [752e1646fc]). +** +** (22) The subquery may not be a recursive CTE. +** +** (**) Subsumed into restriction (17d3). Was: If the outer query is +** a recursive CTE, then the sub-query may not be a compound query. +** This restriction is because transforming the +** parent to a compound query confuses the code that handles +** recursive queries in multiSelect(). +** +** (**) We no longer attempt to flatten aggregate subqueries. Was: +** The subquery may not be an aggregate that uses the built-in min() or +** or max() functions. (Without this restriction, a query like: +** "SELECT x FROM (SELECT max(y), x FROM t1)" would not necessarily +** return the value X for which Y was maximal.) +** +** (25) If either the subquery or the parent query contains a window +** function in the select list or ORDER BY clause, flattening +** is not attempted. +** +** +** In this routine, the "p" parameter is a pointer to the outer query. +** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query +** uses aggregates. +** +** If flattening is not attempted, this routine is a no-op and returns 0. +** If flattening is attempted this routine returns 1. +** +** All of the expression analysis must occur on both the outer query and +** the subquery before this routine runs. +*/ +static int flattenSubquery( + Parse *pParse, /* Parsing context */ + Select *p, /* The parent or outer SELECT statement */ + int iFrom, /* Index in p->pSrc->a[] of the inner subquery */ + int isAgg /* True if outer SELECT uses aggregate functions */ +){ + const char *zSavedAuthContext = pParse->zAuthContext; + Select *pParent; /* Current UNION ALL term of the other query */ + Select *pSub; /* The inner query or "subquery" */ + Select *pSub1; /* Pointer to the rightmost select in sub-query */ + SrcList *pSrc; /* The FROM clause of the outer query */ + SrcList *pSubSrc; /* The FROM clause of the subquery */ + int iParent; /* VDBE cursor number of the pSub result set temp table */ + int iNewParent = -1;/* Replacement table for iParent */ + int isLeftJoin = 0; /* True if pSub is the right side of a LEFT JOIN */ + int i; /* Loop counter */ + Expr *pWhere; /* The WHERE clause */ + struct SrcList_item *pSubitem; /* The subquery */ + sqlite3 *db = pParse->db; + Walker w; /* Walker to persist agginfo data */ + + /* Check to see if flattening is permitted. Return 0 if not. + */ + assert( p!=0 ); + assert( p->pPrior==0 ); + if( OptimizationDisabled(db, SQLITE_QueryFlattener) ) return 0; + pSrc = p->pSrc; + assert( pSrc && iFrom>=0 && iFromnSrc ); + pSubitem = &pSrc->a[iFrom]; + iParent = pSubitem->iCursor; + pSub = pSubitem->pSelect; + assert( pSub!=0 ); + +#ifndef SQLITE_OMIT_WINDOWFUNC + if( p->pWin || pSub->pWin ) return 0; /* Restriction (25) */ +#endif + + pSubSrc = pSub->pSrc; + assert( pSubSrc ); + /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants, + ** not arbitrary expressions, we allowed some combining of LIMIT and OFFSET + ** because they could be computed at compile-time. But when LIMIT and OFFSET + ** became arbitrary expressions, we were forced to add restrictions (13) + ** and (14). */ + if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */ + if( pSub->pLimit && pSub->pLimit->pRight ) return 0; /* Restriction (14) */ + if( (p->selFlags & SF_Compound)!=0 && pSub->pLimit ){ + return 0; /* Restriction (15) */ + } + if( pSubSrc->nSrc==0 ) return 0; /* Restriction (7) */ + if( pSub->selFlags & SF_Distinct ) return 0; /* Restriction (4) */ + if( pSub->pLimit && (pSrc->nSrc>1 || isAgg) ){ + return 0; /* Restrictions (8)(9) */ + } + if( p->pOrderBy && pSub->pOrderBy ){ + return 0; /* Restriction (11) */ + } + if( isAgg && pSub->pOrderBy ) return 0; /* Restriction (16) */ + if( pSub->pLimit && p->pWhere ) return 0; /* Restriction (19) */ + if( pSub->pLimit && (p->selFlags & SF_Distinct)!=0 ){ + return 0; /* Restriction (21) */ + } + if( pSub->selFlags & (SF_Recursive) ){ + return 0; /* Restrictions (22) */ + } + + /* + ** If the subquery is the right operand of a LEFT JOIN, then the + ** subquery may not be a join itself (3a). Example of why this is not + ** allowed: + ** + ** t1 LEFT OUTER JOIN (t2 JOIN t3) + ** + ** If we flatten the above, we would get + ** + ** (t1 LEFT OUTER JOIN t2) JOIN t3 + ** + ** which is not at all the same thing. + ** + ** If the subquery is the right operand of a LEFT JOIN, then the outer + ** query cannot be an aggregate. (3c) This is an artifact of the way + ** aggregates are processed - there is no mechanism to determine if + ** the LEFT JOIN table should be all-NULL. + ** + ** See also tickets #306, #350, and #3300. + */ + if( (pSubitem->fg.jointype & JT_OUTER)!=0 ){ + isLeftJoin = 1; + if( pSubSrc->nSrc>1 /* (3a) */ + || isAgg /* (3b) */ + || IsVirtual(pSubSrc->a[0].pTab) /* (3c) */ + || (p->selFlags & SF_Distinct)!=0 /* (3d) */ + ){ + return 0; + } + } +#ifdef SQLITE_EXTRA_IFNULLROW + else if( iFrom>0 && !isAgg ){ + /* Setting isLeftJoin to -1 causes OP_IfNullRow opcodes to be generated for + ** every reference to any result column from subquery in a join, even + ** though they are not necessary. This will stress-test the OP_IfNullRow + ** opcode. */ + isLeftJoin = -1; + } +#endif + + /* Restriction (17): If the sub-query is a compound SELECT, then it must + ** use only the UNION ALL operator. And none of the simple select queries + ** that make up the compound SELECT are allowed to be aggregate or distinct + ** queries. + */ + if( pSub->pPrior ){ + if( pSub->pOrderBy ){ + return 0; /* Restriction (20) */ + } + if( isAgg || (p->selFlags & SF_Distinct)!=0 || pSrc->nSrc!=1 ){ + return 0; /* (17d1), (17d2), or (17d3) */ + } + for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){ + testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct ); + testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate ); + assert( pSub->pSrc!=0 ); + assert( pSub->pEList->nExpr==pSub1->pEList->nExpr ); + if( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))!=0 /* (17b) */ + || (pSub1->pPrior && pSub1->op!=TK_ALL) /* (17a) */ + || pSub1->pSrc->nSrc<1 /* (17c) */ +#ifndef SQLITE_OMIT_WINDOWFUNC + || pSub1->pWin /* (17e) */ +#endif + ){ + return 0; + } + testcase( pSub1->pSrc->nSrc>1 ); + } + + /* Restriction (18). */ + if( p->pOrderBy ){ + int ii; + for(ii=0; iipOrderBy->nExpr; ii++){ + if( p->pOrderBy->a[ii].u.x.iOrderByCol==0 ) return 0; + } + } + } + + /* Ex-restriction (23): + ** The only way that the recursive part of a CTE can contain a compound + ** subquery is for the subquery to be one term of a join. But if the + ** subquery is a join, then the flattening has already been stopped by + ** restriction (17d3) + */ + assert( (p->selFlags & SF_Recursive)==0 || pSub->pPrior==0 ); + + /***** If we reach this point, flattening is permitted. *****/ + SELECTTRACE(1,pParse,p,("flatten %u.%p from term %d\n", + pSub->selId, pSub, iFrom)); + + /* Authorize the subquery */ + pParse->zAuthContext = pSubitem->zName; + TESTONLY(i =) sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0); + testcase( i==SQLITE_DENY ); + pParse->zAuthContext = zSavedAuthContext; + + /* If the sub-query is a compound SELECT statement, then (by restrictions + ** 17 and 18 above) it must be a UNION ALL and the parent query must + ** be of the form: + ** + ** SELECT FROM () + ** + ** followed by any ORDER BY, LIMIT and/or OFFSET clauses. This block + ** creates N-1 copies of the parent query without any ORDER BY, LIMIT or + ** OFFSET clauses and joins them to the left-hand-side of the original + ** using UNION ALL operators. In this case N is the number of simple + ** select statements in the compound sub-query. + ** + ** Example: + ** + ** SELECT a+1 FROM ( + ** SELECT x FROM tab + ** UNION ALL + ** SELECT y FROM tab + ** UNION ALL + ** SELECT abs(z*2) FROM tab2 + ** ) WHERE a!=5 ORDER BY 1 + ** + ** Transformed into: + ** + ** SELECT x+1 FROM tab WHERE x+1!=5 + ** UNION ALL + ** SELECT y+1 FROM tab WHERE y+1!=5 + ** UNION ALL + ** SELECT abs(z*2)+1 FROM tab2 WHERE abs(z*2)+1!=5 + ** ORDER BY 1 + ** + ** We call this the "compound-subquery flattening". + */ + for(pSub=pSub->pPrior; pSub; pSub=pSub->pPrior){ + Select *pNew; + ExprList *pOrderBy = p->pOrderBy; + Expr *pLimit = p->pLimit; + Select *pPrior = p->pPrior; + p->pOrderBy = 0; + p->pSrc = 0; + p->pPrior = 0; + p->pLimit = 0; + pNew = sqlite3SelectDup(db, p, 0); + p->pLimit = pLimit; + p->pOrderBy = pOrderBy; + p->pSrc = pSrc; + p->op = TK_ALL; + if( pNew==0 ){ + p->pPrior = pPrior; + }else{ + pNew->pPrior = pPrior; + if( pPrior ) pPrior->pNext = pNew; + pNew->pNext = p; + p->pPrior = pNew; + SELECTTRACE(2,pParse,p,("compound-subquery flattener" + " creates %u as peer\n",pNew->selId)); + } + if( db->mallocFailed ) return 1; + } + + /* Begin flattening the iFrom-th entry of the FROM clause + ** in the outer query. + */ + pSub = pSub1 = pSubitem->pSelect; + + /* Delete the transient table structure associated with the + ** subquery + */ + sqlite3DbFree(db, pSubitem->zDatabase); + sqlite3DbFree(db, pSubitem->zName); + sqlite3DbFree(db, pSubitem->zAlias); + pSubitem->zDatabase = 0; + pSubitem->zName = 0; + pSubitem->zAlias = 0; + pSubitem->pSelect = 0; + + /* Defer deleting the Table object associated with the + ** subquery until code generation is + ** complete, since there may still exist Expr.pTab entries that + ** refer to the subquery even after flattening. Ticket #3346. + ** + ** pSubitem->pTab is always non-NULL by test restrictions and tests above. + */ + if( ALWAYS(pSubitem->pTab!=0) ){ + Table *pTabToDel = pSubitem->pTab; + if( pTabToDel->nTabRef==1 ){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + pTabToDel->pNextZombie = pToplevel->pZombieTab; + pToplevel->pZombieTab = pTabToDel; + }else{ + pTabToDel->nTabRef--; + } + pSubitem->pTab = 0; + } + + /* The following loop runs once for each term in a compound-subquery + ** flattening (as described above). If we are doing a different kind + ** of flattening - a flattening other than a compound-subquery flattening - + ** then this loop only runs once. + ** + ** This loop moves all of the FROM elements of the subquery into the + ** the FROM clause of the outer query. Before doing this, remember + ** the cursor number for the original outer query FROM element in + ** iParent. The iParent cursor will never be used. Subsequent code + ** will scan expressions looking for iParent references and replace + ** those references with expressions that resolve to the subquery FROM + ** elements we are now copying in. + */ + for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){ + int nSubSrc; + u8 jointype = 0; + assert( pSub!=0 ); + pSubSrc = pSub->pSrc; /* FROM clause of subquery */ + nSubSrc = pSubSrc->nSrc; /* Number of terms in subquery FROM clause */ + pSrc = pParent->pSrc; /* FROM clause of the outer query */ + + if( pSrc ){ + assert( pParent==p ); /* First time through the loop */ + jointype = pSubitem->fg.jointype; + }else{ + assert( pParent!=p ); /* 2nd and subsequent times through the loop */ + pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); + if( pSrc==0 ) break; + pParent->pSrc = pSrc; + } + + /* The subquery uses a single slot of the FROM clause of the outer + ** query. If the subquery has more than one element in its FROM clause, + ** then expand the outer query to make space for it to hold all elements + ** of the subquery. + ** + ** Example: + ** + ** SELECT * FROM tabA, (SELECT * FROM sub1, sub2), tabB; + ** + ** The outer query has 3 slots in its FROM clause. One slot of the + ** outer query (the middle slot) is used by the subquery. The next + ** block of code will expand the outer query FROM clause to 4 slots. + ** The middle slot is expanded to two slots in order to make space + ** for the two elements in the FROM clause of the subquery. + */ + if( nSubSrc>1 ){ + pSrc = sqlite3SrcListEnlarge(pParse, pSrc, nSubSrc-1,iFrom+1); + if( pSrc==0 ) break; + pParent->pSrc = pSrc; + } + + /* Transfer the FROM clause terms from the subquery into the + ** outer query. + */ + for(i=0; ia[i+iFrom].pUsing); + assert( pSrc->a[i+iFrom].fg.isTabFunc==0 ); + pSrc->a[i+iFrom] = pSubSrc->a[i]; + iNewParent = pSubSrc->a[i].iCursor; + memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i])); + } + pSrc->a[iFrom].fg.jointype = jointype; + + /* Now begin substituting subquery result set expressions for + ** references to the iParent in the outer query. + ** + ** Example: + ** + ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b; + ** \ \_____________ subquery __________/ / + ** \_____________________ outer query ______________________________/ + ** + ** We look at every expression in the outer query and every place we see + ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10". + */ + if( pSub->pOrderBy && (pParent->selFlags & SF_NoopOrderBy)==0 ){ + /* At this point, any non-zero iOrderByCol values indicate that the + ** ORDER BY column expression is identical to the iOrderByCol'th + ** expression returned by SELECT statement pSub. Since these values + ** do not necessarily correspond to columns in SELECT statement pParent, + ** zero them before transfering the ORDER BY clause. + ** + ** Not doing this may cause an error if a subsequent call to this + ** function attempts to flatten a compound sub-query into pParent + ** (the only way this can happen is if the compound sub-query is + ** currently part of pSub->pSrc). See ticket [d11a6e908f]. */ + ExprList *pOrderBy = pSub->pOrderBy; + for(i=0; inExpr; i++){ + pOrderBy->a[i].u.x.iOrderByCol = 0; + } + assert( pParent->pOrderBy==0 ); + pParent->pOrderBy = pOrderBy; + pSub->pOrderBy = 0; + } + pWhere = pSub->pWhere; + pSub->pWhere = 0; + if( isLeftJoin>0 ){ + sqlite3SetJoinExpr(pWhere, iNewParent); + } + if( pWhere ){ + if( pParent->pWhere ){ + pParent->pWhere = sqlite3PExpr(pParse, TK_AND, pWhere, pParent->pWhere); + }else{ + pParent->pWhere = pWhere; + } + } + if( db->mallocFailed==0 ){ + SubstContext x; + x.pParse = pParse; + x.iTable = iParent; + x.iNewTable = iNewParent; + x.isLeftJoin = isLeftJoin; + x.pEList = pSub->pEList; + substSelect(&x, pParent, 0); + } + + /* The flattened query is a compound if either the inner or the + ** outer query is a compound. */ + pParent->selFlags |= pSub->selFlags & SF_Compound; + assert( (pSub->selFlags & SF_Distinct)==0 ); /* restriction (17b) */ + + /* + ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y; + ** + ** One is tempted to try to add a and b to combine the limits. But this + ** does not work if either limit is negative. + */ + if( pSub->pLimit ){ + pParent->pLimit = pSub->pLimit; + pSub->pLimit = 0; + } + + /* Recompute the SrcList_item.colUsed masks for the flattened + ** tables. */ + for(i=0; ia[i+iFrom]); + } + } + + /* Finially, delete what is left of the subquery and return + ** success. + */ + sqlite3AggInfoPersistWalkerInit(&w, pParse); + sqlite3WalkSelect(&w,pSub1); + sqlite3SelectDelete(db, pSub1); + +#if SELECTTRACE_ENABLED + if( sqlite3_unsupported_selecttrace & 0x100 ){ + SELECTTRACE(0x100,pParse,p,("After flattening:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + + return 1; +} +#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ + +/* +** A structure to keep track of all of the column values that are fixed to +** a known value due to WHERE clause constraints of the form COLUMN=VALUE. +*/ +typedef struct WhereConst WhereConst; +struct WhereConst { + Parse *pParse; /* Parsing context */ + int nConst; /* Number for COLUMN=CONSTANT terms */ + int nChng; /* Number of times a constant is propagated */ + Expr **apExpr; /* [i*2] is COLUMN and [i*2+1] is VALUE */ +}; + +/* +** Add a new entry to the pConst object. Except, do not add duplicate +** pColumn entires. Also, do not add if doing so would not be appropriate. +** +** The caller guarantees the pColumn is a column and pValue is a constant. +** This routine has to do some additional checks before completing the +** insert. +*/ +static void constInsert( + WhereConst *pConst, /* The WhereConst into which we are inserting */ + Expr *pColumn, /* The COLUMN part of the constraint */ + Expr *pValue, /* The VALUE part of the constraint */ + Expr *pExpr /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */ +){ + int i; + assert( pColumn->op==TK_COLUMN ); + assert( sqlite3ExprIsConstant(pValue) ); + + if( ExprHasProperty(pColumn, EP_FixedCol) ) return; + if( sqlite3ExprAffinity(pValue)!=0 ) return; + if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){ + return; + } + + /* 2018-10-25 ticket [cf5ed20f] + ** Make sure the same pColumn is not inserted more than once */ + for(i=0; inConst; i++){ + const Expr *pE2 = pConst->apExpr[i*2]; + assert( pE2->op==TK_COLUMN ); + if( pE2->iTable==pColumn->iTable + && pE2->iColumn==pColumn->iColumn + ){ + return; /* Already present. Return without doing anything. */ + } + } + + pConst->nConst++; + pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr, + pConst->nConst*2*sizeof(Expr*)); + if( pConst->apExpr==0 ){ + pConst->nConst = 0; + }else{ + pConst->apExpr[pConst->nConst*2-2] = pColumn; + pConst->apExpr[pConst->nConst*2-1] = pValue; + } +} + +/* +** Find all terms of COLUMN=VALUE or VALUE=COLUMN in pExpr where VALUE +** is a constant expression and where the term must be true because it +** is part of the AND-connected terms of the expression. For each term +** found, add it to the pConst structure. +*/ +static void findConstInWhere(WhereConst *pConst, Expr *pExpr){ + Expr *pRight, *pLeft; + if( pExpr==0 ) return; + if( ExprHasProperty(pExpr, EP_FromJoin) ) return; + if( pExpr->op==TK_AND ){ + findConstInWhere(pConst, pExpr->pRight); + findConstInWhere(pConst, pExpr->pLeft); + return; + } + if( pExpr->op!=TK_EQ ) return; + pRight = pExpr->pRight; + pLeft = pExpr->pLeft; + assert( pRight!=0 ); + assert( pLeft!=0 ); + if( pRight->op==TK_COLUMN && sqlite3ExprIsConstant(pLeft) ){ + constInsert(pConst,pRight,pLeft,pExpr); + } + if( pLeft->op==TK_COLUMN && sqlite3ExprIsConstant(pRight) ){ + constInsert(pConst,pLeft,pRight,pExpr); + } +} + +/* +** This is a Walker expression callback. pExpr is a candidate expression +** to be replaced by a value. If pExpr is equivalent to one of the +** columns named in pWalker->u.pConst, then overwrite it with its +** corresponding value. +*/ +static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){ + int i; + WhereConst *pConst; + if( pExpr->op!=TK_COLUMN ) return WRC_Continue; + if( ExprHasProperty(pExpr, EP_FixedCol|EP_FromJoin) ){ + testcase( ExprHasProperty(pExpr, EP_FixedCol) ); + testcase( ExprHasProperty(pExpr, EP_FromJoin) ); + return WRC_Continue; + } + pConst = pWalker->u.pConst; + for(i=0; inConst; i++){ + Expr *pColumn = pConst->apExpr[i*2]; + if( pColumn==pExpr ) continue; + if( pColumn->iTable!=pExpr->iTable ) continue; + if( pColumn->iColumn!=pExpr->iColumn ) continue; + /* A match is found. Add the EP_FixedCol property */ + pConst->nChng++; + ExprClearProperty(pExpr, EP_Leaf); + ExprSetProperty(pExpr, EP_FixedCol); + assert( pExpr->pLeft==0 ); + pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0); + break; + } + return WRC_Prune; +} + +/* +** The WHERE-clause constant propagation optimization. +** +** If the WHERE clause contains terms of the form COLUMN=CONSTANT or +** CONSTANT=COLUMN that are top-level AND-connected terms that are not +** part of a ON clause from a LEFT JOIN, then throughout the query +** replace all other occurrences of COLUMN with CONSTANT. +** +** For example, the query: +** +** SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=t1.a AND t3.c=t2.b +** +** Is transformed into +** +** SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=39 AND t3.c=39 +** +** Return true if any transformations where made and false if not. +** +** Implementation note: Constant propagation is tricky due to affinity +** and collating sequence interactions. Consider this example: +** +** CREATE TABLE t1(a INT,b TEXT); +** INSERT INTO t1 VALUES(123,'0123'); +** SELECT * FROM t1 WHERE a=123 AND b=a; +** SELECT * FROM t1 WHERE a=123 AND b=123; +** +** The two SELECT statements above should return different answers. b=a +** is alway true because the comparison uses numeric affinity, but b=123 +** is false because it uses text affinity and '0123' is not the same as '123'. +** To work around this, the expression tree is not actually changed from +** "b=a" to "b=123" but rather the "a" in "b=a" is tagged with EP_FixedCol +** and the "123" value is hung off of the pLeft pointer. Code generator +** routines know to generate the constant "123" instead of looking up the +** column value. Also, to avoid collation problems, this optimization is +** only attempted if the "a=123" term uses the default BINARY collation. +*/ +static int propagateConstants( + Parse *pParse, /* The parsing context */ + Select *p /* The query in which to propagate constants */ +){ + WhereConst x; + Walker w; + int nChng = 0; + x.pParse = pParse; + do{ + x.nConst = 0; + x.nChng = 0; + x.apExpr = 0; + findConstInWhere(&x, p->pWhere); + if( x.nConst ){ + memset(&w, 0, sizeof(w)); + w.pParse = pParse; + w.xExprCallback = propagateConstantExprRewrite; + w.xSelectCallback = sqlite3SelectWalkNoop; + w.xSelectCallback2 = 0; + w.walkerDepth = 0; + w.u.pConst = &x; + sqlite3WalkExpr(&w, p->pWhere); + sqlite3DbFree(x.pParse->db, x.apExpr); + nChng += x.nChng; + } + }while( x.nChng ); + return nChng; +} + +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) +/* +** Make copies of relevant WHERE clause terms of the outer query into +** the WHERE clause of subquery. Example: +** +** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1) WHERE x=5 AND y=10; +** +** Transformed into: +** +** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1 WHERE a=5 AND c-d=10) +** WHERE x=5 AND y=10; +** +** The hope is that the terms added to the inner query will make it more +** efficient. +** +** Do not attempt this optimization if: +** +** (1) (** This restriction was removed on 2017-09-29. We used to +** disallow this optimization for aggregate subqueries, but now +** it is allowed by putting the extra terms on the HAVING clause. +** The added HAVING clause is pointless if the subquery lacks +** a GROUP BY clause. But such a HAVING clause is also harmless +** so there does not appear to be any reason to add extra logic +** to suppress it. **) +** +** (2) The inner query is the recursive part of a common table expression. +** +** (3) The inner query has a LIMIT clause (since the changes to the WHERE +** clause would change the meaning of the LIMIT). +** +** (4) The inner query is the right operand of a LEFT JOIN and the +** expression to be pushed down does not come from the ON clause +** on that LEFT JOIN. +** +** (5) The WHERE clause expression originates in the ON or USING clause +** of a LEFT JOIN where iCursor is not the right-hand table of that +** left join. An example: +** +** SELECT * +** FROM (SELECT 1 AS a1 UNION ALL SELECT 2) AS aa +** JOIN (SELECT 1 AS b2 UNION ALL SELECT 2) AS bb ON (a1=b2) +** LEFT JOIN (SELECT 8 AS c3 UNION ALL SELECT 9) AS cc ON (b2=2); +** +** The correct answer is three rows: (1,1,NULL),(2,2,8),(2,2,9). +** But if the (b2=2) term were to be pushed down into the bb subquery, +** then the (1,1,NULL) row would be suppressed. +** +** (6) The inner query features one or more window-functions (since +** changes to the WHERE clause of the inner query could change the +** window over which window functions are calculated). +** +** Return 0 if no changes are made and non-zero if one or more WHERE clause +** terms are duplicated into the subquery. +*/ +static int pushDownWhereTerms( + Parse *pParse, /* Parse context (for malloc() and error reporting) */ + Select *pSubq, /* The subquery whose WHERE clause is to be augmented */ + Expr *pWhere, /* The WHERE clause of the outer query */ + int iCursor, /* Cursor number of the subquery */ + int isLeftJoin /* True if pSubq is the right term of a LEFT JOIN */ +){ + Expr *pNew; + int nChng = 0; + Select *pSel; + if( pWhere==0 ) return 0; + if( pSubq->selFlags & SF_Recursive ) return 0; /* restriction (2) */ + +#ifndef SQLITE_OMIT_WINDOWFUNC + for(pSel=pSubq; pSel; pSel=pSel->pPrior){ + if( pSel->pWin ) return 0; /* restriction (6) */ + } +#endif + +#ifdef SQLITE_DEBUG + /* Only the first term of a compound can have a WITH clause. But make + ** sure no other terms are marked SF_Recursive in case something changes + ** in the future. + */ + { + Select *pX; + for(pX=pSubq; pX; pX=pX->pPrior){ + assert( (pX->selFlags & (SF_Recursive))==0 ); + } + } +#endif + + if( pSubq->pLimit!=0 ){ + return 0; /* restriction (3) */ + } + while( pWhere->op==TK_AND ){ + nChng += pushDownWhereTerms(pParse, pSubq, pWhere->pRight, + iCursor, isLeftJoin); + pWhere = pWhere->pLeft; + } + if( isLeftJoin + && (ExprHasProperty(pWhere,EP_FromJoin)==0 + || pWhere->iRightJoinTable!=iCursor) + ){ + return 0; /* restriction (4) */ + } + if( ExprHasProperty(pWhere,EP_FromJoin) && pWhere->iRightJoinTable!=iCursor ){ + return 0; /* restriction (5) */ + } + if( sqlite3ExprIsTableConstant(pWhere, iCursor) ){ + nChng++; + while( pSubq ){ + SubstContext x; + pNew = sqlite3ExprDup(pParse->db, pWhere, 0); + unsetJoinExpr(pNew, -1); + x.pParse = pParse; + x.iTable = iCursor; + x.iNewTable = iCursor; + x.isLeftJoin = 0; + x.pEList = pSubq->pEList; + pNew = substExpr(&x, pNew); + if( pSubq->selFlags & SF_Aggregate ){ + pSubq->pHaving = sqlite3ExprAnd(pParse, pSubq->pHaving, pNew); + }else{ + pSubq->pWhere = sqlite3ExprAnd(pParse, pSubq->pWhere, pNew); + } + pSubq = pSubq->pPrior; + } + } + return nChng; +} +#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ + +/* +** The pFunc is the only aggregate function in the query. Check to see +** if the query is a candidate for the min/max optimization. +** +** If the query is a candidate for the min/max optimization, then set +** *ppMinMax to be an ORDER BY clause to be used for the optimization +** and return either WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX depending on +** whether pFunc is a min() or max() function. +** +** If the query is not a candidate for the min/max optimization, return +** WHERE_ORDERBY_NORMAL (which must be zero). +** +** This routine must be called after aggregate functions have been +** located but before their arguments have been subjected to aggregate +** analysis. +*/ +static u8 minMaxQuery(sqlite3 *db, Expr *pFunc, ExprList **ppMinMax){ + int eRet = WHERE_ORDERBY_NORMAL; /* Return value */ + ExprList *pEList = pFunc->x.pList; /* Arguments to agg function */ + const char *zFunc; /* Name of aggregate function pFunc */ + ExprList *pOrderBy; + u8 sortFlags = 0; + + assert( *ppMinMax==0 ); + assert( pFunc->op==TK_AGG_FUNCTION ); + assert( !IsWindowFunc(pFunc) ); + if( pEList==0 || pEList->nExpr!=1 || ExprHasProperty(pFunc, EP_WinFunc) ){ + return eRet; + } + zFunc = pFunc->u.zToken; + if( sqlite3StrICmp(zFunc, "min")==0 ){ + eRet = WHERE_ORDERBY_MIN; + if( sqlite3ExprCanBeNull(pEList->a[0].pExpr) ){ + sortFlags = KEYINFO_ORDER_BIGNULL; + } + }else if( sqlite3StrICmp(zFunc, "max")==0 ){ + eRet = WHERE_ORDERBY_MAX; + sortFlags = KEYINFO_ORDER_DESC; + }else{ + return eRet; + } + *ppMinMax = pOrderBy = sqlite3ExprListDup(db, pEList, 0); + assert( pOrderBy!=0 || db->mallocFailed ); + if( pOrderBy ) pOrderBy->a[0].sortFlags = sortFlags; + return eRet; +} + +/* +** The select statement passed as the first argument is an aggregate query. +** The second argument is the associated aggregate-info object. This +** function tests if the SELECT is of the form: +** +** SELECT count(*) FROM +** +** where table is a database table, not a sub-select or view. If the query +** does match this pattern, then a pointer to the Table object representing +** is returned. Otherwise, 0 is returned. +*/ +static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){ + Table *pTab; + Expr *pExpr; + + assert( !p->pGroupBy ); + + if( p->pWhere || p->pEList->nExpr!=1 + || p->pSrc->nSrc!=1 || p->pSrc->a[0].pSelect + ){ + return 0; + } + pTab = p->pSrc->a[0].pTab; + pExpr = p->pEList->a[0].pExpr; + assert( pTab && !pTab->pSelect && pExpr ); + + if( IsVirtual(pTab) ) return 0; + if( pExpr->op!=TK_AGG_FUNCTION ) return 0; + if( NEVER(pAggInfo->nFunc==0) ) return 0; + if( (pAggInfo->aFunc[0].pFunc->funcFlags&SQLITE_FUNC_COUNT)==0 ) return 0; + if( ExprHasProperty(pExpr, EP_Distinct|EP_WinFunc) ) return 0; + + return pTab; +} + +/* +** If the source-list item passed as an argument was augmented with an +** INDEXED BY clause, then try to locate the specified index. If there +** was such a clause and the named index cannot be found, return +** SQLITE_ERROR and leave an error in pParse. Otherwise, populate +** pFrom->pIndex and return SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, struct SrcList_item *pFrom){ + if( pFrom->pTab && pFrom->fg.isIndexedBy ){ + Table *pTab = pFrom->pTab; + char *zIndexedBy = pFrom->u1.zIndexedBy; + Index *pIdx; + for(pIdx=pTab->pIndex; + pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy); + pIdx=pIdx->pNext + ); + if( !pIdx ){ + sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy, 0); + pParse->checkSchema = 1; + return SQLITE_ERROR; + } + pFrom->pIBIndex = pIdx; + } + return SQLITE_OK; +} +/* +** Detect compound SELECT statements that use an ORDER BY clause with +** an alternative collating sequence. +** +** SELECT ... FROM t1 EXCEPT SELECT ... FROM t2 ORDER BY .. COLLATE ... +** +** These are rewritten as a subquery: +** +** SELECT * FROM (SELECT ... FROM t1 EXCEPT SELECT ... FROM t2) +** ORDER BY ... COLLATE ... +** +** This transformation is necessary because the multiSelectOrderBy() routine +** above that generates the code for a compound SELECT with an ORDER BY clause +** uses a merge algorithm that requires the same collating sequence on the +** result columns as on the ORDER BY clause. See ticket +** http://www.sqlite.org/src/info/6709574d2a +** +** This transformation is only needed for EXCEPT, INTERSECT, and UNION. +** The UNION ALL operator works fine with multiSelectOrderBy() even when +** there are COLLATE terms in the ORDER BY. +*/ +static int convertCompoundSelectToSubquery(Walker *pWalker, Select *p){ + int i; + Select *pNew; + Select *pX; + sqlite3 *db; + struct ExprList_item *a; + SrcList *pNewSrc; + Parse *pParse; + Token dummy; + + if( p->pPrior==0 ) return WRC_Continue; + if( p->pOrderBy==0 ) return WRC_Continue; + for(pX=p; pX && (pX->op==TK_ALL || pX->op==TK_SELECT); pX=pX->pPrior){} + if( pX==0 ) return WRC_Continue; + a = p->pOrderBy->a; +#ifndef SQLITE_OMIT_WINDOWFUNC + /* If iOrderByCol is already non-zero, then it has already been matched + ** to a result column of the SELECT statement. This occurs when the + ** SELECT is rewritten for window-functions processing and then passed + ** to sqlite3SelectPrep() and similar a second time. The rewriting done + ** by this function is not required in this case. */ + if( a[0].u.x.iOrderByCol ) return WRC_Continue; +#endif + for(i=p->pOrderBy->nExpr-1; i>=0; i--){ + if( a[i].pExpr->flags & EP_Collate ) break; + } + if( i<0 ) return WRC_Continue; + + /* If we reach this point, that means the transformation is required. */ + + pParse = pWalker->pParse; + db = pParse->db; + pNew = sqlite3DbMallocZero(db, sizeof(*pNew) ); + if( pNew==0 ) return WRC_Abort; + memset(&dummy, 0, sizeof(dummy)); + pNewSrc = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&dummy,pNew,0,0); + if( pNewSrc==0 ) return WRC_Abort; + *pNew = *p; + p->pSrc = pNewSrc; + p->pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ASTERISK, 0)); + p->op = TK_SELECT; + p->pWhere = 0; + pNew->pGroupBy = 0; + pNew->pHaving = 0; + pNew->pOrderBy = 0; + p->pPrior = 0; + p->pNext = 0; + p->pWith = 0; +#ifndef SQLITE_OMIT_WINDOWFUNC + p->pWinDefn = 0; +#endif + p->selFlags &= ~SF_Compound; + assert( (p->selFlags & SF_Converted)==0 ); + p->selFlags |= SF_Converted; + assert( pNew->pPrior!=0 ); + pNew->pPrior->pNext = pNew; + pNew->pLimit = 0; + return WRC_Continue; +} + +/* +** Check to see if the FROM clause term pFrom has table-valued function +** arguments. If it does, leave an error message in pParse and return +** non-zero, since pFrom is not allowed to be a table-valued function. +*/ +static int cannotBeFunction(Parse *pParse, struct SrcList_item *pFrom){ + if( pFrom->fg.isTabFunc ){ + sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName); + return 1; + } + return 0; +} + +#ifndef SQLITE_OMIT_CTE +/* +** Argument pWith (which may be NULL) points to a linked list of nested +** WITH contexts, from inner to outermost. If the table identified by +** FROM clause element pItem is really a common-table-expression (CTE) +** then return a pointer to the CTE definition for that table. Otherwise +** return NULL. +** +** If a non-NULL value is returned, set *ppContext to point to the With +** object that the returned CTE belongs to. +*/ +static struct Cte *searchWith( + With *pWith, /* Current innermost WITH clause */ + struct SrcList_item *pItem, /* FROM clause element to resolve */ + With **ppContext /* OUT: WITH clause return value belongs to */ +){ + const char *zName; + if( pItem->zDatabase==0 && (zName = pItem->zName)!=0 ){ + With *p; + for(p=pWith; p; p=p->pOuter){ + int i; + for(i=0; inCte; i++){ + if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){ + *ppContext = p; + return &p->a[i]; + } + } + } + } + return 0; +} + +/* The code generator maintains a stack of active WITH clauses +** with the inner-most WITH clause being at the top of the stack. +** +** This routine pushes the WITH clause passed as the second argument +** onto the top of the stack. If argument bFree is true, then this +** WITH clause will never be popped from the stack. In this case it +** should be freed along with the Parse object. In other cases, when +** bFree==0, the With object will be freed along with the SELECT +** statement with which it is associated. +*/ +SQLITE_PRIVATE void sqlite3WithPush(Parse *pParse, With *pWith, u8 bFree){ + assert( bFree==0 || (pParse->pWith==0 && pParse->pWithToFree==0) ); + if( pWith ){ + assert( pParse->pWith!=pWith ); + pWith->pOuter = pParse->pWith; + pParse->pWith = pWith; + if( bFree ) pParse->pWithToFree = pWith; + } +} + +/* +** This function checks if argument pFrom refers to a CTE declared by +** a WITH clause on the stack currently maintained by the parser. And, +** if currently processing a CTE expression, if it is a recursive +** reference to the current CTE. +** +** If pFrom falls into either of the two categories above, pFrom->pTab +** and other fields are populated accordingly. The caller should check +** (pFrom->pTab!=0) to determine whether or not a successful match +** was found. +** +** Whether or not a match is found, SQLITE_OK is returned if no error +** occurs. If an error does occur, an error message is stored in the +** parser and some error code other than SQLITE_OK returned. +*/ +static int withExpand( + Walker *pWalker, + struct SrcList_item *pFrom +){ + Parse *pParse = pWalker->pParse; + sqlite3 *db = pParse->db; + struct Cte *pCte; /* Matched CTE (or NULL if no match) */ + With *pWith; /* WITH clause that pCte belongs to */ + + assert( pFrom->pTab==0 ); + if( pParse->nErr ){ + return SQLITE_ERROR; + } + + pCte = searchWith(pParse->pWith, pFrom, &pWith); + if( pCte ){ + Table *pTab; + ExprList *pEList; + Select *pSel; + Select *pLeft; /* Left-most SELECT statement */ + Select *pRecTerm; /* Left-most recursive term */ + int bMayRecursive; /* True if compound joined by UNION [ALL] */ + With *pSavedWith; /* Initial value of pParse->pWith */ + int iRecTab = -1; /* Cursor for recursive table */ + + /* If pCte->zCteErr is non-NULL at this point, then this is an illegal + ** recursive reference to CTE pCte. Leave an error in pParse and return + ** early. If pCte->zCteErr is NULL, then this is not a recursive reference. + ** In this case, proceed. */ + if( pCte->zCteErr ){ + sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName); + return SQLITE_ERROR; + } + if( cannotBeFunction(pParse, pFrom) ) return SQLITE_ERROR; + + assert( pFrom->pTab==0 ); + pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table)); + if( pTab==0 ) return WRC_Abort; + pTab->nTabRef = 1; + pTab->zName = sqlite3DbStrDup(db, pCte->zName); + pTab->iPKey = -1; + pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) ); + pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid; + pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0); + if( db->mallocFailed ) return SQLITE_NOMEM_BKPT; + assert( pFrom->pSelect ); + + /* Check if this is a recursive CTE. */ + pRecTerm = pSel = pFrom->pSelect; + bMayRecursive = ( pSel->op==TK_ALL || pSel->op==TK_UNION ); + while( bMayRecursive && pRecTerm->op==pSel->op ){ + int i; + SrcList *pSrc = pRecTerm->pSrc; + assert( pRecTerm->pPrior!=0 ); + for(i=0; inSrc; i++){ + struct SrcList_item *pItem = &pSrc->a[i]; + if( pItem->zDatabase==0 + && pItem->zName!=0 + && 0==sqlite3StrICmp(pItem->zName, pCte->zName) + ){ + pItem->pTab = pTab; + pTab->nTabRef++; + pItem->fg.isRecursive = 1; + if( pRecTerm->selFlags & SF_Recursive ){ + sqlite3ErrorMsg(pParse, + "multiple references to recursive table: %s", pCte->zName + ); + return SQLITE_ERROR; + } + pRecTerm->selFlags |= SF_Recursive; + if( iRecTab<0 ) iRecTab = pParse->nTab++; + pItem->iCursor = iRecTab; + } + } + if( (pRecTerm->selFlags & SF_Recursive)==0 ) break; + pRecTerm = pRecTerm->pPrior; + } + + pCte->zCteErr = "circular reference: %s"; + pSavedWith = pParse->pWith; + pParse->pWith = pWith; + if( pSel->selFlags & SF_Recursive ){ + assert( pRecTerm!=0 ); + assert( (pRecTerm->selFlags & SF_Recursive)==0 ); + assert( pRecTerm->pNext!=0 ); + assert( (pRecTerm->pNext->selFlags & SF_Recursive)!=0 ); + assert( pRecTerm->pWith==0 ); + pRecTerm->pWith = pSel->pWith; + sqlite3WalkSelect(pWalker, pRecTerm); + pRecTerm->pWith = 0; + }else{ + sqlite3WalkSelect(pWalker, pSel); + } + pParse->pWith = pWith; + + for(pLeft=pSel; pLeft->pPrior; pLeft=pLeft->pPrior); + pEList = pLeft->pEList; + if( pCte->pCols ){ + if( pEList && pEList->nExpr!=pCte->pCols->nExpr ){ + sqlite3ErrorMsg(pParse, "table %s has %d values for %d columns", + pCte->zName, pEList->nExpr, pCte->pCols->nExpr + ); + pParse->pWith = pSavedWith; + return SQLITE_ERROR; + } + pEList = pCte->pCols; + } + + sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol); + if( bMayRecursive ){ + if( pSel->selFlags & SF_Recursive ){ + pCte->zCteErr = "multiple recursive references: %s"; + }else{ + pCte->zCteErr = "recursive reference in a subquery: %s"; + } + sqlite3WalkSelect(pWalker, pSel); + } + pCte->zCteErr = 0; + pParse->pWith = pSavedWith; + } + + return SQLITE_OK; +} +#endif + +#ifndef SQLITE_OMIT_CTE +/* +** If the SELECT passed as the second argument has an associated WITH +** clause, pop it from the stack stored as part of the Parse object. +** +** This function is used as the xSelectCallback2() callback by +** sqlite3SelectExpand() when walking a SELECT tree to resolve table +** names and other FROM clause elements. +*/ +static void selectPopWith(Walker *pWalker, Select *p){ + Parse *pParse = pWalker->pParse; + if( OK_IF_ALWAYS_TRUE(pParse->pWith) && p->pPrior==0 ){ + With *pWith = findRightmost(p)->pWith; + if( pWith!=0 ){ + assert( pParse->pWith==pWith || pParse->nErr ); + pParse->pWith = pWith->pOuter; + } + } +} +#else +#define selectPopWith 0 +#endif + +/* +** The SrcList_item structure passed as the second argument represents a +** sub-query in the FROM clause of a SELECT statement. This function +** allocates and populates the SrcList_item.pTab object. If successful, +** SQLITE_OK is returned. Otherwise, if an OOM error is encountered, +** SQLITE_NOMEM. +*/ +SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse *pParse, struct SrcList_item *pFrom){ + Select *pSel = pFrom->pSelect; + Table *pTab; + + assert( pSel ); + pFrom->pTab = pTab = sqlite3DbMallocZero(pParse->db, sizeof(Table)); + if( pTab==0 ) return SQLITE_NOMEM; + pTab->nTabRef = 1; + if( pFrom->zAlias ){ + pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias); + }else{ + pTab->zName = sqlite3MPrintf(pParse->db, "subquery_%u", pSel->selId); + } + while( pSel->pPrior ){ pSel = pSel->pPrior; } + sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol); + pTab->iPKey = -1; + pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) ); + pTab->tabFlags |= TF_Ephemeral; + + return pParse->nErr ? SQLITE_ERROR : SQLITE_OK; +} + +/* +** This routine is a Walker callback for "expanding" a SELECT statement. +** "Expanding" means to do the following: +** +** (1) Make sure VDBE cursor numbers have been assigned to every +** element of the FROM clause. +** +** (2) Fill in the pTabList->a[].pTab fields in the SrcList that +** defines FROM clause. When views appear in the FROM clause, +** fill pTabList->a[].pSelect with a copy of the SELECT statement +** that implements the view. A copy is made of the view's SELECT +** statement so that we can freely modify or delete that statement +** without worrying about messing up the persistent representation +** of the view. +** +** (3) Add terms to the WHERE clause to accommodate the NATURAL keyword +** on joins and the ON and USING clause of joins. +** +** (4) Scan the list of columns in the result set (pEList) looking +** for instances of the "*" operator or the TABLE.* operator. +** If found, expand each "*" to be every column in every table +** and TABLE.* to be every column in TABLE. +** +*/ +static int selectExpander(Walker *pWalker, Select *p){ + Parse *pParse = pWalker->pParse; + int i, j, k; + SrcList *pTabList; + ExprList *pEList; + struct SrcList_item *pFrom; + sqlite3 *db = pParse->db; + Expr *pE, *pRight, *pExpr; + u16 selFlags = p->selFlags; + u32 elistFlags = 0; + + p->selFlags |= SF_Expanded; + if( db->mallocFailed ){ + return WRC_Abort; + } + assert( p->pSrc!=0 ); + if( (selFlags & SF_Expanded)!=0 ){ + return WRC_Prune; + } + if( pWalker->eCode ){ + /* Renumber selId because it has been copied from a view */ + p->selId = ++pParse->nSelect; + } + pTabList = p->pSrc; + pEList = p->pEList; + sqlite3WithPush(pParse, p->pWith, 0); + + /* Make sure cursor numbers have been assigned to all entries in + ** the FROM clause of the SELECT statement. + */ + sqlite3SrcListAssignCursors(pParse, pTabList); + + /* Look up every table named in the FROM clause of the select. If + ** an entry of the FROM clause is a subquery instead of a table or view, + ** then create a transient table structure to describe the subquery. + */ + for(i=0, pFrom=pTabList->a; inSrc; i++, pFrom++){ + Table *pTab; + assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 ); + if( pFrom->pTab ) continue; + assert( pFrom->fg.isRecursive==0 ); +#ifndef SQLITE_OMIT_CTE + if( withExpand(pWalker, pFrom) ) return WRC_Abort; + if( pFrom->pTab ) {} else +#endif + if( pFrom->zName==0 ){ +#ifndef SQLITE_OMIT_SUBQUERY + Select *pSel = pFrom->pSelect; + /* A sub-query in the FROM clause of a SELECT */ + assert( pSel!=0 ); + assert( pFrom->pTab==0 ); + if( sqlite3WalkSelect(pWalker, pSel) ) return WRC_Abort; + if( sqlite3ExpandSubquery(pParse, pFrom) ) return WRC_Abort; +#endif + }else{ + /* An ordinary table or view name in the FROM clause */ + assert( pFrom->pTab==0 ); + pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom); + if( pTab==0 ) return WRC_Abort; + if( pTab->nTabRef>=0xffff ){ + sqlite3ErrorMsg(pParse, "too many references to \"%s\": max 65535", + pTab->zName); + pFrom->pTab = 0; + return WRC_Abort; + } + pTab->nTabRef++; + if( !IsVirtual(pTab) && cannotBeFunction(pParse, pFrom) ){ + return WRC_Abort; + } +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) + if( IsVirtual(pTab) || pTab->pSelect ){ + i16 nCol; + u8 eCodeOrig = pWalker->eCode; + if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort; + assert( pFrom->pSelect==0 ); + if( pTab->pSelect && (db->flags & SQLITE_EnableView)==0 ){ + sqlite3ErrorMsg(pParse, "access to view \"%s\" prohibited", + pTab->zName); + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) + && pFrom->fg.fromDDL + && ALWAYS(pTab->pVTable!=0) + && pTab->pVTable->eVtabRisk > ((db->flags & SQLITE_TrustedSchema)!=0) + ){ + sqlite3ErrorMsg(pParse, "unsafe use of virtual table \"%s\"", + pTab->zName); + } +#endif + pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0); + nCol = pTab->nCol; + pTab->nCol = -1; + pWalker->eCode = 1; /* Turn on Select.selId renumbering */ + sqlite3WalkSelect(pWalker, pFrom->pSelect); + pWalker->eCode = eCodeOrig; + pTab->nCol = nCol; + } +#endif + } + + /* Locate the index named by the INDEXED BY clause, if any. */ + if( sqlite3IndexedByLookup(pParse, pFrom) ){ + return WRC_Abort; + } + } + + /* Process NATURAL keywords, and ON and USING clauses of joins. + */ + if( pParse->nErr || db->mallocFailed || sqliteProcessJoin(pParse, p) ){ + return WRC_Abort; + } + + /* For every "*" that occurs in the column list, insert the names of + ** all columns in all tables. And for every TABLE.* insert the names + ** of all columns in TABLE. The parser inserted a special expression + ** with the TK_ASTERISK operator for each "*" that it found in the column + ** list. The following code just has to locate the TK_ASTERISK + ** expressions and expand each one to the list of all columns in + ** all tables. + ** + ** The first loop just checks to see if there are any "*" operators + ** that need expanding. + */ + for(k=0; knExpr; k++){ + pE = pEList->a[k].pExpr; + if( pE->op==TK_ASTERISK ) break; + assert( pE->op!=TK_DOT || pE->pRight!=0 ); + assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) ); + if( pE->op==TK_DOT && pE->pRight->op==TK_ASTERISK ) break; + elistFlags |= pE->flags; + } + if( knExpr ){ + /* + ** If we get here it means the result set contains one or more "*" + ** operators that need to be expanded. Loop through each expression + ** in the result set and expand them one by one. + */ + struct ExprList_item *a = pEList->a; + ExprList *pNew = 0; + int flags = pParse->db->flags; + int longNames = (flags & SQLITE_FullColNames)!=0 + && (flags & SQLITE_ShortColNames)==0; + + for(k=0; knExpr; k++){ + pE = a[k].pExpr; + elistFlags |= pE->flags; + pRight = pE->pRight; + assert( pE->op!=TK_DOT || pRight!=0 ); + if( pE->op!=TK_ASTERISK + && (pE->op!=TK_DOT || pRight->op!=TK_ASTERISK) + ){ + /* This particular expression does not need to be expanded. + */ + pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr); + if( pNew ){ + pNew->a[pNew->nExpr-1].zEName = a[k].zEName; + pNew->a[pNew->nExpr-1].eEName = a[k].eEName; + a[k].zEName = 0; + } + a[k].pExpr = 0; + }else{ + /* This expression is a "*" or a "TABLE.*" and needs to be + ** expanded. */ + int tableSeen = 0; /* Set to 1 when TABLE matches */ + char *zTName = 0; /* text of name of TABLE */ + if( pE->op==TK_DOT ){ + assert( pE->pLeft!=0 ); + assert( !ExprHasProperty(pE->pLeft, EP_IntValue) ); + zTName = pE->pLeft->u.zToken; + } + for(i=0, pFrom=pTabList->a; inSrc; i++, pFrom++){ + Table *pTab = pFrom->pTab; + Select *pSub = pFrom->pSelect; + char *zTabName = pFrom->zAlias; + const char *zSchemaName = 0; + int iDb; + if( zTabName==0 ){ + zTabName = pTab->zName; + } + if( db->mallocFailed ) break; + if( pSub==0 || (pSub->selFlags & SF_NestedFrom)==0 ){ + pSub = 0; + if( zTName && sqlite3StrICmp(zTName, zTabName)!=0 ){ + continue; + } + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*"; + } + for(j=0; jnCol; j++){ + char *zName = pTab->aCol[j].zName; + char *zColname; /* The computed column name */ + char *zToFree; /* Malloced string that needs to be freed */ + Token sColname; /* Computed column name as a token */ + + assert( zName ); + if( zTName && pSub + && sqlite3MatchEName(&pSub->pEList->a[j], 0, zTName, 0)==0 + ){ + continue; + } + + /* If a column is marked as 'hidden', omit it from the expanded + ** result-set list unless the SELECT has the SF_IncludeHidden + ** bit set. + */ + if( (p->selFlags & SF_IncludeHidden)==0 + && IsHiddenColumn(&pTab->aCol[j]) + ){ + continue; + } + tableSeen = 1; + + if( i>0 && zTName==0 ){ + if( (pFrom->fg.jointype & JT_NATURAL)!=0 + && tableAndColumnIndex(pTabList, i, zName, 0, 0, 1) + ){ + /* In a NATURAL join, omit the join columns from the + ** table to the right of the join */ + continue; + } + if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){ + /* In a join with a USING clause, omit columns in the + ** using clause from the table on the right. */ + continue; + } + } + pRight = sqlite3Expr(db, TK_ID, zName); + zColname = zName; + zToFree = 0; + if( longNames || pTabList->nSrc>1 ){ + Expr *pLeft; + pLeft = sqlite3Expr(db, TK_ID, zTabName); + pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight); + if( zSchemaName ){ + pLeft = sqlite3Expr(db, TK_ID, zSchemaName); + pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr); + } + if( longNames ){ + zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName); + zToFree = zColname; + } + }else{ + pExpr = pRight; + } + pNew = sqlite3ExprListAppend(pParse, pNew, pExpr); + sqlite3TokenInit(&sColname, zColname); + sqlite3ExprListSetName(pParse, pNew, &sColname, 0); + if( pNew && (p->selFlags & SF_NestedFrom)!=0 && !IN_RENAME_OBJECT ){ + struct ExprList_item *pX = &pNew->a[pNew->nExpr-1]; + sqlite3DbFree(db, pX->zEName); + if( pSub ){ + pX->zEName = sqlite3DbStrDup(db, pSub->pEList->a[j].zEName); + testcase( pX->zEName==0 ); + }else{ + pX->zEName = sqlite3MPrintf(db, "%s.%s.%s", + zSchemaName, zTabName, zColname); + testcase( pX->zEName==0 ); + } + pX->eEName = ENAME_TAB; + } + sqlite3DbFree(db, zToFree); + } + } + if( !tableSeen ){ + if( zTName ){ + sqlite3ErrorMsg(pParse, "no such table: %s", zTName); + }else{ + sqlite3ErrorMsg(pParse, "no tables specified"); + } + } + } + } + sqlite3ExprListDelete(db, pEList); + p->pEList = pNew; + } + if( p->pEList ){ + if( p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ + sqlite3ErrorMsg(pParse, "too many columns in result set"); + return WRC_Abort; + } + if( (elistFlags & (EP_HasFunc|EP_Subquery))!=0 ){ + p->selFlags |= SF_ComplexResult; + } + } + return WRC_Continue; +} + +#if SQLITE_DEBUG +/* +** Always assert. This xSelectCallback2 implementation proves that the +** xSelectCallback2 is never invoked. +*/ +SQLITE_PRIVATE void sqlite3SelectWalkAssert2(Walker *NotUsed, Select *NotUsed2){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + assert( 0 ); +} +#endif +/* +** This routine "expands" a SELECT statement and all of its subqueries. +** For additional information on what it means to "expand" a SELECT +** statement, see the comment on the selectExpand worker callback above. +** +** Expanding a SELECT statement is the first step in processing a +** SELECT statement. The SELECT statement must be expanded before +** name resolution is performed. +** +** If anything goes wrong, an error message is written into pParse. +** The calling function can detect the problem by looking at pParse->nErr +** and/or pParse->db->mallocFailed. +*/ +static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){ + Walker w; + w.xExprCallback = sqlite3ExprWalkNoop; + w.pParse = pParse; + if( OK_IF_ALWAYS_TRUE(pParse->hasCompound) ){ + w.xSelectCallback = convertCompoundSelectToSubquery; + w.xSelectCallback2 = 0; + sqlite3WalkSelect(&w, pSelect); + } + w.xSelectCallback = selectExpander; + w.xSelectCallback2 = selectPopWith; + w.eCode = 0; + sqlite3WalkSelect(&w, pSelect); +} + + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** This is a Walker.xSelectCallback callback for the sqlite3SelectTypeInfo() +** interface. +** +** For each FROM-clause subquery, add Column.zType and Column.zColl +** information to the Table structure that represents the result set +** of that subquery. +** +** The Table structure that represents the result set was constructed +** by selectExpander() but the type and collation information was omitted +** at that point because identifiers had not yet been resolved. This +** routine is called after identifier resolution. +*/ +static void selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){ + Parse *pParse; + int i; + SrcList *pTabList; + struct SrcList_item *pFrom; + + assert( p->selFlags & SF_Resolved ); + if( p->selFlags & SF_HasTypeInfo ) return; + p->selFlags |= SF_HasTypeInfo; + pParse = pWalker->pParse; + pTabList = p->pSrc; + for(i=0, pFrom=pTabList->a; inSrc; i++, pFrom++){ + Table *pTab = pFrom->pTab; + assert( pTab!=0 ); + if( (pTab->tabFlags & TF_Ephemeral)!=0 ){ + /* A sub-query in the FROM clause of a SELECT */ + Select *pSel = pFrom->pSelect; + if( pSel ){ + while( pSel->pPrior ) pSel = pSel->pPrior; + sqlite3SelectAddColumnTypeAndCollation(pParse, pTab, pSel, + SQLITE_AFF_NONE); + } + } + } +} +#endif + + +/* +** This routine adds datatype and collating sequence information to +** the Table structures of all FROM-clause subqueries in a +** SELECT statement. +** +** Use this routine after name resolution. +*/ +static void sqlite3SelectAddTypeInfo(Parse *pParse, Select *pSelect){ +#ifndef SQLITE_OMIT_SUBQUERY + Walker w; + w.xSelectCallback = sqlite3SelectWalkNoop; + w.xSelectCallback2 = selectAddSubqueryTypeInfo; + w.xExprCallback = sqlite3ExprWalkNoop; + w.pParse = pParse; + sqlite3WalkSelect(&w, pSelect); +#endif +} + + +/* +** This routine sets up a SELECT statement for processing. The +** following is accomplished: +** +** * VDBE Cursor numbers are assigned to all FROM-clause terms. +** * Ephemeral Table objects are created for all FROM-clause subqueries. +** * ON and USING clauses are shifted into WHERE statements +** * Wildcards "*" and "TABLE.*" in result sets are expanded. +** * Identifiers in expression are matched to tables. +** +** This routine acts recursively on all subqueries within the SELECT. +*/ +SQLITE_PRIVATE void sqlite3SelectPrep( + Parse *pParse, /* The parser context */ + Select *p, /* The SELECT statement being coded. */ + NameContext *pOuterNC /* Name context for container */ +){ + assert( p!=0 || pParse->db->mallocFailed ); + if( pParse->db->mallocFailed ) return; + if( p->selFlags & SF_HasTypeInfo ) return; + sqlite3SelectExpand(pParse, p); + if( pParse->nErr || pParse->db->mallocFailed ) return; + sqlite3ResolveSelectNames(pParse, p, pOuterNC); + if( pParse->nErr || pParse->db->mallocFailed ) return; + sqlite3SelectAddTypeInfo(pParse, p); +} + +/* +** Reset the aggregate accumulator. +** +** The aggregate accumulator is a set of memory cells that hold +** intermediate results while calculating an aggregate. This +** routine generates code that stores NULLs in all of those memory +** cells. +*/ +static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){ + Vdbe *v = pParse->pVdbe; + int i; + struct AggInfo_func *pFunc; + int nReg = pAggInfo->nFunc + pAggInfo->nColumn; + if( nReg==0 ) return; + if( pParse->nErr || pParse->db->mallocFailed ) return; +#ifdef SQLITE_DEBUG + /* Verify that all AggInfo registers are within the range specified by + ** AggInfo.mnReg..AggInfo.mxReg */ + assert( nReg==pAggInfo->mxReg-pAggInfo->mnReg+1 ); + for(i=0; inColumn; i++){ + assert( pAggInfo->aCol[i].iMem>=pAggInfo->mnReg + && pAggInfo->aCol[i].iMem<=pAggInfo->mxReg ); + } + for(i=0; inFunc; i++){ + assert( pAggInfo->aFunc[i].iMem>=pAggInfo->mnReg + && pAggInfo->aFunc[i].iMem<=pAggInfo->mxReg ); + } +#endif + sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->mnReg, pAggInfo->mxReg); + for(pFunc=pAggInfo->aFunc, i=0; inFunc; i++, pFunc++){ + if( pFunc->iDistinct>=0 ){ + Expr *pE = pFunc->pFExpr; + assert( !ExprHasProperty(pE, EP_xIsSelect) ); + if( pE->x.pList==0 || pE->x.pList->nExpr!=1 ){ + sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one " + "argument"); + pFunc->iDistinct = -1; + }else{ + KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0); + sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0, + (char*)pKeyInfo, P4_KEYINFO); + } + } + } +} + +/* +** Invoke the OP_AggFinalize opcode for every aggregate function +** in the AggInfo structure. +*/ +static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){ + Vdbe *v = pParse->pVdbe; + int i; + struct AggInfo_func *pF; + for(i=0, pF=pAggInfo->aFunc; inFunc; i++, pF++){ + ExprList *pList = pF->pFExpr->x.pList; + assert( !ExprHasProperty(pF->pFExpr, EP_xIsSelect) ); + sqlite3VdbeAddOp2(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0); + sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF); + } +} + + +/* +** Update the accumulator memory cells for an aggregate based on +** the current cursor position. +** +** If regAcc is non-zero and there are no min() or max() aggregates +** in pAggInfo, then only populate the pAggInfo->nAccumulator accumulator +** registers if register regAcc contains 0. The caller will take care +** of setting and clearing regAcc. +*/ +static void updateAccumulator(Parse *pParse, int regAcc, AggInfo *pAggInfo){ + Vdbe *v = pParse->pVdbe; + int i; + int regHit = 0; + int addrHitTest = 0; + struct AggInfo_func *pF; + struct AggInfo_col *pC; + + pAggInfo->directMode = 1; + for(i=0, pF=pAggInfo->aFunc; inFunc; i++, pF++){ + int nArg; + int addrNext = 0; + int regAgg; + ExprList *pList = pF->pFExpr->x.pList; + assert( !ExprHasProperty(pF->pFExpr, EP_xIsSelect) ); + assert( !IsWindowFunc(pF->pFExpr) ); + if( ExprHasProperty(pF->pFExpr, EP_WinFunc) ){ + Expr *pFilter = pF->pFExpr->y.pWin->pFilter; + if( pAggInfo->nAccumulator + && (pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL) + && regAcc + ){ + /* If regAcc==0, there there exists some min() or max() function + ** without a FILTER clause that will ensure the magnet registers + ** are populated. */ + if( regHit==0 ) regHit = ++pParse->nMem; + /* If this is the first row of the group (regAcc contains 0), clear the + ** "magnet" register regHit so that the accumulator registers + ** are populated if the FILTER clause jumps over the the + ** invocation of min() or max() altogether. Or, if this is not + ** the first row (regAcc contains 1), set the magnet register so that + ** the accumulators are not populated unless the min()/max() is invoked + ** and indicates that they should be. */ + sqlite3VdbeAddOp2(v, OP_Copy, regAcc, regHit); + } + addrNext = sqlite3VdbeMakeLabel(pParse); + sqlite3ExprIfFalse(pParse, pFilter, addrNext, SQLITE_JUMPIFNULL); + } + if( pList ){ + nArg = pList->nExpr; + regAgg = sqlite3GetTempRange(pParse, nArg); + sqlite3ExprCodeExprList(pParse, pList, regAgg, 0, SQLITE_ECEL_DUP); + }else{ + nArg = 0; + regAgg = 0; + } + if( pF->iDistinct>=0 ){ + if( addrNext==0 ){ + addrNext = sqlite3VdbeMakeLabel(pParse); + } + testcase( nArg==0 ); /* Error condition */ + testcase( nArg>1 ); /* Also an error */ + codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg); + } + if( pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){ + CollSeq *pColl = 0; + struct ExprList_item *pItem; + int j; + assert( pList!=0 ); /* pList!=0 if pF->pFunc has NEEDCOLL */ + for(j=0, pItem=pList->a; !pColl && jpExpr); + } + if( !pColl ){ + pColl = pParse->db->pDfltColl; + } + if( regHit==0 && pAggInfo->nAccumulator ) regHit = ++pParse->nMem; + sqlite3VdbeAddOp4(v, OP_CollSeq, regHit, 0, 0, (char *)pColl, P4_COLLSEQ); + } + sqlite3VdbeAddOp3(v, OP_AggStep, 0, regAgg, pF->iMem); + sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF); + sqlite3VdbeChangeP5(v, (u8)nArg); + sqlite3ReleaseTempRange(pParse, regAgg, nArg); + if( addrNext ){ + sqlite3VdbeResolveLabel(v, addrNext); + } + } + if( regHit==0 && pAggInfo->nAccumulator ){ + regHit = regAcc; + } + if( regHit ){ + addrHitTest = sqlite3VdbeAddOp1(v, OP_If, regHit); VdbeCoverage(v); + } + for(i=0, pC=pAggInfo->aCol; inAccumulator; i++, pC++){ + sqlite3ExprCode(pParse, pC->pCExpr, pC->iMem); + } + + pAggInfo->directMode = 0; + if( addrHitTest ){ + sqlite3VdbeJumpHereOrPopInst(v, addrHitTest); + } +} + +/* +** Add a single OP_Explain instruction to the VDBE to explain a simple +** count(*) query ("SELECT count(*) FROM pTab"). +*/ +#ifndef SQLITE_OMIT_EXPLAIN +static void explainSimpleCount( + Parse *pParse, /* Parse context */ + Table *pTab, /* Table being queried */ + Index *pIdx /* Index used to optimize scan, or NULL */ +){ + if( pParse->explain==2 ){ + int bCover = (pIdx!=0 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pIdx))); + sqlite3VdbeExplain(pParse, 0, "SCAN TABLE %s%s%s", + pTab->zName, + bCover ? " USING COVERING INDEX " : "", + bCover ? pIdx->zName : "" + ); + } +} +#else +# define explainSimpleCount(a,b,c) +#endif + +/* +** sqlite3WalkExpr() callback used by havingToWhere(). +** +** If the node passed to the callback is a TK_AND node, return +** WRC_Continue to tell sqlite3WalkExpr() to iterate through child nodes. +** +** Otherwise, return WRC_Prune. In this case, also check if the +** sub-expression matches the criteria for being moved to the WHERE +** clause. If so, add it to the WHERE clause and replace the sub-expression +** within the HAVING expression with a constant "1". +*/ +static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){ + if( pExpr->op!=TK_AND ){ + Select *pS = pWalker->u.pSelect; + if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy) + && ExprAlwaysFalse(pExpr)==0 + ){ + sqlite3 *db = pWalker->pParse->db; + Expr *pNew = sqlite3Expr(db, TK_INTEGER, "1"); + if( pNew ){ + Expr *pWhere = pS->pWhere; + SWAP(Expr, *pNew, *pExpr); + pNew = sqlite3ExprAnd(pWalker->pParse, pWhere, pNew); + pS->pWhere = pNew; + pWalker->eCode = 1; + } + } + return WRC_Prune; + } + return WRC_Continue; +} + +/* +** Transfer eligible terms from the HAVING clause of a query, which is +** processed after grouping, to the WHERE clause, which is processed before +** grouping. For example, the query: +** +** SELECT * FROM WHERE a=? GROUP BY b HAVING b=? AND c=? +** +** can be rewritten as: +** +** SELECT * FROM WHERE a=? AND b=? GROUP BY b HAVING c=? +** +** A term of the HAVING expression is eligible for transfer if it consists +** entirely of constants and expressions that are also GROUP BY terms that +** use the "BINARY" collation sequence. +*/ +static void havingToWhere(Parse *pParse, Select *p){ + Walker sWalker; + memset(&sWalker, 0, sizeof(sWalker)); + sWalker.pParse = pParse; + sWalker.xExprCallback = havingToWhereExprCb; + sWalker.u.pSelect = p; + sqlite3WalkExpr(&sWalker, p->pHaving); +#if SELECTTRACE_ENABLED + if( sWalker.eCode && (sqlite3_unsupported_selecttrace & 0x100)!=0 ){ + SELECTTRACE(0x100,pParse,p,("Move HAVING terms into WHERE:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif +} + +/* +** Check to see if the pThis entry of pTabList is a self-join of a prior view. +** If it is, then return the SrcList_item for the prior view. If it is not, +** then return 0. +*/ +static struct SrcList_item *isSelfJoinView( + SrcList *pTabList, /* Search for self-joins in this FROM clause */ + struct SrcList_item *pThis /* Search for prior reference to this subquery */ +){ + struct SrcList_item *pItem; + for(pItem = pTabList->a; pItempSelect==0 ) continue; + if( pItem->fg.viaCoroutine ) continue; + if( pItem->zName==0 ) continue; + assert( pItem->pTab!=0 ); + assert( pThis->pTab!=0 ); + if( pItem->pTab->pSchema!=pThis->pTab->pSchema ) continue; + if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue; + pS1 = pItem->pSelect; + if( pItem->pTab->pSchema==0 && pThis->pSelect->selId!=pS1->selId ){ + /* The query flattener left two different CTE tables with identical + ** names in the same FROM clause. */ + continue; + } + if( sqlite3ExprCompare(0, pThis->pSelect->pWhere, pS1->pWhere, -1) + || sqlite3ExprCompare(0, pThis->pSelect->pHaving, pS1->pHaving, -1) + ){ + /* The view was modified by some other optimization such as + ** pushDownWhereTerms() */ + continue; + } + return pItem; + } + return 0; +} + +#ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION +/* +** Attempt to transform a query of the form +** +** SELECT count(*) FROM (SELECT x FROM t1 UNION ALL SELECT y FROM t2) +** +** Into this: +** +** SELECT (SELECT count(*) FROM t1)+(SELECT count(*) FROM t2) +** +** The transformation only works if all of the following are true: +** +** * The subquery is a UNION ALL of two or more terms +** * The subquery does not have a LIMIT clause +** * There is no WHERE or GROUP BY or HAVING clauses on the subqueries +** * The outer query is a simple count(*) with no WHERE clause or other +** extraneous syntax. +** +** Return TRUE if the optimization is undertaken. +*/ +static int countOfViewOptimization(Parse *pParse, Select *p){ + Select *pSub, *pPrior; + Expr *pExpr; + Expr *pCount; + sqlite3 *db; + if( (p->selFlags & SF_Aggregate)==0 ) return 0; /* This is an aggregate */ + if( p->pEList->nExpr!=1 ) return 0; /* Single result column */ + if( p->pWhere ) return 0; + if( p->pGroupBy ) return 0; + pExpr = p->pEList->a[0].pExpr; + if( pExpr->op!=TK_AGG_FUNCTION ) return 0; /* Result is an aggregate */ + if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0; /* Is count() */ + if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */ + if( p->pSrc->nSrc!=1 ) return 0; /* One table in FROM */ + pSub = p->pSrc->a[0].pSelect; + if( pSub==0 ) return 0; /* The FROM is a subquery */ + if( pSub->pPrior==0 ) return 0; /* Must be a compound ry */ + do{ + if( pSub->op!=TK_ALL && pSub->pPrior ) return 0; /* Must be UNION ALL */ + if( pSub->pWhere ) return 0; /* No WHERE clause */ + if( pSub->pLimit ) return 0; /* No LIMIT clause */ + if( pSub->selFlags & SF_Aggregate ) return 0; /* Not an aggregate */ + pSub = pSub->pPrior; /* Repeat over compound */ + }while( pSub ); + + /* If we reach this point then it is OK to perform the transformation */ + + db = pParse->db; + pCount = pExpr; + pExpr = 0; + pSub = p->pSrc->a[0].pSelect; + p->pSrc->a[0].pSelect = 0; + sqlite3SrcListDelete(db, p->pSrc); + p->pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*p->pSrc)); + while( pSub ){ + Expr *pTerm; + pPrior = pSub->pPrior; + pSub->pPrior = 0; + pSub->pNext = 0; + pSub->selFlags |= SF_Aggregate; + pSub->selFlags &= ~SF_Compound; + pSub->nSelectRow = 0; + sqlite3ExprListDelete(db, pSub->pEList); + pTerm = pPrior ? sqlite3ExprDup(db, pCount, 0) : pCount; + pSub->pEList = sqlite3ExprListAppend(pParse, 0, pTerm); + pTerm = sqlite3PExpr(pParse, TK_SELECT, 0, 0); + sqlite3PExprAddSelect(pParse, pTerm, pSub); + if( pExpr==0 ){ + pExpr = pTerm; + }else{ + pExpr = sqlite3PExpr(pParse, TK_PLUS, pTerm, pExpr); + } + pSub = pPrior; + } + p->pEList->a[0].pExpr = pExpr; + p->selFlags &= ~SF_Aggregate; + +#if SELECTTRACE_ENABLED + if( sqlite3_unsupported_selecttrace & 0x400 ){ + SELECTTRACE(0x400,pParse,p,("After count-of-view optimization:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + return 1; +} +#endif /* SQLITE_COUNTOFVIEW_OPTIMIZATION */ + +/* +** Generate code for the SELECT statement given in the p argument. +** +** The results are returned according to the SelectDest structure. +** See comments in sqliteInt.h for further information. +** +** This routine returns the number of errors. If any errors are +** encountered, then an appropriate error message is left in +** pParse->zErrMsg. +** +** This routine does NOT free the Select structure passed in. The +** calling function needs to do that. +*/ +SQLITE_PRIVATE int sqlite3Select( + Parse *pParse, /* The parser context */ + Select *p, /* The SELECT statement being coded. */ + SelectDest *pDest /* What to do with the query results */ +){ + int i, j; /* Loop counters */ + WhereInfo *pWInfo; /* Return from sqlite3WhereBegin() */ + Vdbe *v; /* The virtual machine under construction */ + int isAgg; /* True for select lists like "count(*)" */ + ExprList *pEList = 0; /* List of columns to extract. */ + SrcList *pTabList; /* List of tables to select from */ + Expr *pWhere; /* The WHERE clause. May be NULL */ + ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */ + Expr *pHaving; /* The HAVING clause. May be NULL */ + AggInfo *pAggInfo = 0; /* Aggregate information */ + int rc = 1; /* Value to return from this function */ + DistinctCtx sDistinct; /* Info on how to code the DISTINCT keyword */ + SortCtx sSort; /* Info on how to code the ORDER BY clause */ + int iEnd; /* Address of the end of the query */ + sqlite3 *db; /* The database connection */ + ExprList *pMinMaxOrderBy = 0; /* Added ORDER BY for min/max queries */ + u8 minMaxFlag; /* Flag for min/max queries */ + + db = pParse->db; + v = sqlite3GetVdbe(pParse); + if( p==0 || db->mallocFailed || pParse->nErr ){ + return 1; + } + if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1; +#if SELECTTRACE_ENABLED + SELECTTRACE(1,pParse,p, ("begin processing:\n", pParse->addrExplain)); + if( sqlite3_unsupported_selecttrace & 0x100 ){ + sqlite3TreeViewSelect(0, p, 0); + } +#endif + + assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistFifo ); + assert( p->pOrderBy==0 || pDest->eDest!=SRT_Fifo ); + assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistQueue ); + assert( p->pOrderBy==0 || pDest->eDest!=SRT_Queue ); + if( IgnorableDistinct(pDest) ){ + assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union || + pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard || + pDest->eDest==SRT_DistQueue || pDest->eDest==SRT_DistFifo ); + /* All of these destinations are also able to ignore the ORDER BY clause */ + sqlite3ExprListDelete(db, p->pOrderBy); + p->pOrderBy = 0; + p->selFlags &= ~SF_Distinct; + p->selFlags |= SF_NoopOrderBy; + } + sqlite3SelectPrep(pParse, p, 0); + if( pParse->nErr || db->mallocFailed ){ + goto select_end; + } + assert( p->pEList!=0 ); +#if SELECTTRACE_ENABLED + if( sqlite3_unsupported_selecttrace & 0x104 ){ + SELECTTRACE(0x104,pParse,p, ("after name resolution:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + + /* If the SF_UpdateFrom flag is set, then this function is being called + ** as part of populating the temp table for an UPDATE...FROM statement. + ** In this case, it is an error if the target object (pSrc->a[0]) name + ** or alias is duplicated within FROM clause (pSrc->a[1..n]). */ + if( p->selFlags & SF_UpdateFrom ){ + struct SrcList_item *p0 = &p->pSrc->a[0]; + for(i=1; ipSrc->nSrc; i++){ + struct SrcList_item *p1 = &p->pSrc->a[i]; + if( p0->pTab==p1->pTab && 0==sqlite3_stricmp(p0->zAlias, p1->zAlias) ){ + sqlite3ErrorMsg(pParse, + "target object/alias may not appear in FROM clause: %s", + p0->zAlias ? p0->zAlias : p0->pTab->zName + ); + goto select_end; + } + } + } + + if( pDest->eDest==SRT_Output ){ + generateColumnNames(pParse, p); + } + +#ifndef SQLITE_OMIT_WINDOWFUNC + rc = sqlite3WindowRewrite(pParse, p); + if( rc ){ + assert( db->mallocFailed || pParse->nErr>0 ); + goto select_end; + } +#if SELECTTRACE_ENABLED + if( p->pWin && (sqlite3_unsupported_selecttrace & 0x108)!=0 ){ + SELECTTRACE(0x104,pParse,p, ("after window rewrite:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif +#endif /* SQLITE_OMIT_WINDOWFUNC */ + pTabList = p->pSrc; + isAgg = (p->selFlags & SF_Aggregate)!=0; + memset(&sSort, 0, sizeof(sSort)); + sSort.pOrderBy = p->pOrderBy; + + /* Try to do various optimizations (flattening subqueries, and strength + ** reduction of join operators) in the FROM clause up into the main query + */ +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) + for(i=0; !p->pPrior && inSrc; i++){ + struct SrcList_item *pItem = &pTabList->a[i]; + Select *pSub = pItem->pSelect; + Table *pTab = pItem->pTab; + + /* The expander should have already created transient Table objects + ** even for FROM clause elements such as subqueries that do not correspond + ** to a real table */ + assert( pTab!=0 ); + + /* Convert LEFT JOIN into JOIN if there are terms of the right table + ** of the LEFT JOIN used in the WHERE clause. + */ + if( (pItem->fg.jointype & JT_LEFT)!=0 + && sqlite3ExprImpliesNonNullRow(p->pWhere, pItem->iCursor) + && OptimizationEnabled(db, SQLITE_SimplifyJoin) + ){ + SELECTTRACE(0x100,pParse,p, + ("LEFT-JOIN simplifies to JOIN on term %d\n",i)); + pItem->fg.jointype &= ~(JT_LEFT|JT_OUTER); + unsetJoinExpr(p->pWhere, pItem->iCursor); + } + + /* No futher action if this term of the FROM clause is no a subquery */ + if( pSub==0 ) continue; + + /* Catch mismatch in the declared columns of a view and the number of + ** columns in the SELECT on the RHS */ + if( pTab->nCol!=pSub->pEList->nExpr ){ + sqlite3ErrorMsg(pParse, "expected %d columns for '%s' but got %d", + pTab->nCol, pTab->zName, pSub->pEList->nExpr); + goto select_end; + } + + /* Do not try to flatten an aggregate subquery. + ** + ** Flattening an aggregate subquery is only possible if the outer query + ** is not a join. But if the outer query is not a join, then the subquery + ** will be implemented as a co-routine and there is no advantage to + ** flattening in that case. + */ + if( (pSub->selFlags & SF_Aggregate)!=0 ) continue; + assert( pSub->pGroupBy==0 ); + + /* If the outer query contains a "complex" result set (that is, + ** if the result set of the outer query uses functions or subqueries) + ** and if the subquery contains an ORDER BY clause and if + ** it will be implemented as a co-routine, then do not flatten. This + ** restriction allows SQL constructs like this: + ** + ** SELECT expensive_function(x) + ** FROM (SELECT x FROM tab ORDER BY y LIMIT 10); + ** + ** The expensive_function() is only computed on the 10 rows that + ** are output, rather than every row of the table. + ** + ** The requirement that the outer query have a complex result set + ** means that flattening does occur on simpler SQL constraints without + ** the expensive_function() like: + ** + ** SELECT x FROM (SELECT x FROM tab ORDER BY y LIMIT 10); + */ + if( pSub->pOrderBy!=0 + && i==0 + && (p->selFlags & SF_ComplexResult)!=0 + && (pTabList->nSrc==1 + || (pTabList->a[1].fg.jointype&(JT_LEFT|JT_CROSS))!=0) + ){ + continue; + } + + if( flattenSubquery(pParse, p, i, isAgg) ){ + if( pParse->nErr ) goto select_end; + /* This subquery can be absorbed into its parent. */ + i = -1; + } + pTabList = p->pSrc; + if( db->mallocFailed ) goto select_end; + if( !IgnorableOrderby(pDest) ){ + sSort.pOrderBy = p->pOrderBy; + } + } +#endif + +#ifndef SQLITE_OMIT_COMPOUND_SELECT + /* Handle compound SELECT statements using the separate multiSelect() + ** procedure. + */ + if( p->pPrior ){ + rc = multiSelect(pParse, p, pDest); +#if SELECTTRACE_ENABLED + SELECTTRACE(0x1,pParse,p,("end compound-select processing\n")); + if( (sqlite3_unsupported_selecttrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){ + sqlite3TreeViewSelect(0, p, 0); + } +#endif + if( p->pNext==0 ) ExplainQueryPlanPop(pParse); + return rc; + } +#endif + + /* Do the WHERE-clause constant propagation optimization if this is + ** a join. No need to speed time on this operation for non-join queries + ** as the equivalent optimization will be handled by query planner in + ** sqlite3WhereBegin(). + */ + if( pTabList->nSrc>1 + && OptimizationEnabled(db, SQLITE_PropagateConst) + && propagateConstants(pParse, p) + ){ +#if SELECTTRACE_ENABLED + if( sqlite3_unsupported_selecttrace & 0x100 ){ + SELECTTRACE(0x100,pParse,p,("After constant propagation:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + }else{ + SELECTTRACE(0x100,pParse,p,("Constant propagation not helpful\n")); + } + +#ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION + if( OptimizationEnabled(db, SQLITE_QueryFlattener|SQLITE_CountOfView) + && countOfViewOptimization(pParse, p) + ){ + if( db->mallocFailed ) goto select_end; + pEList = p->pEList; + pTabList = p->pSrc; + } +#endif + + /* For each term in the FROM clause, do two things: + ** (1) Authorized unreferenced tables + ** (2) Generate code for all sub-queries + */ + for(i=0; inSrc; i++){ + struct SrcList_item *pItem = &pTabList->a[i]; + SelectDest dest; + Select *pSub; +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) + const char *zSavedAuthContext; +#endif + + /* Issue SQLITE_READ authorizations with a fake column name for any + ** tables that are referenced but from which no values are extracted. + ** Examples of where these kinds of null SQLITE_READ authorizations + ** would occur: + ** + ** SELECT count(*) FROM t1; -- SQLITE_READ t1."" + ** SELECT t1.* FROM t1, t2; -- SQLITE_READ t2."" + ** + ** The fake column name is an empty string. It is possible for a table to + ** have a column named by the empty string, in which case there is no way to + ** distinguish between an unreferenced table and an actual reference to the + ** "" column. The original design was for the fake column name to be a NULL, + ** which would be unambiguous. But legacy authorization callbacks might + ** assume the column name is non-NULL and segfault. The use of an empty + ** string for the fake column name seems safer. + */ + if( pItem->colUsed==0 && pItem->zName!=0 ){ + sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", pItem->zDatabase); + } + +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) + /* Generate code for all sub-queries in the FROM clause + */ + pSub = pItem->pSelect; + if( pSub==0 ) continue; + + /* The code for a subquery should only be generated once, though it is + ** technically harmless for it to be generated multiple times. The + ** following assert() will detect if something changes to cause + ** the same subquery to be coded multiple times, as a signal to the + ** developers to try to optimize the situation. + ** + ** Update 2019-07-24: + ** See ticket https://sqlite.org/src/tktview/c52b09c7f38903b1311cec40. + ** The dbsqlfuzz fuzzer found a case where the same subquery gets + ** coded twice. So this assert() now becomes a testcase(). It should + ** be very rare, though. + */ + testcase( pItem->addrFillSub!=0 ); + + /* Increment Parse.nHeight by the height of the largest expression + ** tree referred to by this, the parent select. The child select + ** may contain expression trees of at most + ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit + ** more conservative than necessary, but much easier than enforcing + ** an exact limit. + */ + pParse->nHeight += sqlite3SelectExprHeight(p); + + /* Make copies of constant WHERE-clause terms in the outer query down + ** inside the subquery. This can help the subquery to run more efficiently. + */ + if( OptimizationEnabled(db, SQLITE_PushDown) + && pushDownWhereTerms(pParse, pSub, p->pWhere, pItem->iCursor, + (pItem->fg.jointype & JT_OUTER)!=0) + ){ +#if SELECTTRACE_ENABLED + if( sqlite3_unsupported_selecttrace & 0x100 ){ + SELECTTRACE(0x100,pParse,p, + ("After WHERE-clause push-down into subquery %d:\n", pSub->selId)); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + }else{ + SELECTTRACE(0x100,pParse,p,("Push-down not possible\n")); + } + + zSavedAuthContext = pParse->zAuthContext; + pParse->zAuthContext = pItem->zName; + + /* Generate code to implement the subquery + ** + ** The subquery is implemented as a co-routine if the subquery is + ** guaranteed to be the outer loop (so that it does not need to be + ** computed more than once) + ** + ** TODO: Are there other reasons beside (1) to use a co-routine + ** implementation? + */ + if( i==0 + && (pTabList->nSrc==1 + || (pTabList->a[1].fg.jointype&(JT_LEFT|JT_CROSS))!=0) /* (1) */ + ){ + /* Implement a co-routine that will return a single row of the result + ** set on each invocation. + */ + int addrTop = sqlite3VdbeCurrentAddr(v)+1; + + pItem->regReturn = ++pParse->nMem; + sqlite3VdbeAddOp3(v, OP_InitCoroutine, pItem->regReturn, 0, addrTop); + VdbeComment((v, "%s", pItem->pTab->zName)); + pItem->addrFillSub = addrTop; + sqlite3SelectDestInit(&dest, SRT_Coroutine, pItem->regReturn); + ExplainQueryPlan((pParse, 1, "CO-ROUTINE %u", pSub->selId)); + sqlite3Select(pParse, pSub, &dest); + pItem->pTab->nRowLogEst = pSub->nSelectRow; + pItem->fg.viaCoroutine = 1; + pItem->regResult = dest.iSdst; + sqlite3VdbeEndCoroutine(v, pItem->regReturn); + sqlite3VdbeJumpHere(v, addrTop-1); + sqlite3ClearTempRegCache(pParse); + }else{ + /* Generate a subroutine that will fill an ephemeral table with + ** the content of this subquery. pItem->addrFillSub will point + ** to the address of the generated subroutine. pItem->regReturn + ** is a register allocated to hold the subroutine return address + */ + int topAddr; + int onceAddr = 0; + int retAddr; + struct SrcList_item *pPrior; + + testcase( pItem->addrFillSub==0 ); /* Ticket c52b09c7f38903b1311 */ + pItem->regReturn = ++pParse->nMem; + topAddr = sqlite3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn); + pItem->addrFillSub = topAddr+1; + if( pItem->fg.isCorrelated==0 ){ + /* If the subquery is not correlated and if we are not inside of + ** a trigger, then we only need to compute the value of the subquery + ** once. */ + onceAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + VdbeComment((v, "materialize \"%s\"", pItem->pTab->zName)); + }else{ + VdbeNoopComment((v, "materialize \"%s\"", pItem->pTab->zName)); + } + pPrior = isSelfJoinView(pTabList, pItem); + if( pPrior ){ + sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor); + assert( pPrior->pSelect!=0 ); + pSub->nSelectRow = pPrior->pSelect->nSelectRow; + }else{ + sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor); + ExplainQueryPlan((pParse, 1, "MATERIALIZE %u", pSub->selId)); + sqlite3Select(pParse, pSub, &dest); + } + pItem->pTab->nRowLogEst = pSub->nSelectRow; + if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr); + retAddr = sqlite3VdbeAddOp1(v, OP_Return, pItem->regReturn); + VdbeComment((v, "end %s", pItem->pTab->zName)); + sqlite3VdbeChangeP1(v, topAddr, retAddr); + sqlite3ClearTempRegCache(pParse); + } + if( db->mallocFailed ) goto select_end; + pParse->nHeight -= sqlite3SelectExprHeight(p); + pParse->zAuthContext = zSavedAuthContext; +#endif + } + + /* Various elements of the SELECT copied into local variables for + ** convenience */ + pEList = p->pEList; + pWhere = p->pWhere; + pGroupBy = p->pGroupBy; + pHaving = p->pHaving; + sDistinct.isTnct = (p->selFlags & SF_Distinct)!=0; + +#if SELECTTRACE_ENABLED + if( sqlite3_unsupported_selecttrace & 0x400 ){ + SELECTTRACE(0x400,pParse,p,("After all FROM-clause analysis:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + + /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and + ** if the select-list is the same as the ORDER BY list, then this query + ** can be rewritten as a GROUP BY. In other words, this: + ** + ** SELECT DISTINCT xyz FROM ... ORDER BY xyz + ** + ** is transformed to: + ** + ** SELECT xyz FROM ... GROUP BY xyz ORDER BY xyz + ** + ** The second form is preferred as a single index (or temp-table) may be + ** used for both the ORDER BY and DISTINCT processing. As originally + ** written the query must use a temp-table for at least one of the ORDER + ** BY and DISTINCT, and an index or separate temp-table for the other. + */ + if( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct + && sqlite3ExprListCompare(sSort.pOrderBy, pEList, -1)==0 +#ifndef SQLITE_OMIT_WINDOWFUNC + && p->pWin==0 +#endif + ){ + p->selFlags &= ~SF_Distinct; + pGroupBy = p->pGroupBy = sqlite3ExprListDup(db, pEList, 0); + p->selFlags |= SF_Aggregate; + /* Notice that even thought SF_Distinct has been cleared from p->selFlags, + ** the sDistinct.isTnct is still set. Hence, isTnct represents the + ** original setting of the SF_Distinct flag, not the current setting */ + assert( sDistinct.isTnct ); + +#if SELECTTRACE_ENABLED + if( sqlite3_unsupported_selecttrace & 0x400 ){ + SELECTTRACE(0x400,pParse,p,("Transform DISTINCT into GROUP BY:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + } + + /* If there is an ORDER BY clause, then create an ephemeral index to + ** do the sorting. But this sorting ephemeral index might end up + ** being unused if the data can be extracted in pre-sorted order. + ** If that is the case, then the OP_OpenEphemeral instruction will be + ** changed to an OP_Noop once we figure out that the sorting index is + ** not needed. The sSort.addrSortIndex variable is used to facilitate + ** that change. + */ + if( sSort.pOrderBy ){ + KeyInfo *pKeyInfo; + pKeyInfo = sqlite3KeyInfoFromExprList( + pParse, sSort.pOrderBy, 0, pEList->nExpr); + sSort.iECursor = pParse->nTab++; + sSort.addrSortIndex = + sqlite3VdbeAddOp4(v, OP_OpenEphemeral, + sSort.iECursor, sSort.pOrderBy->nExpr+1+pEList->nExpr, 0, + (char*)pKeyInfo, P4_KEYINFO + ); + }else{ + sSort.addrSortIndex = -1; + } + + /* If the output is destined for a temporary table, open that table. + */ + if( pDest->eDest==SRT_EphemTab ){ + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iSDParm, pEList->nExpr); + } + + /* Set the limiter. + */ + iEnd = sqlite3VdbeMakeLabel(pParse); + if( (p->selFlags & SF_FixedLimit)==0 ){ + p->nSelectRow = 320; /* 4 billion rows */ + } + computeLimitRegisters(pParse, p, iEnd); + if( p->iLimit==0 && sSort.addrSortIndex>=0 ){ + sqlite3VdbeChangeOpcode(v, sSort.addrSortIndex, OP_SorterOpen); + sSort.sortFlags |= SORTFLAG_UseSorter; + } + + /* Open an ephemeral index to use for the distinct set. + */ + if( p->selFlags & SF_Distinct ){ + sDistinct.tabTnct = pParse->nTab++; + sDistinct.addrTnct = sqlite3VdbeAddOp4(v, OP_OpenEphemeral, + sDistinct.tabTnct, 0, 0, + (char*)sqlite3KeyInfoFromExprList(pParse, p->pEList,0,0), + P4_KEYINFO); + sqlite3VdbeChangeP5(v, BTREE_UNORDERED); + sDistinct.eTnctType = WHERE_DISTINCT_UNORDERED; + }else{ + sDistinct.eTnctType = WHERE_DISTINCT_NOOP; + } + + if( !isAgg && pGroupBy==0 ){ + /* No aggregate functions and no GROUP BY clause */ + u16 wctrlFlags = (sDistinct.isTnct ? WHERE_WANT_DISTINCT : 0) + | (p->selFlags & SF_FixedLimit); +#ifndef SQLITE_OMIT_WINDOWFUNC + Window *pWin = p->pWin; /* Main window object (or NULL) */ + if( pWin ){ + sqlite3WindowCodeInit(pParse, p); + } +#endif + assert( WHERE_USE_LIMIT==SF_FixedLimit ); + + + /* Begin the database scan. */ + SELECTTRACE(1,pParse,p,("WhereBegin\n")); + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, sSort.pOrderBy, + p->pEList, wctrlFlags, p->nSelectRow); + if( pWInfo==0 ) goto select_end; + if( sqlite3WhereOutputRowCount(pWInfo) < p->nSelectRow ){ + p->nSelectRow = sqlite3WhereOutputRowCount(pWInfo); + } + if( sDistinct.isTnct && sqlite3WhereIsDistinct(pWInfo) ){ + sDistinct.eTnctType = sqlite3WhereIsDistinct(pWInfo); + } + if( sSort.pOrderBy ){ + sSort.nOBSat = sqlite3WhereIsOrdered(pWInfo); + sSort.labelOBLopt = sqlite3WhereOrderByLimitOptLabel(pWInfo); + if( sSort.nOBSat==sSort.pOrderBy->nExpr ){ + sSort.pOrderBy = 0; + } + } + + /* If sorting index that was created by a prior OP_OpenEphemeral + ** instruction ended up not being needed, then change the OP_OpenEphemeral + ** into an OP_Noop. + */ + if( sSort.addrSortIndex>=0 && sSort.pOrderBy==0 ){ + sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex); + } + + assert( p->pEList==pEList ); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( pWin ){ + int addrGosub = sqlite3VdbeMakeLabel(pParse); + int iCont = sqlite3VdbeMakeLabel(pParse); + int iBreak = sqlite3VdbeMakeLabel(pParse); + int regGosub = ++pParse->nMem; + + sqlite3WindowCodeStep(pParse, p, pWInfo, regGosub, addrGosub); + + sqlite3VdbeAddOp2(v, OP_Goto, 0, iBreak); + sqlite3VdbeResolveLabel(v, addrGosub); + VdbeNoopComment((v, "inner-loop subroutine")); + sSort.labelOBLopt = 0; + selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest, iCont, iBreak); + sqlite3VdbeResolveLabel(v, iCont); + sqlite3VdbeAddOp1(v, OP_Return, regGosub); + VdbeComment((v, "end inner-loop subroutine")); + sqlite3VdbeResolveLabel(v, iBreak); + }else +#endif /* SQLITE_OMIT_WINDOWFUNC */ + { + /* Use the standard inner loop. */ + selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest, + sqlite3WhereContinueLabel(pWInfo), + sqlite3WhereBreakLabel(pWInfo)); + + /* End the database scan loop. + */ + sqlite3WhereEnd(pWInfo); + } + }else{ + /* This case when there exist aggregate functions or a GROUP BY clause + ** or both */ + NameContext sNC; /* Name context for processing aggregate information */ + int iAMem; /* First Mem address for storing current GROUP BY */ + int iBMem; /* First Mem address for previous GROUP BY */ + int iUseFlag; /* Mem address holding flag indicating that at least + ** one row of the input to the aggregator has been + ** processed */ + int iAbortFlag; /* Mem address which causes query abort if positive */ + int groupBySort; /* Rows come from source in GROUP BY order */ + int addrEnd; /* End of processing for this SELECT */ + int sortPTab = 0; /* Pseudotable used to decode sorting results */ + int sortOut = 0; /* Output register from the sorter */ + int orderByGrp = 0; /* True if the GROUP BY and ORDER BY are the same */ + + /* Remove any and all aliases between the result set and the + ** GROUP BY clause. + */ + if( pGroupBy ){ + int k; /* Loop counter */ + struct ExprList_item *pItem; /* For looping over expression in a list */ + + for(k=p->pEList->nExpr, pItem=p->pEList->a; k>0; k--, pItem++){ + pItem->u.x.iAlias = 0; + } + for(k=pGroupBy->nExpr, pItem=pGroupBy->a; k>0; k--, pItem++){ + pItem->u.x.iAlias = 0; + } + assert( 66==sqlite3LogEst(100) ); + if( p->nSelectRow>66 ) p->nSelectRow = 66; + + /* If there is both a GROUP BY and an ORDER BY clause and they are + ** identical, then it may be possible to disable the ORDER BY clause + ** on the grounds that the GROUP BY will cause elements to come out + ** in the correct order. It also may not - the GROUP BY might use a + ** database index that causes rows to be grouped together as required + ** but not actually sorted. Either way, record the fact that the + ** ORDER BY and GROUP BY clauses are the same by setting the orderByGrp + ** variable. */ + if( sSort.pOrderBy && pGroupBy->nExpr==sSort.pOrderBy->nExpr ){ + int ii; + /* The GROUP BY processing doesn't care whether rows are delivered in + ** ASC or DESC order - only that each group is returned contiguously. + ** So set the ASC/DESC flags in the GROUP BY to match those in the + ** ORDER BY to maximize the chances of rows being delivered in an + ** order that makes the ORDER BY redundant. */ + for(ii=0; iinExpr; ii++){ + u8 sortFlags = sSort.pOrderBy->a[ii].sortFlags & KEYINFO_ORDER_DESC; + pGroupBy->a[ii].sortFlags = sortFlags; + } + if( sqlite3ExprListCompare(pGroupBy, sSort.pOrderBy, -1)==0 ){ + orderByGrp = 1; + } + } + }else{ + assert( 0==sqlite3LogEst(1) ); + p->nSelectRow = 0; + } + + /* Create a label to jump to when we want to abort the query */ + addrEnd = sqlite3VdbeMakeLabel(pParse); + + /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in + ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the + ** SELECT statement. + */ + pAggInfo = sqlite3DbMallocZero(db, sizeof(*pAggInfo) ); + if( pAggInfo==0 ){ + goto select_end; + } + pAggInfo->pNext = pParse->pAggList; + pParse->pAggList = pAggInfo; + pAggInfo->selId = p->selId; + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pSrcList = pTabList; + sNC.uNC.pAggInfo = pAggInfo; + VVA_ONLY( sNC.ncFlags = NC_UAggInfo; ) + pAggInfo->mnReg = pParse->nMem+1; + pAggInfo->nSortingColumn = pGroupBy ? pGroupBy->nExpr : 0; + pAggInfo->pGroupBy = pGroupBy; + sqlite3ExprAnalyzeAggList(&sNC, pEList); + sqlite3ExprAnalyzeAggList(&sNC, sSort.pOrderBy); + if( pHaving ){ + if( pGroupBy ){ + assert( pWhere==p->pWhere ); + assert( pHaving==p->pHaving ); + assert( pGroupBy==p->pGroupBy ); + havingToWhere(pParse, p); + pWhere = p->pWhere; + } + sqlite3ExprAnalyzeAggregates(&sNC, pHaving); + } + pAggInfo->nAccumulator = pAggInfo->nColumn; + if( p->pGroupBy==0 && p->pHaving==0 && pAggInfo->nFunc==1 ){ + minMaxFlag = minMaxQuery(db, pAggInfo->aFunc[0].pFExpr, &pMinMaxOrderBy); + }else{ + minMaxFlag = WHERE_ORDERBY_NORMAL; + } + for(i=0; inFunc; i++){ + Expr *pExpr = pAggInfo->aFunc[i].pFExpr; + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + sNC.ncFlags |= NC_InAggFunc; + sqlite3ExprAnalyzeAggList(&sNC, pExpr->x.pList); +#ifndef SQLITE_OMIT_WINDOWFUNC + assert( !IsWindowFunc(pExpr) ); + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + sqlite3ExprAnalyzeAggregates(&sNC, pExpr->y.pWin->pFilter); + } +#endif + sNC.ncFlags &= ~NC_InAggFunc; + } + pAggInfo->mxReg = pParse->nMem; + if( db->mallocFailed ) goto select_end; +#if SELECTTRACE_ENABLED + if( sqlite3_unsupported_selecttrace & 0x400 ){ + int ii; + SELECTTRACE(0x400,pParse,p,("After aggregate analysis %p:\n", pAggInfo)); + sqlite3TreeViewSelect(0, p, 0); + for(ii=0; iinColumn; ii++){ + sqlite3DebugPrintf("agg-column[%d] iMem=%d\n", + ii, pAggInfo->aCol[ii].iMem); + sqlite3TreeViewExpr(0, pAggInfo->aCol[ii].pCExpr, 0); + } + for(ii=0; iinFunc; ii++){ + sqlite3DebugPrintf("agg-func[%d]: iMem=%d\n", + ii, pAggInfo->aFunc[ii].iMem); + sqlite3TreeViewExpr(0, pAggInfo->aFunc[ii].pFExpr, 0); + } + } +#endif + + + /* Processing for aggregates with GROUP BY is very different and + ** much more complex than aggregates without a GROUP BY. + */ + if( pGroupBy ){ + KeyInfo *pKeyInfo; /* Keying information for the group by clause */ + int addr1; /* A-vs-B comparision jump */ + int addrOutputRow; /* Start of subroutine that outputs a result row */ + int regOutputRow; /* Return address register for output subroutine */ + int addrSetAbort; /* Set the abort flag and return */ + int addrTopOfLoop; /* Top of the input loop */ + int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */ + int addrReset; /* Subroutine for resetting the accumulator */ + int regReset; /* Return address register for reset subroutine */ + + /* If there is a GROUP BY clause we might need a sorting index to + ** implement it. Allocate that sorting index now. If it turns out + ** that we do not need it after all, the OP_SorterOpen instruction + ** will be converted into a Noop. + */ + pAggInfo->sortingIdx = pParse->nTab++; + pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pGroupBy, + 0, pAggInfo->nColumn); + addrSortingIdx = sqlite3VdbeAddOp4(v, OP_SorterOpen, + pAggInfo->sortingIdx, pAggInfo->nSortingColumn, + 0, (char*)pKeyInfo, P4_KEYINFO); + + /* Initialize memory locations used by GROUP BY aggregate processing + */ + iUseFlag = ++pParse->nMem; + iAbortFlag = ++pParse->nMem; + regOutputRow = ++pParse->nMem; + addrOutputRow = sqlite3VdbeMakeLabel(pParse); + regReset = ++pParse->nMem; + addrReset = sqlite3VdbeMakeLabel(pParse); + iAMem = pParse->nMem + 1; + pParse->nMem += pGroupBy->nExpr; + iBMem = pParse->nMem + 1; + pParse->nMem += pGroupBy->nExpr; + sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag); + VdbeComment((v, "clear abort flag")); + sqlite3VdbeAddOp3(v, OP_Null, 0, iAMem, iAMem+pGroupBy->nExpr-1); + + /* Begin a loop that will extract all source rows in GROUP BY order. + ** This might involve two separate loops with an OP_Sort in between, or + ** it might be a single loop that uses an index to extract information + ** in the right order to begin with. + */ + sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset); + SELECTTRACE(1,pParse,p,("WhereBegin\n")); + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, 0, + WHERE_GROUPBY | (orderByGrp ? WHERE_SORTBYGROUP : 0), 0 + ); + if( pWInfo==0 ) goto select_end; + if( sqlite3WhereIsOrdered(pWInfo)==pGroupBy->nExpr ){ + /* The optimizer is able to deliver rows in group by order so + ** we do not have to sort. The OP_OpenEphemeral table will be + ** cancelled later because we still need to use the pKeyInfo + */ + groupBySort = 0; + }else{ + /* Rows are coming out in undetermined order. We have to push + ** each row into a sorting index, terminate the first loop, + ** then loop over the sorting index in order to get the output + ** in sorted order + */ + int regBase; + int regRecord; + int nCol; + int nGroupBy; + + explainTempTable(pParse, + (sDistinct.isTnct && (p->selFlags&SF_Distinct)==0) ? + "DISTINCT" : "GROUP BY"); + + groupBySort = 1; + nGroupBy = pGroupBy->nExpr; + nCol = nGroupBy; + j = nGroupBy; + for(i=0; inColumn; i++){ + if( pAggInfo->aCol[i].iSorterColumn>=j ){ + nCol++; + j++; + } + } + regBase = sqlite3GetTempRange(pParse, nCol); + sqlite3ExprCodeExprList(pParse, pGroupBy, regBase, 0, 0); + j = nGroupBy; + for(i=0; inColumn; i++){ + struct AggInfo_col *pCol = &pAggInfo->aCol[i]; + if( pCol->iSorterColumn>=j ){ + int r1 = j + regBase; + sqlite3ExprCodeGetColumnOfTable(v, + pCol->pTab, pCol->iTable, pCol->iColumn, r1); + j++; + } + } + regRecord = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord); + sqlite3VdbeAddOp2(v, OP_SorterInsert, pAggInfo->sortingIdx, regRecord); + sqlite3ReleaseTempReg(pParse, regRecord); + sqlite3ReleaseTempRange(pParse, regBase, nCol); + sqlite3WhereEnd(pWInfo); + pAggInfo->sortingIdxPTab = sortPTab = pParse->nTab++; + sortOut = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol); + sqlite3VdbeAddOp2(v, OP_SorterSort, pAggInfo->sortingIdx, addrEnd); + VdbeComment((v, "GROUP BY sort")); VdbeCoverage(v); + pAggInfo->useSortingIdx = 1; + } + + /* If the index or temporary table used by the GROUP BY sort + ** will naturally deliver rows in the order required by the ORDER BY + ** clause, cancel the ephemeral table open coded earlier. + ** + ** This is an optimization - the correct answer should result regardless. + ** Use the SQLITE_GroupByOrder flag with SQLITE_TESTCTRL_OPTIMIZER to + ** disable this optimization for testing purposes. */ + if( orderByGrp && OptimizationEnabled(db, SQLITE_GroupByOrder) + && (groupBySort || sqlite3WhereIsSorted(pWInfo)) + ){ + sSort.pOrderBy = 0; + sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex); + } + + /* Evaluate the current GROUP BY terms and store in b0, b1, b2... + ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth) + ** Then compare the current GROUP BY terms against the GROUP BY terms + ** from the previous row currently stored in a0, a1, a2... + */ + addrTopOfLoop = sqlite3VdbeCurrentAddr(v); + if( groupBySort ){ + sqlite3VdbeAddOp3(v, OP_SorterData, pAggInfo->sortingIdx, + sortOut, sortPTab); + } + for(j=0; jnExpr; j++){ + if( groupBySort ){ + sqlite3VdbeAddOp3(v, OP_Column, sortPTab, j, iBMem+j); + }else{ + pAggInfo->directMode = 1; + sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j); + } + } + sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr, + (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO); + addr1 = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp3(v, OP_Jump, addr1+1, 0, addr1+1); VdbeCoverage(v); + + /* Generate code that runs whenever the GROUP BY changes. + ** Changes in the GROUP BY are detected by the previous code + ** block. If there were no changes, this block is skipped. + ** + ** This code copies current group by terms in b0,b1,b2,... + ** over to a0,a1,a2. It then calls the output subroutine + ** and resets the aggregate accumulator registers in preparation + ** for the next GROUP BY batch. + */ + sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr); + sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow); + VdbeComment((v, "output one row")); + sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd); VdbeCoverage(v); + VdbeComment((v, "check abort flag")); + sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset); + VdbeComment((v, "reset accumulator")); + + /* Update the aggregate accumulators based on the content of + ** the current row + */ + sqlite3VdbeJumpHere(v, addr1); + updateAccumulator(pParse, iUseFlag, pAggInfo); + sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag); + VdbeComment((v, "indicate data in accumulator")); + + /* End of the loop + */ + if( groupBySort ){ + sqlite3VdbeAddOp2(v, OP_SorterNext, pAggInfo->sortingIdx, addrTopOfLoop); + VdbeCoverage(v); + }else{ + sqlite3WhereEnd(pWInfo); + sqlite3VdbeChangeToNoop(v, addrSortingIdx); + } + + /* Output the final row of result + */ + sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow); + VdbeComment((v, "output final row")); + + /* Jump over the subroutines + */ + sqlite3VdbeGoto(v, addrEnd); + + /* Generate a subroutine that outputs a single row of the result + ** set. This subroutine first looks at the iUseFlag. If iUseFlag + ** is less than or equal to zero, the subroutine is a no-op. If + ** the processing calls for the query to abort, this subroutine + ** increments the iAbortFlag memory location before returning in + ** order to signal the caller to abort. + */ + addrSetAbort = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag); + VdbeComment((v, "set abort flag")); + sqlite3VdbeAddOp1(v, OP_Return, regOutputRow); + sqlite3VdbeResolveLabel(v, addrOutputRow); + addrOutputRow = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2); + VdbeCoverage(v); + VdbeComment((v, "Groupby result generator entry point")); + sqlite3VdbeAddOp1(v, OP_Return, regOutputRow); + finalizeAggFunctions(pParse, pAggInfo); + sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL); + selectInnerLoop(pParse, p, -1, &sSort, + &sDistinct, pDest, + addrOutputRow+1, addrSetAbort); + sqlite3VdbeAddOp1(v, OP_Return, regOutputRow); + VdbeComment((v, "end groupby result generator")); + + /* Generate a subroutine that will reset the group-by accumulator + */ + sqlite3VdbeResolveLabel(v, addrReset); + resetAccumulator(pParse, pAggInfo); + sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag); + VdbeComment((v, "indicate accumulator empty")); + sqlite3VdbeAddOp1(v, OP_Return, regReset); + + } /* endif pGroupBy. Begin aggregate queries without GROUP BY: */ + else { + Table *pTab; + if( (pTab = isSimpleCount(p, pAggInfo))!=0 ){ + /* If isSimpleCount() returns a pointer to a Table structure, then + ** the SQL statement is of the form: + ** + ** SELECT count(*) FROM + ** + ** where the Table structure returned represents table . + ** + ** This statement is so common that it is optimized specially. The + ** OP_Count instruction is executed either on the intkey table that + ** contains the data for table or on one of its indexes. It + ** is better to execute the op on an index, as indexes are almost + ** always spread across less pages than their corresponding tables. + */ + const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + const int iCsr = pParse->nTab++; /* Cursor to scan b-tree */ + Index *pIdx; /* Iterator variable */ + KeyInfo *pKeyInfo = 0; /* Keyinfo for scanned index */ + Index *pBest = 0; /* Best index found so far */ + Pgno iRoot = pTab->tnum; /* Root page of scanned b-tree */ + + sqlite3CodeVerifySchema(pParse, iDb); + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + + /* Search for the index that has the lowest scan cost. + ** + ** (2011-04-15) Do not do a full scan of an unordered index. + ** + ** (2013-10-03) Do not count the entries in a partial index. + ** + ** In practice the KeyInfo structure will not be used. It is only + ** passed to keep OP_OpenRead happy. + */ + if( !HasRowid(pTab) ) pBest = sqlite3PrimaryKeyIndex(pTab); + if( !p->pSrc->a[0].fg.notIndexed ){ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + if( pIdx->bUnordered==0 + && pIdx->szIdxRowszTabRow + && pIdx->pPartIdxWhere==0 + && (!pBest || pIdx->szIdxRowszIdxRow) + ){ + pBest = pIdx; + } + } + } + if( pBest ){ + iRoot = pBest->tnum; + pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pBest); + } + + /* Open a read-only cursor, execute the OP_Count, close the cursor. */ + sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, (int)iRoot, iDb, 1); + if( pKeyInfo ){ + sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO); + } + sqlite3VdbeAddOp2(v, OP_Count, iCsr, pAggInfo->aFunc[0].iMem); + sqlite3VdbeAddOp1(v, OP_Close, iCsr); + explainSimpleCount(pParse, pTab, pBest); + }else{ + int regAcc = 0; /* "populate accumulators" flag */ + int addrSkip; + + /* If there are accumulator registers but no min() or max() functions + ** without FILTER clauses, allocate register regAcc. Register regAcc + ** will contain 0 the first time the inner loop runs, and 1 thereafter. + ** The code generated by updateAccumulator() uses this to ensure + ** that the accumulator registers are (a) updated only once if + ** there are no min() or max functions or (b) always updated for the + ** first row visited by the aggregate, so that they are updated at + ** least once even if the FILTER clause means the min() or max() + ** function visits zero rows. */ + if( pAggInfo->nAccumulator ){ + for(i=0; inFunc; i++){ + if( ExprHasProperty(pAggInfo->aFunc[i].pFExpr, EP_WinFunc) ){ + continue; + } + if( pAggInfo->aFunc[i].pFunc->funcFlags&SQLITE_FUNC_NEEDCOLL ){ + break; + } + } + if( i==pAggInfo->nFunc ){ + regAcc = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regAcc); + } + } + + /* This case runs if the aggregate has no GROUP BY clause. The + ** processing is much simpler since there is only a single row + ** of output. + */ + assert( p->pGroupBy==0 ); + resetAccumulator(pParse, pAggInfo); + + /* If this query is a candidate for the min/max optimization, then + ** minMaxFlag will have been previously set to either + ** WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX and pMinMaxOrderBy will + ** be an appropriate ORDER BY expression for the optimization. + */ + assert( minMaxFlag==WHERE_ORDERBY_NORMAL || pMinMaxOrderBy!=0 ); + assert( pMinMaxOrderBy==0 || pMinMaxOrderBy->nExpr==1 ); + + SELECTTRACE(1,pParse,p,("WhereBegin\n")); + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMaxOrderBy, + 0, minMaxFlag, 0); + if( pWInfo==0 ){ + goto select_end; + } + updateAccumulator(pParse, regAcc, pAggInfo); + if( regAcc ) sqlite3VdbeAddOp2(v, OP_Integer, 1, regAcc); + addrSkip = sqlite3WhereOrderByLimitOptLabel(pWInfo); + if( addrSkip!=sqlite3WhereContinueLabel(pWInfo) ){ + sqlite3VdbeGoto(v, addrSkip); + } + sqlite3WhereEnd(pWInfo); + finalizeAggFunctions(pParse, pAggInfo); + } + + sSort.pOrderBy = 0; + sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL); + selectInnerLoop(pParse, p, -1, 0, 0, + pDest, addrEnd, addrEnd); + } + sqlite3VdbeResolveLabel(v, addrEnd); + + } /* endif aggregate query */ + + if( sDistinct.eTnctType==WHERE_DISTINCT_UNORDERED ){ + explainTempTable(pParse, "DISTINCT"); + } + + /* If there is an ORDER BY clause, then we need to sort the results + ** 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); + } + + /* Jump here to skip this query + */ + sqlite3VdbeResolveLabel(v, iEnd); + + /* The SELECT has been coded. If there is an error in the Parse structure, + ** set the return code to 1. Otherwise 0. */ + rc = (pParse->nErr>0); + + /* Control jumps to here if an error is encountered above, or upon + ** successful coding of the SELECT. + */ +select_end: + sqlite3ExprListDelete(db, pMinMaxOrderBy); +#ifdef SQLITE_DEBUG + if( pAggInfo && !db->mallocFailed ){ + for(i=0; inColumn; i++){ + Expr *pExpr = pAggInfo->aCol[i].pCExpr; + assert( pExpr!=0 || db->mallocFailed ); + if( pExpr==0 ) continue; + assert( pExpr->pAggInfo==pAggInfo ); + assert( pExpr->iAgg==i ); + } + for(i=0; inFunc; i++){ + Expr *pExpr = pAggInfo->aFunc[i].pFExpr; + assert( pExpr!=0 || db->mallocFailed ); + if( pExpr==0 ) continue; + assert( pExpr->pAggInfo==pAggInfo ); + assert( pExpr->iAgg==i ); + } + } +#endif + +#if SELECTTRACE_ENABLED + SELECTTRACE(0x1,pParse,p,("end processing\n")); + if( (sqlite3_unsupported_selecttrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){ + sqlite3TreeViewSelect(0, p, 0); + } +#endif + ExplainQueryPlanPop(pParse); + return rc; +} + +/************** End of select.c **********************************************/ +/************** Begin file table.c *******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the sqlite3_get_table() and sqlite3_free_table() +** interface routines. These are just wrappers around the main +** interface routine of sqlite3_exec(). +** +** These routines are in a separate files so that they will not be linked +** if they are not used. +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_GET_TABLE + +/* +** This structure is used to pass data from sqlite3_get_table() through +** to the callback function is uses to build the result. +*/ +typedef struct TabResult { + char **azResult; /* Accumulated output */ + char *zErrMsg; /* Error message text, if an error occurs */ + u32 nAlloc; /* Slots allocated for azResult[] */ + u32 nRow; /* Number of rows in the result */ + u32 nColumn; /* Number of columns in the result */ + u32 nData; /* Slots used in azResult[]. (nRow+1)*nColumn */ + int rc; /* Return code from sqlite3_exec() */ +} TabResult; + +/* +** This routine is called once for each row in the result table. Its job +** is to fill in the TabResult structure appropriately, allocating new +** memory as necessary. +*/ +static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){ + TabResult *p = (TabResult*)pArg; /* Result accumulator */ + int need; /* Slots needed in p->azResult[] */ + int i; /* Loop counter */ + char *z; /* A single column of result */ + + /* Make sure there is enough space in p->azResult to hold everything + ** we need to remember from this invocation of the callback. + */ + if( p->nRow==0 && argv!=0 ){ + need = nCol*2; + }else{ + need = nCol; + } + if( p->nData + need > p->nAlloc ){ + char **azNew; + p->nAlloc = p->nAlloc*2 + need; + azNew = sqlite3Realloc( p->azResult, sizeof(char*)*p->nAlloc ); + if( azNew==0 ) goto malloc_failed; + p->azResult = azNew; + } + + /* If this is the first row, then generate an extra row containing + ** the names of all columns. + */ + if( p->nRow==0 ){ + p->nColumn = nCol; + for(i=0; iazResult[p->nData++] = z; + } + }else if( (int)p->nColumn!=nCol ){ + sqlite3_free(p->zErrMsg); + p->zErrMsg = sqlite3_mprintf( + "sqlite3_get_table() called with two or more incompatible queries" + ); + p->rc = SQLITE_ERROR; + return 1; + } + + /* Copy over the row data + */ + if( argv!=0 ){ + for(i=0; iazResult[p->nData++] = z; + } + p->nRow++; + } + return 0; + +malloc_failed: + p->rc = SQLITE_NOMEM_BKPT; + return 1; +} + +/* +** Query the database. But instead of invoking a callback for each row, +** malloc() for space to hold the result and return the entire results +** at the conclusion of the call. +** +** The result that is written to ***pazResult is held in memory obtained +** from malloc(). But the caller cannot free this memory directly. +** Instead, the entire table should be passed to sqlite3_free_table() when +** the calling procedure is finished using it. +*/ +SQLITE_API int sqlite3_get_table( + sqlite3 *db, /* The database on which the SQL executes */ + const char *zSql, /* The SQL to be executed */ + char ***pazResult, /* Write the result table here */ + int *pnRow, /* Write the number of rows in the result here */ + int *pnColumn, /* Write the number of columns of result here */ + char **pzErrMsg /* Write error messages here */ +){ + int rc; + TabResult res; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || pazResult==0 ) return SQLITE_MISUSE_BKPT; +#endif + *pazResult = 0; + if( pnColumn ) *pnColumn = 0; + if( pnRow ) *pnRow = 0; + if( pzErrMsg ) *pzErrMsg = 0; + res.zErrMsg = 0; + res.nRow = 0; + res.nColumn = 0; + res.nData = 1; + res.nAlloc = 20; + res.rc = SQLITE_OK; + res.azResult = sqlite3_malloc64(sizeof(char*)*res.nAlloc ); + if( res.azResult==0 ){ + db->errCode = SQLITE_NOMEM; + return SQLITE_NOMEM_BKPT; + } + res.azResult[0] = 0; + rc = sqlite3_exec(db, zSql, sqlite3_get_table_cb, &res, pzErrMsg); + assert( sizeof(res.azResult[0])>= sizeof(res.nData) ); + res.azResult[0] = SQLITE_INT_TO_PTR(res.nData); + if( (rc&0xff)==SQLITE_ABORT ){ + sqlite3_free_table(&res.azResult[1]); + if( res.zErrMsg ){ + if( pzErrMsg ){ + sqlite3_free(*pzErrMsg); + *pzErrMsg = sqlite3_mprintf("%s",res.zErrMsg); + } + sqlite3_free(res.zErrMsg); + } + db->errCode = res.rc; /* Assume 32-bit assignment is atomic */ + return res.rc; + } + sqlite3_free(res.zErrMsg); + if( rc!=SQLITE_OK ){ + sqlite3_free_table(&res.azResult[1]); + return rc; + } + if( res.nAlloc>res.nData ){ + char **azNew; + azNew = sqlite3Realloc( res.azResult, sizeof(char*)*res.nData ); + if( azNew==0 ){ + sqlite3_free_table(&res.azResult[1]); + db->errCode = SQLITE_NOMEM; + return SQLITE_NOMEM_BKPT; + } + res.azResult = azNew; + } + *pazResult = &res.azResult[1]; + if( pnColumn ) *pnColumn = res.nColumn; + if( pnRow ) *pnRow = res.nRow; + return rc; +} + +/* +** This routine frees the space the sqlite3_get_table() malloced. +*/ +SQLITE_API void sqlite3_free_table( + char **azResult /* Result returned from sqlite3_get_table() */ +){ + if( azResult ){ + int i, n; + azResult--; + assert( azResult!=0 ); + n = SQLITE_PTR_TO_INT(azResult[0]); + for(i=1; ipNext; + + sqlite3ExprDelete(db, pTmp->pWhere); + sqlite3ExprListDelete(db, pTmp->pExprList); + sqlite3SelectDelete(db, pTmp->pSelect); + sqlite3IdListDelete(db, pTmp->pIdList); + sqlite3UpsertDelete(db, pTmp->pUpsert); + sqlite3SrcListDelete(db, pTmp->pFrom); + sqlite3DbFree(db, pTmp->zSpan); + + sqlite3DbFree(db, pTmp); + } +} + +/* +** Given table pTab, return a list of all the triggers attached to +** the table. The list is connected by Trigger.pNext pointers. +** +** All of the triggers on pTab that are in the same database as pTab +** are already attached to pTab->pTrigger. But there might be additional +** triggers on pTab in the TEMP schema. This routine prepends all +** TEMP triggers on pTab to the beginning of the pTab->pTrigger list +** and returns the combined list. +** +** To state it another way: This routine returns a list of all triggers +** that fire off of pTab. The list will include any TEMP triggers on +** pTab as well as the triggers lised in pTab->pTrigger. +*/ +SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){ + Schema * const pTmpSchema = pParse->db->aDb[1].pSchema; + Trigger *pList = 0; /* List of triggers to return */ + + if( pParse->disableTriggers ){ + return 0; + } + + if( pTmpSchema!=pTab->pSchema ){ + HashElem *p; + assert( sqlite3SchemaMutexHeld(pParse->db, 0, pTmpSchema) ); + for(p=sqliteHashFirst(&pTmpSchema->trigHash); p; p=sqliteHashNext(p)){ + Trigger *pTrig = (Trigger *)sqliteHashData(p); + if( pTrig->pTabSchema==pTab->pSchema + && 0==sqlite3StrICmp(pTrig->table, pTab->zName) + ){ + pTrig->pNext = (pList ? pList : pTab->pTrigger); + pList = pTrig; + } + } + } + + return (pList ? pList : pTab->pTrigger); +} + +/* +** This is called by the parser when it sees a CREATE TRIGGER statement +** up to the point of the BEGIN before the trigger actions. A Trigger +** structure is generated based on the information available and stored +** in pParse->pNewTrigger. After the trigger actions have been parsed, the +** sqlite3FinishTrigger() function is called to complete the trigger +** construction process. +*/ +SQLITE_PRIVATE void sqlite3BeginTrigger( + Parse *pParse, /* The parse context of the CREATE TRIGGER statement */ + Token *pName1, /* The name of the trigger */ + Token *pName2, /* The name of the trigger */ + int tr_tm, /* One of TK_BEFORE, TK_AFTER, TK_INSTEAD */ + int op, /* One of TK_INSERT, TK_UPDATE, TK_DELETE */ + IdList *pColumns, /* column list if this is an UPDATE OF trigger */ + SrcList *pTableName,/* The name of the table/view the trigger applies to */ + Expr *pWhen, /* WHEN clause */ + int isTemp, /* True if the TEMPORARY keyword is present */ + int noErr /* Suppress errors if the trigger already exists */ +){ + Trigger *pTrigger = 0; /* The new trigger */ + Table *pTab; /* Table that the trigger fires off of */ + char *zName = 0; /* Name of the trigger */ + sqlite3 *db = pParse->db; /* The database connection */ + int iDb; /* The database to store the trigger in */ + Token *pName; /* The unqualified db name */ + DbFixer sFix; /* State vector for the DB fixer */ + + assert( pName1!=0 ); /* pName1->z might be NULL, but not pName1 itself */ + assert( pName2!=0 ); + assert( op==TK_INSERT || op==TK_UPDATE || op==TK_DELETE ); + assert( op>0 && op<0xff ); + if( isTemp ){ + /* If TEMP was specified, then the trigger name may not be qualified. */ + if( pName2->n>0 ){ + sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name"); + goto trigger_cleanup; + } + iDb = 1; + pName = pName1; + }else{ + /* Figure out the db that the trigger will be created in */ + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName); + if( iDb<0 ){ + goto trigger_cleanup; + } + } + if( !pTableName || db->mallocFailed ){ + goto trigger_cleanup; + } + + /* A long-standing parser bug is that this syntax was allowed: + ** + ** CREATE TRIGGER attached.demo AFTER INSERT ON attached.tab .... + ** ^^^^^^^^ + ** + ** To maintain backwards compatibility, ignore the database + ** name on pTableName if we are reparsing out of the schema table + */ + if( db->init.busy && iDb!=1 ){ + sqlite3DbFree(db, pTableName->a[0].zDatabase); + pTableName->a[0].zDatabase = 0; + } + + /* If the trigger name was unqualified, and the table is a temp table, + ** then set iDb to 1 to create the trigger in the temporary database. + ** If sqlite3SrcListLookup() returns 0, indicating the table does not + ** exist, the error is caught by the block below. + */ + pTab = sqlite3SrcListLookup(pParse, pTableName); + if( db->init.busy==0 && pName2->n==0 && pTab + && pTab->pSchema==db->aDb[1].pSchema ){ + iDb = 1; + } + + /* Ensure the table name matches database name and that the table exists */ + if( db->mallocFailed ) goto trigger_cleanup; + assert( pTableName->nSrc==1 ); + sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName); + if( sqlite3FixSrcList(&sFix, pTableName) ){ + goto trigger_cleanup; + } + pTab = sqlite3SrcListLookup(pParse, pTableName); + if( !pTab ){ + /* The table does not exist. */ + goto trigger_orphan_error; + } + if( IsVirtual(pTab) ){ + sqlite3ErrorMsg(pParse, "cannot create triggers on virtual tables"); + goto trigger_orphan_error; + } + + /* Check that the trigger name is not reserved and that no trigger of the + ** specified name exists */ + zName = sqlite3NameFromToken(db, pName); + if( zName==0 ){ + assert( db->mallocFailed ); + goto trigger_cleanup; + } + if( sqlite3CheckObjectName(pParse, zName, "trigger", pTab->zName) ){ + goto trigger_cleanup; + } + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( !IN_RENAME_OBJECT ){ + if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){ + if( !noErr ){ + sqlite3ErrorMsg(pParse, "trigger %T already exists", pName); + }else{ + assert( !db->init.busy ); + sqlite3CodeVerifySchema(pParse, iDb); + } + goto trigger_cleanup; + } + } + + /* Do not create a trigger on a system table */ + if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){ + sqlite3ErrorMsg(pParse, "cannot create trigger on system table"); + goto trigger_cleanup; + } + + /* INSTEAD of triggers are only for views and views only support INSTEAD + ** of triggers. + */ + if( pTab->pSelect && tr_tm!=TK_INSTEAD ){ + sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S", + (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName, 0); + goto trigger_orphan_error; + } + if( !pTab->pSelect && tr_tm==TK_INSTEAD ){ + sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF" + " trigger on table: %S", pTableName, 0); + goto trigger_orphan_error; + } + +#ifndef SQLITE_OMIT_AUTHORIZATION + if( !IN_RENAME_OBJECT ){ + int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema); + int code = SQLITE_CREATE_TRIGGER; + const char *zDb = db->aDb[iTabDb].zDbSName; + const char *zDbTrig = isTemp ? db->aDb[1].zDbSName : zDb; + if( iTabDb==1 || isTemp ) code = SQLITE_CREATE_TEMP_TRIGGER; + if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){ + goto trigger_cleanup; + } + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){ + goto trigger_cleanup; + } + } +#endif + + /* INSTEAD OF triggers can only appear on views and BEFORE triggers + ** cannot appear on views. So we might as well translate every + ** INSTEAD OF trigger into a BEFORE trigger. It simplifies code + ** elsewhere. + */ + if (tr_tm == TK_INSTEAD){ + tr_tm = TK_BEFORE; + } + + /* Build the Trigger object */ + pTrigger = (Trigger*)sqlite3DbMallocZero(db, sizeof(Trigger)); + if( pTrigger==0 ) goto trigger_cleanup; + pTrigger->zName = zName; + zName = 0; + pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName); + pTrigger->pSchema = db->aDb[iDb].pSchema; + pTrigger->pTabSchema = pTab->pSchema; + pTrigger->op = (u8)op; + pTrigger->tr_tm = tr_tm==TK_BEFORE ? TRIGGER_BEFORE : TRIGGER_AFTER; + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenRemap(pParse, pTrigger->table, pTableName->a[0].zName); + pTrigger->pWhen = pWhen; + pWhen = 0; + }else{ + pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE); + } + pTrigger->pColumns = pColumns; + pColumns = 0; + assert( pParse->pNewTrigger==0 ); + pParse->pNewTrigger = pTrigger; + +trigger_cleanup: + sqlite3DbFree(db, zName); + sqlite3SrcListDelete(db, pTableName); + sqlite3IdListDelete(db, pColumns); + sqlite3ExprDelete(db, pWhen); + if( !pParse->pNewTrigger ){ + sqlite3DeleteTrigger(db, pTrigger); + }else{ + assert( pParse->pNewTrigger==pTrigger ); + } + return; + +trigger_orphan_error: + if( db->init.iDb==1 ){ + /* Ticket #3810. + ** Normally, whenever a table is dropped, all associated triggers are + ** dropped too. But if a TEMP trigger is created on a non-TEMP table + ** and the table is dropped by a different database connection, the + ** trigger is not visible to the database connection that does the + ** drop so the trigger cannot be dropped. This results in an + ** "orphaned trigger" - a trigger whose associated table is missing. + ** + ** 2020-11-05 see also https://sqlite.org/forum/forumpost/157dc791df + */ + db->init.orphanTrigger = 1; + } + goto trigger_cleanup; +} + +/* +** This routine is called after all of the trigger actions have been parsed +** in order to complete the process of building the trigger. +*/ +SQLITE_PRIVATE void sqlite3FinishTrigger( + Parse *pParse, /* Parser context */ + TriggerStep *pStepList, /* The triggered program */ + Token *pAll /* Token that describes the complete CREATE TRIGGER */ +){ + Trigger *pTrig = pParse->pNewTrigger; /* Trigger being finished */ + char *zName; /* Name of trigger */ + sqlite3 *db = pParse->db; /* The database */ + DbFixer sFix; /* Fixer object */ + int iDb; /* Database containing the trigger */ + Token nameToken; /* Trigger name for error reporting */ + + pParse->pNewTrigger = 0; + if( NEVER(pParse->nErr) || !pTrig ) goto triggerfinish_cleanup; + zName = pTrig->zName; + iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema); + pTrig->step_list = pStepList; + while( pStepList ){ + pStepList->pTrig = pTrig; + pStepList = pStepList->pNext; + } + sqlite3TokenInit(&nameToken, pTrig->zName); + sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken); + if( sqlite3FixTriggerStep(&sFix, pTrig->step_list) + || sqlite3FixExpr(&sFix, pTrig->pWhen) + ){ + goto triggerfinish_cleanup; + } + +#ifndef SQLITE_OMIT_ALTERTABLE + if( IN_RENAME_OBJECT ){ + assert( !db->init.busy ); + pParse->pNewTrigger = pTrig; + pTrig = 0; + }else +#endif + + /* if we are not initializing, + ** build the sqlite_schema entry + */ + if( !db->init.busy ){ + Vdbe *v; + char *z; + + /* Make an entry in the sqlite_schema table */ + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto triggerfinish_cleanup; + sqlite3BeginWriteOperation(pParse, 0, iDb); + z = sqlite3DbStrNDup(db, (char*)pAll->z, pAll->n); + testcase( z==0 ); + sqlite3NestedParse(pParse, + "INSERT INTO %Q." DFLT_SCHEMA_TABLE + " VALUES('trigger',%Q,%Q,0,'CREATE TRIGGER %q')", + db->aDb[iDb].zDbSName, zName, + pTrig->table, z); + sqlite3DbFree(db, z); + sqlite3ChangeCookie(pParse, iDb); + sqlite3VdbeAddParseSchemaOp(v, iDb, + sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName)); + } + + if( db->init.busy ){ + Trigger *pLink = pTrig; + Hash *pHash = &db->aDb[iDb].pSchema->trigHash; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + assert( pLink!=0 ); + pTrig = sqlite3HashInsert(pHash, zName, pTrig); + if( pTrig ){ + sqlite3OomFault(db); + }else if( pLink->pSchema==pLink->pTabSchema ){ + Table *pTab; + pTab = sqlite3HashFind(&pLink->pTabSchema->tblHash, pLink->table); + assert( pTab!=0 ); + pLink->pNext = pTab->pTrigger; + pTab->pTrigger = pLink; + } + } + +triggerfinish_cleanup: + sqlite3DeleteTrigger(db, pTrig); + assert( IN_RENAME_OBJECT || !pParse->pNewTrigger ); + sqlite3DeleteTriggerStep(db, pStepList); +} + +/* +** Duplicate a range of text from an SQL statement, then convert all +** whitespace characters into ordinary space characters. +*/ +static char *triggerSpanDup(sqlite3 *db, const char *zStart, const char *zEnd){ + char *z = sqlite3DbSpanDup(db, zStart, zEnd); + int i; + if( z ) for(i=0; z[i]; i++) if( sqlite3Isspace(z[i]) ) z[i] = ' '; + return z; +} + +/* +** Turn a SELECT statement (that the pSelect parameter points to) into +** a trigger step. Return a pointer to a TriggerStep structure. +** +** The parser calls this routine when it finds a SELECT statement in +** body of a TRIGGER. +*/ +SQLITE_PRIVATE TriggerStep *sqlite3TriggerSelectStep( + sqlite3 *db, /* Database connection */ + Select *pSelect, /* The SELECT statement */ + const char *zStart, /* Start of SQL text */ + const char *zEnd /* End of SQL text */ +){ + TriggerStep *pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep)); + if( pTriggerStep==0 ) { + sqlite3SelectDelete(db, pSelect); + return 0; + } + pTriggerStep->op = TK_SELECT; + pTriggerStep->pSelect = pSelect; + pTriggerStep->orconf = OE_Default; + pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd); + return pTriggerStep; +} + +/* +** Allocate space to hold a new trigger step. The allocated space +** holds both the TriggerStep object and the TriggerStep.target.z string. +** +** If an OOM error occurs, NULL is returned and db->mallocFailed is set. +*/ +static TriggerStep *triggerStepAllocate( + Parse *pParse, /* Parser context */ + u8 op, /* Trigger opcode */ + Token *pName, /* The target name */ + const char *zStart, /* Start of SQL text */ + const char *zEnd /* End of SQL text */ +){ + sqlite3 *db = pParse->db; + TriggerStep *pTriggerStep; + + pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep) + pName->n + 1); + if( pTriggerStep ){ + char *z = (char*)&pTriggerStep[1]; + memcpy(z, pName->z, pName->n); + sqlite3Dequote(z); + pTriggerStep->zTarget = z; + pTriggerStep->op = op; + pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd); + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenMap(pParse, pTriggerStep->zTarget, pName); + } + } + return pTriggerStep; +} + +/* +** Build a trigger step out of an INSERT statement. Return a pointer +** to the new trigger step. +** +** The parser calls this routine when it sees an INSERT inside the +** body of a trigger. +*/ +SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep( + Parse *pParse, /* Parser */ + Token *pTableName, /* Name of the table into which we insert */ + IdList *pColumn, /* List of columns in pTableName to insert into */ + Select *pSelect, /* A SELECT statement that supplies values */ + u8 orconf, /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */ + Upsert *pUpsert, /* ON CONFLICT clauses for upsert */ + const char *zStart, /* Start of SQL text */ + const char *zEnd /* End of SQL text */ +){ + sqlite3 *db = pParse->db; + TriggerStep *pTriggerStep; + + assert(pSelect != 0 || db->mallocFailed); + + pTriggerStep = triggerStepAllocate(pParse, TK_INSERT, pTableName,zStart,zEnd); + if( pTriggerStep ){ + if( IN_RENAME_OBJECT ){ + pTriggerStep->pSelect = pSelect; + pSelect = 0; + }else{ + pTriggerStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); + } + pTriggerStep->pIdList = pColumn; + pTriggerStep->pUpsert = pUpsert; + pTriggerStep->orconf = orconf; + if( pUpsert ){ + sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget); + } + }else{ + testcase( pColumn ); + sqlite3IdListDelete(db, pColumn); + testcase( pUpsert ); + sqlite3UpsertDelete(db, pUpsert); + } + sqlite3SelectDelete(db, pSelect); + + return pTriggerStep; +} + +/* +** Construct a trigger step that implements an UPDATE statement and return +** a pointer to that trigger step. The parser calls this routine when it +** sees an UPDATE statement inside the body of a CREATE TRIGGER. +*/ +SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep( + Parse *pParse, /* Parser */ + Token *pTableName, /* Name of the table to be updated */ + SrcList *pFrom, + ExprList *pEList, /* The SET clause: list of column and new values */ + Expr *pWhere, /* The WHERE clause */ + u8 orconf, /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */ + const char *zStart, /* Start of SQL text */ + const char *zEnd /* End of SQL text */ +){ + sqlite3 *db = pParse->db; + TriggerStep *pTriggerStep; + + pTriggerStep = triggerStepAllocate(pParse, TK_UPDATE, pTableName,zStart,zEnd); + if( pTriggerStep ){ + if( IN_RENAME_OBJECT ){ + pTriggerStep->pExprList = pEList; + pTriggerStep->pWhere = pWhere; + pTriggerStep->pFrom = pFrom; + pEList = 0; + pWhere = 0; + pFrom = 0; + }else{ + pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE); + pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); + pTriggerStep->pFrom = sqlite3SrcListDup(db, pFrom, EXPRDUP_REDUCE); + } + pTriggerStep->orconf = orconf; + } + sqlite3ExprListDelete(db, pEList); + sqlite3ExprDelete(db, pWhere); + sqlite3SrcListDelete(db, pFrom); + return pTriggerStep; +} + +/* +** Construct a trigger step that implements a DELETE statement and return +** a pointer to that trigger step. The parser calls this routine when it +** sees a DELETE statement inside the body of a CREATE TRIGGER. +*/ +SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep( + Parse *pParse, /* Parser */ + Token *pTableName, /* The table from which rows are deleted */ + Expr *pWhere, /* The WHERE clause */ + const char *zStart, /* Start of SQL text */ + const char *zEnd /* End of SQL text */ +){ + sqlite3 *db = pParse->db; + TriggerStep *pTriggerStep; + + pTriggerStep = triggerStepAllocate(pParse, TK_DELETE, pTableName,zStart,zEnd); + if( pTriggerStep ){ + if( IN_RENAME_OBJECT ){ + pTriggerStep->pWhere = pWhere; + pWhere = 0; + }else{ + pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); + } + pTriggerStep->orconf = OE_Default; + } + sqlite3ExprDelete(db, pWhere); + return pTriggerStep; +} + +/* +** Recursively delete a Trigger structure +*/ +SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3 *db, Trigger *pTrigger){ + if( pTrigger==0 ) return; + sqlite3DeleteTriggerStep(db, pTrigger->step_list); + sqlite3DbFree(db, pTrigger->zName); + sqlite3DbFree(db, pTrigger->table); + sqlite3ExprDelete(db, pTrigger->pWhen); + sqlite3IdListDelete(db, pTrigger->pColumns); + sqlite3DbFree(db, pTrigger); +} + +/* +** This function is called to drop a trigger from the database schema. +** +** This may be called directly from the parser and therefore identifies +** the trigger by name. The sqlite3DropTriggerPtr() routine does the +** same job as this routine except it takes a pointer to the trigger +** instead of the trigger name. +**/ +SQLITE_PRIVATE void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr){ + Trigger *pTrigger = 0; + int i; + const char *zDb; + const char *zName; + sqlite3 *db = pParse->db; + + if( db->mallocFailed ) goto drop_trigger_cleanup; + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto drop_trigger_cleanup; + } + + assert( pName->nSrc==1 ); + zDb = pName->a[0].zDatabase; + zName = pName->a[0].zName; + assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) ); + for(i=OMIT_TEMPDB; inDb; i++){ + int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */ + if( zDb && sqlite3DbIsNamed(db, j, zDb)==0 ) continue; + assert( sqlite3SchemaMutexHeld(db, j, 0) ); + pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName); + if( pTrigger ) break; + } + if( !pTrigger ){ + if( !noErr ){ + sqlite3ErrorMsg(pParse, "no such trigger: %S", pName, 0); + }else{ + sqlite3CodeVerifyNamedSchema(pParse, zDb); + } + pParse->checkSchema = 1; + goto drop_trigger_cleanup; + } + sqlite3DropTriggerPtr(pParse, pTrigger); + +drop_trigger_cleanup: + sqlite3SrcListDelete(db, pName); +} + +/* +** Return a pointer to the Table structure for the table that a trigger +** is set on. +*/ +static Table *tableOfTrigger(Trigger *pTrigger){ + return sqlite3HashFind(&pTrigger->pTabSchema->tblHash, pTrigger->table); +} + + +/* +** Drop a trigger given a pointer to that trigger. +*/ +SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){ + Table *pTable; + Vdbe *v; + sqlite3 *db = pParse->db; + int iDb; + + iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema); + assert( iDb>=0 && iDbnDb ); + pTable = tableOfTrigger(pTrigger); + assert( (pTable && pTable->pSchema==pTrigger->pSchema) || iDb==1 ); +#ifndef SQLITE_OMIT_AUTHORIZATION + if( pTable ){ + int code = SQLITE_DROP_TRIGGER; + const char *zDb = db->aDb[iDb].zDbSName; + const char *zTab = SCHEMA_TABLE(iDb); + if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER; + if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) || + sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){ + return; + } + } +#endif + + /* Generate code to destroy the database record of the trigger. + */ + if( (v = sqlite3GetVdbe(pParse))!=0 ){ + sqlite3NestedParse(pParse, + "DELETE FROM %Q." DFLT_SCHEMA_TABLE " WHERE name=%Q AND type='trigger'", + db->aDb[iDb].zDbSName, pTrigger->zName + ); + sqlite3ChangeCookie(pParse, iDb); + sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0); + } +} + +/* +** Remove a trigger from the hash tables of the sqlite* pointer. +*/ +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){ + Trigger *pTrigger; + Hash *pHash; + + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pHash = &(db->aDb[iDb].pSchema->trigHash); + pTrigger = sqlite3HashInsert(pHash, zName, 0); + if( ALWAYS(pTrigger) ){ + if( pTrigger->pSchema==pTrigger->pTabSchema ){ + Table *pTab = tableOfTrigger(pTrigger); + if( pTab ){ + Trigger **pp; + for(pp=&pTab->pTrigger; *pp; pp=&((*pp)->pNext)){ + if( *pp==pTrigger ){ + *pp = (*pp)->pNext; + break; + } + } + } + } + sqlite3DeleteTrigger(db, pTrigger); + db->mDbFlags |= DBFLAG_SchemaChange; + } +} + +/* +** pEList is the SET clause of an UPDATE statement. Each entry +** in pEList is of the format =. If any of the entries +** in pEList have an which matches an identifier in pIdList, +** then return TRUE. If pIdList==NULL, then it is considered a +** wildcard that matches anything. Likewise if pEList==NULL then +** it matches anything so always return true. Return false only +** if there is no match. +*/ +static int checkColumnOverlap(IdList *pIdList, ExprList *pEList){ + int e; + if( pIdList==0 || NEVER(pEList==0) ) return 1; + for(e=0; enExpr; e++){ + if( sqlite3IdListIndex(pIdList, pEList->a[e].zEName)>=0 ) return 1; + } + return 0; +} + +/* +** Return a list of all triggers on table pTab if there exists at least +** one trigger that must be fired when an operation of type 'op' is +** performed on the table, and, if that operation is an UPDATE, if at +** least one of the columns in pChanges is being modified. +*/ +SQLITE_PRIVATE Trigger *sqlite3TriggersExist( + Parse *pParse, /* Parse context */ + Table *pTab, /* The table the contains the triggers */ + int op, /* one of TK_DELETE, TK_INSERT, TK_UPDATE */ + ExprList *pChanges, /* Columns that change in an UPDATE statement */ + int *pMask /* OUT: Mask of TRIGGER_BEFORE|TRIGGER_AFTER */ +){ + int mask = 0; + Trigger *pList = 0; + Trigger *p; + + if( (pParse->db->flags & SQLITE_EnableTrigger)!=0 ){ + pList = sqlite3TriggerList(pParse, pTab); + } + assert( pList==0 || IsVirtual(pTab)==0 ); + for(p=pList; p; p=p->pNext){ + if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){ + mask |= p->tr_tm; + } + } + if( pMask ){ + *pMask = mask; + } + return (mask ? pList : 0); +} + +/* +** Convert the pStep->zTarget string into a SrcList and return a pointer +** to that SrcList. +** +** This routine adds a specific database name, if needed, to the target when +** forming the SrcList. This prevents a trigger in one database from +** referring to a target in another database. An exception is when the +** trigger is in TEMP in which case it can refer to any other database it +** wants. +*/ +SQLITE_PRIVATE SrcList *sqlite3TriggerStepSrc( + Parse *pParse, /* The parsing context */ + TriggerStep *pStep /* The trigger containing the target token */ +){ + sqlite3 *db = pParse->db; + SrcList *pSrc; /* SrcList to be returned */ + char *zName = sqlite3DbStrDup(db, pStep->zTarget); + pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); + assert( pSrc==0 || pSrc->nSrc==1 ); + assert( zName || pSrc==0 ); + if( pSrc ){ + Schema *pSchema = pStep->pTrig->pSchema; + pSrc->a[0].zName = zName; + if( pSchema!=db->aDb[1].pSchema ){ + pSrc->a[0].pSchema = pSchema; + } + if( pStep->pFrom ){ + SrcList *pDup = sqlite3SrcListDup(db, pStep->pFrom, 0); + pSrc = sqlite3SrcListAppendList(pParse, pSrc, pDup); + } + }else{ + sqlite3DbFree(db, zName); + } + return pSrc; +} + +/* +** Generate VDBE code for the statements inside the body of a single +** trigger. +*/ +static int codeTriggerProgram( + Parse *pParse, /* The parser context */ + TriggerStep *pStepList, /* List of statements inside the trigger body */ + int orconf /* Conflict algorithm. (OE_Abort, etc) */ +){ + TriggerStep *pStep; + Vdbe *v = pParse->pVdbe; + sqlite3 *db = pParse->db; + + assert( pParse->pTriggerTab && pParse->pToplevel ); + assert( pStepList ); + assert( v!=0 ); + for(pStep=pStepList; pStep; pStep=pStep->pNext){ + /* Figure out the ON CONFLICT policy that will be used for this step + ** of the trigger program. If the statement that caused this trigger + ** to fire had an explicit ON CONFLICT, then use it. Otherwise, use + ** the ON CONFLICT policy that was specified as part of the trigger + ** step statement. Example: + ** + ** CREATE TRIGGER AFTER INSERT ON t1 BEGIN; + ** INSERT OR REPLACE INTO t2 VALUES(new.a, new.b); + ** END; + ** + ** INSERT INTO t1 ... ; -- insert into t2 uses REPLACE policy + ** INSERT OR IGNORE INTO t1 ... ; -- insert into t2 uses IGNORE policy + */ + pParse->eOrconf = (orconf==OE_Default)?pStep->orconf:(u8)orconf; + assert( pParse->okConstFactor==0 ); + +#ifndef SQLITE_OMIT_TRACE + if( pStep->zSpan ){ + sqlite3VdbeAddOp4(v, OP_Trace, 0x7fffffff, 1, 0, + sqlite3MPrintf(db, "-- %s", pStep->zSpan), + P4_DYNAMIC); + } +#endif + + switch( pStep->op ){ + case TK_UPDATE: { + sqlite3Update(pParse, + sqlite3TriggerStepSrc(pParse, pStep), + sqlite3ExprListDup(db, pStep->pExprList, 0), + sqlite3ExprDup(db, pStep->pWhere, 0), + pParse->eOrconf, 0, 0, 0 + ); + break; + } + case TK_INSERT: { + sqlite3Insert(pParse, + sqlite3TriggerStepSrc(pParse, pStep), + sqlite3SelectDup(db, pStep->pSelect, 0), + sqlite3IdListDup(db, pStep->pIdList), + pParse->eOrconf, + sqlite3UpsertDup(db, pStep->pUpsert) + ); + break; + } + case TK_DELETE: { + sqlite3DeleteFrom(pParse, + sqlite3TriggerStepSrc(pParse, pStep), + sqlite3ExprDup(db, pStep->pWhere, 0), 0, 0 + ); + break; + } + default: assert( pStep->op==TK_SELECT ); { + SelectDest sDest; + Select *pSelect = sqlite3SelectDup(db, pStep->pSelect, 0); + sqlite3SelectDestInit(&sDest, SRT_Discard, 0); + sqlite3Select(pParse, pSelect, &sDest); + sqlite3SelectDelete(db, pSelect); + break; + } + } + if( pStep->op!=TK_SELECT ){ + sqlite3VdbeAddOp0(v, OP_ResetCount); + } + } + + return 0; +} + +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS +/* +** This function is used to add VdbeComment() annotations to a VDBE +** program. It is not used in production code, only for debugging. +*/ +static const char *onErrorText(int onError){ + switch( onError ){ + case OE_Abort: return "abort"; + case OE_Rollback: return "rollback"; + case OE_Fail: return "fail"; + case OE_Replace: return "replace"; + case OE_Ignore: return "ignore"; + case OE_Default: return "default"; + } + return "n/a"; +} +#endif + +/* +** Parse context structure pFrom has just been used to create a sub-vdbe +** (trigger program). If an error has occurred, transfer error information +** from pFrom to pTo. +*/ +static void transferParseError(Parse *pTo, Parse *pFrom){ + assert( pFrom->zErrMsg==0 || pFrom->nErr ); + assert( pTo->zErrMsg==0 || pTo->nErr ); + if( pTo->nErr==0 ){ + pTo->zErrMsg = pFrom->zErrMsg; + pTo->nErr = pFrom->nErr; + pTo->rc = pFrom->rc; + }else{ + sqlite3DbFree(pFrom->db, pFrom->zErrMsg); + } +} + +/* +** Create and populate a new TriggerPrg object with a sub-program +** implementing trigger pTrigger with ON CONFLICT policy orconf. +*/ +static TriggerPrg *codeRowTrigger( + Parse *pParse, /* Current parse context */ + Trigger *pTrigger, /* Trigger to code */ + Table *pTab, /* The table pTrigger is attached to */ + int orconf /* ON CONFLICT policy to code trigger program with */ +){ + Parse *pTop = sqlite3ParseToplevel(pParse); + sqlite3 *db = pParse->db; /* Database handle */ + TriggerPrg *pPrg; /* Value to return */ + Expr *pWhen = 0; /* Duplicate of trigger WHEN expression */ + Vdbe *v; /* Temporary VM */ + NameContext sNC; /* Name context for sub-vdbe */ + SubProgram *pProgram = 0; /* Sub-vdbe for trigger program */ + Parse *pSubParse; /* Parse context for sub-vdbe */ + int iEndTrigger = 0; /* Label to jump to if WHEN is false */ + + assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) ); + assert( pTop->pVdbe ); + + /* Allocate the TriggerPrg and SubProgram objects. To ensure that they + ** are freed if an error occurs, link them into the Parse.pTriggerPrg + ** list of the top-level Parse object sooner rather than later. */ + pPrg = sqlite3DbMallocZero(db, sizeof(TriggerPrg)); + if( !pPrg ) return 0; + pPrg->pNext = pTop->pTriggerPrg; + pTop->pTriggerPrg = pPrg; + pPrg->pProgram = pProgram = sqlite3DbMallocZero(db, sizeof(SubProgram)); + if( !pProgram ) return 0; + sqlite3VdbeLinkSubProgram(pTop->pVdbe, pProgram); + pPrg->pTrigger = pTrigger; + pPrg->orconf = orconf; + pPrg->aColmask[0] = 0xffffffff; + pPrg->aColmask[1] = 0xffffffff; + + /* Allocate and populate a new Parse context to use for coding the + ** trigger sub-program. */ + pSubParse = sqlite3StackAllocZero(db, sizeof(Parse)); + if( !pSubParse ) return 0; + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pSubParse; + pSubParse->db = db; + pSubParse->pTriggerTab = pTab; + pSubParse->pToplevel = pTop; + pSubParse->zAuthContext = pTrigger->zName; + pSubParse->eTriggerOp = pTrigger->op; + pSubParse->nQueryLoop = pParse->nQueryLoop; + pSubParse->disableVtab = pParse->disableVtab; + + v = sqlite3GetVdbe(pSubParse); + if( v ){ + VdbeComment((v, "Start: %s.%s (%s %s%s%s ON %s)", + pTrigger->zName, onErrorText(orconf), + (pTrigger->tr_tm==TRIGGER_BEFORE ? "BEFORE" : "AFTER"), + (pTrigger->op==TK_UPDATE ? "UPDATE" : ""), + (pTrigger->op==TK_INSERT ? "INSERT" : ""), + (pTrigger->op==TK_DELETE ? "DELETE" : ""), + pTab->zName + )); +#ifndef SQLITE_OMIT_TRACE + if( pTrigger->zName ){ + sqlite3VdbeChangeP4(v, -1, + sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC + ); + } +#endif + + /* If one was specified, code the WHEN clause. If it evaluates to false + ** (or NULL) the sub-vdbe is immediately halted by jumping to the + ** OP_Halt inserted at the end of the program. */ + if( pTrigger->pWhen ){ + pWhen = sqlite3ExprDup(db, pTrigger->pWhen, 0); + if( SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen) + && db->mallocFailed==0 + ){ + iEndTrigger = sqlite3VdbeMakeLabel(pSubParse); + sqlite3ExprIfFalse(pSubParse, pWhen, iEndTrigger, SQLITE_JUMPIFNULL); + } + sqlite3ExprDelete(db, pWhen); + } + + /* Code the trigger program into the sub-vdbe. */ + codeTriggerProgram(pSubParse, pTrigger->step_list, orconf); + + /* Insert an OP_Halt at the end of the sub-program. */ + if( iEndTrigger ){ + sqlite3VdbeResolveLabel(v, iEndTrigger); + } + sqlite3VdbeAddOp0(v, OP_Halt); + VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf))); + + transferParseError(pParse, pSubParse); + if( db->mallocFailed==0 && pParse->nErr==0 ){ + pProgram->aOp = sqlite3VdbeTakeOpArray(v, &pProgram->nOp, &pTop->nMaxArg); + } + pProgram->nMem = pSubParse->nMem; + pProgram->nCsr = pSubParse->nTab; + pProgram->token = (void *)pTrigger; + pPrg->aColmask[0] = pSubParse->oldmask; + pPrg->aColmask[1] = pSubParse->newmask; + sqlite3VdbeDelete(v); + } + + assert( !pSubParse->pAinc && !pSubParse->pZombieTab ); + assert( !pSubParse->pTriggerPrg && !pSubParse->nMaxArg ); + sqlite3ParserReset(pSubParse); + sqlite3StackFree(db, pSubParse); + + return pPrg; +} + +/* +** Return a pointer to a TriggerPrg object containing the sub-program for +** trigger pTrigger with default ON CONFLICT algorithm orconf. If no such +** TriggerPrg object exists, a new object is allocated and populated before +** being returned. +*/ +static TriggerPrg *getRowTrigger( + Parse *pParse, /* Current parse context */ + Trigger *pTrigger, /* Trigger to code */ + Table *pTab, /* The table trigger pTrigger is attached to */ + int orconf /* ON CONFLICT algorithm. */ +){ + Parse *pRoot = sqlite3ParseToplevel(pParse); + TriggerPrg *pPrg; + + assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) ); + + /* It may be that this trigger has already been coded (or is in the + ** process of being coded). If this is the case, then an entry with + ** a matching TriggerPrg.pTrigger field will be present somewhere + ** in the Parse.pTriggerPrg list. Search for such an entry. */ + for(pPrg=pRoot->pTriggerPrg; + pPrg && (pPrg->pTrigger!=pTrigger || pPrg->orconf!=orconf); + pPrg=pPrg->pNext + ); + + /* If an existing TriggerPrg could not be located, create a new one. */ + if( !pPrg ){ + pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf); + } + + return pPrg; +} + +/* +** Generate code for the trigger program associated with trigger p on +** table pTab. The reg, orconf and ignoreJump parameters passed to this +** function are the same as those described in the header function for +** sqlite3CodeRowTrigger() +*/ +SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect( + Parse *pParse, /* Parse context */ + Trigger *p, /* Trigger to code */ + Table *pTab, /* The table to code triggers from */ + int reg, /* Reg array containing OLD.* and NEW.* values */ + int orconf, /* ON CONFLICT policy */ + int ignoreJump /* Instruction to jump to for RAISE(IGNORE) */ +){ + Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */ + TriggerPrg *pPrg; + pPrg = getRowTrigger(pParse, p, pTab, orconf); + assert( pPrg || pParse->nErr || pParse->db->mallocFailed ); + + /* Code the OP_Program opcode in the parent VDBE. P4 of the OP_Program + ** is a pointer to the sub-vdbe containing the trigger program. */ + if( pPrg ){ + int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers)); + + sqlite3VdbeAddOp4(v, OP_Program, reg, ignoreJump, ++pParse->nMem, + (const char *)pPrg->pProgram, P4_SUBPROGRAM); + VdbeComment( + (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf))); + + /* Set the P5 operand of the OP_Program instruction to non-zero if + ** recursive invocation of this trigger program is disallowed. Recursive + ** invocation is disallowed if (a) the sub-program is really a trigger, + ** not a foreign key action, and (b) the flag to enable recursive triggers + ** is clear. */ + sqlite3VdbeChangeP5(v, (u8)bRecursive); + } +} + +/* +** This is called to code the required FOR EACH ROW triggers for an operation +** on table pTab. The operation to code triggers for (INSERT, UPDATE or DELETE) +** is given by the op parameter. The tr_tm parameter determines whether the +** BEFORE or AFTER triggers are coded. If the operation is an UPDATE, then +** parameter pChanges is passed the list of columns being modified. +** +** If there are no triggers that fire at the specified time for the specified +** operation on pTab, this function is a no-op. +** +** The reg argument is the address of the first in an array of registers +** that contain the values substituted for the new.* and old.* references +** in the trigger program. If N is the number of columns in table pTab +** (a copy of pTab->nCol), then registers are populated as follows: +** +** Register Contains +** ------------------------------------------------------ +** reg+0 OLD.rowid +** reg+1 OLD.* value of left-most column of pTab +** ... ... +** reg+N OLD.* value of right-most column of pTab +** reg+N+1 NEW.rowid +** reg+N+2 OLD.* value of left-most column of pTab +** ... ... +** reg+N+N+1 NEW.* value of right-most column of pTab +** +** For ON DELETE triggers, the registers containing the NEW.* values will +** never be accessed by the trigger program, so they are not allocated or +** populated by the caller (there is no data to populate them with anyway). +** Similarly, for ON INSERT triggers the values stored in the OLD.* registers +** are never accessed, and so are not allocated by the caller. So, for an +** ON INSERT trigger, the value passed to this function as parameter reg +** is not a readable register, although registers (reg+N) through +** (reg+N+N+1) are. +** +** Parameter orconf is the default conflict resolution algorithm for the +** trigger program to use (REPLACE, IGNORE etc.). Parameter ignoreJump +** is the instruction that control should jump to if a trigger program +** raises an IGNORE exception. +*/ +SQLITE_PRIVATE void sqlite3CodeRowTrigger( + Parse *pParse, /* Parse context */ + Trigger *pTrigger, /* List of triggers on table pTab */ + int op, /* One of TK_UPDATE, TK_INSERT, TK_DELETE */ + ExprList *pChanges, /* Changes list for any UPDATE OF triggers */ + int tr_tm, /* One of TRIGGER_BEFORE, TRIGGER_AFTER */ + Table *pTab, /* The table to code triggers from */ + int reg, /* The first in an array of registers (see above) */ + int orconf, /* ON CONFLICT policy */ + int ignoreJump /* Instruction to jump to for RAISE(IGNORE) */ +){ + Trigger *p; /* Used to iterate through pTrigger list */ + + assert( op==TK_UPDATE || op==TK_INSERT || op==TK_DELETE ); + assert( tr_tm==TRIGGER_BEFORE || tr_tm==TRIGGER_AFTER ); + assert( (op==TK_UPDATE)==(pChanges!=0) ); + + for(p=pTrigger; p; p=p->pNext){ + + /* Sanity checking: The schema for the trigger and for the table are + ** always defined. The trigger must be in the same schema as the table + ** or else it must be a TEMP trigger. */ + assert( p->pSchema!=0 ); + assert( p->pTabSchema!=0 ); + assert( p->pSchema==p->pTabSchema + || p->pSchema==pParse->db->aDb[1].pSchema ); + + /* Determine whether we should code this trigger */ + if( p->op==op + && p->tr_tm==tr_tm + && checkColumnOverlap(p->pColumns, pChanges) + ){ + sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump); + } + } +} + +/* +** Triggers may access values stored in the old.* or new.* pseudo-table. +** This function returns a 32-bit bitmask indicating which columns of the +** old.* or new.* tables actually are used by triggers. This information +** may be used by the caller, for example, to avoid having to load the entire +** old.* record into memory when executing an UPDATE or DELETE command. +** +** Bit 0 of the returned mask is set if the left-most column of the +** table may be accessed using an [old|new].reference. Bit 1 is set if +** the second leftmost column value is required, and so on. If there +** are more than 32 columns in the table, and at least one of the columns +** with an index greater than 32 may be accessed, 0xffffffff is returned. +** +** It is not possible to determine if the old.rowid or new.rowid column is +** accessed by triggers. The caller must always assume that it is. +** +** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned +** applies to the old.* table. If 1, the new.* table. +** +** Parameter tr_tm must be a mask with one or both of the TRIGGER_BEFORE +** and TRIGGER_AFTER bits set. Values accessed by BEFORE triggers are only +** included in the returned mask if the TRIGGER_BEFORE bit is set in the +** tr_tm parameter. Similarly, values accessed by AFTER triggers are only +** included in the returned mask if the TRIGGER_AFTER bit is set in tr_tm. +*/ +SQLITE_PRIVATE u32 sqlite3TriggerColmask( + Parse *pParse, /* Parse context */ + Trigger *pTrigger, /* List of triggers on table pTab */ + ExprList *pChanges, /* Changes list for any UPDATE OF triggers */ + int isNew, /* 1 for new.* ref mask, 0 for old.* ref mask */ + int tr_tm, /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */ + Table *pTab, /* The table to code triggers from */ + int orconf /* Default ON CONFLICT policy for trigger steps */ +){ + const int op = pChanges ? TK_UPDATE : TK_DELETE; + u32 mask = 0; + Trigger *p; + + assert( isNew==1 || isNew==0 ); + for(p=pTrigger; p; p=p->pNext){ + if( p->op==op && (tr_tm&p->tr_tm) + && checkColumnOverlap(p->pColumns,pChanges) + ){ + TriggerPrg *pPrg; + pPrg = getRowTrigger(pParse, p, pTab, orconf); + if( pPrg ){ + mask |= pPrg->aColmask[isNew]; + } + } + } + + return mask; +} + +#endif /* !defined(SQLITE_OMIT_TRIGGER) */ + +/************** End of trigger.c *********************************************/ +/************** Begin file update.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** to handle UPDATE statements. +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Forward declaration */ +static void updateVirtualTable( + Parse *pParse, /* The parsing context */ + SrcList *pSrc, /* The virtual table to be modified */ + Table *pTab, /* The virtual table */ + ExprList *pChanges, /* The columns to change in the UPDATE statement */ + Expr *pRowidExpr, /* Expression used to recompute the rowid */ + int *aXRef, /* Mapping from columns of pTab to entries in pChanges */ + Expr *pWhere, /* WHERE clause of the UPDATE statement */ + int onError /* ON CONFLICT strategy */ +); +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +/* +** The most recently coded instruction was an OP_Column to retrieve the +** i-th column of table pTab. This routine sets the P4 parameter of the +** OP_Column to the default value, if any. +** +** The default value of a column is specified by a DEFAULT clause in the +** column definition. This was either supplied by the user when the table +** was created, or added later to the table definition by an ALTER TABLE +** command. If the latter, then the row-records in the table btree on disk +** may not contain a value for the column and the default value, taken +** from the P4 parameter of the OP_Column instruction, is returned instead. +** If the former, then all row-records are guaranteed to include a value +** for the column and the P4 value is not required. +** +** Column definitions created by an ALTER TABLE command may only have +** literal default values specified: a number, null or a string. (If a more +** complicated default expression value was provided, it is evaluated +** when the ALTER TABLE is executed and one of the literal values written +** into the sqlite_schema table.) +** +** Therefore, the P4 parameter is only required if the default value for +** the column is a literal number, string or null. The sqlite3ValueFromExpr() +** function is capable of transforming these types of expressions into +** sqlite3_value objects. +** +** If column as REAL affinity and the table is an ordinary b-tree table +** (not a virtual table) then the value might have been stored as an +** integer. In that case, add an OP_RealAffinity opcode to make sure +** it has been converted into REAL. +*/ +SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){ + assert( pTab!=0 ); + if( !pTab->pSelect ){ + sqlite3_value *pValue = 0; + u8 enc = ENC(sqlite3VdbeDb(v)); + Column *pCol = &pTab->aCol[i]; + VdbeComment((v, "%s.%s", pTab->zName, pCol->zName)); + assert( inCol ); + sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol->pDflt, enc, + pCol->affinity, &pValue); + if( pValue ){ + sqlite3VdbeAppendP4(v, pValue, P4_MEM); + } + } +#ifndef SQLITE_OMIT_FLOATING_POINT + if( pTab->aCol[i].affinity==SQLITE_AFF_REAL && !IsVirtual(pTab) ){ + sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg); + } +#endif +} + +/* +** Check to see if column iCol of index pIdx references any of the +** columns defined by aXRef and chngRowid. Return true if it does +** and false if not. This is an optimization. False-positives are a +** performance degradation, but false-negatives can result in a corrupt +** index and incorrect answers. +** +** aXRef[j] will be non-negative if column j of the original table is +** being updated. chngRowid will be true if the rowid of the table is +** being updated. +*/ +static int indexColumnIsBeingUpdated( + Index *pIdx, /* The index to check */ + int iCol, /* Which column of the index to check */ + int *aXRef, /* aXRef[j]>=0 if column j is being updated */ + int chngRowid /* true if the rowid is being updated */ +){ + i16 iIdxCol = pIdx->aiColumn[iCol]; + assert( iIdxCol!=XN_ROWID ); /* Cannot index rowid */ + if( iIdxCol>=0 ){ + return aXRef[iIdxCol]>=0; + } + assert( iIdxCol==XN_EXPR ); + assert( pIdx->aColExpr!=0 ); + assert( pIdx->aColExpr->a[iCol].pExpr!=0 ); + return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr, + aXRef,chngRowid); +} + +/* +** Check to see if index pIdx is a partial index whose conditional +** expression might change values due to an UPDATE. Return true if +** the index is subject to change and false if the index is guaranteed +** to be unchanged. This is an optimization. False-positives are a +** performance degradation, but false-negatives can result in a corrupt +** index and incorrect answers. +** +** aXRef[j] will be non-negative if column j of the original table is +** being updated. chngRowid will be true if the rowid of the table is +** being updated. +*/ +static int indexWhereClauseMightChange( + Index *pIdx, /* The index to check */ + int *aXRef, /* aXRef[j]>=0 if column j is being updated */ + int chngRowid /* true if the rowid is being updated */ +){ + if( pIdx->pPartIdxWhere==0 ) return 0; + return sqlite3ExprReferencesUpdatedColumn(pIdx->pPartIdxWhere, + aXRef, chngRowid); +} + +/* +** Allocate and return a pointer to an expression of type TK_ROW with +** Expr.iColumn set to value (iCol+1). The resolver will modify the +** expression to be a TK_COLUMN reading column iCol of the first +** table in the source-list (pSrc->a[0]). +*/ +static Expr *exprRowColumn(Parse *pParse, int iCol){ + Expr *pRet = sqlite3PExpr(pParse, TK_ROW, 0, 0); + if( pRet ) pRet->iColumn = iCol+1; + return pRet; +} + +/* +** Assuming both the pLimit and pOrderBy parameters are NULL, this function +** generates VM code to run the query: +** +** SELECT , pChanges FROM pTabList WHERE pWhere +** +** and write the results to the ephemeral table already opened as cursor +** iEph. None of pChanges, pTabList or pWhere are modified or consumed by +** this function, they must be deleted by the caller. +** +** Or, if pLimit and pOrderBy are not NULL, and pTab is not a view: +** +** SELECT , pChanges FROM pTabList +** WHERE pWhere +** GROUP BY +** ORDER BY pOrderBy LIMIT pLimit +** +** If pTab is a view, the GROUP BY clause is omitted. +** +** Exactly how results are written to table iEph, and exactly what +** the in the query above are is determined by the type +** of table pTabList->a[0].pTab. +** +** If the table is a WITHOUT ROWID table, then argument pPk must be its +** PRIMARY KEY. In this case are the primary key columns +** of the table, in order. The results of the query are written to ephemeral +** table iEph as index keys, using OP_IdxInsert. +** +** If the table is actually a view, then are all columns of +** the view. The results are written to the ephemeral table iEph as records +** with automatically assigned integer keys. +** +** If the table is a virtual or ordinary intkey table, then +** is its rowid. For a virtual table, the results are written to iEph as +** records with automatically assigned integer keys For intkey tables, the +** rowid value in is used as the integer key, and the +** remaining fields make up the table record. +*/ +static void updateFromSelect( + Parse *pParse, /* Parse context */ + int iEph, /* Cursor for open eph. table */ + Index *pPk, /* PK if table 0 is WITHOUT ROWID */ + ExprList *pChanges, /* List of expressions to return */ + SrcList *pTabList, /* List of tables to select from */ + Expr *pWhere, /* WHERE clause for query */ + ExprList *pOrderBy, /* ORDER BY clause */ + Expr *pLimit /* LIMIT clause */ +){ + int i; + SelectDest dest; + Select *pSelect = 0; + ExprList *pList = 0; + ExprList *pGrp = 0; + Expr *pLimit2 = 0; + ExprList *pOrderBy2 = 0; + sqlite3 *db = pParse->db; + Table *pTab = pTabList->a[0].pTab; + SrcList *pSrc; + Expr *pWhere2; + int eDest; + +#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT + if( pOrderBy && pLimit==0 ) { + sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on UPDATE"); + return; + } + pOrderBy2 = sqlite3ExprListDup(db, pOrderBy, 0); + pLimit2 = sqlite3ExprDup(db, pLimit, 0); +#else + UNUSED_PARAMETER(pOrderBy); + UNUSED_PARAMETER(pLimit); +#endif + + pSrc = sqlite3SrcListDup(db, pTabList, 0); + pWhere2 = sqlite3ExprDup(db, pWhere, 0); + + assert( pTabList->nSrc>1 ); + if( pSrc ){ + pSrc->a[0].iCursor = -1; + pSrc->a[0].pTab->nTabRef--; + pSrc->a[0].pTab = 0; + } + if( pPk ){ + for(i=0; inKeyCol; i++){ + Expr *pNew = exprRowColumn(pParse, pPk->aiColumn[i]); +#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT + if( pLimit ){ + pGrp = sqlite3ExprListAppend(pParse, pGrp, sqlite3ExprDup(db, pNew, 0)); + } +#endif + pList = sqlite3ExprListAppend(pParse, pList, pNew); + } + eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom; + }else if( pTab->pSelect ){ + for(i=0; inCol; i++){ + pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i)); + } + eDest = SRT_Table; + }else{ + eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom; + pList = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0)); +#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT + if( pLimit ){ + pGrp = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0)); + } +#endif + } + if( ALWAYS(pChanges) ){ + for(i=0; inExpr; i++){ + pList = sqlite3ExprListAppend(pParse, pList, + sqlite3ExprDup(db, pChanges->a[i].pExpr, 0) + ); + } + } + pSelect = sqlite3SelectNew(pParse, pList, + pSrc, pWhere2, pGrp, 0, pOrderBy2, SF_UpdateFrom|SF_IncludeHidden, pLimit2 + ); + sqlite3SelectDestInit(&dest, eDest, iEph); + dest.iSDParm2 = (pPk ? pPk->nKeyCol : -1); + sqlite3Select(pParse, pSelect, &dest); + sqlite3SelectDelete(db, pSelect); +} + +/* +** Process an UPDATE statement. +** +** UPDATE OR IGNORE tbl SET a=b, c=d FROM tbl2... WHERE e<5 AND f NOT NULL; +** \_______/ \_/ \______/ \_____/ \________________/ +** onError | pChanges | pWhere +** \_______________________/ +** pTabList +*/ +SQLITE_PRIVATE void sqlite3Update( + Parse *pParse, /* The parser context */ + SrcList *pTabList, /* The table in which we should change things */ + ExprList *pChanges, /* Things to be changed */ + Expr *pWhere, /* The WHERE clause. May be null */ + int onError, /* How to handle constraint errors */ + ExprList *pOrderBy, /* ORDER BY clause. May be null */ + Expr *pLimit, /* LIMIT clause. May be null */ + Upsert *pUpsert /* ON CONFLICT clause, or null */ +){ + int i, j, k; /* Loop counters */ + Table *pTab; /* The table to be updated */ + int addrTop = 0; /* VDBE instruction address of the start of the loop */ + WhereInfo *pWInfo = 0; /* Information about the WHERE clause */ + Vdbe *v; /* The virtual database engine */ + Index *pIdx; /* For looping over indices */ + Index *pPk; /* The PRIMARY KEY index for WITHOUT ROWID tables */ + int nIdx; /* Number of indices that need updating */ + int nAllIdx; /* Total number of indexes */ + int iBaseCur; /* Base cursor number */ + int iDataCur; /* Cursor for the canonical data btree */ + int iIdxCur; /* Cursor for the first index */ + sqlite3 *db; /* The database structure */ + int *aRegIdx = 0; /* Registers for to each index and the main table */ + int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the + ** an expression for the i-th column of the table. + ** aXRef[i]==-1 if the i-th column is not changed. */ + u8 *aToOpen; /* 1 for tables and indices to be opened */ + u8 chngPk; /* PRIMARY KEY changed in a WITHOUT ROWID table */ + u8 chngRowid; /* Rowid changed in a normal table */ + u8 chngKey; /* Either chngPk or chngRowid */ + Expr *pRowidExpr = 0; /* Expression defining the new record number */ + int iRowidExpr = -1; /* Index of "rowid=" (or IPK) assignment in pChanges */ + AuthContext sContext; /* The authorization context */ + NameContext sNC; /* The name-context to resolve expressions in */ + int iDb; /* Database containing the table being updated */ + int eOnePass; /* ONEPASS_XXX value from where.c */ + int hasFK; /* True if foreign key processing is required */ + int labelBreak; /* Jump here to break out of UPDATE loop */ + int labelContinue; /* Jump here to continue next step of UPDATE loop */ + int flags; /* Flags for sqlite3WhereBegin() */ + +#ifndef SQLITE_OMIT_TRIGGER + int isView; /* True when updating a view (INSTEAD OF trigger) */ + Trigger *pTrigger; /* List of triggers on pTab, if required */ + int tmask; /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */ +#endif + int newmask; /* Mask of NEW.* columns accessed by BEFORE triggers */ + int iEph = 0; /* Ephemeral table holding all primary key values */ + int nKey = 0; /* Number of elements in regKey for WITHOUT ROWID */ + int aiCurOnePass[2]; /* The write cursors opened by WHERE_ONEPASS */ + int addrOpen = 0; /* Address of OP_OpenEphemeral */ + int iPk = 0; /* First of nPk cells holding PRIMARY KEY value */ + i16 nPk = 0; /* Number of components of the PRIMARY KEY */ + int bReplace = 0; /* True if REPLACE conflict resolution might happen */ + int bFinishSeek = 1; /* The OP_FinishSeek opcode is needed */ + int nChangeFrom = 0; /* If there is a FROM, pChanges->nExpr, else 0 */ + + /* Register Allocations */ + int regRowCount = 0; /* A count of rows changed */ + int regOldRowid = 0; /* The old rowid */ + int regNewRowid = 0; /* The new rowid */ + int regNew = 0; /* Content of the NEW.* table in triggers */ + int regOld = 0; /* Content of OLD.* table in triggers */ + int regRowSet = 0; /* Rowset of rows to be updated */ + int regKey = 0; /* composite PRIMARY KEY value */ + + memset(&sContext, 0, sizeof(sContext)); + db = pParse->db; + if( pParse->nErr || db->mallocFailed ){ + goto update_cleanup; + } + + /* Locate the table which we want to update. + */ + pTab = sqlite3SrcListLookup(pParse, pTabList); + if( pTab==0 ) goto update_cleanup; + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + + /* Figure out if we have any triggers and if the table being + ** updated is a view. + */ +#ifndef SQLITE_OMIT_TRIGGER + pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask); + isView = pTab->pSelect!=0; + assert( pTrigger || tmask==0 ); +#else +# define pTrigger 0 +# define isView 0 +# define tmask 0 +#endif +#ifdef SQLITE_OMIT_VIEW +# undef isView +# define isView 0 +#endif + + /* If there was a FROM clause, set nChangeFrom to the number of expressions + ** in the change-list. Otherwise, set it to 0. There cannot be a FROM + ** clause if this function is being called to generate code for part of + ** an UPSERT statement. */ + nChangeFrom = (pTabList->nSrc>1) ? pChanges->nExpr : 0; + assert( nChangeFrom==0 || pUpsert==0 ); + +#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT + if( !isView && nChangeFrom==0 ){ + pWhere = sqlite3LimitWhere( + pParse, pTabList, pWhere, pOrderBy, pLimit, "UPDATE" + ); + pOrderBy = 0; + pLimit = 0; + } +#endif + + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto update_cleanup; + } + if( sqlite3IsReadOnly(pParse, pTab, tmask) ){ + goto update_cleanup; + } + + /* Allocate a cursors for the main database table and for all indices. + ** The index cursors might not be used, but if they are used they + ** need to occur right after the database cursor. So go ahead and + ** allocate enough space, just in case. + */ + iBaseCur = iDataCur = pParse->nTab++; + iIdxCur = iDataCur+1; + pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab); + testcase( pPk!=0 && pPk!=pTab->pIndex ); + for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ + if( pPk==pIdx ){ + iDataCur = pParse->nTab; + } + pParse->nTab++; + } + if( pUpsert ){ + /* On an UPSERT, reuse the same cursors already opened by INSERT */ + iDataCur = pUpsert->iDataCur; + iIdxCur = pUpsert->iIdxCur; + pParse->nTab = iBaseCur; + } + pTabList->a[0].iCursor = iDataCur; + + /* Allocate space for aXRef[], aRegIdx[], and aToOpen[]. + ** Initialize aXRef[] and aToOpen[] to their default values. + */ + aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 ); + if( aXRef==0 ) goto update_cleanup; + aRegIdx = aXRef+pTab->nCol; + aToOpen = (u8*)(aRegIdx+nIdx+1); + memset(aToOpen, 1, nIdx+1); + aToOpen[nIdx+1] = 0; + for(i=0; inCol; i++) aXRef[i] = -1; + + /* Initialize the name-context */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pSrcList = pTabList; + sNC.uNC.pUpsert = pUpsert; + sNC.ncFlags = NC_UUpsert; + + /* Begin generating code. */ + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto update_cleanup; + + /* Resolve the column names in all the expressions of the + ** of the UPDATE statement. Also find the column index + ** for each column to be updated in the pChanges array. For each + ** column to be updated, make sure we have authorization to change + ** that column. + */ + chngRowid = chngPk = 0; + for(i=0; inExpr; i++){ + /* If this is an UPDATE with a FROM clause, do not resolve expressions + ** here. The call to sqlite3Select() below will do that. */ + if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){ + goto update_cleanup; + } + for(j=0; jnCol; j++){ + if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zEName)==0 ){ + if( j==pTab->iPKey ){ + chngRowid = 1; + pRowidExpr = pChanges->a[i].pExpr; + iRowidExpr = i; + }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){ + chngPk = 1; + } +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + else if( pTab->aCol[j].colFlags & COLFLAG_GENERATED ){ + testcase( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL ); + testcase( pTab->aCol[j].colFlags & COLFLAG_STORED ); + sqlite3ErrorMsg(pParse, + "cannot UPDATE generated column \"%s\"", + pTab->aCol[j].zName); + goto update_cleanup; + } +#endif + aXRef[j] = i; + break; + } + } + if( j>=pTab->nCol ){ + if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zEName) ){ + j = -1; + chngRowid = 1; + pRowidExpr = pChanges->a[i].pExpr; + iRowidExpr = i; + }else{ + sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zEName); + pParse->checkSchema = 1; + goto update_cleanup; + } + } +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int rc; + rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName, + j<0 ? "ROWID" : pTab->aCol[j].zName, + db->aDb[iDb].zDbSName); + if( rc==SQLITE_DENY ){ + goto update_cleanup; + }else if( rc==SQLITE_IGNORE ){ + aXRef[j] = -1; + } + } +#endif + } + assert( (chngRowid & chngPk)==0 ); + assert( chngRowid==0 || chngRowid==1 ); + assert( chngPk==0 || chngPk==1 ); + chngKey = chngRowid + chngPk; + +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + /* Mark generated columns as changing if their generator expressions + ** reference any changing column. The actual aXRef[] value for + ** generated expressions is not used, other than to check to see that it + ** is non-negative, so the value of aXRef[] for generated columns can be + ** set to any non-negative number. We use 99999 so that the value is + ** obvious when looking at aXRef[] in a symbolic debugger. + */ + if( pTab->tabFlags & TF_HasGenerated ){ + int bProgress; + testcase( pTab->tabFlags & TF_HasVirtual ); + testcase( pTab->tabFlags & TF_HasStored ); + do{ + bProgress = 0; + for(i=0; inCol; i++){ + if( aXRef[i]>=0 ) continue; + if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 ) continue; + if( sqlite3ExprReferencesUpdatedColumn(pTab->aCol[i].pDflt, + aXRef, chngRowid) ){ + aXRef[i] = 99999; + bProgress = 1; + } + } + }while( bProgress ); + } +#endif + + /* The SET expressions are not actually used inside the WHERE loop. + ** So reset the colUsed mask. Unless this is a virtual table. In that + ** case, set all bits of the colUsed mask (to ensure that the virtual + ** table implementation makes all columns available). + */ + pTabList->a[0].colUsed = IsVirtual(pTab) ? ALLBITS : 0; + + hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey); + + /* There is one entry in the aRegIdx[] array for each index on the table + ** being updated. Fill in aRegIdx[] with a register number that will hold + ** the key for accessing each index. + */ + if( onError==OE_Replace ) bReplace = 1; + for(nAllIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nAllIdx++){ + int reg; + if( chngKey || hasFK>1 || pIdx==pPk + || indexWhereClauseMightChange(pIdx,aXRef,chngRowid) + ){ + reg = ++pParse->nMem; + pParse->nMem += pIdx->nColumn; + }else{ + reg = 0; + for(i=0; inKeyCol; i++){ + if( indexColumnIsBeingUpdated(pIdx, i, aXRef, chngRowid) ){ + reg = ++pParse->nMem; + pParse->nMem += pIdx->nColumn; + if( onError==OE_Default && pIdx->onError==OE_Replace ){ + bReplace = 1; + } + break; + } + } + } + if( reg==0 ) aToOpen[nAllIdx+1] = 0; + aRegIdx[nAllIdx] = reg; + } + aRegIdx[nAllIdx] = ++pParse->nMem; /* Register storing the table record */ + if( bReplace ){ + /* If REPLACE conflict resolution might be invoked, open cursors on all + ** indexes in case they are needed to delete records. */ + memset(aToOpen, 1, nIdx+1); + } + + if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); + sqlite3BeginWriteOperation(pParse, pTrigger || hasFK, iDb); + + /* Allocate required registers. */ + if( !IsVirtual(pTab) ){ + /* For now, regRowSet and aRegIdx[nAllIdx] share the same register. + ** If regRowSet turns out to be needed, then aRegIdx[nAllIdx] will be + ** reallocated. aRegIdx[nAllIdx] is the register in which the main + ** table record is written. regRowSet holds the RowSet for the + ** two-pass update algorithm. */ + assert( aRegIdx[nAllIdx]==pParse->nMem ); + regRowSet = aRegIdx[nAllIdx]; + regOldRowid = regNewRowid = ++pParse->nMem; + if( chngPk || pTrigger || hasFK ){ + regOld = pParse->nMem + 1; + pParse->nMem += pTab->nCol; + } + if( chngKey || pTrigger || hasFK ){ + regNewRowid = ++pParse->nMem; + } + regNew = pParse->nMem + 1; + pParse->nMem += pTab->nCol; + } + + /* Start the view context. */ + if( isView ){ + sqlite3AuthContextPush(pParse, &sContext, pTab->zName); + } + + /* If we are trying to update a view, realize that view into + ** an ephemeral table. + */ +#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) + if( nChangeFrom==0 && isView ){ + sqlite3MaterializeView(pParse, pTab, + pWhere, pOrderBy, pLimit, iDataCur + ); + pOrderBy = 0; + pLimit = 0; + } +#endif + + /* Resolve the column names in all the expressions in the + ** WHERE clause. + */ + if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pWhere) ){ + goto update_cleanup; + } + +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* Virtual tables must be handled separately */ + if( IsVirtual(pTab) ){ + updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef, + pWhere, onError); + goto update_cleanup; + } +#endif + + /* Jump to labelBreak to abandon further processing of this UPDATE */ + labelContinue = labelBreak = sqlite3VdbeMakeLabel(pParse); + + /* Not an UPSERT. Normal processing. Begin by + ** initialize the count of updated rows */ + if( (db->flags&SQLITE_CountRows)!=0 + && !pParse->pTriggerTab + && !pParse->nested + && pUpsert==0 + ){ + regRowCount = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount); + } + + if( nChangeFrom==0 && HasRowid(pTab) ){ + sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid); + iEph = pParse->nTab++; + addrOpen = sqlite3VdbeAddOp3(v, OP_OpenEphemeral, iEph, 0, regRowSet); + }else{ + assert( pPk!=0 || HasRowid(pTab) ); + nPk = pPk ? pPk->nKeyCol : 0; + iPk = pParse->nMem+1; + pParse->nMem += nPk; + pParse->nMem += nChangeFrom; + regKey = ++pParse->nMem; + if( pUpsert==0 ){ + int nEphCol = nPk + nChangeFrom + (isView ? pTab->nCol : 0); + iEph = pParse->nTab++; + if( pPk ) sqlite3VdbeAddOp3(v, OP_Null, 0, iPk, iPk+nPk-1); + addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nEphCol); + if( pPk ){ + KeyInfo *pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pPk); + if( pKeyInfo ){ + pKeyInfo->nAllField = nEphCol; + sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO); + } + } + if( nChangeFrom ){ + updateFromSelect( + pParse, iEph, pPk, pChanges, pTabList, pWhere, pOrderBy, pLimit + ); +#ifndef SQLITE_OMIT_SUBQUERY + if( isView ) iDataCur = iEph; +#endif + } + } + } + + if( nChangeFrom ){ + sqlite3MultiWrite(pParse); + eOnePass = ONEPASS_OFF; + nKey = nPk; + regKey = iPk; + }else{ + if( pUpsert ){ + /* If this is an UPSERT, then all cursors have already been opened by + ** the outer INSERT and the data cursor should be pointing at the row + ** that is to be updated. So bypass the code that searches for the + ** row(s) to be updated. + */ + pWInfo = 0; + eOnePass = ONEPASS_SINGLE; + sqlite3ExprIfFalse(pParse, pWhere, labelBreak, SQLITE_JUMPIFNULL); + bFinishSeek = 0; + }else{ + /* Begin the database scan. + ** + ** Do not consider a single-pass strategy for a multi-row update if + ** there are any triggers or foreign keys to process, or rows may + ** be deleted as a result of REPLACE conflict handling. Any of these + ** things might disturb a cursor being used to scan through the table + ** or index, causing a single-pass approach to malfunction. */ + flags = WHERE_ONEPASS_DESIRED; + if( !pParse->nested && !pTrigger && !hasFK && !chngKey && !bReplace ){ + flags |= WHERE_ONEPASS_MULTIROW; + } + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, flags,iIdxCur); + if( pWInfo==0 ) goto update_cleanup; + + /* A one-pass strategy that might update more than one row may not + ** be used if any column of the index used for the scan is being + ** updated. Otherwise, if there is an index on "b", statements like + ** the following could create an infinite loop: + ** + ** UPDATE t1 SET b=b+1 WHERE b>? + ** + ** Fall back to ONEPASS_OFF if where.c has selected a ONEPASS_MULTI + ** strategy that uses an index for which one or more columns are being + ** updated. */ + eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass); + bFinishSeek = sqlite3WhereUsesDeferredSeek(pWInfo); + if( eOnePass!=ONEPASS_SINGLE ){ + sqlite3MultiWrite(pParse); + if( eOnePass==ONEPASS_MULTI ){ + int iCur = aiCurOnePass[1]; + if( iCur>=0 && iCur!=iDataCur && aToOpen[iCur-iBaseCur] ){ + eOnePass = ONEPASS_OFF; + } + assert( iCur!=iDataCur || !HasRowid(pTab) ); + } + } + } + + if( HasRowid(pTab) ){ + /* Read the rowid of the current row of the WHERE scan. In ONEPASS_OFF + ** mode, write the rowid into the FIFO. In either of the one-pass modes, + ** leave it in register regOldRowid. */ + sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid); + if( eOnePass==ONEPASS_OFF ){ + aRegIdx[nAllIdx] = ++pParse->nMem; + sqlite3VdbeAddOp3(v, OP_Insert, iEph, regRowSet, regOldRowid); + }else{ + if( ALWAYS(addrOpen) ) sqlite3VdbeChangeToNoop(v, addrOpen); + } + }else{ + /* Read the PK of the current row into an array of registers. In + ** ONEPASS_OFF mode, serialize the array into a record and store it in + ** the ephemeral table. Or, in ONEPASS_SINGLE or MULTI mode, change + ** the OP_OpenEphemeral instruction to a Noop (the ephemeral table + ** is not required) and leave the PK fields in the array of registers. */ + for(i=0; iaiColumn[i]>=0 ); + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, + pPk->aiColumn[i], iPk+i); + } + if( eOnePass ){ + if( addrOpen ) sqlite3VdbeChangeToNoop(v, addrOpen); + nKey = nPk; + regKey = iPk; + }else{ + sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey, + sqlite3IndexAffinityStr(db, pPk), nPk); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEph, regKey, iPk, nPk); + } + } + } + + if( pUpsert==0 ){ + if( nChangeFrom==0 && eOnePass!=ONEPASS_MULTI ){ + sqlite3WhereEnd(pWInfo); + } + + if( !isView ){ + int addrOnce = 0; + + /* Open every index that needs updating. */ + if( eOnePass!=ONEPASS_OFF ){ + if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0; + if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0; + } + + if( eOnePass==ONEPASS_MULTI && (nIdx-(aiCurOnePass[1]>=0))>0 ){ + addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + } + sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur, + aToOpen, 0, 0); + if( addrOnce ){ + sqlite3VdbeJumpHereOrPopInst(v, addrOnce); + } + } + + /* Top of the update loop */ + if( eOnePass!=ONEPASS_OFF ){ + if( !isView && aiCurOnePass[0]!=iDataCur && aiCurOnePass[1]!=iDataCur ){ + assert( pPk ); + sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey,nKey); + VdbeCoverage(v); + } + if( eOnePass!=ONEPASS_SINGLE ){ + labelContinue = sqlite3VdbeMakeLabel(pParse); + } + sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak); + VdbeCoverageIf(v, pPk==0); + VdbeCoverageIf(v, pPk!=0); + }else if( pPk || nChangeFrom ){ + labelContinue = sqlite3VdbeMakeLabel(pParse); + sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v); + addrTop = sqlite3VdbeCurrentAddr(v); + if( nChangeFrom ){ + if( !isView ){ + if( pPk ){ + for(i=0; i=0 ); + if( nChangeFrom==0 ){ + sqlite3ExprCode(pParse, pRowidExpr, regNewRowid); + }else{ + sqlite3VdbeAddOp3(v, OP_Column, iEph, iRowidExpr, regNewRowid); + } + sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v); + } + + /* Compute the old pre-UPDATE content of the row being changed, if that + ** information is needed */ + if( chngPk || hasFK || pTrigger ){ + u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0); + oldmask |= sqlite3TriggerColmask(pParse, + pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError + ); + for(i=0; inCol; i++){ + u32 colFlags = pTab->aCol[i].colFlags; + k = sqlite3TableColumnToStorage(pTab, i) + regOld; + if( oldmask==0xffffffff + || (i<32 && (oldmask & MASKBIT32(i))!=0) + || (colFlags & COLFLAG_PRIMKEY)!=0 + ){ + testcase( oldmask!=0xffffffff && i==31 ); + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k); + }else{ + sqlite3VdbeAddOp2(v, OP_Null, 0, k); + } + } + if( chngRowid==0 && pPk==0 ){ + sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid); + } + } + + /* Populate the array of registers beginning at regNew with the new + ** row data. This array is used to check constants, create the new + ** table and index records, and as the values for any new.* references + ** made by triggers. + ** + ** If there are one or more BEFORE triggers, then do not populate the + ** registers associated with columns that are (a) not modified by + ** this UPDATE statement and (b) not accessed by new.* references. The + ** values for registers not modified by the UPDATE must be reloaded from + ** the database after the BEFORE triggers are fired anyway (as the trigger + ** may have modified them). So not loading those that are not going to + ** be used eliminates some redundant opcodes. + */ + newmask = sqlite3TriggerColmask( + pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError + ); + for(i=0, k=regNew; inCol; i++, k++){ + if( i==pTab->iPKey ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, k); + }else if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)!=0 ){ + if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--; + }else{ + j = aXRef[i]; + if( j>=0 ){ + if( nChangeFrom ){ + int nOff = (isView ? pTab->nCol : nPk); + assert( eOnePass==ONEPASS_OFF ); + sqlite3VdbeAddOp3(v, OP_Column, iEph, nOff+j, k); + }else{ + sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k); + } + }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask & MASKBIT32(i)) ){ + /* This branch loads the value of a column that will not be changed + ** into a register. This is done if there are no BEFORE triggers, or + ** if there are one or more BEFORE triggers that use this value via + ** a new.* reference in a trigger program. + */ + testcase( i==31 ); + testcase( i==32 ); + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k); + bFinishSeek = 0; + }else{ + sqlite3VdbeAddOp2(v, OP_Null, 0, k); + } + } + } +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( pTab->tabFlags & TF_HasGenerated ){ + testcase( pTab->tabFlags & TF_HasVirtual ); + testcase( pTab->tabFlags & TF_HasStored ); + sqlite3ComputeGeneratedColumns(pParse, regNew, pTab); + } +#endif + + /* Fire any BEFORE UPDATE triggers. This happens before constraints are + ** verified. One could argue that this is wrong. + */ + if( tmask&TRIGGER_BEFORE ){ + sqlite3TableAffinity(v, pTab, regNew); + sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, + TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue); + + if( !isView ){ + /* The row-trigger may have deleted the row being updated. In this + ** case, jump to the next row. No updates or AFTER triggers are + ** required. This behavior - what happens when the row being updated + ** is deleted or renamed by a BEFORE trigger - is left undefined in the + ** documentation. + */ + if( pPk ){ + sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey); + VdbeCoverage(v); + }else{ + sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid); + VdbeCoverage(v); + } + + /* After-BEFORE-trigger-reload-loop: + ** If it did not delete it, the BEFORE trigger may still have modified + ** some of the columns of the row being updated. Load the values for + ** all columns not modified by the update statement into their registers + ** in case this has happened. Only unmodified columns are reloaded. + ** The values computed for modified columns use the values before the + ** BEFORE trigger runs. See test case trigger1-18.0 (added 2018-04-26) + ** for an example. + */ + for(i=0, k=regNew; inCol; i++, k++){ + if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){ + if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--; + }else if( aXRef[i]<0 && i!=pTab->iPKey ){ + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k); + } + } +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( pTab->tabFlags & TF_HasGenerated ){ + testcase( pTab->tabFlags & TF_HasVirtual ); + testcase( pTab->tabFlags & TF_HasStored ); + sqlite3ComputeGeneratedColumns(pParse, regNew, pTab); + } +#endif + } + } + + if( !isView ){ + /* Do constraint checks. */ + assert( regOldRowid>0 ); + sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur, + regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace, + aXRef, 0); + + /* If REPLACE conflict handling may have been used, or if the PK of the + ** row is changing, then the GenerateConstraintChecks() above may have + ** moved cursor iDataCur. Reseek it. */ + if( bReplace || chngKey ){ + if( pPk ){ + sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey); + }else{ + sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid); + } + VdbeCoverageNeverTaken(v); + } + + /* Do FK constraint checks. */ + if( hasFK ){ + sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey); + } + + /* Delete the index entries associated with the current record. */ + sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1); + + /* We must run the OP_FinishSeek opcode to resolve a prior + ** OP_DeferredSeek if there is any possibility that there have been + ** no OP_Column opcodes since the OP_DeferredSeek was issued. But + ** we want to avoid the OP_FinishSeek if possible, as running it + ** costs CPU cycles. */ + if( bFinishSeek ){ + sqlite3VdbeAddOp1(v, OP_FinishSeek, iDataCur); + } + + /* If changing the rowid value, or if there are foreign key constraints + ** to process, delete the old record. Otherwise, add a noop OP_Delete + ** to invoke the pre-update hook. + ** + ** That (regNew==regnewRowid+1) is true is also important for the + ** pre-update hook. If the caller invokes preupdate_new(), the returned + ** value is copied from memory cell (regNewRowid+1+iCol), where iCol + ** is the column index supplied by the user. + */ + assert( regNew==regNewRowid+1 ); +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + sqlite3VdbeAddOp3(v, OP_Delete, iDataCur, + OPFLAG_ISUPDATE | ((hasFK>1 || chngKey) ? 0 : OPFLAG_ISNOOP), + regNewRowid + ); + if( eOnePass==ONEPASS_MULTI ){ + assert( hasFK==0 && chngKey==0 ); + sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION); + } + if( !pParse->nested ){ + sqlite3VdbeAppendP4(v, pTab, P4_TABLE); + } +#else + if( hasFK>1 || chngKey ){ + sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0); + } +#endif + + if( hasFK ){ + sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey); + } + + /* Insert the new index entries and the new record. */ + sqlite3CompleteInsertion( + pParse, pTab, iDataCur, iIdxCur, regNewRowid, aRegIdx, + OPFLAG_ISUPDATE | (eOnePass==ONEPASS_MULTI ? OPFLAG_SAVEPOSITION : 0), + 0, 0 + ); + + /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to + ** handle rows (possibly in other tables) that refer via a foreign key + ** to the row just updated. */ + if( hasFK ){ + sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey); + } + } + + /* Increment the row counter + */ + if( regRowCount ){ + sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1); + } + + sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, + TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue); + + /* Repeat the above with the next record to be updated, until + ** all record selected by the WHERE clause have been updated. + */ + if( eOnePass==ONEPASS_SINGLE ){ + /* Nothing to do at end-of-loop for a single-pass */ + }else if( eOnePass==ONEPASS_MULTI ){ + sqlite3VdbeResolveLabel(v, labelContinue); + sqlite3WhereEnd(pWInfo); + }else{ + sqlite3VdbeResolveLabel(v, labelContinue); + sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v); + } + sqlite3VdbeResolveLabel(v, labelBreak); + + /* Update the sqlite_sequence table by storing the content of the + ** maximum rowid counter values recorded while inserting into + ** autoincrement tables. + */ + if( pParse->nested==0 && pParse->pTriggerTab==0 && pUpsert==0 ){ + sqlite3AutoincrementEnd(pParse); + } + + /* + ** Return the number of rows that were changed, if we are tracking + ** that information. + */ + if( regRowCount ){ + sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC); + } + +update_cleanup: + sqlite3AuthContextPop(&sContext); + sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */ + sqlite3SrcListDelete(db, pTabList); + sqlite3ExprListDelete(db, pChanges); + sqlite3ExprDelete(db, pWhere); +#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) + sqlite3ExprListDelete(db, pOrderBy); + sqlite3ExprDelete(db, pLimit); +#endif + return; +} +/* Make sure "isView" and other macros defined above are undefined. Otherwise +** they may interfere with compilation of other functions in this file +** (or in another file, if this file becomes part of the amalgamation). */ +#ifdef isView + #undef isView +#endif +#ifdef pTrigger + #undef pTrigger +#endif + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Generate code for an UPDATE of a virtual table. +** +** There are two possible strategies - the default and the special +** "onepass" strategy. Onepass is only used if the virtual table +** implementation indicates that pWhere may match at most one row. +** +** The default strategy is to create an ephemeral table that contains +** for each row to be changed: +** +** (A) The original rowid of that row. +** (B) The revised rowid for the row. +** (C) The content of every column in the row. +** +** Then loop through the contents of this ephemeral table executing a +** VUpdate for each row. When finished, drop the ephemeral table. +** +** The "onepass" strategy does not use an ephemeral table. Instead, it +** stores the same values (A, B and C above) in a register array and +** makes a single invocation of VUpdate. +*/ +static void updateVirtualTable( + Parse *pParse, /* The parsing context */ + SrcList *pSrc, /* The virtual table to be modified */ + Table *pTab, /* The virtual table */ + ExprList *pChanges, /* The columns to change in the UPDATE statement */ + Expr *pRowid, /* Expression used to recompute the rowid */ + int *aXRef, /* Mapping from columns of pTab to entries in pChanges */ + Expr *pWhere, /* WHERE clause of the UPDATE statement */ + int onError /* ON CONFLICT strategy */ +){ + Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */ + int ephemTab; /* Table holding the result of the SELECT */ + int i; /* Loop counter */ + sqlite3 *db = pParse->db; /* Database connection */ + const char *pVTab = (const char*)sqlite3GetVTable(db, pTab); + WhereInfo *pWInfo = 0; + int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */ + int regArg; /* First register in VUpdate arg array */ + int regRec; /* Register in which to assemble record */ + int regRowid; /* Register for ephem table rowid */ + int iCsr = pSrc->a[0].iCursor; /* Cursor used for virtual table scan */ + int aDummy[2]; /* Unused arg for sqlite3WhereOkOnePass() */ + int eOnePass; /* True to use onepass strategy */ + int addr; /* Address of OP_OpenEphemeral */ + + /* Allocate nArg registers in which to gather the arguments for VUpdate. Then + ** create and open the ephemeral table in which the records created from + ** these arguments will be temporarily stored. */ + assert( v ); + ephemTab = pParse->nTab++; + addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg); + regArg = pParse->nMem + 1; + pParse->nMem += nArg; + if( pSrc->nSrc>1 ){ + Index *pPk = 0; + Expr *pRow; + ExprList *pList; + if( HasRowid(pTab) ){ + if( pRowid ){ + pRow = sqlite3ExprDup(db, pRowid, 0); + }else{ + pRow = sqlite3PExpr(pParse, TK_ROW, 0, 0); + } + }else{ + i16 iPk; /* PRIMARY KEY column */ + pPk = sqlite3PrimaryKeyIndex(pTab); + assert( pPk!=0 ); + assert( pPk->nKeyCol==1 ); + iPk = pPk->aiColumn[0]; + if( aXRef[iPk]>=0 ){ + pRow = sqlite3ExprDup(db, pChanges->a[aXRef[iPk]].pExpr, 0); + }else{ + pRow = exprRowColumn(pParse, iPk); + } + } + pList = sqlite3ExprListAppend(pParse, 0, pRow); + + for(i=0; inCol; i++){ + if( aXRef[i]>=0 ){ + pList = sqlite3ExprListAppend(pParse, pList, + sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0) + ); + }else{ + pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i)); + } + } + + updateFromSelect(pParse, ephemTab, pPk, pList, pSrc, pWhere, 0, 0); + sqlite3ExprListDelete(db, pList); + eOnePass = ONEPASS_OFF; + }else{ + regRec = ++pParse->nMem; + regRowid = ++pParse->nMem; + + /* Start scanning the virtual table */ + pWInfo = sqlite3WhereBegin(pParse, pSrc,pWhere,0,0,WHERE_ONEPASS_DESIRED,0); + if( pWInfo==0 ) return; + + /* Populate the argument registers. */ + for(i=0; inCol; i++){ + assert( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 ); + if( aXRef[i]>=0 ){ + sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i); + }else{ + sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, i, regArg+2+i); + sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG);/* For sqlite3_vtab_nochange() */ + } + } + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg); + if( pRowid ){ + sqlite3ExprCode(pParse, pRowid, regArg+1); + }else{ + sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg+1); + } + }else{ + Index *pPk; /* PRIMARY KEY index */ + i16 iPk; /* PRIMARY KEY column */ + pPk = sqlite3PrimaryKeyIndex(pTab); + assert( pPk!=0 ); + assert( pPk->nKeyCol==1 ); + iPk = pPk->aiColumn[0]; + sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, iPk, regArg); + sqlite3VdbeAddOp2(v, OP_SCopy, regArg+2+iPk, regArg+1); + } + + eOnePass = sqlite3WhereOkOnePass(pWInfo, aDummy); + + /* There is no ONEPASS_MULTI on virtual tables */ + assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE ); + + if( eOnePass ){ + /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded + ** above. */ + sqlite3VdbeChangeToNoop(v, addr); + sqlite3VdbeAddOp1(v, OP_Close, iCsr); + }else{ + /* Create a record from the argument register contents and insert it into + ** the ephemeral table. */ + sqlite3MultiWrite(pParse); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regArg, nArg, regRec); +#if defined(SQLITE_DEBUG) && !defined(SQLITE_ENABLE_NULL_TRIM) + /* Signal an assert() within OP_MakeRecord that it is allowed to + ** accept no-change records with serial_type 10 */ + sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG_MAGIC); +#endif + sqlite3VdbeAddOp2(v, OP_NewRowid, ephemTab, regRowid); + sqlite3VdbeAddOp3(v, OP_Insert, ephemTab, regRec, regRowid); + } + } + + + if( eOnePass==ONEPASS_OFF ){ + /* End the virtual table scan */ + if( pSrc->nSrc==1 ){ + sqlite3WhereEnd(pWInfo); + } + + /* Begin scannning through the ephemeral table. */ + addr = sqlite3VdbeAddOp1(v, OP_Rewind, ephemTab); VdbeCoverage(v); + + /* Extract arguments from the current row of the ephemeral table and + ** invoke the VUpdate method. */ + for(i=0; ipUpsertTarget); + sqlite3ExprDelete(db, p->pUpsertTargetWhere); + sqlite3ExprListDelete(db, p->pUpsertSet); + sqlite3ExprDelete(db, p->pUpsertWhere); + sqlite3DbFree(db, p); + } +} + +/* +** Duplicate an Upsert object. +*/ +SQLITE_PRIVATE Upsert *sqlite3UpsertDup(sqlite3 *db, Upsert *p){ + if( p==0 ) return 0; + return sqlite3UpsertNew(db, + sqlite3ExprListDup(db, p->pUpsertTarget, 0), + sqlite3ExprDup(db, p->pUpsertTargetWhere, 0), + sqlite3ExprListDup(db, p->pUpsertSet, 0), + sqlite3ExprDup(db, p->pUpsertWhere, 0) + ); +} + +/* +** Create a new Upsert object. +*/ +SQLITE_PRIVATE Upsert *sqlite3UpsertNew( + sqlite3 *db, /* Determines which memory allocator to use */ + ExprList *pTarget, /* Target argument to ON CONFLICT, or NULL */ + Expr *pTargetWhere, /* Optional WHERE clause on the target */ + ExprList *pSet, /* UPDATE columns, or NULL for a DO NOTHING */ + Expr *pWhere /* WHERE clause for the ON CONFLICT UPDATE */ +){ + Upsert *pNew; + pNew = sqlite3DbMallocRaw(db, sizeof(Upsert)); + if( pNew==0 ){ + sqlite3ExprListDelete(db, pTarget); + sqlite3ExprDelete(db, pTargetWhere); + sqlite3ExprListDelete(db, pSet); + sqlite3ExprDelete(db, pWhere); + return 0; + }else{ + pNew->pUpsertTarget = pTarget; + pNew->pUpsertTargetWhere = pTargetWhere; + pNew->pUpsertSet = pSet; + pNew->pUpsertWhere = pWhere; + pNew->pUpsertIdx = 0; + } + return pNew; +} + +/* +** Analyze the ON CONFLICT clause described by pUpsert. Resolve all +** symbols in the conflict-target. +** +** Return SQLITE_OK if everything works, or an error code is something +** is wrong. +*/ +SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget( + Parse *pParse, /* The parsing context */ + SrcList *pTabList, /* Table into which we are inserting */ + Upsert *pUpsert /* The ON CONFLICT clauses */ +){ + Table *pTab; /* That table into which we are inserting */ + int rc; /* Result code */ + int iCursor; /* Cursor used by pTab */ + Index *pIdx; /* One of the indexes of pTab */ + ExprList *pTarget; /* The conflict-target clause */ + Expr *pTerm; /* One term of the conflict-target clause */ + NameContext sNC; /* Context for resolving symbolic names */ + Expr sCol[2]; /* Index column converted into an Expr */ + + assert( pTabList->nSrc==1 ); + assert( pTabList->a[0].pTab!=0 ); + assert( pUpsert!=0 ); + assert( pUpsert->pUpsertTarget!=0 ); + + /* Resolve all symbolic names in the conflict-target clause, which + ** includes both the list of columns and the optional partial-index + ** WHERE clause. + */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pSrcList = pTabList; + rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget); + if( rc ) return rc; + rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere); + if( rc ) return rc; + + /* Check to see if the conflict target matches the rowid. */ + pTab = pTabList->a[0].pTab; + pTarget = pUpsert->pUpsertTarget; + iCursor = pTabList->a[0].iCursor; + if( HasRowid(pTab) + && pTarget->nExpr==1 + && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN + && pTerm->iColumn==XN_ROWID + ){ + /* The conflict-target is the rowid of the primary table */ + assert( pUpsert->pUpsertIdx==0 ); + return SQLITE_OK; + } + + /* Initialize sCol[0..1] to be an expression parse tree for a + ** single column of an index. The sCol[0] node will be the TK_COLLATE + ** operator and sCol[1] will be the TK_COLUMN operator. Code below + ** will populate the specific collation and column number values + ** prior to comparing against the conflict-target expression. + */ + memset(sCol, 0, sizeof(sCol)); + sCol[0].op = TK_COLLATE; + sCol[0].pLeft = &sCol[1]; + sCol[1].op = TK_COLUMN; + sCol[1].iTable = pTabList->a[0].iCursor; + + /* Check for matches against other indexes */ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int ii, jj, nn; + if( !IsUniqueIndex(pIdx) ) continue; + if( pTarget->nExpr!=pIdx->nKeyCol ) continue; + if( pIdx->pPartIdxWhere ){ + if( pUpsert->pUpsertTargetWhere==0 ) continue; + if( sqlite3ExprCompare(pParse, pUpsert->pUpsertTargetWhere, + pIdx->pPartIdxWhere, iCursor)!=0 ){ + continue; + } + } + nn = pIdx->nKeyCol; + for(ii=0; iiazColl[ii]; + if( pIdx->aiColumn[ii]==XN_EXPR ){ + assert( pIdx->aColExpr!=0 ); + assert( pIdx->aColExpr->nExpr>ii ); + pExpr = pIdx->aColExpr->a[ii].pExpr; + if( pExpr->op!=TK_COLLATE ){ + sCol[0].pLeft = pExpr; + pExpr = &sCol[0]; + } + }else{ + sCol[0].pLeft = &sCol[1]; + sCol[1].iColumn = pIdx->aiColumn[ii]; + pExpr = &sCol[0]; + } + for(jj=0; jja[jj].pExpr, pExpr,iCursor)<2 ){ + break; /* Column ii of the index matches column jj of target */ + } + } + if( jj>=nn ){ + /* The target contains no match for column jj of the index */ + break; + } + } + if( iipUpsertIdx = pIdx; + return SQLITE_OK; + } + sqlite3ErrorMsg(pParse, "ON CONFLICT clause does not match any " + "PRIMARY KEY or UNIQUE constraint"); + return SQLITE_ERROR; +} + +/* +** Generate bytecode that does an UPDATE as part of an upsert. +** +** If pIdx is NULL, then the UNIQUE constraint that failed was the IPK. +** In this case parameter iCur is a cursor open on the table b-tree that +** currently points to the conflicting table row. Otherwise, if pIdx +** is not NULL, then pIdx is the constraint that failed and iCur is a +** cursor points to the conflicting row. +*/ +SQLITE_PRIVATE void sqlite3UpsertDoUpdate( + Parse *pParse, /* The parsing and code-generating context */ + Upsert *pUpsert, /* The ON CONFLICT clause for the upsert */ + Table *pTab, /* The table being updated */ + Index *pIdx, /* The UNIQUE constraint that failed */ + int iCur /* Cursor for pIdx (or pTab if pIdx==NULL) */ +){ + Vdbe *v = pParse->pVdbe; + sqlite3 *db = pParse->db; + SrcList *pSrc; /* FROM clause for the UPDATE */ + int iDataCur; + int i; + + assert( v!=0 ); + assert( pUpsert!=0 ); + VdbeNoopComment((v, "Begin DO UPDATE of UPSERT")); + iDataCur = pUpsert->iDataCur; + if( pIdx && iCur!=iDataCur ){ + if( HasRowid(pTab) ){ + int regRowid = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp2(v, OP_IdxRowid, iCur, regRowid); + sqlite3VdbeAddOp3(v, OP_SeekRowid, iDataCur, 0, regRowid); + VdbeCoverage(v); + sqlite3ReleaseTempReg(pParse, regRowid); + }else{ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + int nPk = pPk->nKeyCol; + int iPk = pParse->nMem+1; + pParse->nMem += nPk; + for(i=0; iaiColumn[i]>=0 ); + k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]); + sqlite3VdbeAddOp3(v, OP_Column, iCur, k, iPk+i); + VdbeComment((v, "%s.%s", pIdx->zName, + pTab->aCol[pPk->aiColumn[i]].zName)); + } + sqlite3VdbeVerifyAbortable(v, OE_Abort); + i = sqlite3VdbeAddOp4Int(v, OP_Found, iDataCur, 0, iPk, nPk); + VdbeCoverage(v); + sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CORRUPT, OE_Abort, 0, + "corrupt database", P4_STATIC); + sqlite3MayAbort(pParse); + sqlite3VdbeJumpHere(v, i); + } + } + /* pUpsert does not own pUpsertSrc - the outer INSERT statement does. So + ** we have to make a copy before passing it down into sqlite3Update() */ + pSrc = sqlite3SrcListDup(db, pUpsert->pUpsertSrc, 0); + /* excluded.* columns of type REAL need to be converted to a hard real */ + for(i=0; inCol; i++){ + if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){ + sqlite3VdbeAddOp1(v, OP_RealAffinity, pUpsert->regData+i); + } + } + sqlite3Update(pParse, pSrc, pUpsert->pUpsertSet, + pUpsert->pUpsertWhere, OE_Abort, 0, 0, pUpsert); + pUpsert->pUpsertSet = 0; /* Will have been deleted by sqlite3Update() */ + pUpsert->pUpsertWhere = 0; /* Will have been deleted by sqlite3Update() */ + VdbeNoopComment((v, "End DO UPDATE of UPSERT")); +} + +#endif /* SQLITE_OMIT_UPSERT */ + +/************** End of upsert.c **********************************************/ +/************** Begin file vacuum.c ******************************************/ +/* +** 2003 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the VACUUM command. +** +** Most of the code in this file may be omitted by defining the +** SQLITE_OMIT_VACUUM macro. +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +#if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH) + +/* +** Execute zSql on database db. +** +** If zSql returns rows, then each row will have exactly one +** column. (This will only happen if zSql begins with "SELECT".) +** Take each row of result and call execSql() again recursively. +** +** The execSqlF() routine does the same thing, except it accepts +** a format string as its third argument +*/ +static int execSql(sqlite3 *db, char **pzErrMsg, const char *zSql){ + sqlite3_stmt *pStmt; + int rc; + + /* printf("SQL: [%s]\n", zSql); fflush(stdout); */ + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); + if( rc!=SQLITE_OK ) return rc; + while( SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){ + const char *zSubSql = (const char*)sqlite3_column_text(pStmt,0); + assert( sqlite3_strnicmp(zSql,"SELECT",6)==0 ); + /* The secondary SQL must be one of CREATE TABLE, CREATE INDEX, + ** or INSERT. Historically there have been attacks that first + ** corrupt the sqlite_schema.sql field with other kinds of statements + ** then run VACUUM to get those statements to execute at inappropriate + ** times. */ + if( zSubSql + && (strncmp(zSubSql,"CRE",3)==0 || strncmp(zSubSql,"INS",3)==0) + ){ + rc = execSql(db, pzErrMsg, zSubSql); + if( rc!=SQLITE_OK ) break; + } + } + assert( rc!=SQLITE_ROW ); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + if( rc ){ + sqlite3SetString(pzErrMsg, db, sqlite3_errmsg(db)); + } + (void)sqlite3_finalize(pStmt); + return rc; +} +static int execSqlF(sqlite3 *db, char **pzErrMsg, const char *zSql, ...){ + char *z; + va_list ap; + int rc; + va_start(ap, zSql); + z = sqlite3VMPrintf(db, zSql, ap); + va_end(ap); + if( z==0 ) return SQLITE_NOMEM; + rc = execSql(db, pzErrMsg, z); + sqlite3DbFree(db, z); + return rc; +} + +/* +** The VACUUM command is used to clean up the database, +** collapse free space, etc. It is modelled after the VACUUM command +** in PostgreSQL. The VACUUM command works as follows: +** +** (1) Create a new transient database file +** (2) Copy all content from the database being vacuumed into +** the new transient database file +** (3) Copy content from the transient database back into the +** original database. +** +** The transient database requires temporary disk space approximately +** equal to the size of the original database. The copy operation of +** step (3) requires additional temporary disk space approximately equal +** to the size of the original database for the rollback journal. +** Hence, temporary disk space that is approximately 2x the size of the +** original database is required. Every page of the database is written +** approximately 3 times: Once for step (2) and twice for step (3). +** Two writes per page are required in step (3) because the original +** database content must be written into the rollback journal prior to +** overwriting the database with the vacuumed content. +** +** Only 1x temporary space and only 1x writes would be required if +** the copy of step (3) were replaced by deleting the original database +** and renaming the transient database as the original. But that will +** not work if other processes are attached to the original database. +** And a power loss in between deleting the original and renaming the +** transient would cause the database file to appear to be deleted +** following reboot. +*/ +SQLITE_PRIVATE void sqlite3Vacuum(Parse *pParse, Token *pNm, Expr *pInto){ + Vdbe *v = sqlite3GetVdbe(pParse); + int iDb = 0; + if( v==0 ) goto build_vacuum_end; + if( pParse->nErr ) goto build_vacuum_end; + if( pNm ){ +#ifndef SQLITE_BUG_COMPATIBLE_20160819 + /* Default behavior: Report an error if the argument to VACUUM is + ** not recognized */ + iDb = sqlite3TwoPartName(pParse, pNm, pNm, &pNm); + if( iDb<0 ) goto build_vacuum_end; +#else + /* When SQLITE_BUG_COMPATIBLE_20160819 is defined, unrecognized arguments + ** to VACUUM are silently ignored. This is a back-out of a bug fix that + ** occurred on 2016-08-19 (https://www.sqlite.org/src/info/083f9e6270). + ** The buggy behavior is required for binary compatibility with some + ** legacy applications. */ + iDb = sqlite3FindDb(pParse->db, pNm); + if( iDb<0 ) iDb = 0; +#endif + } + if( iDb!=1 ){ + int iIntoReg = 0; + if( pInto && sqlite3ResolveSelfReference(pParse,0,0,pInto,0)==0 ){ + iIntoReg = ++pParse->nMem; + sqlite3ExprCode(pParse, pInto, iIntoReg); + } + sqlite3VdbeAddOp2(v, OP_Vacuum, iDb, iIntoReg); + sqlite3VdbeUsesBtree(v, iDb); + } +build_vacuum_end: + sqlite3ExprDelete(pParse->db, pInto); + return; +} + +/* +** This routine implements the OP_Vacuum opcode of the VDBE. +*/ +SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum( + char **pzErrMsg, /* Write error message here */ + sqlite3 *db, /* Database connection */ + int iDb, /* Which attached DB to vacuum */ + sqlite3_value *pOut /* Write results here, if not NULL. VACUUM INTO */ +){ + int rc = SQLITE_OK; /* Return code from service routines */ + Btree *pMain; /* The database being vacuumed */ + Btree *pTemp; /* The temporary database we vacuum into */ + u32 saved_mDbFlags; /* Saved value of db->mDbFlags */ + u64 saved_flags; /* Saved value of db->flags */ + int saved_nChange; /* Saved value of db->nChange */ + int saved_nTotalChange; /* Saved value of db->nTotalChange */ + u32 saved_openFlags; /* Saved value of db->openFlags */ + u8 saved_mTrace; /* Saved trace settings */ + Db *pDb = 0; /* Database to detach at end of vacuum */ + int isMemDb; /* True if vacuuming a :memory: database */ + int nRes; /* Bytes of reserved space at the end of each page */ + int nDb; /* Number of attached databases */ + const char *zDbMain; /* Schema name of database to vacuum */ + const char *zOut; /* Name of output file */ + + if( !db->autoCommit ){ + sqlite3SetString(pzErrMsg, db, "cannot VACUUM from within a transaction"); + return SQLITE_ERROR; /* IMP: R-12218-18073 */ + } + if( db->nVdbeActive>1 ){ + sqlite3SetString(pzErrMsg, db,"cannot VACUUM - SQL statements in progress"); + return SQLITE_ERROR; /* IMP: R-15610-35227 */ + } + saved_openFlags = db->openFlags; + if( pOut ){ + if( sqlite3_value_type(pOut)!=SQLITE_TEXT ){ + sqlite3SetString(pzErrMsg, db, "non-text filename"); + return SQLITE_ERROR; + } + zOut = (const char*)sqlite3_value_text(pOut); + db->openFlags &= ~SQLITE_OPEN_READONLY; + db->openFlags |= SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE; + }else{ + zOut = ""; + } + + /* Save the current value of the database flags so that it can be + ** restored before returning. Then set the writable-schema flag, and + ** disable CHECK and foreign key constraints. */ + saved_flags = db->flags; + saved_mDbFlags = db->mDbFlags; + saved_nChange = db->nChange; + saved_nTotalChange = db->nTotalChange; + saved_mTrace = db->mTrace; + db->flags |= SQLITE_WriteSchema | SQLITE_IgnoreChecks; + db->mDbFlags |= DBFLAG_PreferBuiltin | DBFLAG_Vacuum; + db->flags &= ~(u64)(SQLITE_ForeignKeys | SQLITE_ReverseOrder + | SQLITE_Defensive | SQLITE_CountRows); + db->mTrace = 0; + + zDbMain = db->aDb[iDb].zDbSName; + pMain = db->aDb[iDb].pBt; + isMemDb = sqlite3PagerIsMemdb(sqlite3BtreePager(pMain)); + + /* Attach the temporary database as 'vacuum_db'. The synchronous pragma + ** can be set to 'off' for this file, as it is not recovered if a crash + ** occurs anyway. The integrity of the database is maintained by a + ** (possibly synchronous) transaction opened on the main database before + ** sqlite3BtreeCopyFile() is called. + ** + ** An optimisation would be to use a non-journaled pager. + ** (Later:) I tried setting "PRAGMA vacuum_db.journal_mode=OFF" but + ** that actually made the VACUUM run slower. Very little journalling + ** actually occurs when doing a vacuum since the vacuum_db is initially + ** empty. Only the journal header is written. Apparently it takes more + ** time to parse and run the PRAGMA to turn journalling off than it does + ** to write the journal header file. + */ + nDb = db->nDb; + rc = execSqlF(db, pzErrMsg, "ATTACH %Q AS vacuum_db", zOut); + db->openFlags = saved_openFlags; + if( rc!=SQLITE_OK ) goto end_of_vacuum; + assert( (db->nDb-1)==nDb ); + pDb = &db->aDb[nDb]; + assert( strcmp(pDb->zDbSName,"vacuum_db")==0 ); + pTemp = pDb->pBt; + if( pOut ){ + sqlite3_file *id = sqlite3PagerFile(sqlite3BtreePager(pTemp)); + i64 sz = 0; + if( id->pMethods!=0 && (sqlite3OsFileSize(id, &sz)!=SQLITE_OK || sz>0) ){ + rc = SQLITE_ERROR; + sqlite3SetString(pzErrMsg, db, "output file already exists"); + goto end_of_vacuum; + } + db->mDbFlags |= DBFLAG_VacuumInto; + } + nRes = sqlite3BtreeGetRequestedReserve(pMain); + + sqlite3BtreeSetCacheSize(pTemp, db->aDb[iDb].pSchema->cache_size); + sqlite3BtreeSetSpillSize(pTemp, sqlite3BtreeSetSpillSize(pMain,0)); + sqlite3BtreeSetPagerFlags(pTemp, PAGER_SYNCHRONOUS_OFF|PAGER_CACHESPILL); + + /* Begin a transaction and take an exclusive lock on the main database + ** file. This is done before the sqlite3BtreeGetPageSize(pMain) call below, + ** to ensure that we do not try to change the page-size on a WAL database. + */ + rc = execSql(db, pzErrMsg, "BEGIN"); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + rc = sqlite3BtreeBeginTrans(pMain, pOut==0 ? 2 : 0, 0); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + + /* Do not attempt to change the page size for a WAL database */ + if( sqlite3PagerGetJournalMode(sqlite3BtreePager(pMain)) + ==PAGER_JOURNALMODE_WAL ){ + db->nextPagesize = 0; + } + + if( sqlite3BtreeSetPageSize(pTemp, sqlite3BtreeGetPageSize(pMain), nRes, 0) + || (!isMemDb && sqlite3BtreeSetPageSize(pTemp, db->nextPagesize, nRes, 0)) + || NEVER(db->mallocFailed) + ){ + rc = SQLITE_NOMEM_BKPT; + goto end_of_vacuum; + } + +#ifndef SQLITE_OMIT_AUTOVACUUM + sqlite3BtreeSetAutoVacuum(pTemp, db->nextAutovac>=0 ? db->nextAutovac : + sqlite3BtreeGetAutoVacuum(pMain)); +#endif + + /* Query the schema of the main database. Create a mirror schema + ** in the temporary database. + */ + db->init.iDb = nDb; /* force new CREATE statements into vacuum_db */ + rc = execSqlF(db, pzErrMsg, + "SELECT sql FROM \"%w\".sqlite_schema" + " WHERE type='table'AND name<>'sqlite_sequence'" + " AND coalesce(rootpage,1)>0", + zDbMain + ); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + rc = execSqlF(db, pzErrMsg, + "SELECT sql FROM \"%w\".sqlite_schema" + " WHERE type='index'", + zDbMain + ); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + db->init.iDb = 0; + + /* Loop through the tables in the main database. For each, do + ** an "INSERT INTO vacuum_db.xxx SELECT * FROM main.xxx;" to copy + ** the contents to the temporary database. + */ + rc = execSqlF(db, pzErrMsg, + "SELECT'INSERT INTO vacuum_db.'||quote(name)" + "||' SELECT*FROM\"%w\".'||quote(name)" + "FROM vacuum_db.sqlite_schema " + "WHERE type='table'AND coalesce(rootpage,1)>0", + zDbMain + ); + assert( (db->mDbFlags & DBFLAG_Vacuum)!=0 ); + db->mDbFlags &= ~DBFLAG_Vacuum; + if( rc!=SQLITE_OK ) goto end_of_vacuum; + + /* Copy the triggers, views, and virtual tables from the main database + ** over to the temporary database. None of these objects has any + ** associated storage, so all we have to do is copy their entries + ** from the schema table. + */ + rc = execSqlF(db, pzErrMsg, + "INSERT INTO vacuum_db.sqlite_schema" + " SELECT*FROM \"%w\".sqlite_schema" + " WHERE type IN('view','trigger')" + " OR(type='table'AND rootpage=0)", + zDbMain + ); + if( rc ) goto end_of_vacuum; + + /* At this point, there is a write transaction open on both the + ** vacuum database and the main database. Assuming no error occurs, + ** both transactions are closed by this block - the main database + ** transaction by sqlite3BtreeCopyFile() and the other by an explicit + ** call to sqlite3BtreeCommit(). + */ + { + u32 meta; + int i; + + /* This array determines which meta meta values are preserved in the + ** vacuum. Even entries are the meta value number and odd entries + ** are an increment to apply to the meta value after the vacuum. + ** The increment is used to increase the schema cookie so that other + ** connections to the same database will know to reread the schema. + */ + static const unsigned char aCopy[] = { + BTREE_SCHEMA_VERSION, 1, /* Add one to the old schema cookie */ + BTREE_DEFAULT_CACHE_SIZE, 0, /* Preserve the default page cache size */ + BTREE_TEXT_ENCODING, 0, /* Preserve the text encoding */ + BTREE_USER_VERSION, 0, /* Preserve the user version */ + BTREE_APPLICATION_ID, 0, /* Preserve the application id */ + }; + + assert( SQLITE_TXN_WRITE==sqlite3BtreeTxnState(pTemp) ); + assert( pOut!=0 || SQLITE_TXN_WRITE==sqlite3BtreeTxnState(pMain) ); + + /* Copy Btree meta values */ + for(i=0; iflags */ + db->init.iDb = 0; + db->mDbFlags = saved_mDbFlags; + db->flags = saved_flags; + db->nChange = saved_nChange; + db->nTotalChange = saved_nTotalChange; + db->mTrace = saved_mTrace; + sqlite3BtreeSetPageSize(pMain, -1, 0, 1); + + /* Currently there is an SQL level transaction open on the vacuum + ** database. No locks are held on any other files (since the main file + ** was committed at the btree level). So it safe to end the transaction + ** by manually setting the autoCommit flag to true and detaching the + ** vacuum database. The vacuum_db journal file is deleted when the pager + ** is closed by the DETACH. + */ + db->autoCommit = 1; + + if( pDb ){ + sqlite3BtreeClose(pDb->pBt); + pDb->pBt = 0; + pDb->pSchema = 0; + } + + /* This both clears the schemas and reduces the size of the db->aDb[] + ** array. */ + sqlite3ResetAllSchemasOfConnection(db); + + return rc; +} + +#endif /* SQLITE_OMIT_VACUUM && SQLITE_OMIT_ATTACH */ + +/************** End of vacuum.c **********************************************/ +/************** Begin file vtab.c ********************************************/ +/* +** 2006 June 10 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to help implement virtual tables. +*/ +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* #include "sqliteInt.h" */ + +/* +** Before a virtual table xCreate() or xConnect() method is invoked, the +** sqlite3.pVtabCtx member variable is set to point to an instance of +** this struct allocated on the stack. It is used by the implementation of +** the sqlite3_declare_vtab() and sqlite3_vtab_config() APIs, both of which +** are invoked only from within xCreate and xConnect methods. +*/ +struct VtabCtx { + VTable *pVTable; /* The virtual table being constructed */ + Table *pTab; /* The Table object to which the virtual table belongs */ + VtabCtx *pPrior; /* Parent context (if any) */ + int bDeclared; /* True after sqlite3_declare_vtab() is called */ +}; + +/* +** Construct and install a Module object for a virtual table. When this +** routine is called, it is guaranteed that all appropriate locks are held +** and the module is not already part of the connection. +** +** If there already exists a module with zName, replace it with the new one. +** If pModule==0, then delete the module zName if it exists. +*/ +SQLITE_PRIVATE Module *sqlite3VtabCreateModule( + sqlite3 *db, /* Database in which module is registered */ + const char *zName, /* Name assigned to this module */ + const sqlite3_module *pModule, /* The definition of the module */ + void *pAux, /* Context pointer for xCreate/xConnect */ + void (*xDestroy)(void *) /* Module destructor function */ +){ + Module *pMod; + Module *pDel; + char *zCopy; + if( pModule==0 ){ + zCopy = (char*)zName; + pMod = 0; + }else{ + int nName = sqlite3Strlen30(zName); + pMod = (Module *)sqlite3Malloc(sizeof(Module) + nName + 1); + if( pMod==0 ){ + sqlite3OomFault(db); + return 0; + } + zCopy = (char *)(&pMod[1]); + memcpy(zCopy, zName, nName+1); + pMod->zName = zCopy; + pMod->pModule = pModule; + pMod->pAux = pAux; + pMod->xDestroy = xDestroy; + pMod->pEpoTab = 0; + pMod->nRefModule = 1; + } + pDel = (Module *)sqlite3HashInsert(&db->aModule,zCopy,(void*)pMod); + if( pDel ){ + if( pDel==pMod ){ + sqlite3OomFault(db); + sqlite3DbFree(db, pDel); + pMod = 0; + }else{ + sqlite3VtabEponymousTableClear(db, pDel); + sqlite3VtabModuleUnref(db, pDel); + } + } + return pMod; +} + +/* +** The actual function that does the work of creating a new module. +** This function implements the sqlite3_create_module() and +** sqlite3_create_module_v2() interfaces. +*/ +static int createModule( + sqlite3 *db, /* Database in which module is registered */ + const char *zName, /* Name assigned to this module */ + const sqlite3_module *pModule, /* The definition of the module */ + void *pAux, /* Context pointer for xCreate/xConnect */ + void (*xDestroy)(void *) /* Module destructor function */ +){ + int rc = SQLITE_OK; + + sqlite3_mutex_enter(db->mutex); + (void)sqlite3VtabCreateModule(db, zName, pModule, pAux, xDestroy); + rc = sqlite3ApiExit(db, rc); + if( rc!=SQLITE_OK && xDestroy ) xDestroy(pAux); + sqlite3_mutex_leave(db->mutex); + return rc; +} + + +/* +** External API function used to create a new virtual-table module. +*/ +SQLITE_API int sqlite3_create_module( + sqlite3 *db, /* Database in which module is registered */ + const char *zName, /* Name assigned to this module */ + const sqlite3_module *pModule, /* The definition of the module */ + void *pAux /* Context pointer for xCreate/xConnect */ +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT; +#endif + return createModule(db, zName, pModule, pAux, 0); +} + +/* +** External API function used to create a new virtual-table module. +*/ +SQLITE_API int sqlite3_create_module_v2( + sqlite3 *db, /* Database in which module is registered */ + const char *zName, /* Name assigned to this module */ + const sqlite3_module *pModule, /* The definition of the module */ + void *pAux, /* Context pointer for xCreate/xConnect */ + void (*xDestroy)(void *) /* Module destructor function */ +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT; +#endif + return createModule(db, zName, pModule, pAux, xDestroy); +} + +/* +** External API to drop all virtual-table modules, except those named +** on the azNames list. +*/ +SQLITE_API int sqlite3_drop_modules(sqlite3 *db, const char** azNames){ + HashElem *pThis, *pNext; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + for(pThis=sqliteHashFirst(&db->aModule); pThis; pThis=pNext){ + Module *pMod = (Module*)sqliteHashData(pThis); + pNext = sqliteHashNext(pThis); + if( azNames ){ + int ii; + for(ii=0; azNames[ii]!=0 && strcmp(azNames[ii],pMod->zName)!=0; ii++){} + if( azNames[ii]!=0 ) continue; + } + createModule(db, pMod->zName, 0, 0, 0); + } + return SQLITE_OK; +} + +/* +** Decrement the reference count on a Module object. Destroy the +** module when the reference count reaches zero. +*/ +SQLITE_PRIVATE void sqlite3VtabModuleUnref(sqlite3 *db, Module *pMod){ + assert( pMod->nRefModule>0 ); + pMod->nRefModule--; + if( pMod->nRefModule==0 ){ + if( pMod->xDestroy ){ + pMod->xDestroy(pMod->pAux); + } + assert( pMod->pEpoTab==0 ); + sqlite3DbFree(db, pMod); + } +} + +/* +** Lock the virtual table so that it cannot be disconnected. +** Locks nest. Every lock should have a corresponding unlock. +** If an unlock is omitted, resources leaks will occur. +** +** If a disconnect is attempted while a virtual table is locked, +** the disconnect is deferred until all locks have been removed. +*/ +SQLITE_PRIVATE void sqlite3VtabLock(VTable *pVTab){ + pVTab->nRef++; +} + + +/* +** pTab is a pointer to a Table structure representing a virtual-table. +** Return a pointer to the VTable object used by connection db to access +** this virtual-table, if one has been created, or NULL otherwise. +*/ +SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab){ + VTable *pVtab; + assert( IsVirtual(pTab) ); + for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext); + return pVtab; +} + +/* +** Decrement the ref-count on a virtual table object. When the ref-count +** reaches zero, call the xDisconnect() method to delete the object. +*/ +SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *pVTab){ + sqlite3 *db = pVTab->db; + + assert( db ); + assert( pVTab->nRef>0 ); + assert( db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_ZOMBIE ); + + pVTab->nRef--; + if( pVTab->nRef==0 ){ + sqlite3_vtab *p = pVTab->pVtab; + sqlite3VtabModuleUnref(pVTab->db, pVTab->pMod); + if( p ){ + p->pModule->xDisconnect(p); + } + sqlite3DbFree(db, pVTab); + } +} + +/* +** Table p is a virtual table. This function moves all elements in the +** p->pVTable list to the sqlite3.pDisconnect lists of their associated +** database connections to be disconnected at the next opportunity. +** Except, if argument db is not NULL, then the entry associated with +** connection db is left in the p->pVTable list. +*/ +static VTable *vtabDisconnectAll(sqlite3 *db, Table *p){ + VTable *pRet = 0; + VTable *pVTable = p->pVTable; + p->pVTable = 0; + + /* Assert that the mutex (if any) associated with the BtShared database + ** that contains table p is held by the caller. See header comments + ** above function sqlite3VtabUnlockList() for an explanation of why + ** this makes it safe to access the sqlite3.pDisconnect list of any + ** database connection that may have an entry in the p->pVTable list. + */ + assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) ); + + while( pVTable ){ + sqlite3 *db2 = pVTable->db; + VTable *pNext = pVTable->pNext; + assert( db2 ); + if( db2==db ){ + pRet = pVTable; + p->pVTable = pRet; + pRet->pNext = 0; + }else{ + pVTable->pNext = db2->pDisconnect; + db2->pDisconnect = pVTable; + } + pVTable = pNext; + } + + assert( !db || pRet ); + return pRet; +} + +/* +** Table *p is a virtual table. This function removes the VTable object +** for table *p associated with database connection db from the linked +** list in p->pVTab. It also decrements the VTable ref count. This is +** used when closing database connection db to free all of its VTable +** objects without disturbing the rest of the Schema object (which may +** be being used by other shared-cache connections). +*/ +SQLITE_PRIVATE void sqlite3VtabDisconnect(sqlite3 *db, Table *p){ + VTable **ppVTab; + + assert( IsVirtual(p) ); + assert( sqlite3BtreeHoldsAllMutexes(db) ); + assert( sqlite3_mutex_held(db->mutex) ); + + for(ppVTab=&p->pVTable; *ppVTab; ppVTab=&(*ppVTab)->pNext){ + if( (*ppVTab)->db==db ){ + VTable *pVTab = *ppVTab; + *ppVTab = pVTab->pNext; + sqlite3VtabUnlock(pVTab); + break; + } + } +} + + +/* +** Disconnect all the virtual table objects in the sqlite3.pDisconnect list. +** +** This function may only be called when the mutexes associated with all +** shared b-tree databases opened using connection db are held by the +** caller. This is done to protect the sqlite3.pDisconnect list. The +** sqlite3.pDisconnect list is accessed only as follows: +** +** 1) By this function. In this case, all BtShared mutexes and the mutex +** associated with the database handle itself must be held. +** +** 2) By function vtabDisconnectAll(), when it adds a VTable entry to +** the sqlite3.pDisconnect list. In this case either the BtShared mutex +** associated with the database the virtual table is stored in is held +** or, if the virtual table is stored in a non-sharable database, then +** the database handle mutex is held. +** +** As a result, a sqlite3.pDisconnect cannot be accessed simultaneously +** by multiple threads. It is thread-safe. +*/ +SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3 *db){ + VTable *p = db->pDisconnect; + + assert( sqlite3BtreeHoldsAllMutexes(db) ); + assert( sqlite3_mutex_held(db->mutex) ); + + if( p ){ + db->pDisconnect = 0; + sqlite3ExpirePreparedStatements(db, 0); + do { + VTable *pNext = p->pNext; + sqlite3VtabUnlock(p); + p = pNext; + }while( p ); + } +} + +/* +** Clear any and all virtual-table information from the Table record. +** This routine is called, for example, just before deleting the Table +** record. +** +** Since it is a virtual-table, the Table structure contains a pointer +** to the head of a linked list of VTable structures. Each VTable +** structure is associated with a single sqlite3* user of the schema. +** The reference count of the VTable structure associated with database +** connection db is decremented immediately (which may lead to the +** structure being xDisconnected and free). Any other VTable structures +** in the list are moved to the sqlite3.pDisconnect list of the associated +** database connection. +*/ +SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table *p){ + if( !db || db->pnBytesFreed==0 ) vtabDisconnectAll(0, p); + if( p->azModuleArg ){ + int i; + for(i=0; inModuleArg; i++){ + if( i!=1 ) sqlite3DbFree(db, p->azModuleArg[i]); + } + sqlite3DbFree(db, p->azModuleArg); + } +} + +/* +** Add a new module argument to pTable->azModuleArg[]. +** The string is not copied - the pointer is stored. The +** string will be freed automatically when the table is +** deleted. +*/ +static void addModuleArgument(Parse *pParse, Table *pTable, char *zArg){ + sqlite3_int64 nBytes = sizeof(char *)*(2+pTable->nModuleArg); + char **azModuleArg; + sqlite3 *db = pParse->db; + if( pTable->nModuleArg+3>=db->aLimit[SQLITE_LIMIT_COLUMN] ){ + sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName); + } + azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes); + if( azModuleArg==0 ){ + sqlite3DbFree(db, zArg); + }else{ + int i = pTable->nModuleArg++; + azModuleArg[i] = zArg; + azModuleArg[i+1] = 0; + pTable->azModuleArg = azModuleArg; + } +} + +/* +** The parser calls this routine when it first sees a CREATE VIRTUAL TABLE +** statement. The module name has been parsed, but the optional list +** of parameters that follow the module name are still pending. +*/ +SQLITE_PRIVATE void sqlite3VtabBeginParse( + Parse *pParse, /* Parsing context */ + Token *pName1, /* Name of new table, or database name */ + Token *pName2, /* Name of new table or NULL */ + Token *pModuleName, /* Name of the module for the virtual table */ + int ifNotExists /* No error if the table already exists */ +){ + Table *pTable; /* The new virtual table */ + sqlite3 *db; /* Database connection */ + + sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, ifNotExists); + pTable = pParse->pNewTable; + if( pTable==0 ) return; + assert( 0==pTable->pIndex ); + + db = pParse->db; + + assert( pTable->nModuleArg==0 ); + addModuleArgument(pParse, pTable, sqlite3NameFromToken(db, pModuleName)); + addModuleArgument(pParse, pTable, 0); + addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName)); + assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0) + || (pParse->sNameToken.z==pName1->z && pName2->z==0) + ); + pParse->sNameToken.n = (int)( + &pModuleName->z[pModuleName->n] - pParse->sNameToken.z + ); + +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Creating a virtual table invokes the authorization callback twice. + ** The first invocation, to obtain permission to INSERT a row into the + ** sqlite_schema table, has already been made by sqlite3StartTable(). + ** The second call, to obtain permission to create the table, is made now. + */ + if( pTable->azModuleArg ){ + int iDb = sqlite3SchemaToIndex(db, pTable->pSchema); + assert( iDb>=0 ); /* The database the table is being created in */ + sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName, + pTable->azModuleArg[0], pParse->db->aDb[iDb].zDbSName); + } +#endif +} + +/* +** This routine takes the module argument that has been accumulating +** in pParse->zArg[] and appends it to the list of arguments on the +** virtual table currently under construction in pParse->pTable. +*/ +static void addArgumentToVtab(Parse *pParse){ + if( pParse->sArg.z && pParse->pNewTable ){ + const char *z = (const char*)pParse->sArg.z; + int n = pParse->sArg.n; + sqlite3 *db = pParse->db; + addModuleArgument(pParse, pParse->pNewTable, sqlite3DbStrNDup(db, z, n)); + } +} + +/* +** The parser calls this routine after the CREATE VIRTUAL TABLE statement +** has been completely parsed. +*/ +SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){ + Table *pTab = pParse->pNewTable; /* The table being constructed */ + sqlite3 *db = pParse->db; /* The database connection */ + + if( pTab==0 ) return; + addArgumentToVtab(pParse); + pParse->sArg.z = 0; + if( pTab->nModuleArg<1 ) return; + + /* If the CREATE VIRTUAL TABLE statement is being entered for the + ** first time (in other words if the virtual table is actually being + ** created now instead of just being read out of sqlite_schema) then + ** do additional initialization work and store the statement text + ** in the sqlite_schema table. + */ + if( !db->init.busy ){ + char *zStmt; + char *zWhere; + int iDb; + int iReg; + Vdbe *v; + + sqlite3MayAbort(pParse); + + /* Compute the complete text of the CREATE VIRTUAL TABLE statement */ + if( pEnd ){ + pParse->sNameToken.n = (int)(pEnd->z - pParse->sNameToken.z) + pEnd->n; + } + zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken); + + /* A slot for the record has already been allocated in the + ** schema table. We just need to update that slot with all + ** the information we've collected. + ** + ** The VM register number pParse->regRowid holds the rowid of an + ** entry in the sqlite_schema table tht was created for this vtab + ** by sqlite3StartTable(). + */ + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + sqlite3NestedParse(pParse, + "UPDATE %Q." DFLT_SCHEMA_TABLE " " + "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q " + "WHERE rowid=#%d", + db->aDb[iDb].zDbSName, + pTab->zName, + pTab->zName, + zStmt, + pParse->regRowid + ); + v = sqlite3GetVdbe(pParse); + sqlite3ChangeCookie(pParse, iDb); + + sqlite3VdbeAddOp0(v, OP_Expire); + zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt); + sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere); + sqlite3DbFree(db, zStmt); + + iReg = ++pParse->nMem; + sqlite3VdbeLoadString(v, iReg, pTab->zName); + sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg); + } + + /* If we are rereading the sqlite_schema table create the in-memory + ** record of the table. The xConnect() method is not called until + ** the first time the virtual table is used in an SQL statement. This + ** allows a schema that contains virtual tables to be loaded before + ** the required virtual table implementations are registered. */ + else { + Table *pOld; + Schema *pSchema = pTab->pSchema; + const char *zName = pTab->zName; + assert( sqlite3SchemaMutexHeld(db, 0, pSchema) ); + pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab); + if( pOld ){ + sqlite3OomFault(db); + assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */ + return; + } + pParse->pNewTable = 0; + } +} + +/* +** The parser calls this routine when it sees the first token +** of an argument to the module name in a CREATE VIRTUAL TABLE statement. +*/ +SQLITE_PRIVATE void sqlite3VtabArgInit(Parse *pParse){ + addArgumentToVtab(pParse); + pParse->sArg.z = 0; + pParse->sArg.n = 0; +} + +/* +** The parser calls this routine for each token after the first token +** in an argument to the module name in a CREATE VIRTUAL TABLE statement. +*/ +SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse *pParse, Token *p){ + Token *pArg = &pParse->sArg; + if( pArg->z==0 ){ + pArg->z = p->z; + pArg->n = p->n; + }else{ + assert(pArg->z <= p->z); + pArg->n = (int)(&p->z[p->n] - pArg->z); + } +} + +/* +** Invoke a virtual table constructor (either xCreate or xConnect). The +** pointer to the function to invoke is passed as the fourth parameter +** to this procedure. +*/ +static int vtabCallConstructor( + sqlite3 *db, + Table *pTab, + Module *pMod, + int (*xConstruct)(sqlite3*,void*,int,const char*const*,sqlite3_vtab**,char**), + char **pzErr +){ + VtabCtx sCtx; + VTable *pVTable; + int rc; + const char *const*azArg = (const char *const*)pTab->azModuleArg; + int nArg = pTab->nModuleArg; + char *zErr = 0; + char *zModuleName; + int iDb; + VtabCtx *pCtx; + + /* Check that the virtual-table is not already being initialized */ + for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){ + if( pCtx->pTab==pTab ){ + *pzErr = sqlite3MPrintf(db, + "vtable constructor called recursively: %s", pTab->zName + ); + return SQLITE_LOCKED; + } + } + + zModuleName = sqlite3DbStrDup(db, pTab->zName); + if( !zModuleName ){ + return SQLITE_NOMEM_BKPT; + } + + pVTable = sqlite3MallocZero(sizeof(VTable)); + if( !pVTable ){ + sqlite3OomFault(db); + sqlite3DbFree(db, zModuleName); + return SQLITE_NOMEM_BKPT; + } + pVTable->db = db; + pVTable->pMod = pMod; + pVTable->eVtabRisk = SQLITE_VTABRISK_Normal; + + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + pTab->azModuleArg[1] = db->aDb[iDb].zDbSName; + + /* Invoke the virtual table constructor */ + assert( &db->pVtabCtx ); + assert( xConstruct ); + sCtx.pTab = pTab; + sCtx.pVTable = pVTable; + sCtx.pPrior = db->pVtabCtx; + sCtx.bDeclared = 0; + db->pVtabCtx = &sCtx; + rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr); + db->pVtabCtx = sCtx.pPrior; + if( rc==SQLITE_NOMEM ) sqlite3OomFault(db); + assert( sCtx.pTab==pTab ); + + if( SQLITE_OK!=rc ){ + if( zErr==0 ){ + *pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName); + }else { + *pzErr = sqlite3MPrintf(db, "%s", zErr); + sqlite3_free(zErr); + } + sqlite3DbFree(db, pVTable); + }else if( ALWAYS(pVTable->pVtab) ){ + /* Justification of ALWAYS(): A correct vtab constructor must allocate + ** the sqlite3_vtab object if successful. */ + memset(pVTable->pVtab, 0, sizeof(pVTable->pVtab[0])); + pVTable->pVtab->pModule = pMod->pModule; + pMod->nRefModule++; + pVTable->nRef = 1; + if( sCtx.bDeclared==0 ){ + const char *zFormat = "vtable constructor did not declare schema: %s"; + *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName); + sqlite3VtabUnlock(pVTable); + rc = SQLITE_ERROR; + }else{ + int iCol; + u16 oooHidden = 0; + /* If everything went according to plan, link the new VTable structure + ** into the linked list headed by pTab->pVTable. Then loop through the + ** columns of the table to see if any of them contain the token "hidden". + ** If so, set the Column COLFLAG_HIDDEN flag and remove the token from + ** the type string. */ + pVTable->pNext = pTab->pVTable; + pTab->pVTable = pVTable; + + for(iCol=0; iColnCol; iCol++){ + char *zType = sqlite3ColumnType(&pTab->aCol[iCol], ""); + int nType; + int i = 0; + nType = sqlite3Strlen30(zType); + for(i=0; i0 ){ + assert(zType[i-1]==' '); + zType[i-1] = '\0'; + } + pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN; + oooHidden = TF_OOOHidden; + }else{ + pTab->tabFlags |= oooHidden; + } + } + } + } + + sqlite3DbFree(db, zModuleName); + return rc; +} + +/* +** This function is invoked by the parser to call the xConnect() method +** of the virtual table pTab. If an error occurs, an error code is returned +** and an error left in pParse. +** +** This call is a no-op if table pTab is not a virtual table. +*/ +SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){ + sqlite3 *db = pParse->db; + const char *zMod; + Module *pMod; + int rc; + + assert( pTab ); + if( !IsVirtual(pTab) || sqlite3GetVTable(db, pTab) ){ + return SQLITE_OK; + } + + /* Locate the required virtual table module */ + zMod = pTab->azModuleArg[0]; + pMod = (Module*)sqlite3HashFind(&db->aModule, zMod); + + if( !pMod ){ + const char *zModule = pTab->azModuleArg[0]; + sqlite3ErrorMsg(pParse, "no such module: %s", zModule); + rc = SQLITE_ERROR; + }else{ + char *zErr = 0; + rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr); + if( rc!=SQLITE_OK ){ + sqlite3ErrorMsg(pParse, "%s", zErr); + pParse->rc = rc; + } + sqlite3DbFree(db, zErr); + } + + return rc; +} +/* +** Grow the db->aVTrans[] array so that there is room for at least one +** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise. +*/ +static int growVTrans(sqlite3 *db){ + const int ARRAY_INCR = 5; + + /* Grow the sqlite3.aVTrans array if required */ + if( (db->nVTrans%ARRAY_INCR)==0 ){ + VTable **aVTrans; + sqlite3_int64 nBytes = sizeof(sqlite3_vtab*)* + ((sqlite3_int64)db->nVTrans + ARRAY_INCR); + aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes); + if( !aVTrans ){ + return SQLITE_NOMEM_BKPT; + } + memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR); + db->aVTrans = aVTrans; + } + + return SQLITE_OK; +} + +/* +** Add the virtual table pVTab to the array sqlite3.aVTrans[]. Space should +** have already been reserved using growVTrans(). +*/ +static void addToVTrans(sqlite3 *db, VTable *pVTab){ + /* Add pVtab to the end of sqlite3.aVTrans */ + db->aVTrans[db->nVTrans++] = pVTab; + sqlite3VtabLock(pVTab); +} + +/* +** This function is invoked by the vdbe to call the xCreate method +** of the virtual table named zTab in database iDb. +** +** If an error occurs, *pzErr is set to point to an English language +** description of the error and an SQLITE_XXX error code is returned. +** In this case the caller must call sqlite3DbFree(db, ) on *pzErr. +*/ +SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){ + int rc = SQLITE_OK; + Table *pTab; + Module *pMod; + const char *zMod; + + pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName); + assert( pTab && IsVirtual(pTab) && !pTab->pVTable ); + + /* Locate the required virtual table module */ + zMod = pTab->azModuleArg[0]; + pMod = (Module*)sqlite3HashFind(&db->aModule, zMod); + + /* If the module has been registered and includes a Create method, + ** invoke it now. If the module has not been registered, return an + ** error. Otherwise, do nothing. + */ + if( pMod==0 || pMod->pModule->xCreate==0 || pMod->pModule->xDestroy==0 ){ + *pzErr = sqlite3MPrintf(db, "no such module: %s", zMod); + rc = SQLITE_ERROR; + }else{ + rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr); + } + + /* Justification of ALWAYS(): The xConstructor method is required to + ** create a valid sqlite3_vtab if it returns SQLITE_OK. */ + if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){ + rc = growVTrans(db); + if( rc==SQLITE_OK ){ + addToVTrans(db, sqlite3GetVTable(db, pTab)); + } + } + + return rc; +} + +/* +** This function is used to set the schema of a virtual table. It is only +** valid to call this function from within the xCreate() or xConnect() of a +** virtual table module. +*/ +SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){ + VtabCtx *pCtx; + int rc = SQLITE_OK; + Table *pTab; + char *zErr = 0; + Parse sParse; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + pCtx = db->pVtabCtx; + if( !pCtx || pCtx->bDeclared ){ + sqlite3Error(db, SQLITE_MISUSE); + sqlite3_mutex_leave(db->mutex); + return SQLITE_MISUSE_BKPT; + } + pTab = pCtx->pTab; + assert( IsVirtual(pTab) ); + + memset(&sParse, 0, sizeof(sParse)); + sParse.eParseMode = PARSE_MODE_DECLARE_VTAB; + sParse.db = db; + sParse.nQueryLoop = 1; + if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable, &zErr) + && sParse.pNewTable + && !db->mallocFailed + && !sParse.pNewTable->pSelect + && !IsVirtual(sParse.pNewTable) + ){ + if( !pTab->aCol ){ + Table *pNew = sParse.pNewTable; + Index *pIdx; + pTab->aCol = pNew->aCol; + pTab->nCol = pNew->nCol; + pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid); + pNew->nCol = 0; + pNew->aCol = 0; + assert( pTab->pIndex==0 ); + assert( HasRowid(pNew) || sqlite3PrimaryKeyIndex(pNew)!=0 ); + if( !HasRowid(pNew) + && pCtx->pVTable->pMod->pModule->xUpdate!=0 + && sqlite3PrimaryKeyIndex(pNew)->nKeyCol!=1 + ){ + /* WITHOUT ROWID virtual tables must either be read-only (xUpdate==0) + ** or else must have a single-column PRIMARY KEY */ + rc = SQLITE_ERROR; + } + pIdx = pNew->pIndex; + if( pIdx ){ + assert( pIdx->pNext==0 ); + pTab->pIndex = pIdx; + pNew->pIndex = 0; + pIdx->pTable = pTab; + } + } + pCtx->bDeclared = 1; + }else{ + sqlite3ErrorWithMsg(db, SQLITE_ERROR, (zErr ? "%s" : 0), zErr); + sqlite3DbFree(db, zErr); + rc = SQLITE_ERROR; + } + sParse.eParseMode = PARSE_MODE_NORMAL; + + if( sParse.pVdbe ){ + sqlite3VdbeFinalize(sParse.pVdbe); + } + sqlite3DeleteTable(db, sParse.pNewTable); + sqlite3ParserReset(&sParse); + + assert( (rc&0xff)==rc ); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** This function is invoked by the vdbe to call the xDestroy method +** of the virtual table named zTab in database iDb. This occurs +** when a DROP TABLE is mentioned. +** +** This call is a no-op if zTab is not a virtual table. +*/ +SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){ + int rc = SQLITE_OK; + Table *pTab; + + pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName); + if( pTab!=0 && ALWAYS(pTab->pVTable!=0) ){ + VTable *p; + int (*xDestroy)(sqlite3_vtab *); + for(p=pTab->pVTable; p; p=p->pNext){ + assert( p->pVtab ); + if( p->pVtab->nRef>0 ){ + return SQLITE_LOCKED; + } + } + p = vtabDisconnectAll(db, pTab); + xDestroy = p->pMod->pModule->xDestroy; + if( xDestroy==0 ) xDestroy = p->pMod->pModule->xDisconnect; + assert( xDestroy!=0 ); + pTab->nTabRef++; + rc = xDestroy(p->pVtab); + /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */ + if( rc==SQLITE_OK ){ + assert( pTab->pVTable==p && p->pNext==0 ); + p->pVtab = 0; + pTab->pVTable = 0; + sqlite3VtabUnlock(p); + } + sqlite3DeleteTable(db, pTab); + } + + return rc; +} + +/* +** This function invokes either the xRollback or xCommit method +** of each of the virtual tables in the sqlite3.aVTrans array. The method +** called is identified by the second argument, "offset", which is +** the offset of the method to call in the sqlite3_module structure. +** +** The array is cleared after invoking the callbacks. +*/ +static void callFinaliser(sqlite3 *db, int offset){ + int i; + if( db->aVTrans ){ + VTable **aVTrans = db->aVTrans; + db->aVTrans = 0; + for(i=0; inVTrans; i++){ + VTable *pVTab = aVTrans[i]; + sqlite3_vtab *p = pVTab->pVtab; + if( p ){ + int (*x)(sqlite3_vtab *); + x = *(int (**)(sqlite3_vtab *))((char *)p->pModule + offset); + if( x ) x(p); + } + pVTab->iSavepoint = 0; + sqlite3VtabUnlock(pVTab); + } + sqlite3DbFree(db, aVTrans); + db->nVTrans = 0; + } +} + +/* +** Invoke the xSync method of all virtual tables in the sqlite3.aVTrans +** array. Return the error code for the first error that occurs, or +** SQLITE_OK if all xSync operations are successful. +** +** If an error message is available, leave it in p->zErrMsg. +*/ +SQLITE_PRIVATE int sqlite3VtabSync(sqlite3 *db, Vdbe *p){ + int i; + int rc = SQLITE_OK; + VTable **aVTrans = db->aVTrans; + + db->aVTrans = 0; + for(i=0; rc==SQLITE_OK && inVTrans; i++){ + int (*x)(sqlite3_vtab *); + sqlite3_vtab *pVtab = aVTrans[i]->pVtab; + if( pVtab && (x = pVtab->pModule->xSync)!=0 ){ + rc = x(pVtab); + sqlite3VtabImportErrmsg(p, pVtab); + } + } + db->aVTrans = aVTrans; + return rc; +} + +/* +** Invoke the xRollback method of all virtual tables in the +** sqlite3.aVTrans array. Then clear the array itself. +*/ +SQLITE_PRIVATE int sqlite3VtabRollback(sqlite3 *db){ + callFinaliser(db, offsetof(sqlite3_module,xRollback)); + return SQLITE_OK; +} + +/* +** Invoke the xCommit method of all virtual tables in the +** sqlite3.aVTrans array. Then clear the array itself. +*/ +SQLITE_PRIVATE int sqlite3VtabCommit(sqlite3 *db){ + callFinaliser(db, offsetof(sqlite3_module,xCommit)); + return SQLITE_OK; +} + +/* +** If the virtual table pVtab supports the transaction interface +** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is +** not currently open, invoke the xBegin method now. +** +** If the xBegin call is successful, place the sqlite3_vtab pointer +** in the sqlite3.aVTrans array. +*/ +SQLITE_PRIVATE int sqlite3VtabBegin(sqlite3 *db, VTable *pVTab){ + int rc = SQLITE_OK; + const sqlite3_module *pModule; + + /* Special case: If db->aVTrans is NULL and db->nVTrans is greater + ** than zero, then this function is being called from within a + ** virtual module xSync() callback. It is illegal to write to + ** virtual module tables in this case, so return SQLITE_LOCKED. + */ + if( sqlite3VtabInSync(db) ){ + return SQLITE_LOCKED; + } + if( !pVTab ){ + return SQLITE_OK; + } + pModule = pVTab->pVtab->pModule; + + if( pModule->xBegin ){ + int i; + + /* If pVtab is already in the aVTrans array, return early */ + for(i=0; inVTrans; i++){ + if( db->aVTrans[i]==pVTab ){ + return SQLITE_OK; + } + } + + /* Invoke the xBegin method. If successful, add the vtab to the + ** sqlite3.aVTrans[] array. */ + rc = growVTrans(db); + if( rc==SQLITE_OK ){ + rc = pModule->xBegin(pVTab->pVtab); + if( rc==SQLITE_OK ){ + int iSvpt = db->nStatement + db->nSavepoint; + addToVTrans(db, pVTab); + if( iSvpt && pModule->xSavepoint ){ + pVTab->iSavepoint = iSvpt; + rc = pModule->xSavepoint(pVTab->pVtab, iSvpt-1); + } + } + } + } + return rc; +} + +/* +** Invoke either the xSavepoint, xRollbackTo or xRelease method of all +** virtual tables that currently have an open transaction. Pass iSavepoint +** as the second argument to the virtual table method invoked. +** +** If op is SAVEPOINT_BEGIN, the xSavepoint method is invoked. If it is +** SAVEPOINT_ROLLBACK, the xRollbackTo method. Otherwise, if op is +** SAVEPOINT_RELEASE, then the xRelease method of each virtual table with +** an open transaction is invoked. +** +** If any virtual table method returns an error code other than SQLITE_OK, +** processing is abandoned and the error returned to the caller of this +** function immediately. If all calls to virtual table methods are successful, +** SQLITE_OK is returned. +*/ +SQLITE_PRIVATE int sqlite3VtabSavepoint(sqlite3 *db, int op, int iSavepoint){ + int rc = SQLITE_OK; + + assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN ); + assert( iSavepoint>=-1 ); + if( db->aVTrans ){ + int i; + for(i=0; rc==SQLITE_OK && inVTrans; i++){ + VTable *pVTab = db->aVTrans[i]; + const sqlite3_module *pMod = pVTab->pMod->pModule; + if( pVTab->pVtab && pMod->iVersion>=2 ){ + int (*xMethod)(sqlite3_vtab *, int); + sqlite3VtabLock(pVTab); + switch( op ){ + case SAVEPOINT_BEGIN: + xMethod = pMod->xSavepoint; + pVTab->iSavepoint = iSavepoint+1; + break; + case SAVEPOINT_ROLLBACK: + xMethod = pMod->xRollbackTo; + break; + default: + xMethod = pMod->xRelease; + break; + } + if( xMethod && pVTab->iSavepoint>iSavepoint ){ + rc = xMethod(pVTab->pVtab, iSavepoint); + } + sqlite3VtabUnlock(pVTab); + } + } + } + return rc; +} + +/* +** The first parameter (pDef) is a function implementation. The +** second parameter (pExpr) is the first argument to this function. +** If pExpr is a column in a virtual table, then let the virtual +** table implementation have an opportunity to overload the function. +** +** This routine is used to allow virtual table implementations to +** overload MATCH, LIKE, GLOB, and REGEXP operators. +** +** Return either the pDef argument (indicating no change) or a +** new FuncDef structure that is marked as ephemeral using the +** SQLITE_FUNC_EPHEM flag. +*/ +SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction( + sqlite3 *db, /* Database connection for reporting malloc problems */ + FuncDef *pDef, /* Function to possibly overload */ + int nArg, /* Number of arguments to the function */ + Expr *pExpr /* First argument to the function */ +){ + Table *pTab; + sqlite3_vtab *pVtab; + sqlite3_module *pMod; + void (*xSFunc)(sqlite3_context*,int,sqlite3_value**) = 0; + void *pArg = 0; + FuncDef *pNew; + int rc = 0; + + /* Check to see the left operand is a column in a virtual table */ + if( NEVER(pExpr==0) ) return pDef; + if( pExpr->op!=TK_COLUMN ) return pDef; + pTab = pExpr->y.pTab; + if( pTab==0 ) return pDef; + if( !IsVirtual(pTab) ) return pDef; + pVtab = sqlite3GetVTable(db, pTab)->pVtab; + assert( pVtab!=0 ); + assert( pVtab->pModule!=0 ); + pMod = (sqlite3_module *)pVtab->pModule; + if( pMod->xFindFunction==0 ) return pDef; + + /* Call the xFindFunction method on the virtual table implementation + ** to see if the implementation wants to overload this function. + ** + ** Though undocumented, we have historically always invoked xFindFunction + ** with an all lower-case function name. Continue in this tradition to + ** avoid any chance of an incompatibility. + */ +#ifdef SQLITE_DEBUG + { + int i; + for(i=0; pDef->zName[i]; i++){ + unsigned char x = (unsigned char)pDef->zName[i]; + assert( x==sqlite3UpperToLower[x] ); + } + } +#endif + rc = pMod->xFindFunction(pVtab, nArg, pDef->zName, &xSFunc, &pArg); + if( rc==0 ){ + return pDef; + } + + /* Create a new ephemeral function definition for the overloaded + ** function */ + pNew = sqlite3DbMallocZero(db, sizeof(*pNew) + + sqlite3Strlen30(pDef->zName) + 1); + if( pNew==0 ){ + return pDef; + } + *pNew = *pDef; + pNew->zName = (const char*)&pNew[1]; + memcpy((char*)&pNew[1], pDef->zName, sqlite3Strlen30(pDef->zName)+1); + pNew->xSFunc = xSFunc; + pNew->pUserData = pArg; + pNew->funcFlags |= SQLITE_FUNC_EPHEM; + return pNew; +} + +/* +** Make sure virtual table pTab is contained in the pParse->apVirtualLock[] +** array so that an OP_VBegin will get generated for it. Add pTab to the +** array if it is missing. If pTab is already in the array, this routine +** is a no-op. +*/ +SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + int i, n; + Table **apVtabLock; + + assert( IsVirtual(pTab) ); + for(i=0; inVtabLock; i++){ + if( pTab==pToplevel->apVtabLock[i] ) return; + } + n = (pToplevel->nVtabLock+1)*sizeof(pToplevel->apVtabLock[0]); + apVtabLock = sqlite3Realloc(pToplevel->apVtabLock, n); + if( apVtabLock ){ + pToplevel->apVtabLock = apVtabLock; + pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab; + }else{ + sqlite3OomFault(pToplevel->db); + } +} + +/* +** Check to see if virtual table module pMod can be have an eponymous +** virtual table instance. If it can, create one if one does not already +** exist. Return non-zero if the eponymous virtual table instance exists +** when this routine returns, and return zero if it does not exist. +** +** An eponymous virtual table instance is one that is named after its +** module, and more importantly, does not require a CREATE VIRTUAL TABLE +** statement in order to come into existance. Eponymous virtual table +** instances always exist. They cannot be DROP-ed. +** +** Any virtual table module for which xConnect and xCreate are the same +** method can have an eponymous virtual table instance. +*/ +SQLITE_PRIVATE int sqlite3VtabEponymousTableInit(Parse *pParse, Module *pMod){ + const sqlite3_module *pModule = pMod->pModule; + Table *pTab; + char *zErr = 0; + int rc; + sqlite3 *db = pParse->db; + if( pMod->pEpoTab ) return 1; + if( pModule->xCreate!=0 && pModule->xCreate!=pModule->xConnect ) return 0; + pTab = sqlite3DbMallocZero(db, sizeof(Table)); + if( pTab==0 ) return 0; + pTab->zName = sqlite3DbStrDup(db, pMod->zName); + if( pTab->zName==0 ){ + sqlite3DbFree(db, pTab); + return 0; + } + pMod->pEpoTab = pTab; + pTab->nTabRef = 1; + pTab->pSchema = db->aDb[0].pSchema; + assert( pTab->nModuleArg==0 ); + pTab->iPKey = -1; + addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName)); + addModuleArgument(pParse, pTab, 0); + addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName)); + rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr); + if( rc ){ + sqlite3ErrorMsg(pParse, "%s", zErr); + sqlite3DbFree(db, zErr); + sqlite3VtabEponymousTableClear(db, pMod); + return 0; + } + return 1; +} + +/* +** Erase the eponymous virtual table instance associated with +** virtual table module pMod, if it exists. +*/ +SQLITE_PRIVATE void sqlite3VtabEponymousTableClear(sqlite3 *db, Module *pMod){ + Table *pTab = pMod->pEpoTab; + if( pTab!=0 ){ + /* Mark the table as Ephemeral prior to deleting it, so that the + ** sqlite3DeleteTable() routine will know that it is not stored in + ** the schema. */ + pTab->tabFlags |= TF_Ephemeral; + sqlite3DeleteTable(db, pTab); + pMod->pEpoTab = 0; + } +} + +/* +** Return the ON CONFLICT resolution mode in effect for the virtual +** table update operation currently in progress. +** +** The results of this routine are undefined unless it is called from +** within an xUpdate method. +*/ +SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *db){ + static const unsigned char aMap[] = { + SQLITE_ROLLBACK, SQLITE_ABORT, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_REPLACE + }; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + assert( OE_Rollback==1 && OE_Abort==2 && OE_Fail==3 ); + assert( OE_Ignore==4 && OE_Replace==5 ); + assert( db->vtabOnConflict>=1 && db->vtabOnConflict<=5 ); + return (int)aMap[db->vtabOnConflict-1]; +} + +/* +** Call from within the xCreate() or xConnect() methods to provide +** the SQLite core with additional information about the behavior +** of the virtual table being implemented. +*/ +SQLITE_API int sqlite3_vtab_config(sqlite3 *db, int op, ...){ + va_list ap; + int rc = SQLITE_OK; + VtabCtx *p; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + p = db->pVtabCtx; + if( !p ){ + rc = SQLITE_MISUSE_BKPT; + }else{ + assert( p->pTab==0 || IsVirtual(p->pTab) ); + va_start(ap, op); + switch( op ){ + case SQLITE_VTAB_CONSTRAINT_SUPPORT: { + p->pVTable->bConstraint = (u8)va_arg(ap, int); + break; + } + case SQLITE_VTAB_INNOCUOUS: { + p->pVTable->eVtabRisk = SQLITE_VTABRISK_Low; + break; + } + case SQLITE_VTAB_DIRECTONLY: { + p->pVTable->eVtabRisk = SQLITE_VTABRISK_High; + break; + } + default: { + rc = SQLITE_MISUSE_BKPT; + break; + } + } + va_end(ap); + } + + if( rc!=SQLITE_OK ) sqlite3Error(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +/************** End of vtab.c ************************************************/ +/************** Begin file wherecode.c ***************************************/ +/* +** 2015-06-06 +** +** 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 module contains C code that generates VDBE code used to process +** the WHERE clause of SQL statements. +** +** This file was split off from where.c on 2015-06-06 in order to reduce the +** size of where.c and make it easier to edit. This file contains the routines +** that actually generate the bulk of the WHERE loop code. The original where.c +** file retains the code that does query planning and analysis. +*/ +/* #include "sqliteInt.h" */ +/************** Include whereInt.h in the middle of wherecode.c **************/ +/************** Begin file whereInt.h ****************************************/ +/* +** 2013-11-12 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains structure and macro definitions for the query +** planner logic in "where.c". These definitions are broken out into +** a separate source file for easier editing. +*/ +#ifndef SQLITE_WHEREINT_H +#define SQLITE_WHEREINT_H + +/* +** Trace output macros +*/ +#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG) +/***/ extern int sqlite3WhereTrace; +#endif +#if defined(SQLITE_DEBUG) \ + && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_WHERETRACE)) +# define WHERETRACE(K,X) if(sqlite3WhereTrace&(K)) sqlite3DebugPrintf X +# define WHERETRACE_ENABLED 1 +#else +# define WHERETRACE(K,X) +#endif + +/* Forward references +*/ +typedef struct WhereClause WhereClause; +typedef struct WhereMaskSet WhereMaskSet; +typedef struct WhereOrInfo WhereOrInfo; +typedef struct WhereAndInfo WhereAndInfo; +typedef struct WhereLevel WhereLevel; +typedef struct WhereLoop WhereLoop; +typedef struct WherePath WherePath; +typedef struct WhereTerm WhereTerm; +typedef struct WhereLoopBuilder WhereLoopBuilder; +typedef struct WhereScan WhereScan; +typedef struct WhereOrCost WhereOrCost; +typedef struct WhereOrSet WhereOrSet; + +/* +** This object contains information needed to implement a single nested +** loop in WHERE clause. +** +** Contrast this object with WhereLoop. This object describes the +** implementation of the loop. WhereLoop describes the algorithm. +** This object contains a pointer to the WhereLoop algorithm as one of +** its elements. +** +** The WhereInfo object contains a single instance of this object for +** each term in the FROM clause (which is to say, for each of the +** nested loops as implemented). The order of WhereLevel objects determines +** the loop nested order, with WhereInfo.a[0] being the outer loop and +** WhereInfo.a[WhereInfo.nLevel-1] being the inner loop. +*/ +struct WhereLevel { + int iLeftJoin; /* Memory cell used to implement LEFT OUTER JOIN */ + int iTabCur; /* The VDBE cursor used to access the table */ + int iIdxCur; /* The VDBE cursor used to access pIdx */ + int addrBrk; /* Jump here to break out of the loop */ + int addrNxt; /* Jump here to start the next IN combination */ + int addrSkip; /* Jump here for next iteration of skip-scan */ + int addrCont; /* Jump here to continue with the next loop cycle */ + int addrFirst; /* First instruction of interior of the loop */ + int addrBody; /* Beginning of the body of this loop */ + int regBignull; /* big-null flag reg. True if a NULL-scan is needed */ + int addrBignull; /* Jump here for next part of big-null scan */ +#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS + u32 iLikeRepCntr; /* LIKE range processing counter register (times 2) */ + int addrLikeRep; /* LIKE range processing address */ +#endif + u8 iFrom; /* Which entry in the FROM clause */ + u8 op, p3, p5; /* Opcode, P3 & P5 of the opcode that ends the loop */ + int p1, p2; /* Operands of the opcode used to end the loop */ + union { /* Information that depends on pWLoop->wsFlags */ + struct { + int nIn; /* Number of entries in aInLoop[] */ + struct InLoop { + int iCur; /* The VDBE cursor used by this IN operator */ + int addrInTop; /* Top of the IN loop */ + int iBase; /* Base register of multi-key index record */ + int nPrefix; /* Number of prior entires in the key */ + u8 eEndLoopOp; /* IN Loop terminator. OP_Next or OP_Prev */ + } *aInLoop; /* Information about each nested IN operator */ + } in; /* Used when pWLoop->wsFlags&WHERE_IN_ABLE */ + Index *pCovidx; /* Possible covering index for WHERE_MULTI_OR */ + } u; + struct WhereLoop *pWLoop; /* The selected WhereLoop object */ + Bitmask notReady; /* FROM entries not usable at this level */ +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + int addrVisit; /* Address at which row is visited */ +#endif +}; + +/* +** Each instance of this object represents an algorithm for evaluating one +** term of a join. Every term of the FROM clause will have at least +** one corresponding WhereLoop object (unless INDEXED BY constraints +** prevent a query solution - which is an error) and many terms of the +** FROM clause will have multiple WhereLoop objects, each describing a +** potential way of implementing that FROM-clause term, together with +** dependencies and cost estimates for using the chosen algorithm. +** +** Query planning consists of building up a collection of these WhereLoop +** objects, then computing a particular sequence of WhereLoop objects, with +** one WhereLoop object per FROM clause term, that satisfy all dependencies +** and that minimize the overall cost. +*/ +struct WhereLoop { + Bitmask prereq; /* Bitmask of other loops that must run first */ + Bitmask maskSelf; /* Bitmask identifying table iTab */ +#ifdef SQLITE_DEBUG + char cId; /* Symbolic ID of this loop for debugging use */ +#endif + u8 iTab; /* Position in FROM clause of table for this loop */ + u8 iSortIdx; /* Sorting index number. 0==None */ + LogEst rSetup; /* One-time setup cost (ex: create transient index) */ + LogEst rRun; /* Cost of running each loop */ + LogEst nOut; /* Estimated number of output rows */ + union { + struct { /* Information for internal btree tables */ + u16 nEq; /* Number of equality constraints */ + u16 nBtm; /* Size of BTM vector */ + u16 nTop; /* Size of TOP vector */ + u16 nDistinctCol; /* Index columns used to sort for DISTINCT */ + Index *pIndex; /* Index used, or NULL */ + } btree; + struct { /* Information for virtual tables */ + int idxNum; /* Index number */ + u8 needFree; /* True if sqlite3_free(idxStr) is needed */ + i8 isOrdered; /* True if satisfies ORDER BY */ + u16 omitMask; /* Terms that may be omitted */ + char *idxStr; /* Index identifier string */ + } vtab; + } u; + u32 wsFlags; /* WHERE_* flags describing the plan */ + u16 nLTerm; /* Number of entries in aLTerm[] */ + u16 nSkip; /* Number of NULL aLTerm[] entries */ + /**** whereLoopXfer() copies fields above ***********************/ +# define WHERE_LOOP_XFER_SZ offsetof(WhereLoop,nLSlot) + u16 nLSlot; /* Number of slots allocated for aLTerm[] */ + WhereTerm **aLTerm; /* WhereTerms used */ + WhereLoop *pNextLoop; /* Next WhereLoop object in the WhereClause */ + WhereTerm *aLTermSpace[3]; /* Initial aLTerm[] space */ +}; + +/* This object holds the prerequisites and the cost of running a +** subquery on one operand of an OR operator in the WHERE clause. +** See WhereOrSet for additional information +*/ +struct WhereOrCost { + Bitmask prereq; /* Prerequisites */ + LogEst rRun; /* Cost of running this subquery */ + LogEst nOut; /* Number of outputs for this subquery */ +}; + +/* The WhereOrSet object holds a set of possible WhereOrCosts that +** correspond to the subquery(s) of OR-clause processing. Only the +** best N_OR_COST elements are retained. +*/ +#define N_OR_COST 3 +struct WhereOrSet { + u16 n; /* Number of valid a[] entries */ + WhereOrCost a[N_OR_COST]; /* Set of best costs */ +}; + +/* +** Each instance of this object holds a sequence of WhereLoop objects +** that implement some or all of a query plan. +** +** Think of each WhereLoop object as a node in a graph with arcs +** showing dependencies and costs for travelling between nodes. (That is +** not a completely accurate description because WhereLoop costs are a +** vector, not a scalar, and because dependencies are many-to-one, not +** one-to-one as are graph nodes. But it is a useful visualization aid.) +** Then a WherePath object is a path through the graph that visits some +** or all of the WhereLoop objects once. +** +** The "solver" works by creating the N best WherePath objects of length +** 1. Then using those as a basis to compute the N best WherePath objects +** of length 2. And so forth until the length of WherePaths equals the +** number of nodes in the FROM clause. The best (lowest cost) WherePath +** at the end is the chosen query plan. +*/ +struct WherePath { + Bitmask maskLoop; /* Bitmask of all WhereLoop objects in this path */ + Bitmask revLoop; /* aLoop[]s that should be reversed for ORDER BY */ + LogEst nRow; /* Estimated number of rows generated by this path */ + LogEst rCost; /* Total cost of this path */ + LogEst rUnsorted; /* Total cost of this path ignoring sorting costs */ + i8 isOrdered; /* No. of ORDER BY terms satisfied. -1 for unknown */ + WhereLoop **aLoop; /* Array of WhereLoop objects implementing this path */ +}; + +/* +** The query generator uses an array of instances of this structure to +** help it analyze the subexpressions of the WHERE clause. Each WHERE +** clause subexpression is separated from the others by AND operators, +** usually, or sometimes subexpressions separated by OR. +** +** All WhereTerms are collected into a single WhereClause structure. +** The following identity holds: +** +** WhereTerm.pWC->a[WhereTerm.idx] == WhereTerm +** +** When a term is of the form: +** +** X +** +** where X is a column name and is one of certain operators, +** then WhereTerm.leftCursor and WhereTerm.u.leftColumn record the +** cursor number and column number for X. WhereTerm.eOperator records +** the using a bitmask encoding defined by WO_xxx below. The +** use of a bitmask encoding for the operator allows us to search +** quickly for terms that match any of several different operators. +** +** A WhereTerm might also be two or more subterms connected by OR: +** +** (t1.X ) OR (t1.Y ) OR .... +** +** In this second case, wtFlag has the TERM_ORINFO bit set and eOperator==WO_OR +** and the WhereTerm.u.pOrInfo field points to auxiliary information that +** is collected about the OR clause. +** +** If a term in the WHERE clause does not match either of the two previous +** categories, then eOperator==0. The WhereTerm.pExpr field is still set +** to the original subexpression content and wtFlags is set up appropriately +** but no other fields in the WhereTerm object are meaningful. +** +** When eOperator!=0, prereqRight and prereqAll record sets of cursor numbers, +** but they do so indirectly. A single WhereMaskSet structure translates +** cursor number into bits and the translated bit is stored in the prereq +** fields. The translation is used in order to maximize the number of +** bits that will fit in a Bitmask. The VDBE cursor numbers might be +** spread out over the non-negative integers. For example, the cursor +** numbers might be 3, 8, 9, 10, 20, 23, 41, and 45. The WhereMaskSet +** translates these sparse cursor numbers into consecutive integers +** beginning with 0 in order to make the best possible use of the available +** bits in the Bitmask. So, in the example above, the cursor numbers +** would be mapped into integers 0 through 7. +** +** The number of terms in a join is limited by the number of bits +** in prereqRight and prereqAll. The default is 64 bits, hence SQLite +** is only able to process joins with 64 or fewer tables. +*/ +struct WhereTerm { + Expr *pExpr; /* Pointer to the subexpression that is this term */ + WhereClause *pWC; /* The clause this term is part of */ + LogEst truthProb; /* Probability of truth for this expression */ + u16 wtFlags; /* TERM_xxx bit flags. See below */ + u16 eOperator; /* A WO_xx value describing */ + u8 nChild; /* Number of children that must disable us */ + u8 eMatchOp; /* Op for vtab MATCH/LIKE/GLOB/REGEXP terms */ + int iParent; /* Disable pWC->a[iParent] when this term disabled */ + int leftCursor; /* Cursor number of X in "X " */ + union { + struct { + int leftColumn; /* Column number of X in "X " */ + int iField; /* Field in (?,?,?) IN (SELECT...) vector */ + } x; /* Opcode other than OP_OR or OP_AND */ + WhereOrInfo *pOrInfo; /* Extra information if (eOperator & WO_OR)!=0 */ + WhereAndInfo *pAndInfo; /* Extra information if (eOperator& WO_AND)!=0 */ + } u; + Bitmask prereqRight; /* Bitmask of tables used by pExpr->pRight */ + Bitmask prereqAll; /* Bitmask of tables referenced by pExpr */ +}; + +/* +** Allowed values of WhereTerm.wtFlags +*/ +#define TERM_DYNAMIC 0x0001 /* Need to call sqlite3ExprDelete(db, pExpr) */ +#define TERM_VIRTUAL 0x0002 /* Added by the optimizer. Do not code */ +#define TERM_CODED 0x0004 /* This term is already coded */ +#define TERM_COPIED 0x0008 /* Has a child */ +#define TERM_ORINFO 0x0010 /* Need to free the WhereTerm.u.pOrInfo object */ +#define TERM_ANDINFO 0x0020 /* Need to free the WhereTerm.u.pAndInfo obj */ +#define TERM_OR_OK 0x0040 /* Used during OR-clause processing */ +#ifdef SQLITE_ENABLE_STAT4 +# define TERM_VNULL 0x0080 /* Manufactured x>NULL or x<=NULL term */ +#else +# define TERM_VNULL 0x0000 /* Disabled if not using stat4 */ +#endif +#define TERM_LIKEOPT 0x0100 /* Virtual terms from the LIKE optimization */ +#define TERM_LIKECOND 0x0200 /* Conditionally this LIKE operator term */ +#define TERM_LIKE 0x0400 /* The original LIKE operator */ +#define TERM_IS 0x0800 /* Term.pExpr is an IS operator */ +#define TERM_VARSELECT 0x1000 /* Term.pExpr contains a correlated sub-query */ +#define TERM_HEURTRUTH 0x2000 /* Heuristic truthProb used */ +#ifdef SQLITE_ENABLE_STAT4 +# define TERM_HIGHTRUTH 0x4000 /* Term excludes few rows */ +#else +# define TERM_HIGHTRUTH 0 /* Only used with STAT4 */ +#endif + +/* +** An instance of the WhereScan object is used as an iterator for locating +** terms in the WHERE clause that are useful to the query planner. +*/ +struct WhereScan { + WhereClause *pOrigWC; /* Original, innermost WhereClause */ + WhereClause *pWC; /* WhereClause currently being scanned */ + const char *zCollName; /* Required collating sequence, if not NULL */ + Expr *pIdxExpr; /* Search for this index expression */ + char idxaff; /* Must match this affinity, if zCollName!=NULL */ + unsigned char nEquiv; /* Number of entries in aEquiv[] */ + unsigned char iEquiv; /* Next unused slot in aEquiv[] */ + u32 opMask; /* Acceptable operators */ + int k; /* Resume scanning at this->pWC->a[this->k] */ + int aiCur[11]; /* Cursors in the equivalence class */ + i16 aiColumn[11]; /* Corresponding column number in the eq-class */ +}; + +/* +** An instance of the following structure holds all information about a +** WHERE clause. Mostly this is a container for one or more WhereTerms. +** +** Explanation of pOuter: For a WHERE clause of the form +** +** a AND ((b AND c) OR (d AND e)) AND f +** +** There are separate WhereClause objects for the whole clause and for +** the subclauses "(b AND c)" and "(d AND e)". The pOuter field of the +** subclauses points to the WhereClause object for the whole clause. +*/ +struct WhereClause { + WhereInfo *pWInfo; /* WHERE clause processing context */ + WhereClause *pOuter; /* Outer conjunction */ + u8 op; /* Split operator. TK_AND or TK_OR */ + u8 hasOr; /* True if any a[].eOperator is WO_OR */ + int nTerm; /* Number of terms */ + int nSlot; /* Number of entries in a[] */ + WhereTerm *a; /* Each a[] describes a term of the WHERE cluase */ +#if defined(SQLITE_SMALL_STACK) + WhereTerm aStatic[1]; /* Initial static space for a[] */ +#else + WhereTerm aStatic[8]; /* Initial static space for a[] */ +#endif +}; + +/* +** A WhereTerm with eOperator==WO_OR has its u.pOrInfo pointer set to +** a dynamically allocated instance of the following structure. +*/ +struct WhereOrInfo { + WhereClause wc; /* Decomposition into subterms */ + Bitmask indexable; /* Bitmask of all indexable tables in the clause */ +}; + +/* +** A WhereTerm with eOperator==WO_AND has its u.pAndInfo pointer set to +** a dynamically allocated instance of the following structure. +*/ +struct WhereAndInfo { + WhereClause wc; /* The subexpression broken out */ +}; + +/* +** An instance of the following structure keeps track of a mapping +** between VDBE cursor numbers and bits of the bitmasks in WhereTerm. +** +** The VDBE cursor numbers are small integers contained in +** SrcList_item.iCursor and Expr.iTable fields. For any given WHERE +** clause, the cursor numbers might not begin with 0 and they might +** contain gaps in the numbering sequence. But we want to make maximum +** use of the bits in our bitmasks. This structure provides a mapping +** from the sparse cursor numbers into consecutive integers beginning +** with 0. +** +** If WhereMaskSet.ix[A]==B it means that The A-th bit of a Bitmask +** corresponds VDBE cursor number B. The A-th bit of a bitmask is 1<3, 5->1, 8->2, 29->0, +** 57->5, 73->4. Or one of 719 other combinations might be used. It +** does not really matter. What is important is that sparse cursor +** numbers all get mapped into bit numbers that begin with 0 and contain +** no gaps. +*/ +struct WhereMaskSet { + int bVarSelect; /* Used by sqlite3WhereExprUsage() */ + int n; /* Number of assigned cursor values */ + int ix[BMS]; /* Cursor assigned to each bit */ +}; + +/* +** Initialize a WhereMaskSet object +*/ +#define initMaskSet(P) (P)->n=0 + +/* +** This object is a convenience wrapper holding all information needed +** to construct WhereLoop objects for a particular query. +*/ +struct WhereLoopBuilder { + WhereInfo *pWInfo; /* Information about this WHERE */ + WhereClause *pWC; /* WHERE clause terms */ + ExprList *pOrderBy; /* ORDER BY clause */ + WhereLoop *pNew; /* Template WhereLoop */ + WhereOrSet *pOrSet; /* Record best loops here, if not NULL */ +#ifdef SQLITE_ENABLE_STAT4 + UnpackedRecord *pRec; /* Probe for stat4 (if required) */ + int nRecValid; /* Number of valid fields currently in pRec */ +#endif + unsigned char bldFlags1; /* First set of SQLITE_BLDF_* flags */ + unsigned char bldFlags2; /* Second set of SQLITE_BLDF_* flags */ + unsigned int iPlanLimit; /* Search limiter */ +}; + +/* Allowed values for WhereLoopBuider.bldFlags */ +#define SQLITE_BLDF1_INDEXED 0x0001 /* An index is used */ +#define SQLITE_BLDF1_UNIQUE 0x0002 /* All keys of a UNIQUE index used */ + +#define SQLITE_BLDF2_2NDPASS 0x0004 /* Second builder pass needed */ + +/* The WhereLoopBuilder.iPlanLimit is used to limit the number of +** index+constraint combinations the query planner will consider for a +** particular query. If this parameter is unlimited, then certain +** pathological queries can spend excess time in the sqlite3WhereBegin() +** routine. The limit is high enough that is should not impact real-world +** queries. +** +** SQLITE_QUERY_PLANNER_LIMIT is the baseline limit. The limit is +** increased by SQLITE_QUERY_PLANNER_LIMIT_INCR before each term of the FROM +** clause is processed, so that every table in a join is guaranteed to be +** able to propose a some index+constraint combinations even if the initial +** baseline limit was exhausted by prior tables of the join. +*/ +#ifndef SQLITE_QUERY_PLANNER_LIMIT +# define SQLITE_QUERY_PLANNER_LIMIT 20000 +#endif +#ifndef SQLITE_QUERY_PLANNER_LIMIT_INCR +# define SQLITE_QUERY_PLANNER_LIMIT_INCR 1000 +#endif + +/* +** Each instance of this object records a change to a single node +** in an expression tree to cause that node to point to a column +** of an index rather than an expression or a virtual column. All +** such transformations need to be undone at the end of WHERE clause +** processing. +*/ +typedef struct WhereExprMod WhereExprMod; +struct WhereExprMod { + WhereExprMod *pNext; /* Next translation on a list of them all */ + Expr *pExpr; /* The Expr node that was transformed */ + Expr orig; /* Original value of the Expr node */ +}; + +/* +** The WHERE clause processing routine has two halves. The +** first part does the start of the WHERE loop and the second +** half does the tail of the WHERE loop. An instance of +** this structure is returned by the first half and passed +** into the second half to give some continuity. +** +** An instance of this object holds the complete state of the query +** planner. +*/ +struct WhereInfo { + Parse *pParse; /* Parsing and code generating context */ + SrcList *pTabList; /* List of tables in the join */ + ExprList *pOrderBy; /* The ORDER BY clause or NULL */ + ExprList *pResultSet; /* Result set of the query */ + Expr *pWhere; /* The complete WHERE clause */ + int aiCurOnePass[2]; /* OP_OpenWrite cursors for the ONEPASS opt */ + int iContinue; /* Jump here to continue with next record */ + int iBreak; /* Jump here to break out of the loop */ + int savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */ + u16 wctrlFlags; /* Flags originally passed to sqlite3WhereBegin() */ + LogEst iLimit; /* LIMIT if wctrlFlags has WHERE_USE_LIMIT */ + u8 nLevel; /* Number of nested loop */ + i8 nOBSat; /* Number of ORDER BY terms satisfied by indices */ + u8 eOnePass; /* ONEPASS_OFF, or _SINGLE, or _MULTI */ + u8 eDistinct; /* One of the WHERE_DISTINCT_* values */ + unsigned bDeferredSeek :1; /* Uses OP_DeferredSeek */ + unsigned untestedTerms :1; /* Not all WHERE terms resolved by outer loop */ + unsigned bOrderedInnerLoop:1;/* True if only the inner-most loop is ordered */ + unsigned sorted :1; /* True if really sorted (not just grouped) */ + LogEst nRowOut; /* Estimated number of output rows */ + int iTop; /* The very beginning of the WHERE loop */ + int iEndWhere; /* End of the WHERE clause itself */ + WhereLoop *pLoops; /* List of all WhereLoop objects */ + WhereExprMod *pExprMods; /* Expression modifications */ + Bitmask revMask; /* Mask of ORDER BY terms that need reversing */ + WhereClause sWC; /* Decomposition of the WHERE clause */ + WhereMaskSet sMaskSet; /* Map cursor numbers to bitmasks */ + WhereLevel a[1]; /* Information about each nest loop in WHERE */ +}; + +/* +** Private interfaces - callable only by other where.c routines. +** +** where.c: +*/ +SQLITE_PRIVATE Bitmask sqlite3WhereGetMask(WhereMaskSet*,int); +#ifdef WHERETRACE_ENABLED +SQLITE_PRIVATE void sqlite3WhereClausePrint(WhereClause *pWC); +SQLITE_PRIVATE void sqlite3WhereTermPrint(WhereTerm *pTerm, int iTerm); +SQLITE_PRIVATE void sqlite3WhereLoopPrint(WhereLoop *p, WhereClause *pWC); +#endif +SQLITE_PRIVATE WhereTerm *sqlite3WhereFindTerm( + WhereClause *pWC, /* The WHERE clause to be searched */ + int iCur, /* Cursor number of LHS */ + int iColumn, /* Column number of LHS */ + Bitmask notReady, /* RHS must not overlap with this mask */ + u32 op, /* Mask of WO_xx values describing operator */ + Index *pIdx /* Must be compatible with this index, if not NULL */ +); + +/* wherecode.c: */ +#ifndef SQLITE_OMIT_EXPLAIN +SQLITE_PRIVATE int sqlite3WhereExplainOneScan( + Parse *pParse, /* Parse context */ + SrcList *pTabList, /* Table list this loop refers to */ + WhereLevel *pLevel, /* Scan to write OP_Explain opcode for */ + u16 wctrlFlags /* Flags passed to sqlite3WhereBegin() */ +); +#else +# define sqlite3WhereExplainOneScan(u,v,w,x) 0 +#endif /* SQLITE_OMIT_EXPLAIN */ +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS +SQLITE_PRIVATE void sqlite3WhereAddScanStatus( + Vdbe *v, /* Vdbe to add scanstatus entry to */ + SrcList *pSrclist, /* FROM clause pLvl reads data from */ + WhereLevel *pLvl, /* Level to add scanstatus() entry for */ + int addrExplain /* Address of OP_Explain (or 0) */ +); +#else +# define sqlite3WhereAddScanStatus(a, b, c, d) ((void)d) +#endif +SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( + Parse *pParse, /* Parsing context */ + Vdbe *v, /* Prepared statement under construction */ + WhereInfo *pWInfo, /* Complete information about the WHERE clause */ + int iLevel, /* Which level of pWInfo->a[] should be coded */ + WhereLevel *pLevel, /* The current level pointer */ + Bitmask notReady /* Which tables are currently available */ +); + +/* whereexpr.c: */ +SQLITE_PRIVATE void sqlite3WhereClauseInit(WhereClause*,WhereInfo*); +SQLITE_PRIVATE void sqlite3WhereClauseClear(WhereClause*); +SQLITE_PRIVATE void sqlite3WhereSplit(WhereClause*,Expr*,u8); +SQLITE_PRIVATE Bitmask sqlite3WhereExprUsage(WhereMaskSet*, Expr*); +SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN(WhereMaskSet*, Expr*); +SQLITE_PRIVATE Bitmask sqlite3WhereExprListUsage(WhereMaskSet*, ExprList*); +SQLITE_PRIVATE void sqlite3WhereExprAnalyze(SrcList*, WhereClause*); +SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(Parse*, struct SrcList_item*, WhereClause*); + + + + + +/* +** Bitmasks for the operators on WhereTerm objects. These are all +** operators that are of interest to the query planner. An +** OR-ed combination of these values can be used when searching for +** particular WhereTerms within a WhereClause. +** +** Value constraints: +** WO_EQ == SQLITE_INDEX_CONSTRAINT_EQ +** WO_LT == SQLITE_INDEX_CONSTRAINT_LT +** WO_LE == SQLITE_INDEX_CONSTRAINT_LE +** WO_GT == SQLITE_INDEX_CONSTRAINT_GT +** WO_GE == SQLITE_INDEX_CONSTRAINT_GE +*/ +#define WO_IN 0x0001 +#define WO_EQ 0x0002 +#define WO_LT (WO_EQ<<(TK_LT-TK_EQ)) +#define WO_LE (WO_EQ<<(TK_LE-TK_EQ)) +#define WO_GT (WO_EQ<<(TK_GT-TK_EQ)) +#define WO_GE (WO_EQ<<(TK_GE-TK_EQ)) +#define WO_AUX 0x0040 /* Op useful to virtual tables only */ +#define WO_IS 0x0080 +#define WO_ISNULL 0x0100 +#define WO_OR 0x0200 /* Two or more OR-connected terms */ +#define WO_AND 0x0400 /* Two or more AND-connected terms */ +#define WO_EQUIV 0x0800 /* Of the form A==B, both columns */ +#define WO_NOOP 0x1000 /* This term does not restrict search space */ + +#define WO_ALL 0x1fff /* Mask of all possible WO_* values */ +#define WO_SINGLE 0x01ff /* Mask of all non-compound WO_* values */ + +/* +** These are definitions of bits in the WhereLoop.wsFlags field. +** The particular combination of bits in each WhereLoop help to +** determine the algorithm that WhereLoop represents. +*/ +#define WHERE_COLUMN_EQ 0x00000001 /* x=EXPR */ +#define WHERE_COLUMN_RANGE 0x00000002 /* xEXPR */ +#define WHERE_COLUMN_IN 0x00000004 /* x IN (...) */ +#define WHERE_COLUMN_NULL 0x00000008 /* x IS NULL */ +#define WHERE_CONSTRAINT 0x0000000f /* Any of the WHERE_COLUMN_xxx values */ +#define WHERE_TOP_LIMIT 0x00000010 /* xEXPR or x>=EXPR constraint */ +#define WHERE_BOTH_LIMIT 0x00000030 /* Both x>EXPR and xaiColumn[i]; + if( i==XN_EXPR ) return ""; + if( i==XN_ROWID ) return "rowid"; + return pIdx->pTable->aCol[i].zName; +} + +/* +** This routine is a helper for explainIndexRange() below +** +** pStr holds the text of an expression that we are building up one term +** at a time. This routine adds a new term to the end of the expression. +** Terms are separated by AND so add the "AND" text for second and subsequent +** terms only. +*/ +static void explainAppendTerm( + StrAccum *pStr, /* The text expression being built */ + Index *pIdx, /* Index to read column names from */ + int nTerm, /* Number of terms */ + int iTerm, /* Zero-based index of first term. */ + int bAnd, /* Non-zero to append " AND " */ + const char *zOp /* Name of the operator */ +){ + int i; + + assert( nTerm>=1 ); + if( bAnd ) sqlite3_str_append(pStr, " AND ", 5); + + if( nTerm>1 ) sqlite3_str_append(pStr, "(", 1); + for(i=0; i1 ) sqlite3_str_append(pStr, ")", 1); + + sqlite3_str_append(pStr, zOp, 1); + + if( nTerm>1 ) sqlite3_str_append(pStr, "(", 1); + for(i=0; i1 ) sqlite3_str_append(pStr, ")", 1); +} + +/* +** Argument pLevel describes a strategy for scanning table pTab. This +** function appends text to pStr that describes the subset of table +** rows scanned by the strategy in the form of an SQL expression. +** +** For example, if the query: +** +** SELECT * FROM t1 WHERE a=1 AND b>2; +** +** is run and there is an index on (a, b), then this function returns a +** string similar to: +** +** "a=? AND b>?" +*/ +static void explainIndexRange(StrAccum *pStr, WhereLoop *pLoop){ + Index *pIndex = pLoop->u.btree.pIndex; + u16 nEq = pLoop->u.btree.nEq; + u16 nSkip = pLoop->nSkip; + int i, j; + + if( nEq==0 && (pLoop->wsFlags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))==0 ) return; + sqlite3_str_append(pStr, " (", 2); + for(i=0; i=nSkip ? "%s=?" : "ANY(%s)", z); + } + + j = i; + if( pLoop->wsFlags&WHERE_BTM_LIMIT ){ + explainAppendTerm(pStr, pIndex, pLoop->u.btree.nBtm, j, i, ">"); + i = 1; + } + if( pLoop->wsFlags&WHERE_TOP_LIMIT ){ + explainAppendTerm(pStr, pIndex, pLoop->u.btree.nTop, j, i, "<"); + } + sqlite3_str_append(pStr, ")", 1); +} + +/* +** This function is a no-op unless currently processing an EXPLAIN QUERY PLAN +** command, or if either SQLITE_DEBUG or SQLITE_ENABLE_STMT_SCANSTATUS was +** defined at compile-time. If it is not a no-op, a single OP_Explain opcode +** is added to the output to describe the table scan strategy in pLevel. +** +** If an OP_Explain opcode is added to the VM, its address is returned. +** Otherwise, if no OP_Explain is coded, zero is returned. +*/ +SQLITE_PRIVATE int sqlite3WhereExplainOneScan( + Parse *pParse, /* Parse context */ + SrcList *pTabList, /* Table list this loop refers to */ + WhereLevel *pLevel, /* Scan to write OP_Explain opcode for */ + u16 wctrlFlags /* Flags passed to sqlite3WhereBegin() */ +){ + int ret = 0; +#if !defined(SQLITE_DEBUG) && !defined(SQLITE_ENABLE_STMT_SCANSTATUS) + if( sqlite3ParseToplevel(pParse)->explain==2 ) +#endif + { + struct SrcList_item *pItem = &pTabList->a[pLevel->iFrom]; + Vdbe *v = pParse->pVdbe; /* VM being constructed */ + sqlite3 *db = pParse->db; /* Database handle */ + int isSearch; /* True for a SEARCH. False for SCAN. */ + WhereLoop *pLoop; /* The controlling WhereLoop object */ + u32 flags; /* Flags that describe this loop */ + char *zMsg; /* Text to add to EQP output */ + StrAccum str; /* EQP output string */ + char zBuf[100]; /* Initial space for EQP output string */ + + pLoop = pLevel->pWLoop; + flags = pLoop->wsFlags; + if( (flags&WHERE_MULTI_OR) || (wctrlFlags&WHERE_OR_SUBCLAUSE) ) return 0; + + isSearch = (flags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0 + || ((flags&WHERE_VIRTUALTABLE)==0 && (pLoop->u.btree.nEq>0)) + || (wctrlFlags&(WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX)); + + sqlite3StrAccumInit(&str, db, zBuf, sizeof(zBuf), SQLITE_MAX_LENGTH); + sqlite3_str_appendall(&str, isSearch ? "SEARCH" : "SCAN"); + if( pItem->pSelect ){ + sqlite3_str_appendf(&str, " SUBQUERY %u", pItem->pSelect->selId); + }else{ + sqlite3_str_appendf(&str, " TABLE %s", pItem->zName); + } + + if( pItem->zAlias ){ + sqlite3_str_appendf(&str, " AS %s", pItem->zAlias); + } + if( (flags & (WHERE_IPK|WHERE_VIRTUALTABLE))==0 ){ + const char *zFmt = 0; + Index *pIdx; + + assert( pLoop->u.btree.pIndex!=0 ); + pIdx = pLoop->u.btree.pIndex; + assert( !(flags&WHERE_AUTO_INDEX) || (flags&WHERE_IDX_ONLY) ); + if( !HasRowid(pItem->pTab) && IsPrimaryKeyIndex(pIdx) ){ + if( isSearch ){ + zFmt = "PRIMARY KEY"; + } + }else if( flags & WHERE_PARTIALIDX ){ + zFmt = "AUTOMATIC PARTIAL COVERING INDEX"; + }else if( flags & WHERE_AUTO_INDEX ){ + zFmt = "AUTOMATIC COVERING INDEX"; + }else if( flags & WHERE_IDX_ONLY ){ + zFmt = "COVERING INDEX %s"; + }else{ + zFmt = "INDEX %s"; + } + if( zFmt ){ + sqlite3_str_append(&str, " USING ", 7); + sqlite3_str_appendf(&str, zFmt, pIdx->zName); + explainIndexRange(&str, pLoop); + } + }else if( (flags & WHERE_IPK)!=0 && (flags & WHERE_CONSTRAINT)!=0 ){ + const char *zRangeOp; + if( flags&(WHERE_COLUMN_EQ|WHERE_COLUMN_IN) ){ + zRangeOp = "="; + }else if( (flags&WHERE_BOTH_LIMIT)==WHERE_BOTH_LIMIT ){ + zRangeOp = ">? AND rowid<"; + }else if( flags&WHERE_BTM_LIMIT ){ + zRangeOp = ">"; + }else{ + assert( flags&WHERE_TOP_LIMIT); + zRangeOp = "<"; + } + sqlite3_str_appendf(&str, + " USING INTEGER PRIMARY KEY (rowid%s?)",zRangeOp); + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + else if( (flags & WHERE_VIRTUALTABLE)!=0 ){ + sqlite3_str_appendf(&str, " VIRTUAL TABLE INDEX %d:%s", + pLoop->u.vtab.idxNum, pLoop->u.vtab.idxStr); + } +#endif +#ifdef SQLITE_EXPLAIN_ESTIMATED_ROWS + if( pLoop->nOut>=10 ){ + sqlite3_str_appendf(&str, " (~%llu rows)", + sqlite3LogEstToInt(pLoop->nOut)); + }else{ + sqlite3_str_append(&str, " (~1 row)", 9); + } +#endif + zMsg = sqlite3StrAccumFinish(&str); + sqlite3ExplainBreakpoint("",zMsg); + ret = sqlite3VdbeAddOp4(v, OP_Explain, sqlite3VdbeCurrentAddr(v), + pParse->addrExplain, 0, zMsg,P4_DYNAMIC); + } + return ret; +} +#endif /* SQLITE_OMIT_EXPLAIN */ + +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS +/* +** Configure the VM passed as the first argument with an +** sqlite3_stmt_scanstatus() entry corresponding to the scan used to +** implement level pLvl. Argument pSrclist is a pointer to the FROM +** clause that the scan reads data from. +** +** If argument addrExplain is not 0, it must be the address of an +** OP_Explain instruction that describes the same loop. +*/ +SQLITE_PRIVATE void sqlite3WhereAddScanStatus( + Vdbe *v, /* Vdbe to add scanstatus entry to */ + SrcList *pSrclist, /* FROM clause pLvl reads data from */ + WhereLevel *pLvl, /* Level to add scanstatus() entry for */ + int addrExplain /* Address of OP_Explain (or 0) */ +){ + const char *zObj = 0; + WhereLoop *pLoop = pLvl->pWLoop; + if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 && pLoop->u.btree.pIndex!=0 ){ + zObj = pLoop->u.btree.pIndex->zName; + }else{ + zObj = pSrclist->a[pLvl->iFrom].zName; + } + sqlite3VdbeScanStatus( + v, addrExplain, pLvl->addrBody, pLvl->addrVisit, pLoop->nOut, zObj + ); +} +#endif + + +/* +** Disable a term in the WHERE clause. Except, do not disable the term +** if it controls a LEFT OUTER JOIN and it did not originate in the ON +** or USING clause of that join. +** +** Consider the term t2.z='ok' in the following queries: +** +** (1) SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x WHERE t2.z='ok' +** (2) SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x AND t2.z='ok' +** (3) SELECT * FROM t1, t2 WHERE t1.a=t2.x AND t2.z='ok' +** +** The t2.z='ok' is disabled in the in (2) because it originates +** in the ON clause. The term is disabled in (3) because it is not part +** of a LEFT OUTER JOIN. In (1), the term is not disabled. +** +** Disabling a term causes that term to not be tested in the inner loop +** of the join. Disabling is an optimization. When terms are satisfied +** by indices, we disable them to prevent redundant tests in the inner +** loop. We would get the correct results if nothing were ever disabled, +** but joins might run a little slower. The trick is to disable as much +** as we can without disabling too much. If we disabled in (1), we'd get +** the wrong answer. See ticket #813. +** +** If all the children of a term are disabled, then that term is also +** automatically disabled. In this way, terms get disabled if derived +** virtual terms are tested first. For example: +** +** x GLOB 'abc*' AND x>='abc' AND x<'acd' +** \___________/ \______/ \_____/ +** parent child1 child2 +** +** Only the parent term was in the original WHERE clause. The child1 +** and child2 terms were added by the LIKE optimization. If both of +** the virtual child terms are valid, then testing of the parent can be +** skipped. +** +** Usually the parent term is marked as TERM_CODED. But if the parent +** term was originally TERM_LIKE, then the parent gets TERM_LIKECOND instead. +** The TERM_LIKECOND marking indicates that the term should be coded inside +** a conditional such that is only evaluated on the second pass of a +** LIKE-optimization loop, when scanning BLOBs instead of strings. +*/ +static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){ + int nLoop = 0; + assert( pTerm!=0 ); + while( (pTerm->wtFlags & TERM_CODED)==0 + && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin)) + && (pLevel->notReady & pTerm->prereqAll)==0 + ){ + if( nLoop && (pTerm->wtFlags & TERM_LIKE)!=0 ){ + pTerm->wtFlags |= TERM_LIKECOND; + }else{ + pTerm->wtFlags |= TERM_CODED; + } + if( pTerm->iParent<0 ) break; + pTerm = &pTerm->pWC->a[pTerm->iParent]; + assert( pTerm!=0 ); + pTerm->nChild--; + if( pTerm->nChild!=0 ) break; + nLoop++; + } +} + +/* +** Code an OP_Affinity opcode to apply the column affinity string zAff +** to the n registers starting at base. +** +** As an optimization, SQLITE_AFF_BLOB and SQLITE_AFF_NONE entries (which +** are no-ops) at the beginning and end of zAff are ignored. If all entries +** in zAff are SQLITE_AFF_BLOB or SQLITE_AFF_NONE, then no code gets generated. +** +** This routine makes its own copy of zAff so that the caller is free +** to modify zAff after this routine returns. +*/ +static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){ + Vdbe *v = pParse->pVdbe; + if( zAff==0 ){ + assert( pParse->db->mallocFailed ); + return; + } + assert( v!=0 ); + + /* Adjust base and n to skip over SQLITE_AFF_BLOB and SQLITE_AFF_NONE + ** entries at the beginning and end of the affinity string. + */ + assert( SQLITE_AFF_NONE0 && zAff[0]<=SQLITE_AFF_BLOB ){ + n--; + base++; + zAff++; + } + while( n>1 && zAff[n-1]<=SQLITE_AFF_BLOB ){ + n--; + } + + /* Code the OP_Affinity opcode if there is anything left to do. */ + if( n>0 ){ + sqlite3VdbeAddOp4(v, OP_Affinity, base, n, 0, zAff, n); + } +} + +/* +** Expression pRight, which is the RHS of a comparison operation, is +** either a vector of n elements or, if n==1, a scalar expression. +** Before the comparison operation, affinity zAff is to be applied +** to the pRight values. This function modifies characters within the +** affinity string to SQLITE_AFF_BLOB if either: +** +** * the comparison will be performed with no affinity, or +** * the affinity change in zAff is guaranteed not to change the value. +*/ +static void updateRangeAffinityStr( + Expr *pRight, /* RHS of comparison */ + int n, /* Number of vector elements in comparison */ + char *zAff /* Affinity string to modify */ +){ + int i; + for(i=0; idb; + Expr *pNew; + pNew = sqlite3ExprDup(db, pX, 0); + if( db->mallocFailed==0 ){ + ExprList *pOrigRhs = pNew->x.pSelect->pEList; /* Original unmodified RHS */ + ExprList *pOrigLhs = pNew->pLeft->x.pList; /* Original unmodified LHS */ + ExprList *pRhs = 0; /* New RHS after modifications */ + ExprList *pLhs = 0; /* New LHS after mods */ + int i; /* Loop counter */ + Select *pSelect; /* Pointer to the SELECT on the RHS */ + + for(i=iEq; inLTerm; i++){ + if( pLoop->aLTerm[i]->pExpr==pX ){ + int iField = pLoop->aLTerm[i]->u.x.iField - 1; + if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */ + pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr); + pOrigRhs->a[iField].pExpr = 0; + assert( pOrigLhs->a[iField].pExpr!=0 ); + pLhs = sqlite3ExprListAppend(pParse, pLhs, pOrigLhs->a[iField].pExpr); + pOrigLhs->a[iField].pExpr = 0; + } + } + sqlite3ExprListDelete(db, pOrigRhs); + sqlite3ExprListDelete(db, pOrigLhs); + pNew->pLeft->x.pList = pLhs; + pNew->x.pSelect->pEList = pRhs; + if( pLhs && pLhs->nExpr==1 ){ + /* Take care here not to generate a TK_VECTOR containing only a + ** single value. Since the parser never creates such a vector, some + ** of the subroutines do not handle this case. */ + Expr *p = pLhs->a[0].pExpr; + pLhs->a[0].pExpr = 0; + sqlite3ExprDelete(db, pNew->pLeft); + pNew->pLeft = p; + } + pSelect = pNew->x.pSelect; + if( pSelect->pOrderBy ){ + /* If the SELECT statement has an ORDER BY clause, zero the + ** iOrderByCol variables. These are set to non-zero when an + ** ORDER BY term exactly matches one of the terms of the + ** result-set. Since the result-set of the SELECT statement may + ** have been modified or reordered, these variables are no longer + ** set correctly. Since setting them is just an optimization, + ** it's easiest just to zero them here. */ + ExprList *pOrderBy = pSelect->pOrderBy; + for(i=0; inExpr; i++){ + pOrderBy->a[i].u.x.iOrderByCol = 0; + } + } + +#if 0 + printf("For indexing, change the IN expr:\n"); + sqlite3TreeViewExpr(0, pX, 0); + printf("Into:\n"); + sqlite3TreeViewExpr(0, pNew, 0); +#endif + } + return pNew; +} + + +/* +** Generate code for a single equality term of the WHERE clause. An equality +** term can be either X=expr or X IN (...). pTerm is the term to be +** coded. +** +** The current value for the constraint is left in a register, the index +** of which is returned. An attempt is made store the result in iTarget but +** this is only guaranteed for TK_ISNULL and TK_IN constraints. If the +** constraint is a TK_EQ or TK_IS, then the current value might be left in +** some other register and it is the caller's responsibility to compensate. +** +** For a constraint of the form X=expr, the expression is evaluated in +** straight-line code. For constraints of the form X IN (...) +** this routine sets up a loop that will iterate over all values of X. +*/ +static int codeEqualityTerm( + Parse *pParse, /* The parsing context */ + WhereTerm *pTerm, /* The term of the WHERE clause to be coded */ + WhereLevel *pLevel, /* The level of the FROM clause we are working on */ + int iEq, /* Index of the equality term within this level */ + int bRev, /* True for reverse-order IN operations */ + int iTarget /* Attempt to leave results in this register */ +){ + Expr *pX = pTerm->pExpr; + Vdbe *v = pParse->pVdbe; + int iReg; /* Register holding results */ + + assert( pLevel->pWLoop->aLTerm[iEq]==pTerm ); + assert( iTarget>0 ); + if( pX->op==TK_EQ || pX->op==TK_IS ){ + iReg = sqlite3ExprCodeTarget(pParse, pX->pRight, iTarget); + }else if( pX->op==TK_ISNULL ){ + iReg = iTarget; + sqlite3VdbeAddOp2(v, OP_Null, 0, iReg); +#ifndef SQLITE_OMIT_SUBQUERY + }else{ + int eType = IN_INDEX_NOOP; + int iTab; + struct InLoop *pIn; + WhereLoop *pLoop = pLevel->pWLoop; + int i; + int nEq = 0; + int *aiMap = 0; + + if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 + && pLoop->u.btree.pIndex!=0 + && pLoop->u.btree.pIndex->aSortOrder[iEq] + ){ + testcase( iEq==0 ); + testcase( bRev ); + bRev = !bRev; + } + assert( pX->op==TK_IN ); + iReg = iTarget; + + for(i=0; iaLTerm[i] && pLoop->aLTerm[i]->pExpr==pX ){ + disableTerm(pLevel, pTerm); + return iTarget; + } + } + for(i=iEq;inLTerm; i++){ + assert( pLoop->aLTerm[i]!=0 ); + if( pLoop->aLTerm[i]->pExpr==pX ) nEq++; + } + + iTab = 0; + if( (pX->flags & EP_xIsSelect)==0 || pX->x.pSelect->pEList->nExpr==1 ){ + eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0, &iTab); + }else{ + sqlite3 *db = pParse->db; + pX = removeUnindexableInClauseTerms(pParse, iEq, pLoop, pX); + + if( !db->mallocFailed ){ + aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*nEq); + eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap, &iTab); + pTerm->pExpr->iTable = iTab; + } + sqlite3ExprDelete(db, pX); + pX = pTerm->pExpr; + } + + if( eType==IN_INDEX_INDEX_DESC ){ + testcase( bRev ); + bRev = !bRev; + } + sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iTab, 0); + VdbeCoverageIf(v, bRev); + VdbeCoverageIf(v, !bRev); + assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 ); + + pLoop->wsFlags |= WHERE_IN_ABLE; + if( pLevel->u.in.nIn==0 ){ + pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse); + } + if( iEq>0 && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)==0 ){ + pLoop->wsFlags |= WHERE_IN_EARLYOUT; + } + + i = pLevel->u.in.nIn; + pLevel->u.in.nIn += nEq; + pLevel->u.in.aInLoop = + sqlite3DbReallocOrFree(pParse->db, pLevel->u.in.aInLoop, + sizeof(pLevel->u.in.aInLoop[0])*pLevel->u.in.nIn); + pIn = pLevel->u.in.aInLoop; + if( pIn ){ + int iMap = 0; /* Index in aiMap[] */ + pIn += i; + for(i=iEq;inLTerm; i++){ + if( pLoop->aLTerm[i]->pExpr==pX ){ + int iOut = iReg + i - iEq; + if( eType==IN_INDEX_ROWID ){ + pIn->addrInTop = sqlite3VdbeAddOp2(v, OP_Rowid, iTab, iOut); + }else{ + int iCol = aiMap ? aiMap[iMap++] : 0; + pIn->addrInTop = sqlite3VdbeAddOp3(v,OP_Column,iTab, iCol, iOut); + } + sqlite3VdbeAddOp1(v, OP_IsNull, iOut); VdbeCoverage(v); + if( i==iEq ){ + pIn->iCur = iTab; + pIn->eEndLoopOp = bRev ? OP_Prev : OP_Next; + if( iEq>0 ){ + pIn->iBase = iReg - i; + pIn->nPrefix = i; + }else{ + pIn->nPrefix = 0; + } + }else{ + pIn->eEndLoopOp = OP_Noop; + } + pIn++; + } + } + testcase( iEq>0 + && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)==0 + && (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 ); + if( iEq>0 + && (pLoop->wsFlags & (WHERE_IN_SEEKSCAN|WHERE_VIRTUALTABLE))==0 + ){ + sqlite3VdbeAddOp3(v, OP_SeekHit, pLevel->iIdxCur, 0, iEq); + } + }else{ + pLevel->u.in.nIn = 0; + } + sqlite3DbFree(pParse->db, aiMap); +#endif + } + disableTerm(pLevel, pTerm); + return iReg; +} + +/* +** Generate code that will evaluate all == and IN constraints for an +** index scan. +** +** For example, consider table t1(a,b,c,d,e,f) with index i1(a,b,c). +** Suppose the WHERE clause is this: a==5 AND b IN (1,2,3) AND c>5 AND c<10 +** The index has as many as three equality constraints, but in this +** example, the third "c" value is an inequality. So only two +** constraints are coded. This routine will generate code to evaluate +** a==5 and b IN (1,2,3). The current values for a and b will be stored +** in consecutive registers and the index of the first register is returned. +** +** In the example above nEq==2. But this subroutine works for any value +** of nEq including 0. If nEq==0, this routine is nearly a no-op. +** The only thing it does is allocate the pLevel->iMem memory cell and +** compute the affinity string. +** +** The nExtraReg parameter is 0 or 1. It is 0 if all WHERE clause constraints +** are == or IN and are covered by the nEq. nExtraReg is 1 if there is +** an inequality constraint (such as the "c>=5 AND c<10" in the example) that +** occurs after the nEq quality constraints. +** +** This routine allocates a range of nEq+nExtraReg memory cells and returns +** the index of the first memory cell in that range. The code that +** calls this routine will use that memory range to store keys for +** start and termination conditions of the loop. +** key value of the loop. If one or more IN operators appear, then +** this routine allocates an additional nEq memory cells for internal +** use. +** +** Before returning, *pzAff is set to point to a buffer containing a +** copy of the column affinity string of the index allocated using +** sqlite3DbMalloc(). Except, entries in the copy of the string associated +** with equality constraints that use BLOB or NONE affinity are set to +** SQLITE_AFF_BLOB. This is to deal with SQL such as the following: +** +** CREATE TABLE t1(a TEXT PRIMARY KEY, b); +** SELECT ... FROM t1 AS t2, t1 WHERE t1.a = t2.b; +** +** In the example above, the index on t1(a) has TEXT affinity. But since +** the right hand side of the equality constraint (t2.b) has BLOB/NONE affinity, +** no conversion should be attempted before using a t2.b value as part of +** a key to search the index. Hence the first byte in the returned affinity +** string in this example would be set to SQLITE_AFF_BLOB. +*/ +static int codeAllEqualityTerms( + Parse *pParse, /* Parsing context */ + WhereLevel *pLevel, /* Which nested loop of the FROM we are coding */ + int bRev, /* Reverse the order of IN operators */ + int nExtraReg, /* Number of extra registers to allocate */ + char **pzAff /* OUT: Set to point to affinity string */ +){ + u16 nEq; /* The number of == or IN constraints to code */ + u16 nSkip; /* Number of left-most columns to skip */ + Vdbe *v = pParse->pVdbe; /* The vm under construction */ + Index *pIdx; /* The index being used for this loop */ + WhereTerm *pTerm; /* A single constraint term */ + WhereLoop *pLoop; /* The WhereLoop object */ + int j; /* Loop counter */ + int regBase; /* Base register */ + int nReg; /* Number of registers to allocate */ + char *zAff; /* Affinity string to return */ + + /* This module is only called on query plans that use an index. */ + pLoop = pLevel->pWLoop; + assert( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 ); + nEq = pLoop->u.btree.nEq; + nSkip = pLoop->nSkip; + pIdx = pLoop->u.btree.pIndex; + assert( pIdx!=0 ); + + /* Figure out how many memory cells we will need then allocate them. + */ + regBase = pParse->nMem + 1; + nReg = pLoop->u.btree.nEq + nExtraReg; + pParse->nMem += nReg; + + zAff = sqlite3DbStrDup(pParse->db,sqlite3IndexAffinityStr(pParse->db,pIdx)); + assert( zAff!=0 || pParse->db->mallocFailed ); + + if( nSkip ){ + int iIdxCur = pLevel->iIdxCur; + sqlite3VdbeAddOp1(v, (bRev?OP_Last:OP_Rewind), iIdxCur); + VdbeCoverageIf(v, bRev==0); + VdbeCoverageIf(v, bRev!=0); + VdbeComment((v, "begin skip-scan on %s", pIdx->zName)); + j = sqlite3VdbeAddOp0(v, OP_Goto); + pLevel->addrSkip = sqlite3VdbeAddOp4Int(v, (bRev?OP_SeekLT:OP_SeekGT), + iIdxCur, 0, regBase, nSkip); + VdbeCoverageIf(v, bRev==0); + VdbeCoverageIf(v, bRev!=0); + sqlite3VdbeJumpHere(v, j); + for(j=0; jaiColumn[j]==XN_EXPR ); + VdbeComment((v, "%s", explainIndexColumnName(pIdx, j))); + } + } + + /* Evaluate the equality constraints + */ + assert( zAff==0 || (int)strlen(zAff)>=nEq ); + for(j=nSkip; jaLTerm[j]; + assert( pTerm!=0 ); + /* The following testcase is true for indices with redundant columns. + ** Ex: CREATE INDEX i1 ON t1(a,b,a); SELECT * FROM t1 WHERE a=0 AND b=0; */ + testcase( (pTerm->wtFlags & TERM_CODED)!=0 ); + testcase( pTerm->wtFlags & TERM_VIRTUAL ); + r1 = codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, regBase+j); + if( r1!=regBase+j ){ + if( nReg==1 ){ + sqlite3ReleaseTempReg(pParse, regBase); + regBase = r1; + }else{ + sqlite3VdbeAddOp2(v, OP_SCopy, r1, regBase+j); + } + } + if( pTerm->eOperator & WO_IN ){ + if( pTerm->pExpr->flags & EP_xIsSelect ){ + /* No affinity ever needs to be (or should be) applied to a value + ** from the RHS of an "? IN (SELECT ...)" expression. The + ** sqlite3FindInIndex() routine has already ensured that the + ** affinity of the comparison has been applied to the value. */ + if( zAff ) zAff[j] = SQLITE_AFF_BLOB; + } + }else if( (pTerm->eOperator & WO_ISNULL)==0 ){ + Expr *pRight = pTerm->pExpr->pRight; + if( (pTerm->wtFlags & TERM_IS)==0 && sqlite3ExprCanBeNull(pRight) ){ + sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->addrBrk); + VdbeCoverage(v); + } + if( zAff ){ + if( sqlite3CompareAffinity(pRight, zAff[j])==SQLITE_AFF_BLOB ){ + zAff[j] = SQLITE_AFF_BLOB; + } + if( sqlite3ExprNeedsNoAffinityChange(pRight, zAff[j]) ){ + zAff[j] = SQLITE_AFF_BLOB; + } + } + } + } + *pzAff = zAff; + return regBase; +} + +#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS +/* +** If the most recently coded instruction is a constant range constraint +** (a string literal) that originated from the LIKE optimization, then +** set P3 and P5 on the OP_String opcode so that the string will be cast +** to a BLOB at appropriate times. +** +** The LIKE optimization trys to evaluate "x LIKE 'abc%'" as a range +** expression: "x>='ABC' AND x<'abd'". But this requires that the range +** scan loop run twice, once for strings and a second time for BLOBs. +** The OP_String opcodes on the second pass convert the upper and lower +** bound string constants to blobs. This routine makes the necessary changes +** to the OP_String opcodes for that to happen. +** +** Except, of course, if SQLITE_LIKE_DOESNT_MATCH_BLOBS is defined, then +** only the one pass through the string space is required, so this routine +** becomes a no-op. +*/ +static void whereLikeOptimizationStringFixup( + Vdbe *v, /* prepared statement under construction */ + WhereLevel *pLevel, /* The loop that contains the LIKE operator */ + WhereTerm *pTerm /* The upper or lower bound just coded */ +){ + if( pTerm->wtFlags & TERM_LIKEOPT ){ + VdbeOp *pOp; + assert( pLevel->iLikeRepCntr>0 ); + pOp = sqlite3VdbeGetOp(v, -1); + assert( pOp!=0 ); + assert( pOp->opcode==OP_String8 + || pTerm->pWC->pWInfo->pParse->db->mallocFailed ); + pOp->p3 = (int)(pLevel->iLikeRepCntr>>1); /* Register holding counter */ + pOp->p5 = (u8)(pLevel->iLikeRepCntr&1); /* ASC or DESC */ + } +} +#else +# define whereLikeOptimizationStringFixup(A,B,C) +#endif + +#ifdef SQLITE_ENABLE_CURSOR_HINTS +/* +** Information is passed from codeCursorHint() down to individual nodes of +** the expression tree (by sqlite3WalkExpr()) using an instance of this +** structure. +*/ +struct CCurHint { + int iTabCur; /* Cursor for the main table */ + int iIdxCur; /* Cursor for the index, if pIdx!=0. Unused otherwise */ + Index *pIdx; /* The index used to access the table */ +}; + +/* +** This function is called for every node of an expression that is a candidate +** for a cursor hint on an index cursor. For TK_COLUMN nodes that reference +** the table CCurHint.iTabCur, verify that the same column can be +** accessed through the index. If it cannot, then set pWalker->eCode to 1. +*/ +static int codeCursorHintCheckExpr(Walker *pWalker, Expr *pExpr){ + struct CCurHint *pHint = pWalker->u.pCCurHint; + assert( pHint->pIdx!=0 ); + if( pExpr->op==TK_COLUMN + && pExpr->iTable==pHint->iTabCur + && sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn)<0 + ){ + pWalker->eCode = 1; + } + return WRC_Continue; +} + +/* +** Test whether or not expression pExpr, which was part of a WHERE clause, +** should be included in the cursor-hint for a table that is on the rhs +** of a LEFT JOIN. Set Walker.eCode to non-zero before returning if the +** expression is not suitable. +** +** An expression is unsuitable if it might evaluate to non NULL even if +** a TK_COLUMN node that does affect the value of the expression is set +** to NULL. For example: +** +** col IS NULL +** col IS NOT NULL +** coalesce(col, 1) +** CASE WHEN col THEN 0 ELSE 1 END +*/ +static int codeCursorHintIsOrFunction(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_IS + || pExpr->op==TK_ISNULL || pExpr->op==TK_ISNOT + || pExpr->op==TK_NOTNULL || pExpr->op==TK_CASE + ){ + pWalker->eCode = 1; + }else if( pExpr->op==TK_FUNCTION ){ + int d1; + char d2[4]; + if( 0==sqlite3IsLikeFunction(pWalker->pParse->db, pExpr, &d1, d2) ){ + pWalker->eCode = 1; + } + } + + return WRC_Continue; +} + + +/* +** This function is called on every node of an expression tree used as an +** argument to the OP_CursorHint instruction. If the node is a TK_COLUMN +** that accesses any table other than the one identified by +** CCurHint.iTabCur, then do the following: +** +** 1) allocate a register and code an OP_Column instruction to read +** the specified column into the new register, and +** +** 2) transform the expression node to a TK_REGISTER node that reads +** from the newly populated register. +** +** Also, if the node is a TK_COLUMN that does access the table idenified +** by pCCurHint.iTabCur, and an index is being used (which we will +** know because CCurHint.pIdx!=0) then transform the TK_COLUMN into +** an access of the index rather than the original table. +*/ +static int codeCursorHintFixExpr(Walker *pWalker, Expr *pExpr){ + int rc = WRC_Continue; + struct CCurHint *pHint = pWalker->u.pCCurHint; + if( pExpr->op==TK_COLUMN ){ + if( pExpr->iTable!=pHint->iTabCur ){ + int reg = ++pWalker->pParse->nMem; /* Register for column value */ + sqlite3ExprCode(pWalker->pParse, pExpr, reg); + pExpr->op = TK_REGISTER; + pExpr->iTable = reg; + }else if( pHint->pIdx!=0 ){ + pExpr->iTable = pHint->iIdxCur; + pExpr->iColumn = sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn); + assert( pExpr->iColumn>=0 ); + } + }else if( pExpr->op==TK_AGG_FUNCTION ){ + /* An aggregate function in the WHERE clause of a query means this must + ** be a correlated sub-query, and expression pExpr is an aggregate from + ** the parent context. Do not walk the function arguments in this case. + ** + ** todo: It should be possible to replace this node with a TK_REGISTER + ** expression, as the result of the expression must be stored in a + ** register at this point. The same holds for TK_AGG_COLUMN nodes. */ + rc = WRC_Prune; + } + return rc; +} + +/* +** Insert an OP_CursorHint instruction if it is appropriate to do so. +*/ +static void codeCursorHint( + struct SrcList_item *pTabItem, /* FROM clause item */ + WhereInfo *pWInfo, /* The where clause */ + WhereLevel *pLevel, /* Which loop to provide hints for */ + WhereTerm *pEndRange /* Hint this end-of-scan boundary term if not NULL */ +){ + Parse *pParse = pWInfo->pParse; + sqlite3 *db = pParse->db; + Vdbe *v = pParse->pVdbe; + Expr *pExpr = 0; + WhereLoop *pLoop = pLevel->pWLoop; + int iCur; + WhereClause *pWC; + WhereTerm *pTerm; + int i, j; + struct CCurHint sHint; + Walker sWalker; + + if( OptimizationDisabled(db, SQLITE_CursorHints) ) return; + iCur = pLevel->iTabCur; + assert( iCur==pWInfo->pTabList->a[pLevel->iFrom].iCursor ); + sHint.iTabCur = iCur; + sHint.iIdxCur = pLevel->iIdxCur; + sHint.pIdx = pLoop->u.btree.pIndex; + memset(&sWalker, 0, sizeof(sWalker)); + sWalker.pParse = pParse; + sWalker.u.pCCurHint = &sHint; + pWC = &pWInfo->sWC; + for(i=0; inTerm; i++){ + pTerm = &pWC->a[i]; + if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue; + if( pTerm->prereqAll & pLevel->notReady ) continue; + + /* Any terms specified as part of the ON(...) clause for any LEFT + ** JOIN for which the current table is not the rhs are omitted + ** from the cursor-hint. + ** + ** If this table is the rhs of a LEFT JOIN, "IS" or "IS NULL" terms + ** that were specified as part of the WHERE clause must be excluded. + ** This is to address the following: + ** + ** SELECT ... t1 LEFT JOIN t2 ON (t1.a=t2.b) WHERE t2.c IS NULL; + ** + ** Say there is a single row in t2 that matches (t1.a=t2.b), but its + ** t2.c values is not NULL. If the (t2.c IS NULL) constraint is + ** pushed down to the cursor, this row is filtered out, causing + ** SQLite to synthesize a row of NULL values. Which does match the + ** WHERE clause, and so the query returns a row. Which is incorrect. + ** + ** For the same reason, WHERE terms such as: + ** + ** WHERE 1 = (t2.c IS NULL) + ** + ** are also excluded. See codeCursorHintIsOrFunction() for details. + */ + if( pTabItem->fg.jointype & JT_LEFT ){ + Expr *pExpr = pTerm->pExpr; + if( !ExprHasProperty(pExpr, EP_FromJoin) + || pExpr->iRightJoinTable!=pTabItem->iCursor + ){ + sWalker.eCode = 0; + sWalker.xExprCallback = codeCursorHintIsOrFunction; + sqlite3WalkExpr(&sWalker, pTerm->pExpr); + if( sWalker.eCode ) continue; + } + }else{ + if( ExprHasProperty(pTerm->pExpr, EP_FromJoin) ) continue; + } + + /* All terms in pWLoop->aLTerm[] except pEndRange are used to initialize + ** the cursor. These terms are not needed as hints for a pure range + ** scan (that has no == terms) so omit them. */ + if( pLoop->u.btree.nEq==0 && pTerm!=pEndRange ){ + for(j=0; jnLTerm && pLoop->aLTerm[j]!=pTerm; j++){} + if( jnLTerm ) continue; + } + + /* No subqueries or non-deterministic functions allowed */ + if( sqlite3ExprContainsSubquery(pTerm->pExpr) ) continue; + + /* For an index scan, make sure referenced columns are actually in + ** the index. */ + if( sHint.pIdx!=0 ){ + sWalker.eCode = 0; + sWalker.xExprCallback = codeCursorHintCheckExpr; + sqlite3WalkExpr(&sWalker, pTerm->pExpr); + if( sWalker.eCode ) continue; + } + + /* If we survive all prior tests, that means this term is worth hinting */ + pExpr = sqlite3ExprAnd(pParse, pExpr, sqlite3ExprDup(db, pTerm->pExpr, 0)); + } + if( pExpr!=0 ){ + sWalker.xExprCallback = codeCursorHintFixExpr; + sqlite3WalkExpr(&sWalker, pExpr); + sqlite3VdbeAddOp4(v, OP_CursorHint, + (sHint.pIdx ? sHint.iIdxCur : sHint.iTabCur), 0, 0, + (const char*)pExpr, P4_EXPR); + } +} +#else +# define codeCursorHint(A,B,C,D) /* No-op */ +#endif /* SQLITE_ENABLE_CURSOR_HINTS */ + +/* +** Cursor iCur is open on an intkey b-tree (a table). Register iRowid contains +** a rowid value just read from cursor iIdxCur, open on index pIdx. This +** function generates code to do a deferred seek of cursor iCur to the +** rowid stored in register iRowid. +** +** Normally, this is just: +** +** OP_DeferredSeek $iCur $iRowid +** +** However, if the scan currently being coded is a branch of an OR-loop and +** the statement currently being coded is a SELECT, then P3 of OP_DeferredSeek +** is set to iIdxCur and P4 is set to point to an array of integers +** containing one entry for each column of the table cursor iCur is open +** on. For each table column, if the column is the i'th column of the +** index, then the corresponding array entry is set to (i+1). If the column +** does not appear in the index at all, the array entry is set to 0. +*/ +static void codeDeferredSeek( + WhereInfo *pWInfo, /* Where clause context */ + Index *pIdx, /* Index scan is using */ + int iCur, /* Cursor for IPK b-tree */ + int iIdxCur /* Index cursor */ +){ + Parse *pParse = pWInfo->pParse; /* Parse context */ + Vdbe *v = pParse->pVdbe; /* Vdbe to generate code within */ + + assert( iIdxCur>0 ); + assert( pIdx->aiColumn[pIdx->nColumn-1]==-1 ); + + pWInfo->bDeferredSeek = 1; + sqlite3VdbeAddOp3(v, OP_DeferredSeek, iIdxCur, 0, iCur); + if( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE) + && DbMaskAllZero(sqlite3ParseToplevel(pParse)->writeMask) + ){ + int i; + Table *pTab = pIdx->pTable; + u32 *ai = (u32*)sqlite3DbMallocZero(pParse->db, sizeof(u32)*(pTab->nCol+1)); + if( ai ){ + ai[0] = pTab->nCol; + for(i=0; inColumn-1; i++){ + int x1, x2; + assert( pIdx->aiColumn[i]nCol ); + x1 = pIdx->aiColumn[i]; + x2 = sqlite3TableColumnToStorage(pTab, x1); + testcase( x1!=x2 ); + if( x1>=0 ) ai[x2+1] = i+1; + } + sqlite3VdbeChangeP4(v, -1, (char*)ai, P4_INTARRAY); + } + } +} + +/* +** If the expression passed as the second argument is a vector, generate +** code to write the first nReg elements of the vector into an array +** of registers starting with iReg. +** +** If the expression is not a vector, then nReg must be passed 1. In +** this case, generate code to evaluate the expression and leave the +** result in register iReg. +*/ +static void codeExprOrVector(Parse *pParse, Expr *p, int iReg, int nReg){ + assert( nReg>0 ); + if( p && sqlite3ExprIsVector(p) ){ +#ifndef SQLITE_OMIT_SUBQUERY + if( (p->flags & EP_xIsSelect) ){ + Vdbe *v = pParse->pVdbe; + int iSelect; + assert( p->op==TK_SELECT ); + iSelect = sqlite3CodeSubselect(pParse, p); + sqlite3VdbeAddOp3(v, OP_Copy, iSelect, iReg, nReg-1); + }else +#endif + { + int i; + ExprList *pList = p->x.pList; + assert( nReg<=pList->nExpr ); + for(i=0; ia[i].pExpr, iReg+i); + } + } + }else{ + assert( nReg==1 ); + sqlite3ExprCode(pParse, p, iReg); + } +} + +/* An instance of the IdxExprTrans object carries information about a +** mapping from an expression on table columns into a column in an index +** down through the Walker. +*/ +typedef struct IdxExprTrans { + Expr *pIdxExpr; /* The index expression */ + int iTabCur; /* The cursor of the corresponding table */ + int iIdxCur; /* The cursor for the index */ + int iIdxCol; /* The column for the index */ + int iTabCol; /* The column for the table */ + WhereInfo *pWInfo; /* Complete WHERE clause information */ + sqlite3 *db; /* Database connection (for malloc()) */ +} IdxExprTrans; + +/* +** Preserve pExpr on the WhereETrans list of the WhereInfo. +*/ +static void preserveExpr(IdxExprTrans *pTrans, Expr *pExpr){ + WhereExprMod *pNew; + pNew = sqlite3DbMallocRaw(pTrans->db, sizeof(*pNew)); + if( pNew==0 ) return; + pNew->pNext = pTrans->pWInfo->pExprMods; + pTrans->pWInfo->pExprMods = pNew; + pNew->pExpr = pExpr; + memcpy(&pNew->orig, pExpr, sizeof(*pExpr)); +} + +/* The walker node callback used to transform matching expressions into +** a reference to an index column for an index on an expression. +** +** If pExpr matches, then transform it into a reference to the index column +** that contains the value of pExpr. +*/ +static int whereIndexExprTransNode(Walker *p, Expr *pExpr){ + IdxExprTrans *pX = p->u.pIdxTrans; + if( sqlite3ExprCompare(0, pExpr, pX->pIdxExpr, pX->iTabCur)==0 ){ + preserveExpr(pX, pExpr); + pExpr->affExpr = sqlite3ExprAffinity(pExpr); + pExpr->op = TK_COLUMN; + pExpr->iTable = pX->iIdxCur; + pExpr->iColumn = pX->iIdxCol; + pExpr->y.pTab = 0; + testcase( ExprHasProperty(pExpr, EP_Skip) ); + testcase( ExprHasProperty(pExpr, EP_Unlikely) ); + ExprClearProperty(pExpr, EP_Skip|EP_Unlikely); + return WRC_Prune; + }else{ + return WRC_Continue; + } +} + +#ifndef SQLITE_OMIT_GENERATED_COLUMNS +/* A walker node callback that translates a column reference to a table +** into a corresponding column reference of an index. +*/ +static int whereIndexExprTransColumn(Walker *p, Expr *pExpr){ + if( pExpr->op==TK_COLUMN ){ + IdxExprTrans *pX = p->u.pIdxTrans; + if( pExpr->iTable==pX->iTabCur && pExpr->iColumn==pX->iTabCol ){ + assert( pExpr->y.pTab!=0 ); + preserveExpr(pX, pExpr); + pExpr->affExpr = sqlite3TableColumnAffinity(pExpr->y.pTab,pExpr->iColumn); + pExpr->iTable = pX->iIdxCur; + pExpr->iColumn = pX->iIdxCol; + pExpr->y.pTab = 0; + } + } + return WRC_Continue; +} +#endif /* SQLITE_OMIT_GENERATED_COLUMNS */ + +/* +** For an indexes on expression X, locate every instance of expression X +** in pExpr and change that subexpression into a reference to the appropriate +** column of the index. +** +** 2019-10-24: Updated to also translate references to a VIRTUAL column in +** the table into references to the corresponding (stored) column of the +** index. +*/ +static void whereIndexExprTrans( + Index *pIdx, /* The Index */ + int iTabCur, /* Cursor of the table that is being indexed */ + int iIdxCur, /* Cursor of the index itself */ + WhereInfo *pWInfo /* Transform expressions in this WHERE clause */ +){ + int iIdxCol; /* Column number of the index */ + ExprList *aColExpr; /* Expressions that are indexed */ + Table *pTab; + Walker w; + IdxExprTrans x; + aColExpr = pIdx->aColExpr; + if( aColExpr==0 && !pIdx->bHasVCol ){ + /* The index does not reference any expressions or virtual columns + ** so no translations are needed. */ + return; + } + pTab = pIdx->pTable; + memset(&w, 0, sizeof(w)); + w.u.pIdxTrans = &x; + x.iTabCur = iTabCur; + x.iIdxCur = iIdxCur; + x.pWInfo = pWInfo; + x.db = pWInfo->pParse->db; + for(iIdxCol=0; iIdxColnColumn; iIdxCol++){ + i16 iRef = pIdx->aiColumn[iIdxCol]; + if( iRef==XN_EXPR ){ + assert( aColExpr->a[iIdxCol].pExpr!=0 ); + x.pIdxExpr = aColExpr->a[iIdxCol].pExpr; + if( sqlite3ExprIsConstant(x.pIdxExpr) ) continue; + w.xExprCallback = whereIndexExprTransNode; +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + }else if( iRef>=0 + && (pTab->aCol[iRef].colFlags & COLFLAG_VIRTUAL)!=0 + && (pTab->aCol[iRef].zColl==0 + || sqlite3StrICmp(pTab->aCol[iRef].zColl, sqlite3StrBINARY)==0) + ){ + /* Check to see if there are direct references to generated columns + ** that are contained in the index. Pulling the generated column + ** out of the index is an optimization only - the main table is always + ** available if the index cannot be used. To avoid unnecessary + ** complication, omit this optimization if the collating sequence for + ** the column is non-standard */ + x.iTabCol = iRef; + w.xExprCallback = whereIndexExprTransColumn; +#endif /* SQLITE_OMIT_GENERATED_COLUMNS */ + }else{ + continue; + } + x.iIdxCol = iIdxCol; + sqlite3WalkExpr(&w, pWInfo->pWhere); + sqlite3WalkExprList(&w, pWInfo->pOrderBy); + sqlite3WalkExprList(&w, pWInfo->pResultSet); + } +} + +/* +** The pTruth expression is always true because it is the WHERE clause +** a partial index that is driving a query loop. Look through all of the +** WHERE clause terms on the query, and if any of those terms must be +** true because pTruth is true, then mark those WHERE clause terms as +** coded. +*/ +static void whereApplyPartialIndexConstraints( + Expr *pTruth, + int iTabCur, + WhereClause *pWC +){ + int i; + WhereTerm *pTerm; + while( pTruth->op==TK_AND ){ + whereApplyPartialIndexConstraints(pTruth->pLeft, iTabCur, pWC); + pTruth = pTruth->pRight; + } + for(i=0, pTerm=pWC->a; inTerm; i++, pTerm++){ + Expr *pExpr; + if( pTerm->wtFlags & TERM_CODED ) continue; + pExpr = pTerm->pExpr; + if( sqlite3ExprCompare(0, pExpr, pTruth, iTabCur)==0 ){ + pTerm->wtFlags |= TERM_CODED; + } + } +} + +/* +** Generate code for the start of the iLevel-th loop in the WHERE clause +** implementation described by pWInfo. +*/ +SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( + Parse *pParse, /* Parsing context */ + Vdbe *v, /* Prepared statement under construction */ + WhereInfo *pWInfo, /* Complete information about the WHERE clause */ + int iLevel, /* Which level of pWInfo->a[] should be coded */ + WhereLevel *pLevel, /* The current level pointer */ + Bitmask notReady /* Which tables are currently available */ +){ + int j, k; /* Loop counters */ + int iCur; /* The VDBE cursor for the table */ + int addrNxt; /* Where to jump to continue with the next IN case */ + int bRev; /* True if we need to scan in reverse order */ + WhereLoop *pLoop; /* The WhereLoop object being coded */ + WhereClause *pWC; /* Decomposition of the entire WHERE clause */ + WhereTerm *pTerm; /* A WHERE clause term */ + sqlite3 *db; /* Database connection */ + struct SrcList_item *pTabItem; /* FROM clause term being coded */ + int addrBrk; /* Jump here to break out of the loop */ + int addrHalt; /* addrBrk for the outermost loop */ + int addrCont; /* Jump here to continue with next cycle */ + int iRowidReg = 0; /* Rowid is stored in this register, if not zero */ + int iReleaseReg = 0; /* Temp register to free before returning */ + Index *pIdx = 0; /* Index used by loop (if any) */ + int iLoop; /* Iteration of constraint generator loop */ + + pWC = &pWInfo->sWC; + db = pParse->db; + pLoop = pLevel->pWLoop; + pTabItem = &pWInfo->pTabList->a[pLevel->iFrom]; + iCur = pTabItem->iCursor; + pLevel->notReady = notReady & ~sqlite3WhereGetMask(&pWInfo->sMaskSet, iCur); + bRev = (pWInfo->revMask>>iLevel)&1; + VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName)); +#if WHERETRACE_ENABLED /* 0x20800 */ + if( sqlite3WhereTrace & 0x800 ){ + sqlite3DebugPrintf("Coding level %d of %d: notReady=%llx iFrom=%d\n", + iLevel, pWInfo->nLevel, (u64)notReady, pLevel->iFrom); + sqlite3WhereLoopPrint(pLoop, pWC); + } + if( sqlite3WhereTrace & 0x20000 ){ + if( iLevel==0 ){ + sqlite3DebugPrintf("WHERE clause being coded:\n"); + sqlite3TreeViewExpr(0, pWInfo->pWhere, 0); + } + sqlite3DebugPrintf("All WHERE-clause terms before coding:\n"); + sqlite3WhereClausePrint(pWC); + } +#endif + + /* Create labels for the "break" and "continue" instructions + ** for the current loop. Jump to addrBrk to break out of a loop. + ** Jump to cont to go immediately to the next iteration of the + ** loop. + ** + ** When there is an IN operator, we also have a "addrNxt" label that + ** means to continue with the next IN value combination. When + ** there are no IN operators in the constraints, the "addrNxt" label + ** is the same as "addrBrk". + */ + addrBrk = pLevel->addrBrk = pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse); + addrCont = pLevel->addrCont = sqlite3VdbeMakeLabel(pParse); + + /* If this is the right table of a LEFT OUTER JOIN, allocate and + ** initialize a memory cell that records if this table matches any + ** row of the left table of the join. + */ + assert( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE) + || pLevel->iFrom>0 || (pTabItem[0].fg.jointype & JT_LEFT)==0 + ); + if( pLevel->iFrom>0 && (pTabItem[0].fg.jointype & JT_LEFT)!=0 ){ + pLevel->iLeftJoin = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin); + VdbeComment((v, "init LEFT JOIN no-match flag")); + } + + /* Compute a safe address to jump to if we discover that the table for + ** this loop is empty and can never contribute content. */ + for(j=iLevel; j>0 && pWInfo->a[j].iLeftJoin==0; j--){} + addrHalt = pWInfo->a[j].addrBrk; + + /* Special case of a FROM clause subquery implemented as a co-routine */ + if( pTabItem->fg.viaCoroutine ){ + int regYield = pTabItem->regReturn; + sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub); + pLevel->p2 = sqlite3VdbeAddOp2(v, OP_Yield, regYield, addrBrk); + VdbeCoverage(v); + VdbeComment((v, "next row of %s", pTabItem->pTab->zName)); + pLevel->op = OP_Goto; + }else + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 ){ + /* Case 1: The table is a virtual-table. Use the VFilter and VNext + ** to access the data. + */ + int iReg; /* P3 Value for OP_VFilter */ + int addrNotFound; + int nConstraint = pLoop->nLTerm; + int iIn; /* Counter for IN constraints */ + + iReg = sqlite3GetTempRange(pParse, nConstraint+2); + addrNotFound = pLevel->addrBrk; + for(j=0; jaLTerm[j]; + if( NEVER(pTerm==0) ) continue; + if( pTerm->eOperator & WO_IN ){ + codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, iTarget); + addrNotFound = pLevel->addrNxt; + }else{ + Expr *pRight = pTerm->pExpr->pRight; + codeExprOrVector(pParse, pRight, iTarget, 1); + } + } + sqlite3VdbeAddOp2(v, OP_Integer, pLoop->u.vtab.idxNum, iReg); + sqlite3VdbeAddOp2(v, OP_Integer, nConstraint, iReg+1); + sqlite3VdbeAddOp4(v, OP_VFilter, iCur, addrNotFound, iReg, + pLoop->u.vtab.idxStr, + pLoop->u.vtab.needFree ? P4_DYNAMIC : P4_STATIC); + VdbeCoverage(v); + pLoop->u.vtab.needFree = 0; + /* An OOM inside of AddOp4(OP_VFilter) instruction above might have freed + ** the u.vtab.idxStr. NULL it out to prevent a use-after-free */ + if( db->mallocFailed ) pLoop->u.vtab.idxStr = 0; + pLevel->p1 = iCur; + pLevel->op = pWInfo->eOnePass ? OP_Noop : OP_VNext; + pLevel->p2 = sqlite3VdbeCurrentAddr(v); + iIn = pLevel->u.in.nIn; + for(j=nConstraint-1; j>=0; j--){ + pTerm = pLoop->aLTerm[j]; + if( (pTerm->eOperator & WO_IN)!=0 ) iIn--; + if( j<16 && (pLoop->u.vtab.omitMask>>j)&1 ){ + disableTerm(pLevel, pTerm); + }else if( (pTerm->eOperator & WO_IN)!=0 + && sqlite3ExprVectorSize(pTerm->pExpr->pLeft)==1 + ){ + Expr *pCompare; /* The comparison operator */ + Expr *pRight; /* RHS of the comparison */ + VdbeOp *pOp; /* Opcode to access the value of the IN constraint */ + + /* Reload the constraint value into reg[iReg+j+2]. The same value + ** was loaded into the same register prior to the OP_VFilter, but + ** the xFilter implementation might have changed the datatype or + ** encoding of the value in the register, so it *must* be reloaded. */ + assert( pLevel->u.in.aInLoop!=0 || db->mallocFailed ); + if( !db->mallocFailed ){ + assert( iIn>=0 && iInu.in.nIn ); + pOp = sqlite3VdbeGetOp(v, pLevel->u.in.aInLoop[iIn].addrInTop); + assert( pOp->opcode==OP_Column || pOp->opcode==OP_Rowid ); + assert( pOp->opcode!=OP_Column || pOp->p3==iReg+j+2 ); + assert( pOp->opcode!=OP_Rowid || pOp->p2==iReg+j+2 ); + testcase( pOp->opcode==OP_Rowid ); + sqlite3VdbeAddOp3(v, pOp->opcode, pOp->p1, pOp->p2, pOp->p3); + } + + /* Generate code that will continue to the next row if + ** the IN constraint is not satisfied */ + pCompare = sqlite3PExpr(pParse, TK_EQ, 0, 0); + assert( pCompare!=0 || db->mallocFailed ); + if( pCompare ){ + pCompare->pLeft = pTerm->pExpr->pLeft; + pCompare->pRight = pRight = sqlite3Expr(db, TK_REGISTER, 0); + if( pRight ){ + pRight->iTable = iReg+j+2; + sqlite3ExprIfFalse( + pParse, pCompare, pLevel->addrCont, SQLITE_JUMPIFNULL + ); + } + pCompare->pLeft = 0; + sqlite3ExprDelete(db, pCompare); + } + } + } + assert( iIn==0 || db->mallocFailed ); + /* These registers need to be preserved in case there is an IN operator + ** loop. So we could deallocate the registers here (and potentially + ** reuse them later) if (pLoop->wsFlags & WHERE_IN_ABLE)==0. But it seems + ** simpler and safer to simply not reuse the registers. + ** + ** sqlite3ReleaseTempRange(pParse, iReg, nConstraint+2); + */ + }else +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + + if( (pLoop->wsFlags & WHERE_IPK)!=0 + && (pLoop->wsFlags & (WHERE_COLUMN_IN|WHERE_COLUMN_EQ))!=0 + ){ + /* Case 2: We can directly reference a single row using an + ** equality comparison against the ROWID field. Or + ** we reference multiple rows using a "rowid IN (...)" + ** construct. + */ + assert( pLoop->u.btree.nEq==1 ); + pTerm = pLoop->aLTerm[0]; + assert( pTerm!=0 ); + assert( pTerm->pExpr!=0 ); + testcase( pTerm->wtFlags & TERM_VIRTUAL ); + iReleaseReg = ++pParse->nMem; + iRowidReg = codeEqualityTerm(pParse, pTerm, pLevel, 0, bRev, iReleaseReg); + if( iRowidReg!=iReleaseReg ) sqlite3ReleaseTempReg(pParse, iReleaseReg); + addrNxt = pLevel->addrNxt; + sqlite3VdbeAddOp3(v, OP_SeekRowid, iCur, addrNxt, iRowidReg); + VdbeCoverage(v); + pLevel->op = OP_Noop; + if( (pTerm->prereqAll & pLevel->notReady)==0 ){ + pTerm->wtFlags |= TERM_CODED; + } + }else if( (pLoop->wsFlags & WHERE_IPK)!=0 + && (pLoop->wsFlags & WHERE_COLUMN_RANGE)!=0 + ){ + /* Case 3: We have an inequality comparison against the ROWID field. + */ + int testOp = OP_Noop; + int start; + int memEndValue = 0; + WhereTerm *pStart, *pEnd; + + j = 0; + pStart = pEnd = 0; + if( pLoop->wsFlags & WHERE_BTM_LIMIT ) pStart = pLoop->aLTerm[j++]; + if( pLoop->wsFlags & WHERE_TOP_LIMIT ) pEnd = pLoop->aLTerm[j++]; + assert( pStart!=0 || pEnd!=0 ); + if( bRev ){ + pTerm = pStart; + pStart = pEnd; + pEnd = pTerm; + } + codeCursorHint(pTabItem, pWInfo, pLevel, pEnd); + if( pStart ){ + Expr *pX; /* The expression that defines the start bound */ + int r1, rTemp; /* Registers for holding the start boundary */ + int op; /* Cursor seek operation */ + + /* The following constant maps TK_xx codes into corresponding + ** seek opcodes. It depends on a particular ordering of TK_xx + */ + const u8 aMoveOp[] = { + /* TK_GT */ OP_SeekGT, + /* TK_LE */ OP_SeekLE, + /* TK_LT */ OP_SeekLT, + /* TK_GE */ OP_SeekGE + }; + assert( TK_LE==TK_GT+1 ); /* Make sure the ordering.. */ + assert( TK_LT==TK_GT+2 ); /* ... of the TK_xx values... */ + assert( TK_GE==TK_GT+3 ); /* ... is correcct. */ + + assert( (pStart->wtFlags & TERM_VNULL)==0 ); + testcase( pStart->wtFlags & TERM_VIRTUAL ); + pX = pStart->pExpr; + assert( pX!=0 ); + testcase( pStart->leftCursor!=iCur ); /* transitive constraints */ + if( sqlite3ExprIsVector(pX->pRight) ){ + r1 = rTemp = sqlite3GetTempReg(pParse); + codeExprOrVector(pParse, pX->pRight, r1, 1); + testcase( pX->op==TK_GT ); + testcase( pX->op==TK_GE ); + testcase( pX->op==TK_LT ); + testcase( pX->op==TK_LE ); + op = aMoveOp[((pX->op - TK_GT - 1) & 0x3) | 0x1]; + assert( pX->op!=TK_GT || op==OP_SeekGE ); + assert( pX->op!=TK_GE || op==OP_SeekGE ); + assert( pX->op!=TK_LT || op==OP_SeekLE ); + assert( pX->op!=TK_LE || op==OP_SeekLE ); + }else{ + r1 = sqlite3ExprCodeTemp(pParse, pX->pRight, &rTemp); + disableTerm(pLevel, pStart); + op = aMoveOp[(pX->op - TK_GT)]; + } + sqlite3VdbeAddOp3(v, op, iCur, addrBrk, r1); + VdbeComment((v, "pk")); + VdbeCoverageIf(v, pX->op==TK_GT); + VdbeCoverageIf(v, pX->op==TK_LE); + VdbeCoverageIf(v, pX->op==TK_LT); + VdbeCoverageIf(v, pX->op==TK_GE); + sqlite3ReleaseTempReg(pParse, rTemp); + }else{ + sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, addrHalt); + VdbeCoverageIf(v, bRev==0); + VdbeCoverageIf(v, bRev!=0); + } + if( pEnd ){ + Expr *pX; + pX = pEnd->pExpr; + assert( pX!=0 ); + assert( (pEnd->wtFlags & TERM_VNULL)==0 ); + testcase( pEnd->leftCursor!=iCur ); /* Transitive constraints */ + testcase( pEnd->wtFlags & TERM_VIRTUAL ); + memEndValue = ++pParse->nMem; + codeExprOrVector(pParse, pX->pRight, memEndValue, 1); + if( 0==sqlite3ExprIsVector(pX->pRight) + && (pX->op==TK_LT || pX->op==TK_GT) + ){ + testOp = bRev ? OP_Le : OP_Ge; + }else{ + testOp = bRev ? OP_Lt : OP_Gt; + } + if( 0==sqlite3ExprIsVector(pX->pRight) ){ + disableTerm(pLevel, pEnd); + } + } + start = sqlite3VdbeCurrentAddr(v); + pLevel->op = bRev ? OP_Prev : OP_Next; + pLevel->p1 = iCur; + pLevel->p2 = start; + assert( pLevel->p5==0 ); + if( testOp!=OP_Noop ){ + iRowidReg = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Rowid, iCur, iRowidReg); + sqlite3VdbeAddOp3(v, testOp, memEndValue, addrBrk, iRowidReg); + VdbeCoverageIf(v, testOp==OP_Le); + VdbeCoverageIf(v, testOp==OP_Lt); + VdbeCoverageIf(v, testOp==OP_Ge); + VdbeCoverageIf(v, testOp==OP_Gt); + sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC | SQLITE_JUMPIFNULL); + } + }else if( pLoop->wsFlags & WHERE_INDEXED ){ + /* Case 4: A scan using an index. + ** + ** The WHERE clause may contain zero or more equality + ** terms ("==" or "IN" operators) that refer to the N + ** left-most columns of the index. It may also contain + ** inequality constraints (>, <, >= or <=) on the indexed + ** column that immediately follows the N equalities. Only + ** the right-most column can be an inequality - the rest must + ** use the "==" and "IN" operators. For example, if the + ** index is on (x,y,z), then the following clauses are all + ** optimized: + ** + ** x=5 + ** x=5 AND y=10 + ** x=5 AND y<10 + ** x=5 AND y>5 AND y<10 + ** x=5 AND y=5 AND z<=10 + ** + ** The z<10 term of the following cannot be used, only + ** the x=5 term: + ** + ** x=5 AND z<10 + ** + ** N may be zero if there are inequality constraints. + ** If there are no inequality constraints, then N is at + ** least one. + ** + ** This case is also used when there are no WHERE clause + ** constraints but an index is selected anyway, in order + ** to force the output order to conform to an ORDER BY. + */ + static const u8 aStartOp[] = { + 0, + 0, + OP_Rewind, /* 2: (!start_constraints && startEq && !bRev) */ + OP_Last, /* 3: (!start_constraints && startEq && bRev) */ + OP_SeekGT, /* 4: (start_constraints && !startEq && !bRev) */ + OP_SeekLT, /* 5: (start_constraints && !startEq && bRev) */ + OP_SeekGE, /* 6: (start_constraints && startEq && !bRev) */ + OP_SeekLE /* 7: (start_constraints && startEq && bRev) */ + }; + static const u8 aEndOp[] = { + OP_IdxGE, /* 0: (end_constraints && !bRev && !endEq) */ + OP_IdxGT, /* 1: (end_constraints && !bRev && endEq) */ + OP_IdxLE, /* 2: (end_constraints && bRev && !endEq) */ + OP_IdxLT, /* 3: (end_constraints && bRev && endEq) */ + }; + u16 nEq = pLoop->u.btree.nEq; /* Number of == or IN terms */ + u16 nBtm = pLoop->u.btree.nBtm; /* Length of BTM vector */ + u16 nTop = pLoop->u.btree.nTop; /* Length of TOP vector */ + int regBase; /* Base register holding constraint values */ + WhereTerm *pRangeStart = 0; /* Inequality constraint at range start */ + WhereTerm *pRangeEnd = 0; /* Inequality constraint at range end */ + int startEq; /* True if range start uses ==, >= or <= */ + int endEq; /* True if range end uses ==, >= or <= */ + int start_constraints; /* Start of range is constrained */ + int nConstraint; /* Number of constraint terms */ + int iIdxCur; /* The VDBE cursor for the index */ + int nExtraReg = 0; /* Number of extra registers needed */ + int op; /* Instruction opcode */ + char *zStartAff; /* Affinity for start of range constraint */ + char *zEndAff = 0; /* Affinity for end of range constraint */ + u8 bSeekPastNull = 0; /* True to seek past initial nulls */ + u8 bStopAtNull = 0; /* Add condition to terminate at NULLs */ + int omitTable; /* True if we use the index only */ + int regBignull = 0; /* big-null flag register */ + int addrSeekScan = 0; /* Opcode of the OP_SeekScan, if any */ + + pIdx = pLoop->u.btree.pIndex; + iIdxCur = pLevel->iIdxCur; + assert( nEq>=pLoop->nSkip ); + + /* Find any inequality constraint terms for the start and end + ** of the range. + */ + j = nEq; + if( pLoop->wsFlags & WHERE_BTM_LIMIT ){ + pRangeStart = pLoop->aLTerm[j++]; + nExtraReg = MAX(nExtraReg, pLoop->u.btree.nBtm); + /* Like optimization range constraints always occur in pairs */ + assert( (pRangeStart->wtFlags & TERM_LIKEOPT)==0 || + (pLoop->wsFlags & WHERE_TOP_LIMIT)!=0 ); + } + if( pLoop->wsFlags & WHERE_TOP_LIMIT ){ + pRangeEnd = pLoop->aLTerm[j++]; + nExtraReg = MAX(nExtraReg, pLoop->u.btree.nTop); +#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS + if( (pRangeEnd->wtFlags & TERM_LIKEOPT)!=0 ){ + assert( pRangeStart!=0 ); /* LIKE opt constraints */ + assert( pRangeStart->wtFlags & TERM_LIKEOPT ); /* occur in pairs */ + pLevel->iLikeRepCntr = (u32)++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 1, (int)pLevel->iLikeRepCntr); + VdbeComment((v, "LIKE loop counter")); + pLevel->addrLikeRep = sqlite3VdbeCurrentAddr(v); + /* iLikeRepCntr actually stores 2x the counter register number. The + ** bottom bit indicates whether the search order is ASC or DESC. */ + testcase( bRev ); + testcase( pIdx->aSortOrder[nEq]==SQLITE_SO_DESC ); + assert( (bRev & ~1)==0 ); + pLevel->iLikeRepCntr <<=1; + pLevel->iLikeRepCntr |= bRev ^ (pIdx->aSortOrder[nEq]==SQLITE_SO_DESC); + } +#endif + if( pRangeStart==0 ){ + j = pIdx->aiColumn[nEq]; + if( (j>=0 && pIdx->pTable->aCol[j].notNull==0) || j==XN_EXPR ){ + bSeekPastNull = 1; + } + } + } + assert( pRangeEnd==0 || (pRangeEnd->wtFlags & TERM_VNULL)==0 ); + + /* If the WHERE_BIGNULL_SORT flag is set, then index column nEq uses + ** a non-default "big-null" sort (either ASC NULLS LAST or DESC NULLS + ** FIRST). In both cases separate ordered scans are made of those + ** index entries for which the column is null and for those for which + ** it is not. For an ASC sort, the non-NULL entries are scanned first. + ** For DESC, NULL entries are scanned first. + */ + if( (pLoop->wsFlags & (WHERE_TOP_LIMIT|WHERE_BTM_LIMIT))==0 + && (pLoop->wsFlags & WHERE_BIGNULL_SORT)!=0 + ){ + assert( bSeekPastNull==0 && nExtraReg==0 && nBtm==0 && nTop==0 ); + assert( pRangeEnd==0 && pRangeStart==0 ); + testcase( pLoop->nSkip>0 ); + nExtraReg = 1; + bSeekPastNull = 1; + pLevel->regBignull = regBignull = ++pParse->nMem; + if( pLevel->iLeftJoin ){ + sqlite3VdbeAddOp2(v, OP_Integer, 0, regBignull); + } + pLevel->addrBignull = sqlite3VdbeMakeLabel(pParse); + } + + /* If we are doing a reverse order scan on an ascending index, or + ** a forward order scan on a descending index, interchange the + ** start and end terms (pRangeStart and pRangeEnd). + */ + if( (nEqnKeyCol && bRev==(pIdx->aSortOrder[nEq]==SQLITE_SO_ASC)) + || (bRev && pIdx->nKeyCol==nEq) + ){ + SWAP(WhereTerm *, pRangeEnd, pRangeStart); + SWAP(u8, bSeekPastNull, bStopAtNull); + SWAP(u8, nBtm, nTop); + } + + /* Generate code to evaluate all constraint terms using == or IN + ** and store the values of those terms in an array of registers + ** starting at regBase. + */ + codeCursorHint(pTabItem, pWInfo, pLevel, pRangeEnd); + regBase = codeAllEqualityTerms(pParse,pLevel,bRev,nExtraReg,&zStartAff); + assert( zStartAff==0 || sqlite3Strlen30(zStartAff)>=nEq ); + if( zStartAff && nTop ){ + zEndAff = sqlite3DbStrDup(db, &zStartAff[nEq]); + } + addrNxt = (regBignull ? pLevel->addrBignull : pLevel->addrNxt); + + testcase( pRangeStart && (pRangeStart->eOperator & WO_LE)!=0 ); + testcase( pRangeStart && (pRangeStart->eOperator & WO_GE)!=0 ); + testcase( pRangeEnd && (pRangeEnd->eOperator & WO_LE)!=0 ); + testcase( pRangeEnd && (pRangeEnd->eOperator & WO_GE)!=0 ); + startEq = !pRangeStart || pRangeStart->eOperator & (WO_LE|WO_GE); + endEq = !pRangeEnd || pRangeEnd->eOperator & (WO_LE|WO_GE); + start_constraints = pRangeStart || nEq>0; + + /* Seek the index cursor to the start of the range. */ + nConstraint = nEq; + if( pRangeStart ){ + Expr *pRight = pRangeStart->pExpr->pRight; + codeExprOrVector(pParse, pRight, regBase+nEq, nBtm); + whereLikeOptimizationStringFixup(v, pLevel, pRangeStart); + if( (pRangeStart->wtFlags & TERM_VNULL)==0 + && sqlite3ExprCanBeNull(pRight) + ){ + sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt); + VdbeCoverage(v); + } + if( zStartAff ){ + updateRangeAffinityStr(pRight, nBtm, &zStartAff[nEq]); + } + nConstraint += nBtm; + testcase( pRangeStart->wtFlags & TERM_VIRTUAL ); + if( sqlite3ExprIsVector(pRight)==0 ){ + disableTerm(pLevel, pRangeStart); + }else{ + startEq = 1; + } + bSeekPastNull = 0; + }else if( bSeekPastNull ){ + startEq = 0; + sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq); + start_constraints = 1; + nConstraint++; + }else if( regBignull ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq); + start_constraints = 1; + nConstraint++; + } + codeApplyAffinity(pParse, regBase, nConstraint - bSeekPastNull, zStartAff); + if( pLoop->nSkip>0 && nConstraint==pLoop->nSkip ){ + /* The skip-scan logic inside the call to codeAllEqualityConstraints() + ** above has already left the cursor sitting on the correct row, + ** so no further seeking is needed */ + }else{ + if( regBignull ){ + sqlite3VdbeAddOp2(v, OP_Integer, 1, regBignull); + VdbeComment((v, "NULL-scan pass ctr")); + } + + op = aStartOp[(start_constraints<<2) + (startEq<<1) + bRev]; + assert( op!=0 ); + if( (pLoop->wsFlags & WHERE_IN_SEEKSCAN)!=0 && op==OP_SeekGE ){ + assert( regBignull==0 ); + /* TUNING: The OP_SeekScan opcode seeks to reduce the number + ** of expensive seek operations by replacing a single seek with + ** 1 or more step operations. The question is, how many steps + ** should we try before giving up and going with a seek. The cost + ** of a seek is proportional to the logarithm of the of the number + ** of entries in the tree, so basing the number of steps to try + ** on the estimated number of rows in the btree seems like a good + ** guess. */ + addrSeekScan = sqlite3VdbeAddOp1(v, OP_SeekScan, + (pIdx->aiRowLogEst[0]+9)/10); + VdbeCoverage(v); + } + sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint); + VdbeCoverage(v); + VdbeCoverageIf(v, op==OP_Rewind); testcase( op==OP_Rewind ); + VdbeCoverageIf(v, op==OP_Last); testcase( op==OP_Last ); + VdbeCoverageIf(v, op==OP_SeekGT); testcase( op==OP_SeekGT ); + VdbeCoverageIf(v, op==OP_SeekGE); testcase( op==OP_SeekGE ); + VdbeCoverageIf(v, op==OP_SeekLE); testcase( op==OP_SeekLE ); + VdbeCoverageIf(v, op==OP_SeekLT); testcase( op==OP_SeekLT ); + + assert( bSeekPastNull==0 || bStopAtNull==0 ); + if( regBignull ){ + assert( bSeekPastNull==1 || bStopAtNull==1 ); + assert( bSeekPastNull==!bStopAtNull ); + assert( bStopAtNull==startEq ); + sqlite3VdbeAddOp2(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+2); + op = aStartOp[(nConstraint>1)*4 + 2 + bRev]; + sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, + nConstraint-startEq); + VdbeCoverage(v); + VdbeCoverageIf(v, op==OP_Rewind); testcase( op==OP_Rewind ); + VdbeCoverageIf(v, op==OP_Last); testcase( op==OP_Last ); + VdbeCoverageIf(v, op==OP_SeekGE); testcase( op==OP_SeekGE ); + VdbeCoverageIf(v, op==OP_SeekLE); testcase( op==OP_SeekLE ); + assert( op==OP_Rewind || op==OP_Last || op==OP_SeekGE || op==OP_SeekLE); + } + } + + /* Load the value for the inequality constraint at the end of the + ** range (if any). + */ + nConstraint = nEq; + if( pRangeEnd ){ + Expr *pRight = pRangeEnd->pExpr->pRight; + codeExprOrVector(pParse, pRight, regBase+nEq, nTop); + whereLikeOptimizationStringFixup(v, pLevel, pRangeEnd); + if( (pRangeEnd->wtFlags & TERM_VNULL)==0 + && sqlite3ExprCanBeNull(pRight) + ){ + sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt); + VdbeCoverage(v); + } + if( zEndAff ){ + updateRangeAffinityStr(pRight, nTop, zEndAff); + codeApplyAffinity(pParse, regBase+nEq, nTop, zEndAff); + }else{ + assert( pParse->db->mallocFailed ); + } + nConstraint += nTop; + testcase( pRangeEnd->wtFlags & TERM_VIRTUAL ); + + if( sqlite3ExprIsVector(pRight)==0 ){ + disableTerm(pLevel, pRangeEnd); + }else{ + endEq = 1; + } + }else if( bStopAtNull ){ + if( regBignull==0 ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq); + endEq = 0; + } + nConstraint++; + } + sqlite3DbFree(db, zStartAff); + sqlite3DbFree(db, zEndAff); + + /* Top of the loop body */ + pLevel->p2 = sqlite3VdbeCurrentAddr(v); + + /* Check if the index cursor is past the end of the range. */ + if( nConstraint ){ + if( regBignull ){ + /* Except, skip the end-of-range check while doing the NULL-scan */ + sqlite3VdbeAddOp2(v, OP_IfNot, regBignull, sqlite3VdbeCurrentAddr(v)+3); + VdbeComment((v, "If NULL-scan 2nd pass")); + VdbeCoverage(v); + } + op = aEndOp[bRev*2 + endEq]; + sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint); + testcase( op==OP_IdxGT ); VdbeCoverageIf(v, op==OP_IdxGT ); + testcase( op==OP_IdxGE ); VdbeCoverageIf(v, op==OP_IdxGE ); + testcase( op==OP_IdxLT ); VdbeCoverageIf(v, op==OP_IdxLT ); + testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE ); + if( addrSeekScan ) sqlite3VdbeJumpHere(v, addrSeekScan); + } + if( regBignull ){ + /* During a NULL-scan, check to see if we have reached the end of + ** the NULLs */ + assert( bSeekPastNull==!bStopAtNull ); + assert( bSeekPastNull+bStopAtNull==1 ); + assert( nConstraint+bSeekPastNull>0 ); + sqlite3VdbeAddOp2(v, OP_If, regBignull, sqlite3VdbeCurrentAddr(v)+2); + VdbeComment((v, "If NULL-scan 1st pass")); + VdbeCoverage(v); + op = aEndOp[bRev*2 + bSeekPastNull]; + sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, + nConstraint+bSeekPastNull); + testcase( op==OP_IdxGT ); VdbeCoverageIf(v, op==OP_IdxGT ); + testcase( op==OP_IdxGE ); VdbeCoverageIf(v, op==OP_IdxGE ); + testcase( op==OP_IdxLT ); VdbeCoverageIf(v, op==OP_IdxLT ); + testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE ); + } + + if( (pLoop->wsFlags & WHERE_IN_EARLYOUT)!=0 ){ + sqlite3VdbeAddOp3(v, OP_SeekHit, iIdxCur, nEq, nEq); + } + + /* Seek the table cursor, if required */ + omitTable = (pLoop->wsFlags & WHERE_IDX_ONLY)!=0 + && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0; + if( omitTable ){ + /* pIdx is a covering index. No need to access the main table. */ + }else if( HasRowid(pIdx->pTable) ){ + codeDeferredSeek(pWInfo, pIdx, iCur, iIdxCur); + }else if( iCur!=iIdxCur ){ + Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable); + iRowidReg = sqlite3GetTempRange(pParse, pPk->nKeyCol); + for(j=0; jnKeyCol; j++){ + k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[j]); + sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, iRowidReg+j); + } + sqlite3VdbeAddOp4Int(v, OP_NotFound, iCur, addrCont, + iRowidReg, pPk->nKeyCol); VdbeCoverage(v); + } + + if( pLevel->iLeftJoin==0 ){ + /* If pIdx is an index on one or more expressions, then look through + ** all the expressions in pWInfo and try to transform matching expressions + ** into reference to index columns. Also attempt to translate references + ** to virtual columns in the table into references to (stored) columns + ** of the index. + ** + ** Do not do this for the RHS of a LEFT JOIN. This is because the + ** expression may be evaluated after OP_NullRow has been executed on + ** the cursor. In this case it is important to do the full evaluation, + ** as the result of the expression may not be NULL, even if all table + ** column values are. https://www.sqlite.org/src/info/7fa8049685b50b5a + ** + ** Also, do not do this when processing one index an a multi-index + ** OR clause, since the transformation will become invalid once we + ** move forward to the next index. + ** https://sqlite.org/src/info/4e8e4857d32d401f + */ + if( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0 ){ + whereIndexExprTrans(pIdx, iCur, iIdxCur, pWInfo); + } + + /* If a partial index is driving the loop, try to eliminate WHERE clause + ** terms from the query that must be true due to the WHERE clause of + ** the partial index. + ** + ** 2019-11-02 ticket 623eff57e76d45f6: This optimization does not work + ** for a LEFT JOIN. + */ + if( pIdx->pPartIdxWhere ){ + whereApplyPartialIndexConstraints(pIdx->pPartIdxWhere, iCur, pWC); + } + }else{ + testcase( pIdx->pPartIdxWhere ); + /* The following assert() is not a requirement, merely an observation: + ** The OR-optimization doesn't work for the right hand table of + ** a LEFT JOIN: */ + assert( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0 ); + } + + /* Record the instruction used to terminate the loop. */ + if( pLoop->wsFlags & WHERE_ONEROW ){ + pLevel->op = OP_Noop; + }else if( bRev ){ + pLevel->op = OP_Prev; + }else{ + pLevel->op = OP_Next; + } + pLevel->p1 = iIdxCur; + pLevel->p3 = (pLoop->wsFlags&WHERE_UNQ_WANTED)!=0 ? 1:0; + if( (pLoop->wsFlags & WHERE_CONSTRAINT)==0 ){ + pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP; + }else{ + assert( pLevel->p5==0 ); + } + if( omitTable ) pIdx = 0; + }else + +#ifndef SQLITE_OMIT_OR_OPTIMIZATION + if( pLoop->wsFlags & WHERE_MULTI_OR ){ + /* Case 5: Two or more separately indexed terms connected by OR + ** + ** Example: + ** + ** CREATE TABLE t1(a,b,c,d); + ** CREATE INDEX i1 ON t1(a); + ** CREATE INDEX i2 ON t1(b); + ** CREATE INDEX i3 ON t1(c); + ** + ** SELECT * FROM t1 WHERE a=5 OR b=7 OR (c=11 AND d=13) + ** + ** In the example, there are three indexed terms connected by OR. + ** The top of the loop looks like this: + ** + ** Null 1 # Zero the rowset in reg 1 + ** + ** Then, for each indexed term, the following. The arguments to + ** RowSetTest are such that the rowid of the current row is inserted + ** into the RowSet. If it is already present, control skips the + ** Gosub opcode and jumps straight to the code generated by WhereEnd(). + ** + ** sqlite3WhereBegin() + ** RowSetTest # Insert rowid into rowset + ** Gosub 2 A + ** sqlite3WhereEnd() + ** + ** Following the above, code to terminate the loop. Label A, the target + ** of the Gosub above, jumps to the instruction right after the Goto. + ** + ** Null 1 # Zero the rowset in reg 1 + ** Goto B # The loop is finished. + ** + ** A: # Return data, whatever. + ** + ** Return 2 # Jump back to the Gosub + ** + ** B: + ** + ** Added 2014-05-26: If the table is a WITHOUT ROWID table, then + ** use an ephemeral index instead of a RowSet to record the primary + ** keys of the rows we have already seen. + ** + */ + WhereClause *pOrWc; /* The OR-clause broken out into subterms */ + SrcList *pOrTab; /* Shortened table list or OR-clause generation */ + Index *pCov = 0; /* Potential covering index (or NULL) */ + int iCovCur = pParse->nTab++; /* Cursor used for index scans (if any) */ + + int regReturn = ++pParse->nMem; /* Register used with OP_Gosub */ + int regRowset = 0; /* Register for RowSet object */ + int regRowid = 0; /* Register holding rowid */ + int iLoopBody = sqlite3VdbeMakeLabel(pParse);/* Start of loop body */ + int iRetInit; /* Address of regReturn init */ + int untestedTerms = 0; /* Some terms not completely tested */ + int ii; /* Loop counter */ + Expr *pAndExpr = 0; /* An ".. AND (...)" expression */ + Table *pTab = pTabItem->pTab; + + pTerm = pLoop->aLTerm[0]; + assert( pTerm!=0 ); + assert( pTerm->eOperator & WO_OR ); + assert( (pTerm->wtFlags & TERM_ORINFO)!=0 ); + pOrWc = &pTerm->u.pOrInfo->wc; + pLevel->op = OP_Return; + pLevel->p1 = regReturn; + + /* Set up a new SrcList in pOrTab containing the table being scanned + ** by this loop in the a[0] slot and all notReady tables in a[1..] slots. + ** This becomes the SrcList in the recursive call to sqlite3WhereBegin(). + */ + if( pWInfo->nLevel>1 ){ + int nNotReady; /* The number of notReady tables */ + struct SrcList_item *origSrc; /* Original list of tables */ + nNotReady = pWInfo->nLevel - iLevel - 1; + pOrTab = sqlite3StackAllocRaw(db, + sizeof(*pOrTab)+ nNotReady*sizeof(pOrTab->a[0])); + if( pOrTab==0 ) return notReady; + pOrTab->nAlloc = (u8)(nNotReady + 1); + pOrTab->nSrc = pOrTab->nAlloc; + memcpy(pOrTab->a, pTabItem, sizeof(*pTabItem)); + origSrc = pWInfo->pTabList->a; + for(k=1; k<=nNotReady; k++){ + memcpy(&pOrTab->a[k], &origSrc[pLevel[k].iFrom], sizeof(pOrTab->a[k])); + } + }else{ + pOrTab = pWInfo->pTabList; + } + + /* Initialize the rowset register to contain NULL. An SQL NULL is + ** equivalent to an empty rowset. Or, create an ephemeral index + ** capable of holding primary keys in the case of a WITHOUT ROWID. + ** + ** Also initialize regReturn to contain the address of the instruction + ** immediately following the OP_Return at the bottom of the loop. This + ** is required in a few obscure LEFT JOIN cases where control jumps + ** over the top of the loop into the body of it. In this case the + ** correct response for the end-of-loop code (the OP_Return) is to + ** fall through to the next instruction, just as an OP_Next does if + ** called on an uninitialized cursor. + */ + if( (pWInfo->wctrlFlags & WHERE_DUPLICATES_OK)==0 ){ + if( HasRowid(pTab) ){ + regRowset = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Null, 0, regRowset); + }else{ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + regRowset = pParse->nTab++; + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, regRowset, pPk->nKeyCol); + sqlite3VdbeSetP4KeyInfo(pParse, pPk); + } + regRowid = ++pParse->nMem; + } + iRetInit = sqlite3VdbeAddOp2(v, OP_Integer, 0, regReturn); + + /* If the original WHERE clause is z of the form: (x1 OR x2 OR ...) AND y + ** Then for every term xN, evaluate as the subexpression: xN AND z + ** That way, terms in y that are factored into the disjunction will + ** be picked up by the recursive calls to sqlite3WhereBegin() below. + ** + ** Actually, each subexpression is converted to "xN AND w" where w is + ** the "interesting" terms of z - terms that did not originate in the + ** ON or USING clause of a LEFT JOIN, and terms that are usable as + ** indices. + ** + ** This optimization also only applies if the (x1 OR x2 OR ...) term + ** is not contained in the ON clause of a LEFT JOIN. + ** See ticket http://www.sqlite.org/src/info/f2369304e4 + */ + if( pWC->nTerm>1 ){ + int iTerm; + for(iTerm=0; iTermnTerm; iTerm++){ + Expr *pExpr = pWC->a[iTerm].pExpr; + if( &pWC->a[iTerm] == pTerm ) continue; + testcase( pWC->a[iTerm].wtFlags & TERM_VIRTUAL ); + testcase( pWC->a[iTerm].wtFlags & TERM_CODED ); + if( (pWC->a[iTerm].wtFlags & (TERM_VIRTUAL|TERM_CODED))!=0 ) continue; + if( (pWC->a[iTerm].eOperator & WO_ALL)==0 ) continue; + testcase( pWC->a[iTerm].wtFlags & TERM_ORINFO ); + pExpr = sqlite3ExprDup(db, pExpr, 0); + pAndExpr = sqlite3ExprAnd(pParse, pAndExpr, pExpr); + } + if( pAndExpr ){ + /* The extra 0x10000 bit on the opcode is masked off and does not + ** become part of the new Expr.op. However, it does make the + ** op==TK_AND comparison inside of sqlite3PExpr() false, and this + ** prevents sqlite3PExpr() from implementing AND short-circuit + ** optimization, which we do not want here. */ + pAndExpr = sqlite3PExpr(pParse, TK_AND|0x10000, 0, pAndExpr); + } + } + + /* Run a separate WHERE clause for each term of the OR clause. After + ** eliminating duplicates from other WHERE clauses, the action for each + ** sub-WHERE clause is to to invoke the main loop body as a subroutine. + */ + ExplainQueryPlan((pParse, 1, "MULTI-INDEX OR")); + for(ii=0; iinTerm; ii++){ + WhereTerm *pOrTerm = &pOrWc->a[ii]; + if( pOrTerm->leftCursor==iCur || (pOrTerm->eOperator & WO_AND)!=0 ){ + WhereInfo *pSubWInfo; /* Info for single OR-term scan */ + Expr *pOrExpr = pOrTerm->pExpr; /* Current OR clause term */ + int jmp1 = 0; /* Address of jump operation */ + testcase( (pTabItem[0].fg.jointype & JT_LEFT)!=0 + && !ExprHasProperty(pOrExpr, EP_FromJoin) + ); /* See TH3 vtab25.400 and ticket 614b25314c766238 */ + if( pAndExpr ){ + pAndExpr->pLeft = pOrExpr; + pOrExpr = pAndExpr; + } + /* Loop through table entries that match term pOrTerm. */ + ExplainQueryPlan((pParse, 1, "INDEX %d", ii+1)); + WHERETRACE(0xffff, ("Subplan for OR-clause:\n")); + pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrExpr, 0, 0, + WHERE_OR_SUBCLAUSE, iCovCur); + assert( pSubWInfo || pParse->nErr || db->mallocFailed ); + if( pSubWInfo ){ + WhereLoop *pSubLoop; + int addrExplain = sqlite3WhereExplainOneScan( + pParse, pOrTab, &pSubWInfo->a[0], 0 + ); + sqlite3WhereAddScanStatus(v, pOrTab, &pSubWInfo->a[0], addrExplain); + + /* This is the sub-WHERE clause body. First skip over + ** duplicate rows from prior sub-WHERE clauses, and record the + ** rowid (or PRIMARY KEY) for the current row so that the same + ** row will be skipped in subsequent sub-WHERE clauses. + */ + if( (pWInfo->wctrlFlags & WHERE_DUPLICATES_OK)==0 ){ + int iSet = ((ii==pOrWc->nTerm-1)?-1:ii); + if( HasRowid(pTab) ){ + sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, regRowid); + jmp1 = sqlite3VdbeAddOp4Int(v, OP_RowSetTest, regRowset, 0, + regRowid, iSet); + VdbeCoverage(v); + }else{ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + int nPk = pPk->nKeyCol; + int iPk; + int r; + + /* Read the PK into an array of temp registers. */ + r = sqlite3GetTempRange(pParse, nPk); + for(iPk=0; iPkaiColumn[iPk]; + sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk); + } + + /* Check if the temp table already contains this key. If so, + ** the row has already been included in the result set and + ** can be ignored (by jumping past the Gosub below). Otherwise, + ** insert the key into the temp table and proceed with processing + ** the row. + ** + ** Use some of the same optimizations as OP_RowSetTest: If iSet + ** is zero, assume that the key cannot already be present in + ** the temp table. And if iSet is -1, assume that there is no + ** need to insert the key into the temp table, as it will never + ** be tested for. */ + if( iSet ){ + jmp1 = sqlite3VdbeAddOp4Int(v, OP_Found, regRowset, 0, r, nPk); + VdbeCoverage(v); + } + if( iSet>=0 ){ + sqlite3VdbeAddOp3(v, OP_MakeRecord, r, nPk, regRowid); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, regRowset, regRowid, + r, nPk); + if( iSet ) sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + } + + /* Release the array of temp registers */ + sqlite3ReleaseTempRange(pParse, r, nPk); + } + } + + /* Invoke the main loop body as a subroutine */ + sqlite3VdbeAddOp2(v, OP_Gosub, regReturn, iLoopBody); + + /* Jump here (skipping the main loop body subroutine) if the + ** current sub-WHERE row is a duplicate from prior sub-WHEREs. */ + if( jmp1 ) sqlite3VdbeJumpHere(v, jmp1); + + /* The pSubWInfo->untestedTerms flag means that this OR term + ** contained one or more AND term from a notReady table. The + ** terms from the notReady table could not be tested and will + ** need to be tested later. + */ + if( pSubWInfo->untestedTerms ) untestedTerms = 1; + + /* If all of the OR-connected terms are optimized using the same + ** index, and the index is opened using the same cursor number + ** by each call to sqlite3WhereBegin() made by this loop, it may + ** be possible to use that index as a covering index. + ** + ** If the call to sqlite3WhereBegin() above resulted in a scan that + ** uses an index, and this is either the first OR-connected term + ** processed or the index is the same as that used by all previous + ** terms, set pCov to the candidate covering index. Otherwise, set + ** pCov to NULL to indicate that no candidate covering index will + ** be available. + */ + pSubLoop = pSubWInfo->a[0].pWLoop; + assert( (pSubLoop->wsFlags & WHERE_AUTO_INDEX)==0 ); + if( (pSubLoop->wsFlags & WHERE_INDEXED)!=0 + && (ii==0 || pSubLoop->u.btree.pIndex==pCov) + && (HasRowid(pTab) || !IsPrimaryKeyIndex(pSubLoop->u.btree.pIndex)) + ){ + assert( pSubWInfo->a[0].iIdxCur==iCovCur ); + pCov = pSubLoop->u.btree.pIndex; + }else{ + pCov = 0; + } + if( sqlite3WhereUsesDeferredSeek(pSubWInfo) ){ + pWInfo->bDeferredSeek = 1; + } + + /* Finish the loop through table entries that match term pOrTerm. */ + sqlite3WhereEnd(pSubWInfo); + ExplainQueryPlanPop(pParse); + } + } + } + ExplainQueryPlanPop(pParse); + pLevel->u.pCovidx = pCov; + if( pCov ) pLevel->iIdxCur = iCovCur; + if( pAndExpr ){ + pAndExpr->pLeft = 0; + sqlite3ExprDelete(db, pAndExpr); + } + sqlite3VdbeChangeP1(v, iRetInit, sqlite3VdbeCurrentAddr(v)); + sqlite3VdbeGoto(v, pLevel->addrBrk); + sqlite3VdbeResolveLabel(v, iLoopBody); + + if( pWInfo->nLevel>1 ){ sqlite3StackFree(db, pOrTab); } + if( !untestedTerms ) disableTerm(pLevel, pTerm); + }else +#endif /* SQLITE_OMIT_OR_OPTIMIZATION */ + + { + /* Case 6: There is no usable index. We must do a complete + ** scan of the entire table. + */ + static const u8 aStep[] = { OP_Next, OP_Prev }; + static const u8 aStart[] = { OP_Rewind, OP_Last }; + assert( bRev==0 || bRev==1 ); + if( pTabItem->fg.isRecursive ){ + /* Tables marked isRecursive have only a single row that is stored in + ** a pseudo-cursor. No need to Rewind or Next such cursors. */ + pLevel->op = OP_Noop; + }else{ + codeCursorHint(pTabItem, pWInfo, pLevel, 0); + pLevel->op = aStep[bRev]; + pLevel->p1 = iCur; + pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrHalt); + VdbeCoverageIf(v, bRev==0); + VdbeCoverageIf(v, bRev!=0); + pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP; + } + } + +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + pLevel->addrVisit = sqlite3VdbeCurrentAddr(v); +#endif + + /* Insert code to test every subexpression that can be completely + ** computed using the current set of tables. + ** + ** This loop may run between one and three times, depending on the + ** constraints to be generated. The value of stack variable iLoop + ** determines the constraints coded by each iteration, as follows: + ** + ** iLoop==1: Code only expressions that are entirely covered by pIdx. + ** iLoop==2: Code remaining expressions that do not contain correlated + ** sub-queries. + ** iLoop==3: Code all remaining expressions. + ** + ** An effort is made to skip unnecessary iterations of the loop. + */ + iLoop = (pIdx ? 1 : 2); + do{ + int iNext = 0; /* Next value for iLoop */ + for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){ + Expr *pE; + int skipLikeAddr = 0; + testcase( pTerm->wtFlags & TERM_VIRTUAL ); + testcase( pTerm->wtFlags & TERM_CODED ); + if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue; + if( (pTerm->prereqAll & pLevel->notReady)!=0 ){ + testcase( pWInfo->untestedTerms==0 + && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)!=0 ); + pWInfo->untestedTerms = 1; + continue; + } + pE = pTerm->pExpr; + assert( pE!=0 ); + if( (pTabItem->fg.jointype&JT_LEFT) && !ExprHasProperty(pE,EP_FromJoin) ){ + continue; + } + + if( iLoop==1 && !sqlite3ExprCoveredByIndex(pE, pLevel->iTabCur, pIdx) ){ + iNext = 2; + continue; + } + if( iLoop<3 && (pTerm->wtFlags & TERM_VARSELECT) ){ + if( iNext==0 ) iNext = 3; + continue; + } + + if( (pTerm->wtFlags & TERM_LIKECOND)!=0 ){ + /* If the TERM_LIKECOND flag is set, that means that the range search + ** is sufficient to guarantee that the LIKE operator is true, so we + ** can skip the call to the like(A,B) function. But this only works + ** for strings. So do not skip the call to the function on the pass + ** that compares BLOBs. */ +#ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS + continue; +#else + u32 x = pLevel->iLikeRepCntr; + if( x>0 ){ + skipLikeAddr = sqlite3VdbeAddOp1(v, (x&1)?OP_IfNot:OP_If,(int)(x>>1)); + VdbeCoverageIf(v, (x&1)==1); + VdbeCoverageIf(v, (x&1)==0); + } +#endif + } +#ifdef WHERETRACE_ENABLED /* 0xffff */ + if( sqlite3WhereTrace ){ + VdbeNoopComment((v, "WhereTerm[%d] (%p) priority=%d", + pWC->nTerm-j, pTerm, iLoop)); + } + if( sqlite3WhereTrace & 0x800 ){ + sqlite3DebugPrintf("Coding auxiliary constraint:\n"); + sqlite3WhereTermPrint(pTerm, pWC->nTerm-j); + } +#endif + sqlite3ExprIfFalse(pParse, pE, addrCont, SQLITE_JUMPIFNULL); + if( skipLikeAddr ) sqlite3VdbeJumpHere(v, skipLikeAddr); + pTerm->wtFlags |= TERM_CODED; + } + iLoop = iNext; + }while( iLoop>0 ); + + /* Insert code to test for implied constraints based on transitivity + ** of the "==" operator. + ** + ** Example: If the WHERE clause contains "t1.a=t2.b" and "t2.b=123" + ** and we are coding the t1 loop and the t2 loop has not yet coded, + ** then we cannot use the "t1.a=t2.b" constraint, but we can code + ** the implied "t1.a=123" constraint. + */ + for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){ + Expr *pE, sEAlt; + WhereTerm *pAlt; + if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue; + if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) continue; + if( (pTerm->eOperator & WO_EQUIV)==0 ) continue; + if( pTerm->leftCursor!=iCur ) continue; + if( pTabItem->fg.jointype & JT_LEFT ) continue; + pE = pTerm->pExpr; +#ifdef WHERETRACE_ENABLED /* 0x800 */ + if( sqlite3WhereTrace & 0x800 ){ + sqlite3DebugPrintf("Coding transitive constraint:\n"); + sqlite3WhereTermPrint(pTerm, pWC->nTerm-j); + } +#endif + assert( !ExprHasProperty(pE, EP_FromJoin) ); + assert( (pTerm->prereqRight & pLevel->notReady)!=0 ); + pAlt = sqlite3WhereFindTerm(pWC, iCur, pTerm->u.x.leftColumn, notReady, + WO_EQ|WO_IN|WO_IS, 0); + if( pAlt==0 ) continue; + if( pAlt->wtFlags & (TERM_CODED) ) continue; + if( (pAlt->eOperator & WO_IN) + && (pAlt->pExpr->flags & EP_xIsSelect) + && (pAlt->pExpr->x.pSelect->pEList->nExpr>1) + ){ + continue; + } + testcase( pAlt->eOperator & WO_EQ ); + testcase( pAlt->eOperator & WO_IS ); + testcase( pAlt->eOperator & WO_IN ); + VdbeModuleComment((v, "begin transitive constraint")); + sEAlt = *pAlt->pExpr; + sEAlt.pLeft = pE->pLeft; + sqlite3ExprIfFalse(pParse, &sEAlt, addrCont, SQLITE_JUMPIFNULL); + } + + /* For a LEFT OUTER JOIN, generate code that will record the fact that + ** at least one row of the right table has matched the left table. + */ + if( pLevel->iLeftJoin ){ + pLevel->addrFirst = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp2(v, OP_Integer, 1, pLevel->iLeftJoin); + VdbeComment((v, "record LEFT JOIN hit")); + for(pTerm=pWC->a, j=0; jnTerm; j++, pTerm++){ + testcase( pTerm->wtFlags & TERM_VIRTUAL ); + testcase( pTerm->wtFlags & TERM_CODED ); + if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue; + if( (pTerm->prereqAll & pLevel->notReady)!=0 ){ + assert( pWInfo->untestedTerms ); + continue; + } + assert( pTerm->pExpr ); + sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL); + pTerm->wtFlags |= TERM_CODED; + } + } + +#if WHERETRACE_ENABLED /* 0x20800 */ + if( sqlite3WhereTrace & 0x20000 ){ + sqlite3DebugPrintf("All WHERE-clause terms after coding level %d:\n", + iLevel); + sqlite3WhereClausePrint(pWC); + } + if( sqlite3WhereTrace & 0x800 ){ + sqlite3DebugPrintf("End Coding level %d: notReady=%llx\n", + iLevel, (u64)pLevel->notReady); + } +#endif + return pLevel->notReady; +} + +/************** End of wherecode.c *******************************************/ +/************** Begin file whereexpr.c ***************************************/ +/* +** 2015-06-08 +** +** 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 module contains C code that generates VDBE code used to process +** the WHERE clause of SQL statements. +** +** This file was originally part of where.c but was split out to improve +** readability and editabiliity. This file contains utility routines for +** analyzing Expr objects in the WHERE clause. +*/ +/* #include "sqliteInt.h" */ +/* #include "whereInt.h" */ + +/* Forward declarations */ +static void exprAnalyze(SrcList*, WhereClause*, int); + +/* +** Deallocate all memory associated with a WhereOrInfo object. +*/ +static void whereOrInfoDelete(sqlite3 *db, WhereOrInfo *p){ + sqlite3WhereClauseClear(&p->wc); + sqlite3DbFree(db, p); +} + +/* +** Deallocate all memory associated with a WhereAndInfo object. +*/ +static void whereAndInfoDelete(sqlite3 *db, WhereAndInfo *p){ + sqlite3WhereClauseClear(&p->wc); + sqlite3DbFree(db, p); +} + +/* +** Add a single new WhereTerm entry to the WhereClause object pWC. +** The new WhereTerm object is constructed from Expr p and with wtFlags. +** The index in pWC->a[] of the new WhereTerm is returned on success. +** 0 is returned if the new WhereTerm could not be added due to a memory +** allocation error. The memory allocation failure will be recorded in +** the db->mallocFailed flag so that higher-level functions can detect it. +** +** This routine will increase the size of the pWC->a[] array as necessary. +** +** If the wtFlags argument includes TERM_DYNAMIC, then responsibility +** for freeing the expression p is assumed by the WhereClause object pWC. +** This is true even if this routine fails to allocate a new WhereTerm. +** +** WARNING: This routine might reallocate the space used to store +** WhereTerms. All pointers to WhereTerms should be invalidated after +** calling this routine. Such pointers may be reinitialized by referencing +** the pWC->a[] array. +*/ +static int whereClauseInsert(WhereClause *pWC, Expr *p, u16 wtFlags){ + WhereTerm *pTerm; + int idx; + testcase( wtFlags & TERM_VIRTUAL ); + if( pWC->nTerm>=pWC->nSlot ){ + WhereTerm *pOld = pWC->a; + sqlite3 *db = pWC->pWInfo->pParse->db; + pWC->a = sqlite3DbMallocRawNN(db, sizeof(pWC->a[0])*pWC->nSlot*2 ); + if( pWC->a==0 ){ + if( wtFlags & TERM_DYNAMIC ){ + sqlite3ExprDelete(db, p); + } + pWC->a = pOld; + return 0; + } + memcpy(pWC->a, pOld, sizeof(pWC->a[0])*pWC->nTerm); + if( pOld!=pWC->aStatic ){ + sqlite3DbFree(db, pOld); + } + pWC->nSlot = sqlite3DbMallocSize(db, pWC->a)/sizeof(pWC->a[0]); + } + pTerm = &pWC->a[idx = pWC->nTerm++]; + if( p && ExprHasProperty(p, EP_Unlikely) ){ + pTerm->truthProb = sqlite3LogEst(p->iTable) - 270; + }else{ + pTerm->truthProb = 1; + } + pTerm->pExpr = sqlite3ExprSkipCollateAndLikely(p); + pTerm->wtFlags = wtFlags; + pTerm->pWC = pWC; + pTerm->iParent = -1; + memset(&pTerm->eOperator, 0, + sizeof(WhereTerm) - offsetof(WhereTerm,eOperator)); + return idx; +} + +/* +** Return TRUE if the given operator is one of the operators that is +** allowed for an indexable WHERE clause term. The allowed operators are +** "=", "<", ">", "<=", ">=", "IN", "IS", and "IS NULL" +*/ +static int allowedOp(int op){ + assert( TK_GT>TK_EQ && TK_GTTK_EQ && TK_LTTK_EQ && TK_LE=TK_EQ && op<=TK_GE) || op==TK_ISNULL || op==TK_IS; +} + +/* +** Commute a comparison operator. Expressions of the form "X op Y" +** are converted into "Y op X". +*/ +static u16 exprCommute(Parse *pParse, Expr *pExpr){ + if( pExpr->pLeft->op==TK_VECTOR + || pExpr->pRight->op==TK_VECTOR + || sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, pExpr->pRight) != + sqlite3BinaryCompareCollSeq(pParse, pExpr->pRight, pExpr->pLeft) + ){ + pExpr->flags ^= EP_Commuted; + } + SWAP(Expr*,pExpr->pRight,pExpr->pLeft); + if( pExpr->op>=TK_GT ){ + assert( TK_LT==TK_GT+2 ); + assert( TK_GE==TK_LE+2 ); + assert( TK_GT>TK_EQ ); + assert( TK_GTop>=TK_GT && pExpr->op<=TK_GE ); + pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT; + } + return 0; +} + +/* +** Translate from TK_xx operator to WO_xx bitmask. +*/ +static u16 operatorMask(int op){ + u16 c; + assert( allowedOp(op) ); + if( op==TK_IN ){ + c = WO_IN; + }else if( op==TK_ISNULL ){ + c = WO_ISNULL; + }else if( op==TK_IS ){ + c = WO_IS; + }else{ + assert( (WO_EQ<<(op-TK_EQ)) < 0x7fff ); + c = (u16)(WO_EQ<<(op-TK_EQ)); + } + assert( op!=TK_ISNULL || c==WO_ISNULL ); + assert( op!=TK_IN || c==WO_IN ); + assert( op!=TK_EQ || c==WO_EQ ); + assert( op!=TK_LT || c==WO_LT ); + assert( op!=TK_LE || c==WO_LE ); + assert( op!=TK_GT || c==WO_GT ); + assert( op!=TK_GE || c==WO_GE ); + assert( op!=TK_IS || c==WO_IS ); + return c; +} + + +#ifndef SQLITE_OMIT_LIKE_OPTIMIZATION +/* +** Check to see if the given expression is a LIKE or GLOB operator that +** can be optimized using inequality constraints. Return TRUE if it is +** so and false if not. +** +** In order for the operator to be optimizible, the RHS must be a string +** literal that does not begin with a wildcard. The LHS must be a column +** that may only be NULL, a string, or a BLOB, never a number. (This means +** that virtual tables cannot participate in the LIKE optimization.) The +** collating sequence for the column on the LHS must be appropriate for +** the operator. +*/ +static int isLikeOrGlob( + Parse *pParse, /* Parsing and code generating context */ + Expr *pExpr, /* Test this expression */ + Expr **ppPrefix, /* Pointer to TK_STRING expression with pattern prefix */ + int *pisComplete, /* True if the only wildcard is % in the last character */ + int *pnoCase /* True if uppercase is equivalent to lowercase */ +){ + const u8 *z = 0; /* String on RHS of LIKE operator */ + Expr *pRight, *pLeft; /* Right and left size of LIKE operator */ + ExprList *pList; /* List of operands to the LIKE operator */ + u8 c; /* One character in z[] */ + int cnt; /* Number of non-wildcard prefix characters */ + u8 wc[4]; /* Wildcard characters */ + sqlite3 *db = pParse->db; /* Database connection */ + sqlite3_value *pVal = 0; + int op; /* Opcode of pRight */ + int rc; /* Result code to return */ + + if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, (char*)wc) ){ + return 0; + } +#ifdef SQLITE_EBCDIC + if( *pnoCase ) return 0; +#endif + pList = pExpr->x.pList; + pLeft = pList->a[1].pExpr; + + pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr); + op = pRight->op; + if( op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){ + Vdbe *pReprepare = pParse->pReprepare; + int iCol = pRight->iColumn; + pVal = sqlite3VdbeGetBoundValue(pReprepare, iCol, SQLITE_AFF_BLOB); + if( pVal && sqlite3_value_type(pVal)==SQLITE_TEXT ){ + z = sqlite3_value_text(pVal); + } + sqlite3VdbeSetVarmask(pParse->pVdbe, iCol); + assert( pRight->op==TK_VARIABLE || pRight->op==TK_REGISTER ); + }else if( op==TK_STRING ){ + z = (u8*)pRight->u.zToken; + } + if( z ){ + + /* Count the number of prefix characters prior to the first wildcard */ + cnt = 0; + while( (c=z[cnt])!=0 && c!=wc[0] && c!=wc[1] && c!=wc[2] ){ + cnt++; + if( c==wc[3] && z[cnt]!=0 ) cnt++; + } + + /* The optimization is possible only if (1) the pattern does not begin + ** with a wildcard and if (2) the non-wildcard prefix does not end with + ** an (illegal 0xff) character, or (3) the pattern does not consist of + ** a single escape character. The second condition is necessary so + ** that we can increment the prefix key to find an upper bound for the + ** range search. The third is because the caller assumes that the pattern + ** consists of at least one character after all escapes have been + ** removed. */ + if( cnt!=0 && 255!=(u8)z[cnt-1] && (cnt>1 || z[0]!=wc[3]) ){ + Expr *pPrefix; + + /* A "complete" match if the pattern ends with "*" or "%" */ + *pisComplete = c==wc[0] && z[cnt+1]==0; + + /* Get the pattern prefix. Remove all escapes from the prefix. */ + pPrefix = sqlite3Expr(db, TK_STRING, (char*)z); + if( pPrefix ){ + int iFrom, iTo; + char *zNew = pPrefix->u.zToken; + zNew[cnt] = 0; + for(iFrom=iTo=0; iFrom0 ); + + /* If the LHS is not an ordinary column with TEXT affinity, then the + ** pattern prefix boundaries (both the start and end boundaries) must + ** not look like a number. Otherwise the pattern might be treated as + ** a number, which will invalidate the LIKE optimization. + ** + ** Getting this right has been a persistent source of bugs in the + ** LIKE optimization. See, for example: + ** 2018-09-10 https://sqlite.org/src/info/c94369cae9b561b1 + ** 2019-05-02 https://sqlite.org/src/info/b043a54c3de54b28 + ** 2019-06-10 https://sqlite.org/src/info/fd76310a5e843e07 + ** 2019-06-14 https://sqlite.org/src/info/ce8717f0885af975 + ** 2019-09-03 https://sqlite.org/src/info/0f0428096f17252a + */ + if( pLeft->op!=TK_COLUMN + || sqlite3ExprAffinity(pLeft)!=SQLITE_AFF_TEXT + || IsVirtual(pLeft->y.pTab) /* Value might be numeric */ + ){ + int isNum; + double rDummy; + isNum = sqlite3AtoF(zNew, &rDummy, iTo, SQLITE_UTF8); + if( isNum<=0 ){ + if( iTo==1 && zNew[0]=='-' ){ + isNum = +1; + }else{ + zNew[iTo-1]++; + isNum = sqlite3AtoF(zNew, &rDummy, iTo, SQLITE_UTF8); + zNew[iTo-1]--; + } + } + if( isNum>0 ){ + sqlite3ExprDelete(db, pPrefix); + sqlite3ValueFree(pVal); + return 0; + } + } + } + *ppPrefix = pPrefix; + + /* If the RHS pattern is a bound parameter, make arrangements to + ** reprepare the statement when that parameter is rebound */ + if( op==TK_VARIABLE ){ + Vdbe *v = pParse->pVdbe; + sqlite3VdbeSetVarmask(v, pRight->iColumn); + if( *pisComplete && pRight->u.zToken[1] ){ + /* If the rhs of the LIKE expression is a variable, and the current + ** value of the variable means there is no need to invoke the LIKE + ** function, then no OP_Variable will be added to the program. + ** This causes problems for the sqlite3_bind_parameter_name() + ** API. To work around them, add a dummy OP_Variable here. + */ + int r1 = sqlite3GetTempReg(pParse); + sqlite3ExprCodeTarget(pParse, pRight, r1); + sqlite3VdbeChangeP3(v, sqlite3VdbeCurrentAddr(v)-1, 0); + sqlite3ReleaseTempReg(pParse, r1); + } + } + }else{ + z = 0; + } + } + + rc = (z!=0); + sqlite3ValueFree(pVal); + return rc; +} +#endif /* SQLITE_OMIT_LIKE_OPTIMIZATION */ + + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Check to see if the pExpr expression is a form that needs to be passed +** to the xBestIndex method of virtual tables. Forms of interest include: +** +** Expression Virtual Table Operator +** ----------------------- --------------------------------- +** 1. column MATCH expr SQLITE_INDEX_CONSTRAINT_MATCH +** 2. column GLOB expr SQLITE_INDEX_CONSTRAINT_GLOB +** 3. column LIKE expr SQLITE_INDEX_CONSTRAINT_LIKE +** 4. column REGEXP expr SQLITE_INDEX_CONSTRAINT_REGEXP +** 5. column != expr SQLITE_INDEX_CONSTRAINT_NE +** 6. expr != column SQLITE_INDEX_CONSTRAINT_NE +** 7. column IS NOT expr SQLITE_INDEX_CONSTRAINT_ISNOT +** 8. expr IS NOT column SQLITE_INDEX_CONSTRAINT_ISNOT +** 9. column IS NOT NULL SQLITE_INDEX_CONSTRAINT_ISNOTNULL +** +** In every case, "column" must be a column of a virtual table. If there +** is a match, set *ppLeft to the "column" expression, set *ppRight to the +** "expr" expression (even though in forms (6) and (8) the column is on the +** right and the expression is on the left). Also set *peOp2 to the +** appropriate virtual table operator. The return value is 1 or 2 if there +** is a match. The usual return is 1, but if the RHS is also a column +** of virtual table in forms (5) or (7) then return 2. +** +** If the expression matches none of the patterns above, return 0. +*/ +static int isAuxiliaryVtabOperator( + sqlite3 *db, /* Parsing context */ + Expr *pExpr, /* Test this expression */ + unsigned char *peOp2, /* OUT: 0 for MATCH, or else an op2 value */ + Expr **ppLeft, /* Column expression to left of MATCH/op2 */ + Expr **ppRight /* Expression to left of MATCH/op2 */ +){ + if( pExpr->op==TK_FUNCTION ){ + static const struct Op2 { + const char *zOp; + unsigned char eOp2; + } aOp[] = { + { "match", SQLITE_INDEX_CONSTRAINT_MATCH }, + { "glob", SQLITE_INDEX_CONSTRAINT_GLOB }, + { "like", SQLITE_INDEX_CONSTRAINT_LIKE }, + { "regexp", SQLITE_INDEX_CONSTRAINT_REGEXP } + }; + ExprList *pList; + Expr *pCol; /* Column reference */ + int i; + + pList = pExpr->x.pList; + if( pList==0 || pList->nExpr!=2 ){ + return 0; + } + + /* Built-in operators MATCH, GLOB, LIKE, and REGEXP attach to a + ** virtual table on their second argument, which is the same as + ** the left-hand side operand in their in-fix form. + ** + ** vtab_column MATCH expression + ** MATCH(expression,vtab_column) + */ + pCol = pList->a[1].pExpr; + testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 ); + if( ExprIsVtab(pCol) ){ + for(i=0; iu.zToken, aOp[i].zOp)==0 ){ + *peOp2 = aOp[i].eOp2; + *ppRight = pList->a[0].pExpr; + *ppLeft = pCol; + return 1; + } + } + } + + /* We can also match against the first column of overloaded + ** functions where xFindFunction returns a value of at least + ** SQLITE_INDEX_CONSTRAINT_FUNCTION. + ** + ** OVERLOADED(vtab_column,expression) + ** + ** Historically, xFindFunction expected to see lower-case function + ** names. But for this use case, xFindFunction is expected to deal + ** with function names in an arbitrary case. + */ + pCol = pList->a[0].pExpr; + testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 ); + if( ExprIsVtab(pCol) ){ + sqlite3_vtab *pVtab; + sqlite3_module *pMod; + void (*xNotUsed)(sqlite3_context*,int,sqlite3_value**); + void *pNotUsed; + pVtab = sqlite3GetVTable(db, pCol->y.pTab)->pVtab; + assert( pVtab!=0 ); + assert( pVtab->pModule!=0 ); + pMod = (sqlite3_module *)pVtab->pModule; + if( pMod->xFindFunction!=0 ){ + i = pMod->xFindFunction(pVtab,2, pExpr->u.zToken, &xNotUsed, &pNotUsed); + if( i>=SQLITE_INDEX_CONSTRAINT_FUNCTION ){ + *peOp2 = i; + *ppRight = pList->a[1].pExpr; + *ppLeft = pCol; + return 1; + } + } + } + }else if( pExpr->op==TK_NE || pExpr->op==TK_ISNOT || pExpr->op==TK_NOTNULL ){ + int res = 0; + Expr *pLeft = pExpr->pLeft; + Expr *pRight = pExpr->pRight; + testcase( pLeft->op==TK_COLUMN && pLeft->y.pTab==0 ); + if( ExprIsVtab(pLeft) ){ + res++; + } + testcase( pRight && pRight->op==TK_COLUMN && pRight->y.pTab==0 ); + if( pRight && ExprIsVtab(pRight) ){ + res++; + SWAP(Expr*, pLeft, pRight); + } + *ppLeft = pLeft; + *ppRight = pRight; + if( pExpr->op==TK_NE ) *peOp2 = SQLITE_INDEX_CONSTRAINT_NE; + if( pExpr->op==TK_ISNOT ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOT; + if( pExpr->op==TK_NOTNULL ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOTNULL; + return res; + } + return 0; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +/* +** If the pBase expression originated in the ON or USING clause of +** a join, then transfer the appropriate markings over to derived. +*/ +static void transferJoinMarkings(Expr *pDerived, Expr *pBase){ + if( pDerived ){ + pDerived->flags |= pBase->flags & EP_FromJoin; + pDerived->iRightJoinTable = pBase->iRightJoinTable; + } +} + +/* +** Mark term iChild as being a child of term iParent +*/ +static void markTermAsChild(WhereClause *pWC, int iChild, int iParent){ + pWC->a[iChild].iParent = iParent; + pWC->a[iChild].truthProb = pWC->a[iParent].truthProb; + pWC->a[iParent].nChild++; +} + +/* +** Return the N-th AND-connected subterm of pTerm. Or if pTerm is not +** a conjunction, then return just pTerm when N==0. If N is exceeds +** the number of available subterms, return NULL. +*/ +static WhereTerm *whereNthSubterm(WhereTerm *pTerm, int N){ + if( pTerm->eOperator!=WO_AND ){ + return N==0 ? pTerm : 0; + } + if( Nu.pAndInfo->wc.nTerm ){ + return &pTerm->u.pAndInfo->wc.a[N]; + } + return 0; +} + +/* +** Subterms pOne and pTwo are contained within WHERE clause pWC. The +** two subterms are in disjunction - they are OR-ed together. +** +** If these two terms are both of the form: "A op B" with the same +** A and B values but different operators and if the operators are +** compatible (if one is = and the other is <, for example) then +** add a new virtual AND term to pWC that is the combination of the +** two. +** +** Some examples: +** +** x x<=y +** x=y OR x=y --> x=y +** x<=y OR x x<=y +** +** The following is NOT generated: +** +** xy --> x!=y +*/ +static void whereCombineDisjuncts( + SrcList *pSrc, /* the FROM clause */ + WhereClause *pWC, /* The complete WHERE clause */ + WhereTerm *pOne, /* First disjunct */ + WhereTerm *pTwo /* Second disjunct */ +){ + u16 eOp = pOne->eOperator | pTwo->eOperator; + sqlite3 *db; /* Database connection (for malloc) */ + Expr *pNew; /* New virtual expression */ + int op; /* Operator for the combined expression */ + int idxNew; /* Index in pWC of the next virtual term */ + + if( (pOne->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return; + if( (pTwo->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return; + if( (eOp & (WO_EQ|WO_LT|WO_LE))!=eOp + && (eOp & (WO_EQ|WO_GT|WO_GE))!=eOp ) return; + assert( pOne->pExpr->pLeft!=0 && pOne->pExpr->pRight!=0 ); + assert( pTwo->pExpr->pLeft!=0 && pTwo->pExpr->pRight!=0 ); + if( sqlite3ExprCompare(0,pOne->pExpr->pLeft, pTwo->pExpr->pLeft, -1) ) return; + if( sqlite3ExprCompare(0,pOne->pExpr->pRight, pTwo->pExpr->pRight,-1) )return; + /* If we reach this point, it means the two subterms can be combined */ + if( (eOp & (eOp-1))!=0 ){ + if( eOp & (WO_LT|WO_LE) ){ + eOp = WO_LE; + }else{ + assert( eOp & (WO_GT|WO_GE) ); + eOp = WO_GE; + } + } + db = pWC->pWInfo->pParse->db; + pNew = sqlite3ExprDup(db, pOne->pExpr, 0); + if( pNew==0 ) return; + for(op=TK_EQ; eOp!=(WO_EQ<<(op-TK_EQ)); op++){ assert( opop = op; + idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC); + exprAnalyze(pSrc, pWC, idxNew); +} + +#if !defined(SQLITE_OMIT_OR_OPTIMIZATION) && !defined(SQLITE_OMIT_SUBQUERY) +/* +** Analyze a term that consists of two or more OR-connected +** subterms. So in: +** +** ... WHERE (a=5) AND (b=7 OR c=9 OR d=13) AND (d=13) +** ^^^^^^^^^^^^^^^^^^^^ +** +** This routine analyzes terms such as the middle term in the above example. +** A WhereOrTerm object is computed and attached to the term under +** analysis, regardless of the outcome of the analysis. Hence: +** +** WhereTerm.wtFlags |= TERM_ORINFO +** WhereTerm.u.pOrInfo = a dynamically allocated WhereOrTerm object +** +** The term being analyzed must have two or more of OR-connected subterms. +** A single subterm might be a set of AND-connected sub-subterms. +** Examples of terms under analysis: +** +** (A) t1.x=t2.y OR t1.x=t2.z OR t1.y=15 OR t1.z=t3.a+5 +** (B) x=expr1 OR expr2=x OR x=expr3 +** (C) t1.x=t2.y OR (t1.x=t2.z AND t1.y=15) +** (D) x=expr1 OR (y>11 AND y<22 AND z LIKE '*hello*') +** (E) (p.a=1 AND q.b=2 AND r.c=3) OR (p.x=4 AND q.y=5 AND r.z=6) +** (F) x>A OR (x=A AND y>=B) +** +** CASE 1: +** +** If all subterms are of the form T.C=expr for some single column of C and +** a single table T (as shown in example B above) then create a new virtual +** term that is an equivalent IN expression. In other words, if the term +** being analyzed is: +** +** x = expr1 OR expr2 = x OR x = expr3 +** +** then create a new virtual term like this: +** +** x IN (expr1,expr2,expr3) +** +** CASE 2: +** +** If there are exactly two disjuncts and one side has x>A and the other side +** has x=A (for the same x and A) then add a new virtual conjunct term to the +** WHERE clause of the form "x>=A". Example: +** +** x>A OR (x=A AND y>B) adds: x>=A +** +** The added conjunct can sometimes be helpful in query planning. +** +** CASE 3: +** +** If all subterms are indexable by a single table T, then set +** +** WhereTerm.eOperator = WO_OR +** WhereTerm.u.pOrInfo->indexable |= the cursor number for table T +** +** A subterm is "indexable" if it is of the form +** "T.C " where C is any column of table T and +** is one of "=", "<", "<=", ">", ">=", "IS NULL", or "IN". +** A subterm is also indexable if it is an AND of two or more +** subsubterms at least one of which is indexable. Indexable AND +** subterms have their eOperator set to WO_AND and they have +** u.pAndInfo set to a dynamically allocated WhereAndTerm object. +** +** From another point of view, "indexable" means that the subterm could +** potentially be used with an index if an appropriate index exists. +** This analysis does not consider whether or not the index exists; that +** is decided elsewhere. This analysis only looks at whether subterms +** appropriate for indexing exist. +** +** All examples A through E above satisfy case 3. But if a term +** also satisfies case 1 (such as B) we know that the optimizer will +** always prefer case 1, so in that case we pretend that case 3 is not +** satisfied. +** +** It might be the case that multiple tables are indexable. For example, +** (E) above is indexable on tables P, Q, and R. +** +** Terms that satisfy case 3 are candidates for lookup by using +** separate indices to find rowids for each subterm and composing +** the union of all rowids using a RowSet object. This is similar +** to "bitmap indices" in other database engines. +** +** OTHERWISE: +** +** If none of cases 1, 2, or 3 apply, then leave the eOperator set to +** zero. This term is not useful for search. +*/ +static void exprAnalyzeOrTerm( + SrcList *pSrc, /* the FROM clause */ + WhereClause *pWC, /* the complete WHERE clause */ + int idxTerm /* Index of the OR-term to be analyzed */ +){ + WhereInfo *pWInfo = pWC->pWInfo; /* WHERE clause processing context */ + Parse *pParse = pWInfo->pParse; /* Parser context */ + sqlite3 *db = pParse->db; /* Database connection */ + WhereTerm *pTerm = &pWC->a[idxTerm]; /* The term to be analyzed */ + Expr *pExpr = pTerm->pExpr; /* The expression of the term */ + int i; /* Loop counters */ + WhereClause *pOrWc; /* Breakup of pTerm into subterms */ + WhereTerm *pOrTerm; /* A Sub-term within the pOrWc */ + WhereOrInfo *pOrInfo; /* Additional information associated with pTerm */ + Bitmask chngToIN; /* Tables that might satisfy case 1 */ + Bitmask indexable; /* Tables that are indexable, satisfying case 2 */ + + /* + ** Break the OR clause into its separate subterms. The subterms are + ** stored in a WhereClause structure containing within the WhereOrInfo + ** object that is attached to the original OR clause term. + */ + assert( (pTerm->wtFlags & (TERM_DYNAMIC|TERM_ORINFO|TERM_ANDINFO))==0 ); + assert( pExpr->op==TK_OR ); + pTerm->u.pOrInfo = pOrInfo = sqlite3DbMallocZero(db, sizeof(*pOrInfo)); + if( pOrInfo==0 ) return; + pTerm->wtFlags |= TERM_ORINFO; + pOrWc = &pOrInfo->wc; + memset(pOrWc->aStatic, 0, sizeof(pOrWc->aStatic)); + sqlite3WhereClauseInit(pOrWc, pWInfo); + sqlite3WhereSplit(pOrWc, pExpr, TK_OR); + sqlite3WhereExprAnalyze(pSrc, pOrWc); + if( db->mallocFailed ) return; + assert( pOrWc->nTerm>=2 ); + + /* + ** Compute the set of tables that might satisfy cases 1 or 3. + */ + indexable = ~(Bitmask)0; + chngToIN = ~(Bitmask)0; + for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0 && indexable; i--, pOrTerm++){ + if( (pOrTerm->eOperator & WO_SINGLE)==0 ){ + WhereAndInfo *pAndInfo; + assert( (pOrTerm->wtFlags & (TERM_ANDINFO|TERM_ORINFO))==0 ); + chngToIN = 0; + pAndInfo = sqlite3DbMallocRawNN(db, sizeof(*pAndInfo)); + if( pAndInfo ){ + WhereClause *pAndWC; + WhereTerm *pAndTerm; + int j; + Bitmask b = 0; + pOrTerm->u.pAndInfo = pAndInfo; + pOrTerm->wtFlags |= TERM_ANDINFO; + pOrTerm->eOperator = WO_AND; + pAndWC = &pAndInfo->wc; + memset(pAndWC->aStatic, 0, sizeof(pAndWC->aStatic)); + sqlite3WhereClauseInit(pAndWC, pWC->pWInfo); + sqlite3WhereSplit(pAndWC, pOrTerm->pExpr, TK_AND); + sqlite3WhereExprAnalyze(pSrc, pAndWC); + pAndWC->pOuter = pWC; + if( !db->mallocFailed ){ + for(j=0, pAndTerm=pAndWC->a; jnTerm; j++, pAndTerm++){ + assert( pAndTerm->pExpr ); + if( allowedOp(pAndTerm->pExpr->op) + || pAndTerm->eOperator==WO_AUX + ){ + b |= sqlite3WhereGetMask(&pWInfo->sMaskSet, pAndTerm->leftCursor); + } + } + } + indexable &= b; + } + }else if( pOrTerm->wtFlags & TERM_COPIED ){ + /* Skip this term for now. We revisit it when we process the + ** corresponding TERM_VIRTUAL term */ + }else{ + Bitmask b; + b = sqlite3WhereGetMask(&pWInfo->sMaskSet, pOrTerm->leftCursor); + if( pOrTerm->wtFlags & TERM_VIRTUAL ){ + WhereTerm *pOther = &pOrWc->a[pOrTerm->iParent]; + b |= sqlite3WhereGetMask(&pWInfo->sMaskSet, pOther->leftCursor); + } + indexable &= b; + if( (pOrTerm->eOperator & WO_EQ)==0 ){ + chngToIN = 0; + }else{ + chngToIN &= b; + } + } + } + + /* + ** Record the set of tables that satisfy case 3. The set might be + ** empty. + */ + pOrInfo->indexable = indexable; + if( indexable ){ + pTerm->eOperator = WO_OR; + pWC->hasOr = 1; + }else{ + pTerm->eOperator = WO_OR; + } + + /* For a two-way OR, attempt to implementation case 2. + */ + if( indexable && pOrWc->nTerm==2 ){ + int iOne = 0; + WhereTerm *pOne; + while( (pOne = whereNthSubterm(&pOrWc->a[0],iOne++))!=0 ){ + int iTwo = 0; + WhereTerm *pTwo; + while( (pTwo = whereNthSubterm(&pOrWc->a[1],iTwo++))!=0 ){ + whereCombineDisjuncts(pSrc, pWC, pOne, pTwo); + } + } + } + + /* + ** chngToIN holds a set of tables that *might* satisfy case 1. But + ** we have to do some additional checking to see if case 1 really + ** is satisfied. + ** + ** chngToIN will hold either 0, 1, or 2 bits. The 0-bit case means + ** that there is no possibility of transforming the OR clause into an + ** IN operator because one or more terms in the OR clause contain + ** something other than == on a column in the single table. The 1-bit + ** case means that every term of the OR clause is of the form + ** "table.column=expr" for some single table. The one bit that is set + ** will correspond to the common table. We still need to check to make + ** sure the same column is used on all terms. The 2-bit case is when + ** the all terms are of the form "table1.column=table2.column". It + ** might be possible to form an IN operator with either table1.column + ** or table2.column as the LHS if either is common to every term of + ** the OR clause. + ** + ** Note that terms of the form "table.column1=table.column2" (the + ** same table on both sizes of the ==) cannot be optimized. + */ + if( chngToIN ){ + int okToChngToIN = 0; /* True if the conversion to IN is valid */ + int iColumn = -1; /* Column index on lhs of IN operator */ + int iCursor = -1; /* Table cursor common to all terms */ + int j = 0; /* Loop counter */ + + /* Search for a table and column that appears on one side or the + ** other of the == operator in every subterm. That table and column + ** will be recorded in iCursor and iColumn. There might not be any + ** such table and column. Set okToChngToIN if an appropriate table + ** and column is found but leave okToChngToIN false if not found. + */ + for(j=0; j<2 && !okToChngToIN; j++){ + Expr *pLeft = 0; + pOrTerm = pOrWc->a; + for(i=pOrWc->nTerm-1; i>=0; i--, pOrTerm++){ + assert( pOrTerm->eOperator & WO_EQ ); + pOrTerm->wtFlags &= ~TERM_OR_OK; + if( pOrTerm->leftCursor==iCursor ){ + /* This is the 2-bit case and we are on the second iteration and + ** current term is from the first iteration. So skip this term. */ + assert( j==1 ); + continue; + } + if( (chngToIN & sqlite3WhereGetMask(&pWInfo->sMaskSet, + pOrTerm->leftCursor))==0 ){ + /* This term must be of the form t1.a==t2.b where t2 is in the + ** chngToIN set but t1 is not. This term will be either preceded + ** or follwed by an inverted copy (t2.b==t1.a). Skip this term + ** and use its inversion. */ + testcase( pOrTerm->wtFlags & TERM_COPIED ); + testcase( pOrTerm->wtFlags & TERM_VIRTUAL ); + assert( pOrTerm->wtFlags & (TERM_COPIED|TERM_VIRTUAL) ); + continue; + } + iColumn = pOrTerm->u.x.leftColumn; + iCursor = pOrTerm->leftCursor; + pLeft = pOrTerm->pExpr->pLeft; + break; + } + if( i<0 ){ + /* No candidate table+column was found. This can only occur + ** on the second iteration */ + assert( j==1 ); + assert( IsPowerOfTwo(chngToIN) ); + assert( chngToIN==sqlite3WhereGetMask(&pWInfo->sMaskSet, iCursor) ); + break; + } + testcase( j==1 ); + + /* We have found a candidate table and column. Check to see if that + ** table and column is common to every term in the OR clause */ + okToChngToIN = 1; + for(; i>=0 && okToChngToIN; i--, pOrTerm++){ + assert( pOrTerm->eOperator & WO_EQ ); + if( pOrTerm->leftCursor!=iCursor ){ + pOrTerm->wtFlags &= ~TERM_OR_OK; + }else if( pOrTerm->u.x.leftColumn!=iColumn || (iColumn==XN_EXPR + && sqlite3ExprCompare(pParse, pOrTerm->pExpr->pLeft, pLeft, -1) + )){ + okToChngToIN = 0; + }else{ + int affLeft, affRight; + /* If the right-hand side is also a column, then the affinities + ** of both right and left sides must be such that no type + ** conversions are required on the right. (Ticket #2249) + */ + affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight); + affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft); + if( affRight!=0 && affRight!=affLeft ){ + okToChngToIN = 0; + }else{ + pOrTerm->wtFlags |= TERM_OR_OK; + } + } + } + } + + /* At this point, okToChngToIN is true if original pTerm satisfies + ** case 1. In that case, construct a new virtual term that is + ** pTerm converted into an IN operator. + */ + if( okToChngToIN ){ + Expr *pDup; /* A transient duplicate expression */ + ExprList *pList = 0; /* The RHS of the IN operator */ + Expr *pLeft = 0; /* The LHS of the IN operator */ + Expr *pNew; /* The complete IN operator */ + + for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0; i--, pOrTerm++){ + if( (pOrTerm->wtFlags & TERM_OR_OK)==0 ) continue; + assert( pOrTerm->eOperator & WO_EQ ); + assert( pOrTerm->leftCursor==iCursor ); + assert( pOrTerm->u.x.leftColumn==iColumn ); + pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0); + pList = sqlite3ExprListAppend(pWInfo->pParse, pList, pDup); + pLeft = pOrTerm->pExpr->pLeft; + } + assert( pLeft!=0 ); + pDup = sqlite3ExprDup(db, pLeft, 0); + pNew = sqlite3PExpr(pParse, TK_IN, pDup, 0); + if( pNew ){ + int idxNew; + transferJoinMarkings(pNew, pExpr); + assert( !ExprHasProperty(pNew, EP_xIsSelect) ); + pNew->x.pList = pList; + idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC); + testcase( idxNew==0 ); + exprAnalyze(pSrc, pWC, idxNew); + /* pTerm = &pWC->a[idxTerm]; // would be needed if pTerm where used again */ + markTermAsChild(pWC, idxNew, idxTerm); + }else{ + sqlite3ExprListDelete(db, pList); + } + } + } +} +#endif /* !SQLITE_OMIT_OR_OPTIMIZATION && !SQLITE_OMIT_SUBQUERY */ + +/* +** We already know that pExpr is a binary operator where both operands are +** column references. This routine checks to see if pExpr is an equivalence +** relation: +** 1. The SQLITE_Transitive optimization must be enabled +** 2. Must be either an == or an IS operator +** 3. Not originating in the ON clause of an OUTER JOIN +** 4. The affinities of A and B must be compatible +** 5a. Both operands use the same collating sequence OR +** 5b. The overall collating sequence is BINARY +** If this routine returns TRUE, that means that the RHS can be substituted +** for the LHS anyplace else in the WHERE clause where the LHS column occurs. +** This is an optimization. No harm comes from returning 0. But if 1 is +** returned when it should not be, then incorrect answers might result. +*/ +static int termIsEquivalence(Parse *pParse, Expr *pExpr){ + char aff1, aff2; + CollSeq *pColl; + if( !OptimizationEnabled(pParse->db, SQLITE_Transitive) ) return 0; + if( pExpr->op!=TK_EQ && pExpr->op!=TK_IS ) return 0; + if( ExprHasProperty(pExpr, EP_FromJoin) ) return 0; + aff1 = sqlite3ExprAffinity(pExpr->pLeft); + aff2 = sqlite3ExprAffinity(pExpr->pRight); + if( aff1!=aff2 + && (!sqlite3IsNumericAffinity(aff1) || !sqlite3IsNumericAffinity(aff2)) + ){ + return 0; + } + pColl = sqlite3ExprCompareCollSeq(pParse, pExpr); + if( sqlite3IsBinary(pColl) ) return 1; + return sqlite3ExprCollSeqMatch(pParse, pExpr->pLeft, pExpr->pRight); +} + +/* +** Recursively walk the expressions of a SELECT statement and generate +** a bitmask indicating which tables are used in that expression +** tree. +*/ +static Bitmask exprSelectUsage(WhereMaskSet *pMaskSet, Select *pS){ + Bitmask mask = 0; + while( pS ){ + SrcList *pSrc = pS->pSrc; + mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pEList); + mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pGroupBy); + mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pOrderBy); + mask |= sqlite3WhereExprUsage(pMaskSet, pS->pWhere); + mask |= sqlite3WhereExprUsage(pMaskSet, pS->pHaving); + if( ALWAYS(pSrc!=0) ){ + int i; + for(i=0; inSrc; i++){ + mask |= exprSelectUsage(pMaskSet, pSrc->a[i].pSelect); + mask |= sqlite3WhereExprUsage(pMaskSet, pSrc->a[i].pOn); + if( pSrc->a[i].fg.isTabFunc ){ + mask |= sqlite3WhereExprListUsage(pMaskSet, pSrc->a[i].u1.pFuncArg); + } + } + } + pS = pS->pPrior; + } + return mask; +} + +/* +** Expression pExpr is one operand of a comparison operator that might +** be useful for indexing. This routine checks to see if pExpr appears +** in any index. Return TRUE (1) if pExpr is an indexed term and return +** FALSE (0) if not. If TRUE is returned, also set aiCurCol[0] to the cursor +** number of the table that is indexed and aiCurCol[1] to the column number +** of the column that is indexed, or XN_EXPR (-2) if an expression is being +** indexed. +** +** If pExpr is a TK_COLUMN column reference, then this routine always returns +** true even if that particular column is not indexed, because the column +** might be added to an automatic index later. +*/ +static SQLITE_NOINLINE int exprMightBeIndexed2( + SrcList *pFrom, /* The FROM clause */ + Bitmask mPrereq, /* Bitmask of FROM clause terms referenced by pExpr */ + int *aiCurCol, /* Write the referenced table cursor and column here */ + Expr *pExpr /* An operand of a comparison operator */ +){ + Index *pIdx; + int i; + int iCur; + for(i=0; mPrereq>1; i++, mPrereq>>=1){} + iCur = pFrom->a[i].iCursor; + for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + if( pIdx->aColExpr==0 ) continue; + for(i=0; inKeyCol; i++){ + if( pIdx->aiColumn[i]!=XN_EXPR ) continue; + if( sqlite3ExprCompareSkip(pExpr, pIdx->aColExpr->a[i].pExpr, iCur)==0 ){ + aiCurCol[0] = iCur; + aiCurCol[1] = XN_EXPR; + return 1; + } + } + } + return 0; +} +static int exprMightBeIndexed( + SrcList *pFrom, /* The FROM clause */ + Bitmask mPrereq, /* Bitmask of FROM clause terms referenced by pExpr */ + int *aiCurCol, /* Write the referenced table cursor & column here */ + Expr *pExpr, /* An operand of a comparison operator */ + int op /* The specific comparison operator */ +){ + /* If this expression is a vector to the left or right of a + ** inequality constraint (>, <, >= or <=), perform the processing + ** on the first element of the vector. */ + assert( TK_GT+1==TK_LE && TK_GT+2==TK_LT && TK_GT+3==TK_GE ); + assert( TK_ISop==TK_VECTOR && (op>=TK_GT && ALWAYS(op<=TK_GE)) ){ + pExpr = pExpr->x.pList->a[0].pExpr; + } + + if( pExpr->op==TK_COLUMN ){ + aiCurCol[0] = pExpr->iTable; + aiCurCol[1] = pExpr->iColumn; + return 1; + } + if( mPrereq==0 ) return 0; /* No table references */ + if( (mPrereq&(mPrereq-1))!=0 ) return 0; /* Refs more than one table */ + return exprMightBeIndexed2(pFrom,mPrereq,aiCurCol,pExpr); +} + +/* +** The input to this routine is an WhereTerm structure with only the +** "pExpr" field filled in. The job of this routine is to analyze the +** subexpression and populate all the other fields of the WhereTerm +** structure. +** +** If the expression is of the form " X" it gets commuted +** to the standard form of "X ". +** +** If the expression is of the form "X Y" where both X and Y are +** columns, then the original expression is unchanged and a new virtual +** term of the form "Y X" is added to the WHERE clause and +** analyzed separately. The original term is marked with TERM_COPIED +** and the new term is marked with TERM_DYNAMIC (because it's pExpr +** needs to be freed with the WhereClause) and TERM_VIRTUAL (because it +** is a commuted copy of a prior term.) The original term has nChild=1 +** and the copy has idxParent set to the index of the original term. +*/ +static void exprAnalyze( + SrcList *pSrc, /* the FROM clause */ + WhereClause *pWC, /* the WHERE clause */ + int idxTerm /* Index of the term to be analyzed */ +){ + WhereInfo *pWInfo = pWC->pWInfo; /* WHERE clause processing context */ + WhereTerm *pTerm; /* The term to be analyzed */ + WhereMaskSet *pMaskSet; /* Set of table index masks */ + Expr *pExpr; /* The expression to be analyzed */ + Bitmask prereqLeft; /* Prerequesites of the pExpr->pLeft */ + Bitmask prereqAll; /* Prerequesites of pExpr */ + Bitmask extraRight = 0; /* Extra dependencies on LEFT JOIN */ + Expr *pStr1 = 0; /* RHS of LIKE/GLOB operator */ + int isComplete = 0; /* RHS of LIKE/GLOB ends with wildcard */ + int noCase = 0; /* uppercase equivalent to lowercase */ + int op; /* Top-level operator. pExpr->op */ + Parse *pParse = pWInfo->pParse; /* Parsing context */ + sqlite3 *db = pParse->db; /* Database connection */ + unsigned char eOp2 = 0; /* op2 value for LIKE/REGEXP/GLOB */ + int nLeft; /* Number of elements on left side vector */ + + if( db->mallocFailed ){ + return; + } + pTerm = &pWC->a[idxTerm]; + pMaskSet = &pWInfo->sMaskSet; + pExpr = pTerm->pExpr; + assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE ); + prereqLeft = sqlite3WhereExprUsage(pMaskSet, pExpr->pLeft); + op = pExpr->op; + if( op==TK_IN ){ + assert( pExpr->pRight==0 ); + if( sqlite3ExprCheckIN(pParse, pExpr) ) return; + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect); + }else{ + pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList); + } + }else if( op==TK_ISNULL ){ + pTerm->prereqRight = 0; + }else{ + pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight); + } + pMaskSet->bVarSelect = 0; + prereqAll = sqlite3WhereExprUsageNN(pMaskSet, pExpr); + if( pMaskSet->bVarSelect ) pTerm->wtFlags |= TERM_VARSELECT; + if( ExprHasProperty(pExpr, EP_FromJoin) ){ + Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->iRightJoinTable); + prereqAll |= x; + extraRight = x-1; /* ON clause terms may not be used with an index + ** on left table of a LEFT JOIN. Ticket #3015 */ + if( (prereqAll>>1)>=x ){ + sqlite3ErrorMsg(pParse, "ON clause references tables to its right"); + return; + } + } + pTerm->prereqAll = prereqAll; + pTerm->leftCursor = -1; + pTerm->iParent = -1; + pTerm->eOperator = 0; + if( allowedOp(op) ){ + int aiCurCol[2]; + Expr *pLeft = sqlite3ExprSkipCollate(pExpr->pLeft); + Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight); + u16 opMask = (pTerm->prereqRight & prereqLeft)==0 ? WO_ALL : WO_EQUIV; + + if( pTerm->u.x.iField>0 ){ + assert( op==TK_IN ); + assert( pLeft->op==TK_VECTOR ); + pLeft = pLeft->x.pList->a[pTerm->u.x.iField-1].pExpr; + } + + if( exprMightBeIndexed(pSrc, prereqLeft, aiCurCol, pLeft, op) ){ + pTerm->leftCursor = aiCurCol[0]; + pTerm->u.x.leftColumn = aiCurCol[1]; + pTerm->eOperator = operatorMask(op) & opMask; + } + if( op==TK_IS ) pTerm->wtFlags |= TERM_IS; + if( pRight + && exprMightBeIndexed(pSrc, pTerm->prereqRight, aiCurCol, pRight, op) + ){ + WhereTerm *pNew; + Expr *pDup; + u16 eExtraOp = 0; /* Extra bits for pNew->eOperator */ + assert( pTerm->u.x.iField==0 ); + if( pTerm->leftCursor>=0 ){ + int idxNew; + pDup = sqlite3ExprDup(db, pExpr, 0); + if( db->mallocFailed ){ + sqlite3ExprDelete(db, pDup); + return; + } + idxNew = whereClauseInsert(pWC, pDup, TERM_VIRTUAL|TERM_DYNAMIC); + if( idxNew==0 ) return; + pNew = &pWC->a[idxNew]; + markTermAsChild(pWC, idxNew, idxTerm); + if( op==TK_IS ) pNew->wtFlags |= TERM_IS; + pTerm = &pWC->a[idxTerm]; + pTerm->wtFlags |= TERM_COPIED; + + if( termIsEquivalence(pParse, pDup) ){ + pTerm->eOperator |= WO_EQUIV; + eExtraOp = WO_EQUIV; + } + }else{ + pDup = pExpr; + pNew = pTerm; + } + pNew->wtFlags |= exprCommute(pParse, pDup); + pNew->leftCursor = aiCurCol[0]; + pNew->u.x.leftColumn = aiCurCol[1]; + testcase( (prereqLeft | extraRight) != prereqLeft ); + pNew->prereqRight = prereqLeft | extraRight; + pNew->prereqAll = prereqAll; + pNew->eOperator = (operatorMask(pDup->op) + eExtraOp) & opMask; + } + } + +#ifndef SQLITE_OMIT_BETWEEN_OPTIMIZATION + /* If a term is the BETWEEN operator, create two new virtual terms + ** that define the range that the BETWEEN implements. For example: + ** + ** a BETWEEN b AND c + ** + ** is converted into: + ** + ** (a BETWEEN b AND c) AND (a>=b) AND (a<=c) + ** + ** The two new terms are added onto the end of the WhereClause object. + ** The new terms are "dynamic" and are children of the original BETWEEN + ** term. That means that if the BETWEEN term is coded, the children are + ** skipped. Or, if the children are satisfied by an index, the original + ** BETWEEN term is skipped. + */ + else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){ + ExprList *pList = pExpr->x.pList; + int i; + static const u8 ops[] = {TK_GE, TK_LE}; + assert( pList!=0 ); + assert( pList->nExpr==2 ); + for(i=0; i<2; i++){ + Expr *pNewExpr; + int idxNew; + pNewExpr = sqlite3PExpr(pParse, ops[i], + sqlite3ExprDup(db, pExpr->pLeft, 0), + sqlite3ExprDup(db, pList->a[i].pExpr, 0)); + transferJoinMarkings(pNewExpr, pExpr); + idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC); + testcase( idxNew==0 ); + exprAnalyze(pSrc, pWC, idxNew); + pTerm = &pWC->a[idxTerm]; + markTermAsChild(pWC, idxNew, idxTerm); + } + } +#endif /* SQLITE_OMIT_BETWEEN_OPTIMIZATION */ + +#if !defined(SQLITE_OMIT_OR_OPTIMIZATION) && !defined(SQLITE_OMIT_SUBQUERY) + /* Analyze a term that is composed of two or more subterms connected by + ** an OR operator. + */ + else if( pExpr->op==TK_OR ){ + assert( pWC->op==TK_AND ); + exprAnalyzeOrTerm(pSrc, pWC, idxTerm); + pTerm = &pWC->a[idxTerm]; + } +#endif /* SQLITE_OMIT_OR_OPTIMIZATION */ + +#ifndef SQLITE_OMIT_LIKE_OPTIMIZATION + /* Add constraints to reduce the search space on a LIKE or GLOB + ** operator. + ** + ** A like pattern of the form "x LIKE 'aBc%'" is changed into constraints + ** + ** x>='ABC' AND x<'abd' AND x LIKE 'aBc%' + ** + ** The last character of the prefix "abc" is incremented to form the + ** termination condition "abd". If case is not significant (the default + ** for LIKE) then the lower-bound is made all uppercase and the upper- + ** bound is made all lowercase so that the bounds also work when comparing + ** BLOBs. + */ + if( pWC->op==TK_AND + && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase) + ){ + Expr *pLeft; /* LHS of LIKE/GLOB operator */ + Expr *pStr2; /* Copy of pStr1 - RHS of LIKE/GLOB operator */ + Expr *pNewExpr1; + Expr *pNewExpr2; + int idxNew1; + int idxNew2; + const char *zCollSeqName; /* Name of collating sequence */ + const u16 wtFlags = TERM_LIKEOPT | TERM_VIRTUAL | TERM_DYNAMIC; + + pLeft = pExpr->x.pList->a[1].pExpr; + pStr2 = sqlite3ExprDup(db, pStr1, 0); + + /* Convert the lower bound to upper-case and the upper bound to + ** lower-case (upper-case is less than lower-case in ASCII) so that + ** the range constraints also work for BLOBs + */ + if( noCase && !pParse->db->mallocFailed ){ + int i; + char c; + pTerm->wtFlags |= TERM_LIKE; + for(i=0; (c = pStr1->u.zToken[i])!=0; i++){ + pStr1->u.zToken[i] = sqlite3Toupper(c); + pStr2->u.zToken[i] = sqlite3Tolower(c); + } + } + + if( !db->mallocFailed ){ + u8 c, *pC; /* Last character before the first wildcard */ + pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1]; + c = *pC; + if( noCase ){ + /* The point is to increment the last character before the first + ** wildcard. But if we increment '@', that will push it into the + ** alphabetic range where case conversions will mess up the + ** inequality. To avoid this, make sure to also run the full + ** LIKE on all candidate expressions by clearing the isComplete flag + */ + if( c=='A'-1 ) isComplete = 0; + c = sqlite3UpperToLower[c]; + } + *pC = c + 1; + } + zCollSeqName = noCase ? "NOCASE" : sqlite3StrBINARY; + pNewExpr1 = sqlite3ExprDup(db, pLeft, 0); + pNewExpr1 = sqlite3PExpr(pParse, TK_GE, + sqlite3ExprAddCollateString(pParse,pNewExpr1,zCollSeqName), + pStr1); + transferJoinMarkings(pNewExpr1, pExpr); + idxNew1 = whereClauseInsert(pWC, pNewExpr1, wtFlags); + testcase( idxNew1==0 ); + exprAnalyze(pSrc, pWC, idxNew1); + pNewExpr2 = sqlite3ExprDup(db, pLeft, 0); + pNewExpr2 = sqlite3PExpr(pParse, TK_LT, + sqlite3ExprAddCollateString(pParse,pNewExpr2,zCollSeqName), + pStr2); + transferJoinMarkings(pNewExpr2, pExpr); + idxNew2 = whereClauseInsert(pWC, pNewExpr2, wtFlags); + testcase( idxNew2==0 ); + exprAnalyze(pSrc, pWC, idxNew2); + pTerm = &pWC->a[idxTerm]; + if( isComplete ){ + markTermAsChild(pWC, idxNew1, idxTerm); + markTermAsChild(pWC, idxNew2, idxTerm); + } + } +#endif /* SQLITE_OMIT_LIKE_OPTIMIZATION */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* Add a WO_AUX auxiliary term to the constraint set if the + ** current expression is of the form "column OP expr" where OP + ** is an operator that gets passed into virtual tables but which is + ** not normally optimized for ordinary tables. In other words, OP + ** is one of MATCH, LIKE, GLOB, REGEXP, !=, IS, IS NOT, or NOT NULL. + ** This information is used by the xBestIndex methods of + ** virtual tables. The native query optimizer does not attempt + ** to do anything with MATCH functions. + */ + if( pWC->op==TK_AND ){ + Expr *pRight = 0, *pLeft = 0; + int res = isAuxiliaryVtabOperator(db, pExpr, &eOp2, &pLeft, &pRight); + while( res-- > 0 ){ + int idxNew; + WhereTerm *pNewTerm; + Bitmask prereqColumn, prereqExpr; + + prereqExpr = sqlite3WhereExprUsage(pMaskSet, pRight); + prereqColumn = sqlite3WhereExprUsage(pMaskSet, pLeft); + if( (prereqExpr & prereqColumn)==0 ){ + Expr *pNewExpr; + pNewExpr = sqlite3PExpr(pParse, TK_MATCH, + 0, sqlite3ExprDup(db, pRight, 0)); + if( ExprHasProperty(pExpr, EP_FromJoin) && pNewExpr ){ + ExprSetProperty(pNewExpr, EP_FromJoin); + pNewExpr->iRightJoinTable = pExpr->iRightJoinTable; + } + idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC); + testcase( idxNew==0 ); + pNewTerm = &pWC->a[idxNew]; + pNewTerm->prereqRight = prereqExpr; + pNewTerm->leftCursor = pLeft->iTable; + pNewTerm->u.x.leftColumn = pLeft->iColumn; + pNewTerm->eOperator = WO_AUX; + pNewTerm->eMatchOp = eOp2; + markTermAsChild(pWC, idxNew, idxTerm); + pTerm = &pWC->a[idxTerm]; + pTerm->wtFlags |= TERM_COPIED; + pNewTerm->prereqAll = pTerm->prereqAll; + } + SWAP(Expr*, pLeft, pRight); + } + } +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + + /* If there is a vector == or IS term - e.g. "(a, b) == (?, ?)" - create + ** new terms for each component comparison - "a = ?" and "b = ?". The + ** new terms completely replace the original vector comparison, which is + ** no longer used. + ** + ** This is only required if at least one side of the comparison operation + ** is not a sub-select. */ + if( pWC->op==TK_AND + && (pExpr->op==TK_EQ || pExpr->op==TK_IS) + && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1 + && sqlite3ExprVectorSize(pExpr->pRight)==nLeft + && ( (pExpr->pLeft->flags & EP_xIsSelect)==0 + || (pExpr->pRight->flags & EP_xIsSelect)==0) + ){ + int i; + for(i=0; ipLeft, i); + Expr *pRight = sqlite3ExprForVectorField(pParse, pExpr->pRight, i); + + pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight); + transferJoinMarkings(pNew, pExpr); + idxNew = whereClauseInsert(pWC, pNew, TERM_DYNAMIC); + exprAnalyze(pSrc, pWC, idxNew); + } + pTerm = &pWC->a[idxTerm]; + pTerm->wtFlags |= TERM_CODED|TERM_VIRTUAL; /* Disable the original */ + pTerm->eOperator = 0; + } + + /* If there is a vector IN term - e.g. "(a, b) IN (SELECT ...)" - create + ** a virtual term for each vector component. The expression object + ** used by each such virtual term is pExpr (the full vector IN(...) + ** expression). The WhereTerm.u.x.iField variable identifies the index within + ** the vector on the LHS that the virtual term represents. + ** + ** This only works if the RHS is a simple SELECT (not a compound) that does + ** not use window functions. + */ + if( pWC->op==TK_AND && pExpr->op==TK_IN && pTerm->u.x.iField==0 + && pExpr->pLeft->op==TK_VECTOR + && pExpr->x.pSelect->pPrior==0 +#ifndef SQLITE_OMIT_WINDOWFUNC + && pExpr->x.pSelect->pWin==0 +#endif + ){ + int i; + for(i=0; ipLeft); i++){ + int idxNew; + idxNew = whereClauseInsert(pWC, pExpr, TERM_VIRTUAL); + pWC->a[idxNew].u.x.iField = i+1; + exprAnalyze(pSrc, pWC, idxNew); + markTermAsChild(pWC, idxNew, idxTerm); + } + } + +#ifdef SQLITE_ENABLE_STAT4 + /* When sqlite_stat4 histogram data is available an operator of the + ** form "x IS NOT NULL" can sometimes be evaluated more efficiently + ** as "x>NULL" if x is not an INTEGER PRIMARY KEY. So construct a + ** virtual term of that form. + ** + ** Note that the virtual term must be tagged with TERM_VNULL. + */ + if( pExpr->op==TK_NOTNULL + && pExpr->pLeft->op==TK_COLUMN + && pExpr->pLeft->iColumn>=0 + && !ExprHasProperty(pExpr, EP_FromJoin) + && OptimizationEnabled(db, SQLITE_Stat4) + ){ + Expr *pNewExpr; + Expr *pLeft = pExpr->pLeft; + int idxNew; + WhereTerm *pNewTerm; + + pNewExpr = sqlite3PExpr(pParse, TK_GT, + sqlite3ExprDup(db, pLeft, 0), + sqlite3ExprAlloc(db, TK_NULL, 0, 0)); + + idxNew = whereClauseInsert(pWC, pNewExpr, + TERM_VIRTUAL|TERM_DYNAMIC|TERM_VNULL); + if( idxNew ){ + pNewTerm = &pWC->a[idxNew]; + pNewTerm->prereqRight = 0; + pNewTerm->leftCursor = pLeft->iTable; + pNewTerm->u.x.leftColumn = pLeft->iColumn; + pNewTerm->eOperator = WO_GT; + markTermAsChild(pWC, idxNew, idxTerm); + pTerm = &pWC->a[idxTerm]; + pTerm->wtFlags |= TERM_COPIED; + pNewTerm->prereqAll = pTerm->prereqAll; + } + } +#endif /* SQLITE_ENABLE_STAT4 */ + + /* Prevent ON clause terms of a LEFT JOIN from being used to drive + ** an index for tables to the left of the join. + */ + testcase( pTerm!=&pWC->a[idxTerm] ); + pTerm = &pWC->a[idxTerm]; + pTerm->prereqRight |= extraRight; +} + +/*************************************************************************** +** Routines with file scope above. Interface to the rest of the where.c +** subsystem follows. +***************************************************************************/ + +/* +** This routine identifies subexpressions in the WHERE clause where +** each subexpression is separated by the AND operator or some other +** operator specified in the op parameter. The WhereClause structure +** is filled with pointers to subexpressions. For example: +** +** WHERE a=='hello' AND coalesce(b,11)<10 AND (c+12!=d OR c==22) +** \________/ \_______________/ \________________/ +** slot[0] slot[1] slot[2] +** +** The original WHERE clause in pExpr is unaltered. All this routine +** does is make slot[] entries point to substructure within pExpr. +** +** In the previous sentence and in the diagram, "slot[]" refers to +** the WhereClause.a[] array. The slot[] array grows as needed to contain +** all terms of the WHERE clause. +*/ +SQLITE_PRIVATE void sqlite3WhereSplit(WhereClause *pWC, Expr *pExpr, u8 op){ + Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pExpr); + pWC->op = op; + assert( pE2!=0 || pExpr==0 ); + if( pE2==0 ) return; + if( pE2->op!=op ){ + whereClauseInsert(pWC, pExpr, 0); + }else{ + sqlite3WhereSplit(pWC, pE2->pLeft, op); + sqlite3WhereSplit(pWC, pE2->pRight, op); + } +} + +/* +** Initialize a preallocated WhereClause structure. +*/ +SQLITE_PRIVATE void sqlite3WhereClauseInit( + WhereClause *pWC, /* The WhereClause to be initialized */ + WhereInfo *pWInfo /* The WHERE processing context */ +){ + pWC->pWInfo = pWInfo; + pWC->hasOr = 0; + pWC->pOuter = 0; + pWC->nTerm = 0; + pWC->nSlot = ArraySize(pWC->aStatic); + pWC->a = pWC->aStatic; +} + +/* +** Deallocate a WhereClause structure. The WhereClause structure +** itself is not freed. This routine is the inverse of +** sqlite3WhereClauseInit(). +*/ +SQLITE_PRIVATE void sqlite3WhereClauseClear(WhereClause *pWC){ + int i; + WhereTerm *a; + sqlite3 *db = pWC->pWInfo->pParse->db; + for(i=pWC->nTerm-1, a=pWC->a; i>=0; i--, a++){ + if( a->wtFlags & TERM_DYNAMIC ){ + sqlite3ExprDelete(db, a->pExpr); + } + if( a->wtFlags & TERM_ORINFO ){ + whereOrInfoDelete(db, a->u.pOrInfo); + }else if( a->wtFlags & TERM_ANDINFO ){ + whereAndInfoDelete(db, a->u.pAndInfo); + } + } + if( pWC->a!=pWC->aStatic ){ + sqlite3DbFree(db, pWC->a); + } +} + + +/* +** These routines walk (recursively) an expression tree and generate +** a bitmask indicating which tables are used in that expression +** tree. +*/ +SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN(WhereMaskSet *pMaskSet, Expr *p){ + Bitmask mask; + if( p->op==TK_COLUMN && !ExprHasProperty(p, EP_FixedCol) ){ + return sqlite3WhereGetMask(pMaskSet, p->iTable); + }else if( ExprHasProperty(p, EP_TokenOnly|EP_Leaf) ){ + assert( p->op!=TK_IF_NULL_ROW ); + return 0; + } + mask = (p->op==TK_IF_NULL_ROW) ? sqlite3WhereGetMask(pMaskSet, p->iTable) : 0; + if( p->pLeft ) mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pLeft); + if( p->pRight ){ + mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pRight); + assert( p->x.pList==0 ); + }else if( ExprHasProperty(p, EP_xIsSelect) ){ + if( ExprHasProperty(p, EP_VarSelect) ) pMaskSet->bVarSelect = 1; + mask |= exprSelectUsage(pMaskSet, p->x.pSelect); + }else if( p->x.pList ){ + mask |= sqlite3WhereExprListUsage(pMaskSet, p->x.pList); + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( (p->op==TK_FUNCTION || p->op==TK_AGG_FUNCTION) && p->y.pWin ){ + mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pPartition); + mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pOrderBy); + mask |= sqlite3WhereExprUsage(pMaskSet, p->y.pWin->pFilter); + } +#endif + return mask; +} +SQLITE_PRIVATE Bitmask sqlite3WhereExprUsage(WhereMaskSet *pMaskSet, Expr *p){ + return p ? sqlite3WhereExprUsageNN(pMaskSet,p) : 0; +} +SQLITE_PRIVATE Bitmask sqlite3WhereExprListUsage(WhereMaskSet *pMaskSet, ExprList *pList){ + int i; + Bitmask mask = 0; + if( pList ){ + for(i=0; inExpr; i++){ + mask |= sqlite3WhereExprUsage(pMaskSet, pList->a[i].pExpr); + } + } + return mask; +} + + +/* +** Call exprAnalyze on all terms in a WHERE clause. +** +** Note that exprAnalyze() might add new virtual terms onto the +** end of the WHERE clause. We do not want to analyze these new +** virtual terms, so start analyzing at the end and work forward +** so that the added virtual terms are never processed. +*/ +SQLITE_PRIVATE void sqlite3WhereExprAnalyze( + SrcList *pTabList, /* the FROM clause */ + WhereClause *pWC /* the WHERE clause to be analyzed */ +){ + int i; + for(i=pWC->nTerm-1; i>=0; i--){ + exprAnalyze(pTabList, pWC, i); + } +} + +/* +** For table-valued-functions, transform the function arguments into +** new WHERE clause terms. +** +** Each function argument translates into an equality constraint against +** a HIDDEN column in the table. +*/ +SQLITE_PRIVATE void sqlite3WhereTabFuncArgs( + Parse *pParse, /* Parsing context */ + struct SrcList_item *pItem, /* The FROM clause term to process */ + WhereClause *pWC /* Xfer function arguments to here */ +){ + Table *pTab; + int j, k; + ExprList *pArgs; + Expr *pColRef; + Expr *pTerm; + if( pItem->fg.isTabFunc==0 ) return; + pTab = pItem->pTab; + assert( pTab!=0 ); + pArgs = pItem->u1.pFuncArg; + if( pArgs==0 ) return; + for(j=k=0; jnExpr; j++){ + Expr *pRhs; + while( knCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){k++;} + if( k>=pTab->nCol ){ + sqlite3ErrorMsg(pParse, "too many arguments on %s() - max %d", + pTab->zName, j); + return; + } + pColRef = sqlite3ExprAlloc(pParse->db, TK_COLUMN, 0, 0); + if( pColRef==0 ) return; + pColRef->iTable = pItem->iCursor; + pColRef->iColumn = k++; + pColRef->y.pTab = pTab; + pRhs = sqlite3PExpr(pParse, TK_UPLUS, + sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0); + pTerm = sqlite3PExpr(pParse, TK_EQ, pColRef, pRhs); + if( pItem->fg.jointype & JT_LEFT ){ + sqlite3SetJoinExpr(pTerm, pItem->iCursor); + } + whereClauseInsert(pWC, pTerm, TERM_DYNAMIC); + } +} + +/************** End of whereexpr.c *******************************************/ +/************** Begin file where.c *******************************************/ +/* +** 2001 September 15 +** +** 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 module contains C code that generates VDBE code used to process +** the WHERE clause of SQL statements. This module is responsible for +** generating the code that loops through a table looking for applicable +** rows. Indices are selected and used to speed the search when doing +** so is applicable. Because this module is responsible for selecting +** indices, you might also think of this module as the "query optimizer". +*/ +/* #include "sqliteInt.h" */ +/* #include "whereInt.h" */ + +/* +** Extra information appended to the end of sqlite3_index_info but not +** visible to the xBestIndex function, at least not directly. The +** sqlite3_vtab_collation() interface knows how to reach it, however. +** +** This object is not an API and can be changed from one release to the +** next. As long as allocateIndexInfo() and sqlite3_vtab_collation() +** agree on the structure, all will be well. +*/ +typedef struct HiddenIndexInfo HiddenIndexInfo; +struct HiddenIndexInfo { + WhereClause *pWC; /* The Where clause being analyzed */ + Parse *pParse; /* The parsing context */ +}; + +/* Forward declaration of methods */ +static int whereLoopResize(sqlite3*, WhereLoop*, int); + +/* Test variable that can be set to enable WHERE tracing */ +#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG) +/***/ int sqlite3WhereTrace = 0; +#endif + + +/* +** Return the estimated number of output rows from a WHERE clause +*/ +SQLITE_PRIVATE LogEst sqlite3WhereOutputRowCount(WhereInfo *pWInfo){ + return pWInfo->nRowOut; +} + +/* +** Return one of the WHERE_DISTINCT_xxxxx values to indicate how this +** WHERE clause returns outputs for DISTINCT processing. +*/ +SQLITE_PRIVATE int sqlite3WhereIsDistinct(WhereInfo *pWInfo){ + return pWInfo->eDistinct; +} + +/* +** Return the number of ORDER BY terms that are satisfied by the +** WHERE clause. A return of 0 means that the output must be +** completely sorted. A return equal to the number of ORDER BY +** terms means that no sorting is needed at all. A return that +** is positive but less than the number of ORDER BY terms means that +** block sorting is required. +*/ +SQLITE_PRIVATE int sqlite3WhereIsOrdered(WhereInfo *pWInfo){ + return pWInfo->nOBSat; +} + +/* +** In the ORDER BY LIMIT optimization, if the inner-most loop is known +** to emit rows in increasing order, and if the last row emitted by the +** inner-most loop did not fit within the sorter, then we can skip all +** subsequent rows for the current iteration of the inner loop (because they +** will not fit in the sorter either) and continue with the second inner +** loop - the loop immediately outside the inner-most. +** +** When a row does not fit in the sorter (because the sorter already +** holds LIMIT+OFFSET rows that are smaller), then a jump is made to the +** label returned by this function. +** +** If the ORDER BY LIMIT optimization applies, the jump destination should +** be the continuation for the second-inner-most loop. If the ORDER BY +** LIMIT optimization does not apply, then the jump destination should +** be the continuation for the inner-most loop. +** +** It is always safe for this routine to return the continuation of the +** inner-most loop, in the sense that a correct answer will result. +** Returning the continuation the second inner loop is an optimization +** that might make the code run a little faster, but should not change +** the final answer. +*/ +SQLITE_PRIVATE int sqlite3WhereOrderByLimitOptLabel(WhereInfo *pWInfo){ + WhereLevel *pInner; + if( !pWInfo->bOrderedInnerLoop ){ + /* The ORDER BY LIMIT optimization does not apply. Jump to the + ** continuation of the inner-most loop. */ + return pWInfo->iContinue; + } + pInner = &pWInfo->a[pWInfo->nLevel-1]; + assert( pInner->addrNxt!=0 ); + return pInner->addrNxt; +} + +/* +** Return the VDBE address or label to jump to in order to continue +** immediately with the next row of a WHERE clause. +*/ +SQLITE_PRIVATE int sqlite3WhereContinueLabel(WhereInfo *pWInfo){ + assert( pWInfo->iContinue!=0 ); + return pWInfo->iContinue; +} + +/* +** Return the VDBE address or label to jump to in order to break +** out of a WHERE loop. +*/ +SQLITE_PRIVATE int sqlite3WhereBreakLabel(WhereInfo *pWInfo){ + return pWInfo->iBreak; +} + +/* +** Return ONEPASS_OFF (0) if an UPDATE or DELETE statement is unable to +** operate directly on the rowids returned by a WHERE clause. Return +** ONEPASS_SINGLE (1) if the statement can operation directly because only +** a single row is to be changed. Return ONEPASS_MULTI (2) if the one-pass +** optimization can be used on multiple +** +** If the ONEPASS optimization is used (if this routine returns true) +** then also write the indices of open cursors used by ONEPASS +** into aiCur[0] and aiCur[1]. iaCur[0] gets the cursor of the data +** table and iaCur[1] gets the cursor used by an auxiliary index. +** Either value may be -1, indicating that cursor is not used. +** Any cursors returned will have been opened for writing. +** +** aiCur[0] and aiCur[1] both get -1 if the where-clause logic is +** unable to use the ONEPASS optimization. +*/ +SQLITE_PRIVATE int sqlite3WhereOkOnePass(WhereInfo *pWInfo, int *aiCur){ + memcpy(aiCur, pWInfo->aiCurOnePass, sizeof(int)*2); +#ifdef WHERETRACE_ENABLED + if( sqlite3WhereTrace && pWInfo->eOnePass!=ONEPASS_OFF ){ + sqlite3DebugPrintf("%s cursors: %d %d\n", + pWInfo->eOnePass==ONEPASS_SINGLE ? "ONEPASS_SINGLE" : "ONEPASS_MULTI", + aiCur[0], aiCur[1]); + } +#endif + return pWInfo->eOnePass; +} + +/* +** Return TRUE if the WHERE loop uses the OP_DeferredSeek opcode to move +** the data cursor to the row selected by the index cursor. +*/ +SQLITE_PRIVATE int sqlite3WhereUsesDeferredSeek(WhereInfo *pWInfo){ + return pWInfo->bDeferredSeek; +} + +/* +** Move the content of pSrc into pDest +*/ +static void whereOrMove(WhereOrSet *pDest, WhereOrSet *pSrc){ + pDest->n = pSrc->n; + memcpy(pDest->a, pSrc->a, pDest->n*sizeof(pDest->a[0])); +} + +/* +** Try to insert a new prerequisite/cost entry into the WhereOrSet pSet. +** +** The new entry might overwrite an existing entry, or it might be +** appended, or it might be discarded. Do whatever is the right thing +** so that pSet keeps the N_OR_COST best entries seen so far. +*/ +static int whereOrInsert( + WhereOrSet *pSet, /* The WhereOrSet to be updated */ + Bitmask prereq, /* Prerequisites of the new entry */ + LogEst rRun, /* Run-cost of the new entry */ + LogEst nOut /* Number of outputs for the new entry */ +){ + u16 i; + WhereOrCost *p; + for(i=pSet->n, p=pSet->a; i>0; i--, p++){ + if( rRun<=p->rRun && (prereq & p->prereq)==prereq ){ + goto whereOrInsert_done; + } + if( p->rRun<=rRun && (p->prereq & prereq)==p->prereq ){ + return 0; + } + } + if( pSet->na[pSet->n++]; + p->nOut = nOut; + }else{ + p = pSet->a; + for(i=1; in; i++){ + if( p->rRun>pSet->a[i].rRun ) p = pSet->a + i; + } + if( p->rRun<=rRun ) return 0; + } +whereOrInsert_done: + p->prereq = prereq; + p->rRun = rRun; + if( p->nOut>nOut ) p->nOut = nOut; + return 1; +} + +/* +** Return the bitmask for the given cursor number. Return 0 if +** iCursor is not in the set. +*/ +SQLITE_PRIVATE Bitmask sqlite3WhereGetMask(WhereMaskSet *pMaskSet, int iCursor){ + int i; + assert( pMaskSet->n<=(int)sizeof(Bitmask)*8 ); + for(i=0; in; i++){ + if( pMaskSet->ix[i]==iCursor ){ + return MASKBIT(i); + } + } + return 0; +} + +/* +** Create a new mask for cursor iCursor. +** +** There is one cursor per table in the FROM clause. The number of +** tables in the FROM clause is limited by a test early in the +** sqlite3WhereBegin() routine. So we know that the pMaskSet->ix[] +** array will never overflow. +*/ +static void createMask(WhereMaskSet *pMaskSet, int iCursor){ + assert( pMaskSet->n < ArraySize(pMaskSet->ix) ); + pMaskSet->ix[pMaskSet->n++] = iCursor; +} + +/* +** If the right-hand branch of the expression is a TK_COLUMN, then return +** a pointer to the right-hand branch. Otherwise, return NULL. +*/ +static Expr *whereRightSubexprIsColumn(Expr *p){ + p = sqlite3ExprSkipCollateAndLikely(p->pRight); + if( ALWAYS(p!=0) && p->op==TK_COLUMN ) return p; + return 0; +} + +/* +** Advance to the next WhereTerm that matches according to the criteria +** established when the pScan object was initialized by whereScanInit(). +** Return NULL if there are no more matching WhereTerms. +*/ +static WhereTerm *whereScanNext(WhereScan *pScan){ + int iCur; /* The cursor on the LHS of the term */ + i16 iColumn; /* The column on the LHS of the term. -1 for IPK */ + Expr *pX; /* An expression being tested */ + WhereClause *pWC; /* Shorthand for pScan->pWC */ + WhereTerm *pTerm; /* The term being tested */ + int k = pScan->k; /* Where to start scanning */ + + assert( pScan->iEquiv<=pScan->nEquiv ); + pWC = pScan->pWC; + while(1){ + iColumn = pScan->aiColumn[pScan->iEquiv-1]; + iCur = pScan->aiCur[pScan->iEquiv-1]; + assert( pWC!=0 ); + do{ + for(pTerm=pWC->a+k; knTerm; k++, pTerm++){ + if( pTerm->leftCursor==iCur + && pTerm->u.x.leftColumn==iColumn + && (iColumn!=XN_EXPR + || sqlite3ExprCompareSkip(pTerm->pExpr->pLeft, + pScan->pIdxExpr,iCur)==0) + && (pScan->iEquiv<=1 || !ExprHasProperty(pTerm->pExpr, EP_FromJoin)) + ){ + if( (pTerm->eOperator & WO_EQUIV)!=0 + && pScan->nEquivaiCur) + && (pX = whereRightSubexprIsColumn(pTerm->pExpr))!=0 + ){ + int j; + for(j=0; jnEquiv; j++){ + if( pScan->aiCur[j]==pX->iTable + && pScan->aiColumn[j]==pX->iColumn ){ + break; + } + } + if( j==pScan->nEquiv ){ + pScan->aiCur[j] = pX->iTable; + pScan->aiColumn[j] = pX->iColumn; + pScan->nEquiv++; + } + } + if( (pTerm->eOperator & pScan->opMask)!=0 ){ + /* Verify the affinity and collating sequence match */ + if( pScan->zCollName && (pTerm->eOperator & WO_ISNULL)==0 ){ + CollSeq *pColl; + Parse *pParse = pWC->pWInfo->pParse; + pX = pTerm->pExpr; + if( !sqlite3IndexAffinityOk(pX, pScan->idxaff) ){ + continue; + } + assert(pX->pLeft); + pColl = sqlite3ExprCompareCollSeq(pParse, pX); + if( pColl==0 ) pColl = pParse->db->pDfltColl; + if( sqlite3StrICmp(pColl->zName, pScan->zCollName) ){ + continue; + } + } + if( (pTerm->eOperator & (WO_EQ|WO_IS))!=0 + && (pX = pTerm->pExpr->pRight)->op==TK_COLUMN + && pX->iTable==pScan->aiCur[0] + && pX->iColumn==pScan->aiColumn[0] + ){ + testcase( pTerm->eOperator & WO_IS ); + continue; + } + pScan->pWC = pWC; + pScan->k = k+1; + return pTerm; + } + } + } + pWC = pWC->pOuter; + k = 0; + }while( pWC!=0 ); + if( pScan->iEquiv>=pScan->nEquiv ) break; + pWC = pScan->pOrigWC; + k = 0; + pScan->iEquiv++; + } + return 0; +} + +/* +** This is whereScanInit() for the case of an index on an expression. +** It is factored out into a separate tail-recursion subroutine so that +** the normal whereScanInit() routine, which is a high-runner, does not +** need to push registers onto the stack as part of its prologue. +*/ +static SQLITE_NOINLINE WhereTerm *whereScanInitIndexExpr(WhereScan *pScan){ + pScan->idxaff = sqlite3ExprAffinity(pScan->pIdxExpr); + return whereScanNext(pScan); +} + +/* +** Initialize a WHERE clause scanner object. Return a pointer to the +** first match. Return NULL if there are no matches. +** +** The scanner will be searching the WHERE clause pWC. It will look +** for terms of the form "X " where X is column iColumn of table +** iCur. Or if pIdx!=0 then X is column iColumn of index pIdx. pIdx +** must be one of the indexes of table iCur. +** +** The must be one of the operators described by opMask. +** +** If the search is for X and the WHERE clause contains terms of the +** form X=Y then this routine might also return terms of the form +** "Y ". The number of levels of transitivity is limited, +** but is enough to handle most commonly occurring SQL statements. +** +** If X is not the INTEGER PRIMARY KEY then X must be compatible with +** index pIdx. +*/ +static WhereTerm *whereScanInit( + WhereScan *pScan, /* The WhereScan object being initialized */ + WhereClause *pWC, /* The WHERE clause to be scanned */ + int iCur, /* Cursor to scan for */ + int iColumn, /* Column to scan for */ + u32 opMask, /* Operator(s) to scan for */ + Index *pIdx /* Must be compatible with this index */ +){ + pScan->pOrigWC = pWC; + pScan->pWC = pWC; + pScan->pIdxExpr = 0; + pScan->idxaff = 0; + pScan->zCollName = 0; + pScan->opMask = opMask; + pScan->k = 0; + pScan->aiCur[0] = iCur; + pScan->nEquiv = 1; + pScan->iEquiv = 1; + if( pIdx ){ + int j = iColumn; + iColumn = pIdx->aiColumn[j]; + if( iColumn==XN_EXPR ){ + pScan->pIdxExpr = pIdx->aColExpr->a[j].pExpr; + pScan->zCollName = pIdx->azColl[j]; + pScan->aiColumn[0] = XN_EXPR; + return whereScanInitIndexExpr(pScan); + }else if( iColumn==pIdx->pTable->iPKey ){ + iColumn = XN_ROWID; + }else if( iColumn>=0 ){ + pScan->idxaff = pIdx->pTable->aCol[iColumn].affinity; + pScan->zCollName = pIdx->azColl[j]; + } + }else if( iColumn==XN_EXPR ){ + return 0; + } + pScan->aiColumn[0] = iColumn; + return whereScanNext(pScan); +} + +/* +** Search for a term in the WHERE clause that is of the form "X " +** where X is a reference to the iColumn of table iCur or of index pIdx +** if pIdx!=0 and is one of the WO_xx operator codes specified by +** the op parameter. Return a pointer to the term. Return 0 if not found. +** +** If pIdx!=0 then it must be one of the indexes of table iCur. +** Search for terms matching the iColumn-th column of pIdx +** rather than the iColumn-th column of table iCur. +** +** The term returned might by Y= if there is another constraint in +** the WHERE clause that specifies that X=Y. Any such constraints will be +** identified by the WO_EQUIV bit in the pTerm->eOperator field. The +** aiCur[]/iaColumn[] arrays hold X and all its equivalents. There are 11 +** slots in aiCur[]/aiColumn[] so that means we can look for X plus up to 10 +** other equivalent values. Hence a search for X will return if X=A1 +** and A1=A2 and A2=A3 and ... and A9=A10 and A10=. +** +** If there are multiple terms in the WHERE clause of the form "X " +** then try for the one with no dependencies on - in other words where +** is a constant expression of some kind. Only return entries of +** the form "X Y" where Y is a column in another table if no terms of +** the form "X " exist. If no terms with a constant RHS +** exist, try to return a term that does not use WO_EQUIV. +*/ +SQLITE_PRIVATE WhereTerm *sqlite3WhereFindTerm( + WhereClause *pWC, /* The WHERE clause to be searched */ + int iCur, /* Cursor number of LHS */ + int iColumn, /* Column number of LHS */ + Bitmask notReady, /* RHS must not overlap with this mask */ + u32 op, /* Mask of WO_xx values describing operator */ + Index *pIdx /* Must be compatible with this index, if not NULL */ +){ + WhereTerm *pResult = 0; + WhereTerm *p; + WhereScan scan; + + p = whereScanInit(&scan, pWC, iCur, iColumn, op, pIdx); + op &= WO_EQ|WO_IS; + while( p ){ + if( (p->prereqRight & notReady)==0 ){ + if( p->prereqRight==0 && (p->eOperator&op)!=0 ){ + testcase( p->eOperator & WO_IS ); + return p; + } + if( pResult==0 ) pResult = p; + } + p = whereScanNext(&scan); + } + return pResult; +} + +/* +** This function searches pList for an entry that matches the iCol-th column +** of index pIdx. +** +** If such an expression is found, its index in pList->a[] is returned. If +** no expression is found, -1 is returned. +*/ +static int findIndexCol( + Parse *pParse, /* Parse context */ + ExprList *pList, /* Expression list to search */ + int iBase, /* Cursor for table associated with pIdx */ + Index *pIdx, /* Index to match column of */ + int iCol /* Column of index to match */ +){ + int i; + const char *zColl = pIdx->azColl[iCol]; + + for(i=0; inExpr; i++){ + Expr *p = sqlite3ExprSkipCollateAndLikely(pList->a[i].pExpr); + if( ALWAYS(p!=0) + && p->op==TK_COLUMN + && p->iColumn==pIdx->aiColumn[iCol] + && p->iTable==iBase + ){ + CollSeq *pColl = sqlite3ExprNNCollSeq(pParse, pList->a[i].pExpr); + if( 0==sqlite3StrICmp(pColl->zName, zColl) ){ + return i; + } + } + } + + return -1; +} + +/* +** Return TRUE if the iCol-th column of index pIdx is NOT NULL +*/ +static int indexColumnNotNull(Index *pIdx, int iCol){ + int j; + assert( pIdx!=0 ); + assert( iCol>=0 && iColnColumn ); + j = pIdx->aiColumn[iCol]; + if( j>=0 ){ + return pIdx->pTable->aCol[j].notNull; + }else if( j==(-1) ){ + return 1; + }else{ + assert( j==(-2) ); + return 0; /* Assume an indexed expression can always yield a NULL */ + + } +} + +/* +** Return true if the DISTINCT expression-list passed as the third argument +** is redundant. +** +** A DISTINCT list is redundant if any subset of the columns in the +** DISTINCT list are collectively unique and individually non-null. +*/ +static int isDistinctRedundant( + Parse *pParse, /* Parsing context */ + SrcList *pTabList, /* The FROM clause */ + WhereClause *pWC, /* The WHERE clause */ + ExprList *pDistinct /* The result set that needs to be DISTINCT */ +){ + Table *pTab; + Index *pIdx; + int i; + int iBase; + + /* If there is more than one table or sub-select in the FROM clause of + ** this query, then it will not be possible to show that the DISTINCT + ** clause is redundant. */ + if( pTabList->nSrc!=1 ) return 0; + iBase = pTabList->a[0].iCursor; + pTab = pTabList->a[0].pTab; + + /* If any of the expressions is an IPK column on table iBase, then return + ** true. Note: The (p->iTable==iBase) part of this test may be false if the + ** current SELECT is a correlated sub-query. + */ + for(i=0; inExpr; i++){ + Expr *p = sqlite3ExprSkipCollateAndLikely(pDistinct->a[i].pExpr); + if( NEVER(p==0) ) continue; + if( p->op==TK_COLUMN && p->iTable==iBase && p->iColumn<0 ) return 1; + } + + /* Loop through all indices on the table, checking each to see if it makes + ** the DISTINCT qualifier redundant. It does so if: + ** + ** 1. The index is itself UNIQUE, and + ** + ** 2. All of the columns in the index are either part of the pDistinct + ** list, or else the WHERE clause contains a term of the form "col=X", + ** where X is a constant value. The collation sequences of the + ** comparison and select-list expressions must match those of the index. + ** + ** 3. All of those index columns for which the WHERE clause does not + ** contain a "col=X" term are subject to a NOT NULL constraint. + */ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + if( !IsUniqueIndex(pIdx) ) continue; + for(i=0; inKeyCol; i++){ + if( 0==sqlite3WhereFindTerm(pWC, iBase, i, ~(Bitmask)0, WO_EQ, pIdx) ){ + if( findIndexCol(pParse, pDistinct, iBase, pIdx, i)<0 ) break; + if( indexColumnNotNull(pIdx, i)==0 ) break; + } + } + if( i==pIdx->nKeyCol ){ + /* This index implies that the DISTINCT qualifier is redundant. */ + return 1; + } + } + + return 0; +} + + +/* +** Estimate the logarithm of the input value to base 2. +*/ +static LogEst estLog(LogEst N){ + return N<=10 ? 0 : sqlite3LogEst(N) - 33; +} + +/* +** Convert OP_Column opcodes to OP_Copy in previously generated code. +** +** This routine runs over generated VDBE code and translates OP_Column +** opcodes into OP_Copy when the table is being accessed via co-routine +** instead of via table lookup. +** +** If the iAutoidxCur is not zero, then any OP_Rowid instructions on +** cursor iTabCur are transformed into OP_Sequence opcode for the +** iAutoidxCur cursor, in order to generate unique rowids for the +** automatic index being generated. +*/ +static void translateColumnToCopy( + Parse *pParse, /* Parsing context */ + int iStart, /* Translate from this opcode to the end */ + int iTabCur, /* OP_Column/OP_Rowid references to this table */ + int iRegister, /* The first column is in this register */ + int iAutoidxCur /* If non-zero, cursor of autoindex being generated */ +){ + Vdbe *v = pParse->pVdbe; + VdbeOp *pOp = sqlite3VdbeGetOp(v, iStart); + int iEnd = sqlite3VdbeCurrentAddr(v); + if( pParse->db->mallocFailed ) return; + for(; iStartp1!=iTabCur ) continue; + if( pOp->opcode==OP_Column ){ + pOp->opcode = OP_Copy; + pOp->p1 = pOp->p2 + iRegister; + pOp->p2 = pOp->p3; + pOp->p3 = 0; + }else if( pOp->opcode==OP_Rowid ){ + if( iAutoidxCur ){ + pOp->opcode = OP_Sequence; + pOp->p1 = iAutoidxCur; + }else{ + pOp->opcode = OP_Null; + pOp->p1 = 0; + pOp->p3 = 0; + } + } + } +} + +/* +** Two routines for printing the content of an sqlite3_index_info +** structure. Used for testing and debugging only. If neither +** SQLITE_TEST or SQLITE_DEBUG are defined, then these routines +** are no-ops. +*/ +#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(WHERETRACE_ENABLED) +static void whereTraceIndexInfoInputs(sqlite3_index_info *p){ + int i; + if( !sqlite3WhereTrace ) return; + for(i=0; inConstraint; i++){ + sqlite3DebugPrintf(" constraint[%d]: col=%d termid=%d op=%d usabled=%d\n", + i, + p->aConstraint[i].iColumn, + p->aConstraint[i].iTermOffset, + p->aConstraint[i].op, + p->aConstraint[i].usable); + } + for(i=0; inOrderBy; i++){ + sqlite3DebugPrintf(" orderby[%d]: col=%d desc=%d\n", + i, + p->aOrderBy[i].iColumn, + p->aOrderBy[i].desc); + } +} +static void whereTraceIndexInfoOutputs(sqlite3_index_info *p){ + int i; + if( !sqlite3WhereTrace ) return; + for(i=0; inConstraint; i++){ + sqlite3DebugPrintf(" usage[%d]: argvIdx=%d omit=%d\n", + i, + p->aConstraintUsage[i].argvIndex, + p->aConstraintUsage[i].omit); + } + sqlite3DebugPrintf(" idxNum=%d\n", p->idxNum); + sqlite3DebugPrintf(" idxStr=%s\n", p->idxStr); + sqlite3DebugPrintf(" orderByConsumed=%d\n", p->orderByConsumed); + sqlite3DebugPrintf(" estimatedCost=%g\n", p->estimatedCost); + sqlite3DebugPrintf(" estimatedRows=%lld\n", p->estimatedRows); +} +#else +#define whereTraceIndexInfoInputs(A) +#define whereTraceIndexInfoOutputs(A) +#endif + +#ifndef SQLITE_OMIT_AUTOMATIC_INDEX +/* +** Return TRUE if the WHERE clause term pTerm is of a form where it +** could be used with an index to access pSrc, assuming an appropriate +** index existed. +*/ +static int termCanDriveIndex( + WhereTerm *pTerm, /* WHERE clause term to check */ + struct SrcList_item *pSrc, /* Table we are trying to access */ + Bitmask notReady /* Tables in outer loops of the join */ +){ + char aff; + if( pTerm->leftCursor!=pSrc->iCursor ) return 0; + if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) return 0; + if( (pSrc->fg.jointype & JT_LEFT) + && !ExprHasProperty(pTerm->pExpr, EP_FromJoin) + && (pTerm->eOperator & WO_IS) + ){ + /* Cannot use an IS term from the WHERE clause as an index driver for + ** the RHS of a LEFT JOIN. Such a term can only be used if it is from + ** the ON clause. */ + return 0; + } + if( (pTerm->prereqRight & notReady)!=0 ) return 0; + if( pTerm->u.x.leftColumn<0 ) return 0; + aff = pSrc->pTab->aCol[pTerm->u.x.leftColumn].affinity; + if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0; + testcase( pTerm->pExpr->op==TK_IS ); + return 1; +} +#endif + + +#ifndef SQLITE_OMIT_AUTOMATIC_INDEX +/* +** Generate code to construct the Index object for an automatic index +** and to set up the WhereLevel object pLevel so that the code generator +** makes use of the automatic index. +*/ +static void constructAutomaticIndex( + Parse *pParse, /* The parsing context */ + WhereClause *pWC, /* The WHERE clause */ + struct SrcList_item *pSrc, /* The FROM clause term to get the next index */ + Bitmask notReady, /* Mask of cursors that are not available */ + WhereLevel *pLevel /* Write new index here */ +){ + int nKeyCol; /* Number of columns in the constructed index */ + WhereTerm *pTerm; /* A single term of the WHERE clause */ + WhereTerm *pWCEnd; /* End of pWC->a[] */ + Index *pIdx; /* Object describing the transient index */ + Vdbe *v; /* Prepared statement under construction */ + int addrInit; /* Address of the initialization bypass jump */ + Table *pTable; /* The table being indexed */ + int addrTop; /* Top of the index fill loop */ + int regRecord; /* Register holding an index record */ + int n; /* Column counter */ + int i; /* Loop counter */ + int mxBitCol; /* Maximum column in pSrc->colUsed */ + CollSeq *pColl; /* Collating sequence to on a column */ + WhereLoop *pLoop; /* The Loop object */ + char *zNotUsed; /* Extra space on the end of pIdx */ + Bitmask idxCols; /* Bitmap of columns used for indexing */ + Bitmask extraCols; /* Bitmap of additional columns */ + u8 sentWarning = 0; /* True if a warnning has been issued */ + Expr *pPartial = 0; /* Partial Index Expression */ + int iContinue = 0; /* Jump here to skip excluded rows */ + struct SrcList_item *pTabItem; /* FROM clause term being indexed */ + int addrCounter = 0; /* Address where integer counter is initialized */ + int regBase; /* Array of registers where record is assembled */ + + /* Generate code to skip over the creation and initialization of the + ** transient index on 2nd and subsequent iterations of the loop. */ + v = pParse->pVdbe; + assert( v!=0 ); + addrInit = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + + /* Count the number of columns that will be added to the index + ** and used to match WHERE clause constraints */ + nKeyCol = 0; + pTable = pSrc->pTab; + pWCEnd = &pWC->a[pWC->nTerm]; + pLoop = pLevel->pWLoop; + idxCols = 0; + for(pTerm=pWC->a; pTermpExpr; + assert( !ExprHasProperty(pExpr, EP_FromJoin) /* prereq always non-zero */ + || pExpr->iRightJoinTable!=pSrc->iCursor /* for the right-hand */ + || pLoop->prereq!=0 ); /* table of a LEFT JOIN */ + if( pLoop->prereq==0 + && (pTerm->wtFlags & TERM_VIRTUAL)==0 + && !ExprHasProperty(pExpr, EP_FromJoin) + && sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor) ){ + pPartial = sqlite3ExprAnd(pParse, pPartial, + sqlite3ExprDup(pParse->db, pExpr, 0)); + } + if( termCanDriveIndex(pTerm, pSrc, notReady) ){ + int iCol = pTerm->u.x.leftColumn; + Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol); + testcase( iCol==BMS ); + testcase( iCol==BMS-1 ); + if( !sentWarning ){ + sqlite3_log(SQLITE_WARNING_AUTOINDEX, + "automatic index on %s(%s)", pTable->zName, + pTable->aCol[iCol].zName); + sentWarning = 1; + } + if( (idxCols & cMask)==0 ){ + if( whereLoopResize(pParse->db, pLoop, nKeyCol+1) ){ + goto end_auto_index_create; + } + pLoop->aLTerm[nKeyCol++] = pTerm; + idxCols |= cMask; + } + } + } + assert( nKeyCol>0 ); + pLoop->u.btree.nEq = pLoop->nLTerm = nKeyCol; + pLoop->wsFlags = WHERE_COLUMN_EQ | WHERE_IDX_ONLY | WHERE_INDEXED + | WHERE_AUTO_INDEX; + + /* Count the number of additional columns needed to create a + ** covering index. A "covering index" is an index that contains all + ** columns that are needed by the query. With a covering index, the + ** original table never needs to be accessed. Automatic indices must + ** be a covering index because the index will not be updated if the + ** original table changes and the index and table cannot both be used + ** if they go out of sync. + */ + extraCols = pSrc->colUsed & (~idxCols | MASKBIT(BMS-1)); + mxBitCol = MIN(BMS-1,pTable->nCol); + testcase( pTable->nCol==BMS-1 ); + testcase( pTable->nCol==BMS-2 ); + for(i=0; icolUsed & MASKBIT(BMS-1) ){ + nKeyCol += pTable->nCol - BMS + 1; + } + + /* Construct the Index object to describe this index */ + pIdx = sqlite3AllocateIndexObject(pParse->db, nKeyCol+1, 0, &zNotUsed); + if( pIdx==0 ) goto end_auto_index_create; + pLoop->u.btree.pIndex = pIdx; + pIdx->zName = "auto-index"; + pIdx->pTable = pTable; + n = 0; + idxCols = 0; + for(pTerm=pWC->a; pTermu.x.leftColumn; + Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol); + testcase( iCol==BMS-1 ); + testcase( iCol==BMS ); + if( (idxCols & cMask)==0 ){ + Expr *pX = pTerm->pExpr; + idxCols |= cMask; + pIdx->aiColumn[n] = pTerm->u.x.leftColumn; + pColl = sqlite3ExprCompareCollSeq(pParse, pX); + assert( pColl!=0 || pParse->nErr>0 ); /* TH3 collate01.800 */ + pIdx->azColl[n] = pColl ? pColl->zName : sqlite3StrBINARY; + n++; + } + } + } + assert( (u32)n==pLoop->u.btree.nEq ); + + /* Add additional columns needed to make the automatic index into + ** a covering index */ + for(i=0; iaiColumn[n] = i; + pIdx->azColl[n] = sqlite3StrBINARY; + n++; + } + } + if( pSrc->colUsed & MASKBIT(BMS-1) ){ + for(i=BMS-1; inCol; i++){ + pIdx->aiColumn[n] = i; + pIdx->azColl[n] = sqlite3StrBINARY; + n++; + } + } + assert( n==nKeyCol ); + pIdx->aiColumn[n] = XN_ROWID; + pIdx->azColl[n] = sqlite3StrBINARY; + + /* Create the automatic index */ + assert( pLevel->iIdxCur>=0 ); + pLevel->iIdxCur = pParse->nTab++; + sqlite3VdbeAddOp2(v, OP_OpenAutoindex, pLevel->iIdxCur, nKeyCol+1); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + VdbeComment((v, "for %s", pTable->zName)); + + /* Fill the automatic index with content */ + pTabItem = &pWC->pWInfo->pTabList->a[pLevel->iFrom]; + if( pTabItem->fg.viaCoroutine ){ + int regYield = pTabItem->regReturn; + addrCounter = sqlite3VdbeAddOp2(v, OP_Integer, 0, 0); + sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub); + addrTop = sqlite3VdbeAddOp1(v, OP_Yield, regYield); + VdbeCoverage(v); + VdbeComment((v, "next row of %s", pTabItem->pTab->zName)); + }else{ + addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, pLevel->iTabCur); VdbeCoverage(v); + } + if( pPartial ){ + iContinue = sqlite3VdbeMakeLabel(pParse); + sqlite3ExprIfFalse(pParse, pPartial, iContinue, SQLITE_JUMPIFNULL); + pLoop->wsFlags |= WHERE_PARTIALIDX; + } + regRecord = sqlite3GetTempReg(pParse); + regBase = sqlite3GenerateIndexKey( + pParse, pIdx, pLevel->iTabCur, regRecord, 0, 0, 0, 0 + ); + sqlite3VdbeAddOp2(v, OP_IdxInsert, pLevel->iIdxCur, regRecord); + sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + if( pPartial ) sqlite3VdbeResolveLabel(v, iContinue); + if( pTabItem->fg.viaCoroutine ){ + sqlite3VdbeChangeP2(v, addrCounter, regBase+n); + testcase( pParse->db->mallocFailed ); + assert( pLevel->iIdxCur>0 ); + translateColumnToCopy(pParse, addrTop, pLevel->iTabCur, + pTabItem->regResult, pLevel->iIdxCur); + sqlite3VdbeGoto(v, addrTop); + pTabItem->fg.viaCoroutine = 0; + }else{ + sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1); VdbeCoverage(v); + sqlite3VdbeChangeP5(v, SQLITE_STMTSTATUS_AUTOINDEX); + } + sqlite3VdbeJumpHere(v, addrTop); + sqlite3ReleaseTempReg(pParse, regRecord); + + /* Jump here when skipping the initialization */ + sqlite3VdbeJumpHere(v, addrInit); + +end_auto_index_create: + sqlite3ExprDelete(pParse->db, pPartial); +} +#endif /* SQLITE_OMIT_AUTOMATIC_INDEX */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Allocate and populate an sqlite3_index_info structure. It is the +** responsibility of the caller to eventually release the structure +** by passing the pointer returned by this function to sqlite3_free(). +*/ +static sqlite3_index_info *allocateIndexInfo( + Parse *pParse, /* The parsing context */ + WhereClause *pWC, /* The WHERE clause being analyzed */ + Bitmask mUnusable, /* Ignore terms with these prereqs */ + struct SrcList_item *pSrc, /* The FROM clause term that is the vtab */ + ExprList *pOrderBy, /* The ORDER BY clause */ + u16 *pmNoOmit /* Mask of terms not to omit */ +){ + int i, j; + int nTerm; + struct sqlite3_index_constraint *pIdxCons; + struct sqlite3_index_orderby *pIdxOrderBy; + struct sqlite3_index_constraint_usage *pUsage; + struct HiddenIndexInfo *pHidden; + WhereTerm *pTerm; + int nOrderBy; + sqlite3_index_info *pIdxInfo; + u16 mNoOmit = 0; + + /* Count the number of possible WHERE clause constraints referring + ** to this virtual table */ + for(i=nTerm=0, pTerm=pWC->a; inTerm; i++, pTerm++){ + if( pTerm->leftCursor != pSrc->iCursor ) continue; + if( pTerm->prereqRight & mUnusable ) continue; + assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) ); + testcase( pTerm->eOperator & WO_IN ); + testcase( pTerm->eOperator & WO_ISNULL ); + testcase( pTerm->eOperator & WO_IS ); + testcase( pTerm->eOperator & WO_ALL ); + if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue; + if( pTerm->wtFlags & TERM_VNULL ) continue; + assert( pTerm->u.x.leftColumn>=(-1) ); + nTerm++; + } + + /* If the ORDER BY clause contains only columns in the current + ** virtual table then allocate space for the aOrderBy part of + ** the sqlite3_index_info structure. + */ + nOrderBy = 0; + if( pOrderBy ){ + int n = pOrderBy->nExpr; + for(i=0; ia[i].pExpr; + if( pExpr->op!=TK_COLUMN || pExpr->iTable!=pSrc->iCursor ) break; + if( pOrderBy->a[i].sortFlags & KEYINFO_ORDER_BIGNULL ) break; + } + if( i==n){ + nOrderBy = n; + } + } + + /* Allocate the sqlite3_index_info structure + */ + pIdxInfo = sqlite3DbMallocZero(pParse->db, sizeof(*pIdxInfo) + + (sizeof(*pIdxCons) + sizeof(*pUsage))*nTerm + + sizeof(*pIdxOrderBy)*nOrderBy + sizeof(*pHidden) ); + if( pIdxInfo==0 ){ + sqlite3ErrorMsg(pParse, "out of memory"); + return 0; + } + pHidden = (struct HiddenIndexInfo*)&pIdxInfo[1]; + pIdxCons = (struct sqlite3_index_constraint*)&pHidden[1]; + pIdxOrderBy = (struct sqlite3_index_orderby*)&pIdxCons[nTerm]; + pUsage = (struct sqlite3_index_constraint_usage*)&pIdxOrderBy[nOrderBy]; + pIdxInfo->nOrderBy = nOrderBy; + pIdxInfo->aConstraint = pIdxCons; + pIdxInfo->aOrderBy = pIdxOrderBy; + pIdxInfo->aConstraintUsage = pUsage; + pHidden->pWC = pWC; + pHidden->pParse = pParse; + for(i=j=0, pTerm=pWC->a; inTerm; i++, pTerm++){ + u16 op; + if( pTerm->leftCursor != pSrc->iCursor ) continue; + if( pTerm->prereqRight & mUnusable ) continue; + assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) ); + testcase( pTerm->eOperator & WO_IN ); + testcase( pTerm->eOperator & WO_IS ); + testcase( pTerm->eOperator & WO_ISNULL ); + testcase( pTerm->eOperator & WO_ALL ); + if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue; + if( pTerm->wtFlags & TERM_VNULL ) continue; + + /* tag-20191211-002: WHERE-clause constraints are not useful to the + ** right-hand table of a LEFT JOIN. See tag-20191211-001 for the + ** equivalent restriction for ordinary tables. */ + if( (pSrc->fg.jointype & JT_LEFT)!=0 + && !ExprHasProperty(pTerm->pExpr, EP_FromJoin) + ){ + continue; + } + assert( pTerm->u.x.leftColumn>=(-1) ); + pIdxCons[j].iColumn = pTerm->u.x.leftColumn; + pIdxCons[j].iTermOffset = i; + op = pTerm->eOperator & WO_ALL; + if( op==WO_IN ) op = WO_EQ; + if( op==WO_AUX ){ + pIdxCons[j].op = pTerm->eMatchOp; + }else if( op & (WO_ISNULL|WO_IS) ){ + if( op==WO_ISNULL ){ + pIdxCons[j].op = SQLITE_INDEX_CONSTRAINT_ISNULL; + }else{ + pIdxCons[j].op = SQLITE_INDEX_CONSTRAINT_IS; + } + }else{ + pIdxCons[j].op = (u8)op; + /* The direct assignment in the previous line is possible only because + ** the WO_ and SQLITE_INDEX_CONSTRAINT_ codes are identical. The + ** following asserts verify this fact. */ + assert( WO_EQ==SQLITE_INDEX_CONSTRAINT_EQ ); + assert( WO_LT==SQLITE_INDEX_CONSTRAINT_LT ); + assert( WO_LE==SQLITE_INDEX_CONSTRAINT_LE ); + assert( WO_GT==SQLITE_INDEX_CONSTRAINT_GT ); + assert( WO_GE==SQLITE_INDEX_CONSTRAINT_GE ); + assert( pTerm->eOperator&(WO_IN|WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE|WO_AUX) ); + + if( op & (WO_LT|WO_LE|WO_GT|WO_GE) + && sqlite3ExprIsVector(pTerm->pExpr->pRight) + ){ + testcase( j!=i ); + if( j<16 ) mNoOmit |= (1 << j); + if( op==WO_LT ) pIdxCons[j].op = WO_LE; + if( op==WO_GT ) pIdxCons[j].op = WO_GE; + } + } + + j++; + } + pIdxInfo->nConstraint = j; + for(i=0; ia[i].pExpr; + pIdxOrderBy[i].iColumn = pExpr->iColumn; + pIdxOrderBy[i].desc = pOrderBy->a[i].sortFlags & KEYINFO_ORDER_DESC; + } + + *pmNoOmit = mNoOmit; + return pIdxInfo; +} + +/* +** The table object reference passed as the second argument to this function +** must represent a virtual table. This function invokes the xBestIndex() +** method of the virtual table with the sqlite3_index_info object that +** comes in as the 3rd argument to this function. +** +** If an error occurs, pParse is populated with an error message and an +** appropriate error code is returned. A return of SQLITE_CONSTRAINT from +** xBestIndex is not considered an error. SQLITE_CONSTRAINT indicates that +** the current configuration of "unusable" flags in sqlite3_index_info can +** not result in a valid plan. +** +** Whether or not an error is returned, it is the responsibility of the +** caller to eventually free p->idxStr if p->needToFreeIdxStr indicates +** that this is required. +*/ +static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){ + sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab; + int rc; + + whereTraceIndexInfoInputs(p); + rc = pVtab->pModule->xBestIndex(pVtab, p); + whereTraceIndexInfoOutputs(p); + + if( rc!=SQLITE_OK && rc!=SQLITE_CONSTRAINT ){ + if( rc==SQLITE_NOMEM ){ + sqlite3OomFault(pParse->db); + }else if( !pVtab->zErrMsg ){ + sqlite3ErrorMsg(pParse, "%s", sqlite3ErrStr(rc)); + }else{ + sqlite3ErrorMsg(pParse, "%s", pVtab->zErrMsg); + } + } + sqlite3_free(pVtab->zErrMsg); + pVtab->zErrMsg = 0; + return rc; +} +#endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) */ + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Estimate the location of a particular key among all keys in an +** index. Store the results in aStat as follows: +** +** aStat[0] Est. number of rows less than pRec +** aStat[1] Est. number of rows equal to pRec +** +** Return the index of the sample that is the smallest sample that +** is greater than or equal to pRec. Note that this index is not an index +** into the aSample[] array - it is an index into a virtual set of samples +** based on the contents of aSample[] and the number of fields in record +** pRec. +*/ +static int whereKeyStats( + Parse *pParse, /* Database connection */ + Index *pIdx, /* Index to consider domain of */ + UnpackedRecord *pRec, /* Vector of values to consider */ + int roundUp, /* Round up if true. Round down if false */ + tRowcnt *aStat /* OUT: stats written here */ +){ + IndexSample *aSample = pIdx->aSample; + int iCol; /* Index of required stats in anEq[] etc. */ + int i; /* Index of first sample >= pRec */ + int iSample; /* Smallest sample larger than or equal to pRec */ + int iMin = 0; /* Smallest sample not yet tested */ + int iTest; /* Next sample to test */ + int res; /* Result of comparison operation */ + int nField; /* Number of fields in pRec */ + tRowcnt iLower = 0; /* anLt[] + anEq[] of largest sample pRec is > */ + +#ifndef SQLITE_DEBUG + UNUSED_PARAMETER( pParse ); +#endif + assert( pRec!=0 ); + assert( pIdx->nSample>0 ); + assert( pRec->nField>0 && pRec->nField<=pIdx->nSampleCol ); + + /* Do a binary search to find the first sample greater than or equal + ** to pRec. If pRec contains a single field, the set of samples to search + ** is simply the aSample[] array. If the samples in aSample[] contain more + ** than one fields, all fields following the first are ignored. + ** + ** If pRec contains N fields, where N is more than one, then as well as the + ** samples in aSample[] (truncated to N fields), the search also has to + ** consider prefixes of those samples. For example, if the set of samples + ** in aSample is: + ** + ** aSample[0] = (a, 5) + ** aSample[1] = (a, 10) + ** aSample[2] = (b, 5) + ** aSample[3] = (c, 100) + ** aSample[4] = (c, 105) + ** + ** Then the search space should ideally be the samples above and the + ** unique prefixes [a], [b] and [c]. But since that is hard to organize, + ** the code actually searches this set: + ** + ** 0: (a) + ** 1: (a, 5) + ** 2: (a, 10) + ** 3: (a, 10) + ** 4: (b) + ** 5: (b, 5) + ** 6: (c) + ** 7: (c, 100) + ** 8: (c, 105) + ** 9: (c, 105) + ** + ** For each sample in the aSample[] array, N samples are present in the + ** effective sample array. In the above, samples 0 and 1 are based on + ** sample aSample[0]. Samples 2 and 3 on aSample[1] etc. + ** + ** Often, sample i of each block of N effective samples has (i+1) fields. + ** Except, each sample may be extended to ensure that it is greater than or + ** equal to the previous sample in the array. For example, in the above, + ** sample 2 is the first sample of a block of N samples, so at first it + ** appears that it should be 1 field in size. However, that would make it + ** smaller than sample 1, so the binary search would not work. As a result, + ** it is extended to two fields. The duplicates that this creates do not + ** cause any problems. + */ + nField = pRec->nField; + iCol = 0; + iSample = pIdx->nSample * nField; + do{ + int iSamp; /* Index in aSample[] of test sample */ + int n; /* Number of fields in test sample */ + + iTest = (iMin+iSample)/2; + iSamp = iTest / nField; + if( iSamp>0 ){ + /* The proposed effective sample is a prefix of sample aSample[iSamp]. + ** Specifically, the shortest prefix of at least (1 + iTest%nField) + ** fields that is greater than the previous effective sample. */ + for(n=(iTest % nField) + 1; nnField = n; + res = sqlite3VdbeRecordCompare(aSample[iSamp].n, aSample[iSamp].p, pRec); + if( res<0 ){ + iLower = aSample[iSamp].anLt[n-1] + aSample[iSamp].anEq[n-1]; + iMin = iTest+1; + }else if( res==0 && ndb->mallocFailed==0 ){ + if( res==0 ){ + /* If (res==0) is true, then pRec must be equal to sample i. */ + assert( inSample ); + assert( iCol==nField-1 ); + pRec->nField = nField; + assert( 0==sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec) + || pParse->db->mallocFailed + ); + }else{ + /* Unless i==pIdx->nSample, indicating that pRec is larger than + ** all samples in the aSample[] array, pRec must be smaller than the + ** (iCol+1) field prefix of sample i. */ + assert( i<=pIdx->nSample && i>=0 ); + pRec->nField = iCol+1; + assert( i==pIdx->nSample + || sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)>0 + || pParse->db->mallocFailed ); + + /* if i==0 and iCol==0, then record pRec is smaller than all samples + ** in the aSample[] array. Otherwise, if (iCol>0) then pRec must + ** be greater than or equal to the (iCol) field prefix of sample i. + ** If (i>0), then pRec must also be greater than sample (i-1). */ + if( iCol>0 ){ + pRec->nField = iCol; + assert( sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)<=0 + || pParse->db->mallocFailed ); + } + if( i>0 ){ + pRec->nField = nField; + assert( sqlite3VdbeRecordCompare(aSample[i-1].n, aSample[i-1].p, pRec)<0 + || pParse->db->mallocFailed ); + } + } + } +#endif /* ifdef SQLITE_DEBUG */ + + if( res==0 ){ + /* Record pRec is equal to sample i */ + assert( iCol==nField-1 ); + aStat[0] = aSample[i].anLt[iCol]; + aStat[1] = aSample[i].anEq[iCol]; + }else{ + /* At this point, the (iCol+1) field prefix of aSample[i] is the first + ** sample that is greater than pRec. Or, if i==pIdx->nSample then pRec + ** is larger than all samples in the array. */ + tRowcnt iUpper, iGap; + if( i>=pIdx->nSample ){ + iUpper = sqlite3LogEstToInt(pIdx->aiRowLogEst[0]); + }else{ + iUpper = aSample[i].anLt[iCol]; + } + + if( iLower>=iUpper ){ + iGap = 0; + }else{ + iGap = iUpper - iLower; + } + if( roundUp ){ + iGap = (iGap*2)/3; + }else{ + iGap = iGap/3; + } + aStat[0] = iLower + iGap; + aStat[1] = pIdx->aAvgEq[nField-1]; + } + + /* Restore the pRec->nField value before returning. */ + pRec->nField = nField; + return i; +} +#endif /* SQLITE_ENABLE_STAT4 */ + +/* +** If it is not NULL, pTerm is a term that provides an upper or lower +** bound on a range scan. Without considering pTerm, it is estimated +** that the scan will visit nNew rows. This function returns the number +** estimated to be visited after taking pTerm into account. +** +** If the user explicitly specified a likelihood() value for this term, +** then the return value is the likelihood multiplied by the number of +** input rows. Otherwise, this function assumes that an "IS NOT NULL" term +** has a likelihood of 0.50, and any other term a likelihood of 0.25. +*/ +static LogEst whereRangeAdjust(WhereTerm *pTerm, LogEst nNew){ + LogEst nRet = nNew; + if( pTerm ){ + if( pTerm->truthProb<=0 ){ + nRet += pTerm->truthProb; + }else if( (pTerm->wtFlags & TERM_VNULL)==0 ){ + nRet -= 20; assert( 20==sqlite3LogEst(4) ); + } + } + return nRet; +} + + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Return the affinity for a single column of an index. +*/ +SQLITE_PRIVATE char sqlite3IndexColumnAffinity(sqlite3 *db, Index *pIdx, int iCol){ + assert( iCol>=0 && iColnColumn ); + if( !pIdx->zColAff ){ + if( sqlite3IndexAffinityStr(db, pIdx)==0 ) return SQLITE_AFF_BLOB; + } + assert( pIdx->zColAff[iCol]!=0 ); + return pIdx->zColAff[iCol]; +} +#endif + + +#ifdef SQLITE_ENABLE_STAT4 +/* +** This function is called to estimate the number of rows visited by a +** range-scan on a skip-scan index. For example: +** +** CREATE INDEX i1 ON t1(a, b, c); +** SELECT * FROM t1 WHERE a=? AND c BETWEEN ? AND ?; +** +** Value pLoop->nOut is currently set to the estimated number of rows +** visited for scanning (a=? AND b=?). This function reduces that estimate +** by some factor to account for the (c BETWEEN ? AND ?) expression based +** on the stat4 data for the index. this scan will be peformed multiple +** times (once for each (a,b) combination that matches a=?) is dealt with +** by the caller. +** +** It does this by scanning through all stat4 samples, comparing values +** extracted from pLower and pUpper with the corresponding column in each +** sample. If L and U are the number of samples found to be less than or +** equal to the values extracted from pLower and pUpper respectively, and +** N is the total number of samples, the pLoop->nOut value is adjusted +** as follows: +** +** nOut = nOut * ( min(U - L, 1) / N ) +** +** If pLower is NULL, or a value cannot be extracted from the term, L is +** set to zero. If pUpper is NULL, or a value cannot be extracted from it, +** U is set to N. +** +** Normally, this function sets *pbDone to 1 before returning. However, +** if no value can be extracted from either pLower or pUpper (and so the +** estimate of the number of rows delivered remains unchanged), *pbDone +** is left as is. +** +** If an error occurs, an SQLite error code is returned. Otherwise, +** SQLITE_OK. +*/ +static int whereRangeSkipScanEst( + Parse *pParse, /* Parsing & code generating context */ + WhereTerm *pLower, /* Lower bound on the range. ex: "x>123" Might be NULL */ + WhereTerm *pUpper, /* Upper bound on the range. ex: "x<455" Might be NULL */ + WhereLoop *pLoop, /* Update the .nOut value of this loop */ + int *pbDone /* Set to true if at least one expr. value extracted */ +){ + Index *p = pLoop->u.btree.pIndex; + int nEq = pLoop->u.btree.nEq; + sqlite3 *db = pParse->db; + int nLower = -1; + int nUpper = p->nSample+1; + int rc = SQLITE_OK; + u8 aff = sqlite3IndexColumnAffinity(db, p, nEq); + CollSeq *pColl; + + sqlite3_value *p1 = 0; /* Value extracted from pLower */ + sqlite3_value *p2 = 0; /* Value extracted from pUpper */ + sqlite3_value *pVal = 0; /* Value extracted from record */ + + pColl = sqlite3LocateCollSeq(pParse, p->azColl[nEq]); + if( pLower ){ + rc = sqlite3Stat4ValueFromExpr(pParse, pLower->pExpr->pRight, aff, &p1); + nLower = 0; + } + if( pUpper && rc==SQLITE_OK ){ + rc = sqlite3Stat4ValueFromExpr(pParse, pUpper->pExpr->pRight, aff, &p2); + nUpper = p2 ? 0 : p->nSample; + } + + if( p1 || p2 ){ + int i; + int nDiff; + for(i=0; rc==SQLITE_OK && inSample; i++){ + rc = sqlite3Stat4Column(db, p->aSample[i].p, p->aSample[i].n, nEq, &pVal); + if( rc==SQLITE_OK && p1 ){ + int res = sqlite3MemCompare(p1, pVal, pColl); + if( res>=0 ) nLower++; + } + if( rc==SQLITE_OK && p2 ){ + int res = sqlite3MemCompare(p2, pVal, pColl); + if( res>=0 ) nUpper++; + } + } + nDiff = (nUpper - nLower); + if( nDiff<=0 ) nDiff = 1; + + /* If there is both an upper and lower bound specified, and the + ** comparisons indicate that they are close together, use the fallback + ** method (assume that the scan visits 1/64 of the rows) for estimating + ** the number of rows visited. Otherwise, estimate the number of rows + ** using the method described in the header comment for this function. */ + if( nDiff!=1 || pUpper==0 || pLower==0 ){ + int nAdjust = (sqlite3LogEst(p->nSample) - sqlite3LogEst(nDiff)); + pLoop->nOut -= nAdjust; + *pbDone = 1; + WHERETRACE(0x10, ("range skip-scan regions: %u..%u adjust=%d est=%d\n", + nLower, nUpper, nAdjust*-1, pLoop->nOut)); + } + + }else{ + assert( *pbDone==0 ); + } + + sqlite3ValueFree(p1); + sqlite3ValueFree(p2); + sqlite3ValueFree(pVal); + + return rc; +} +#endif /* SQLITE_ENABLE_STAT4 */ + +/* +** This function is used to estimate the number of rows that will be visited +** by scanning an index for a range of values. The range may have an upper +** bound, a lower bound, or both. The WHERE clause terms that set the upper +** and lower bounds are represented by pLower and pUpper respectively. For +** example, assuming that index p is on t1(a): +** +** ... FROM t1 WHERE a > ? AND a < ? ... +** |_____| |_____| +** | | +** pLower pUpper +** +** If either of the upper or lower bound is not present, then NULL is passed in +** place of the corresponding WhereTerm. +** +** The value in (pBuilder->pNew->u.btree.nEq) is the number of the index +** column subject to the range constraint. Or, equivalently, the number of +** equality constraints optimized by the proposed index scan. For example, +** assuming index p is on t1(a, b), and the SQL query is: +** +** ... FROM t1 WHERE a = ? AND b > ? AND b < ? ... +** +** then nEq is set to 1 (as the range restricted column, b, is the second +** left-most column of the index). Or, if the query is: +** +** ... FROM t1 WHERE a > ? AND a < ? ... +** +** then nEq is set to 0. +** +** When this function is called, *pnOut is set to the sqlite3LogEst() of the +** number of rows that the index scan is expected to visit without +** considering the range constraints. If nEq is 0, then *pnOut is the number of +** rows in the index. Assuming no error occurs, *pnOut is adjusted (reduced) +** to account for the range constraints pLower and pUpper. +** +** In the absence of sqlite_stat4 ANALYZE data, or if such data cannot be +** used, a single range inequality reduces the search space by a factor of 4. +** and a pair of constraints (x>? AND x123" Might be NULL */ + WhereTerm *pUpper, /* Upper bound on the range. ex: "x<455" Might be NULL */ + WhereLoop *pLoop /* Modify the .nOut and maybe .rRun fields */ +){ + int rc = SQLITE_OK; + int nOut = pLoop->nOut; + LogEst nNew; + +#ifdef SQLITE_ENABLE_STAT4 + Index *p = pLoop->u.btree.pIndex; + int nEq = pLoop->u.btree.nEq; + + if( p->nSample>0 && ALWAYS(nEqnSampleCol) + && OptimizationEnabled(pParse->db, SQLITE_Stat4) + ){ + if( nEq==pBuilder->nRecValid ){ + UnpackedRecord *pRec = pBuilder->pRec; + tRowcnt a[2]; + int nBtm = pLoop->u.btree.nBtm; + int nTop = pLoop->u.btree.nTop; + + /* Variable iLower will be set to the estimate of the number of rows in + ** the index that are less than the lower bound of the range query. The + ** lower bound being the concatenation of $P and $L, where $P is the + ** key-prefix formed by the nEq values matched against the nEq left-most + ** columns of the index, and $L is the value in pLower. + ** + ** Or, if pLower is NULL or $L cannot be extracted from it (because it + ** is not a simple variable or literal value), the lower bound of the + ** range is $P. Due to a quirk in the way whereKeyStats() works, even + ** if $L is available, whereKeyStats() is called for both ($P) and + ** ($P:$L) and the larger of the two returned values is used. + ** + ** Similarly, iUpper is to be set to the estimate of the number of rows + ** less than the upper bound of the range query. Where the upper bound + ** is either ($P) or ($P:$U). Again, even if $U is available, both values + ** of iUpper are requested of whereKeyStats() and the smaller used. + ** + ** The number of rows between the two bounds is then just iUpper-iLower. + */ + tRowcnt iLower; /* Rows less than the lower bound */ + tRowcnt iUpper; /* Rows less than the upper bound */ + int iLwrIdx = -2; /* aSample[] for the lower bound */ + int iUprIdx = -1; /* aSample[] for the upper bound */ + + if( pRec ){ + testcase( pRec->nField!=pBuilder->nRecValid ); + pRec->nField = pBuilder->nRecValid; + } + /* Determine iLower and iUpper using ($P) only. */ + if( nEq==0 ){ + iLower = 0; + iUpper = p->nRowEst0; + }else{ + /* Note: this call could be optimized away - since the same values must + ** have been requested when testing key $P in whereEqualScanEst(). */ + whereKeyStats(pParse, p, pRec, 0, a); + iLower = a[0]; + iUpper = a[0] + a[1]; + } + + assert( pLower==0 || (pLower->eOperator & (WO_GT|WO_GE))!=0 ); + assert( pUpper==0 || (pUpper->eOperator & (WO_LT|WO_LE))!=0 ); + assert( p->aSortOrder!=0 ); + if( p->aSortOrder[nEq] ){ + /* The roles of pLower and pUpper are swapped for a DESC index */ + SWAP(WhereTerm*, pLower, pUpper); + SWAP(int, nBtm, nTop); + } + + /* If possible, improve on the iLower estimate using ($P:$L). */ + if( pLower ){ + int n; /* Values extracted from pExpr */ + Expr *pExpr = pLower->pExpr->pRight; + rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nBtm, nEq, &n); + if( rc==SQLITE_OK && n ){ + tRowcnt iNew; + u16 mask = WO_GT|WO_LE; + if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT); + iLwrIdx = whereKeyStats(pParse, p, pRec, 0, a); + iNew = a[0] + ((pLower->eOperator & mask) ? a[1] : 0); + if( iNew>iLower ) iLower = iNew; + nOut--; + pLower = 0; + } + } + + /* If possible, improve on the iUpper estimate using ($P:$U). */ + if( pUpper ){ + int n; /* Values extracted from pExpr */ + Expr *pExpr = pUpper->pExpr->pRight; + rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nTop, nEq, &n); + if( rc==SQLITE_OK && n ){ + tRowcnt iNew; + u16 mask = WO_GT|WO_LE; + if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT); + iUprIdx = whereKeyStats(pParse, p, pRec, 1, a); + iNew = a[0] + ((pUpper->eOperator & mask) ? a[1] : 0); + if( iNewpRec = pRec; + if( rc==SQLITE_OK ){ + if( iUpper>iLower ){ + nNew = sqlite3LogEst(iUpper - iLower); + /* TUNING: If both iUpper and iLower are derived from the same + ** sample, then assume they are 4x more selective. This brings + ** the estimated selectivity more in line with what it would be + ** if estimated without the use of STAT4 tables. */ + if( iLwrIdx==iUprIdx ) nNew -= 20; assert( 20==sqlite3LogEst(4) ); + }else{ + nNew = 10; assert( 10==sqlite3LogEst(2) ); + } + if( nNewwtFlags & TERM_VNULL)==0 ); + nNew = whereRangeAdjust(pLower, nOut); + nNew = whereRangeAdjust(pUpper, nNew); + + /* TUNING: If there is both an upper and lower limit and neither limit + ** has an application-defined likelihood(), assume the range is + ** reduced by an additional 75%. This means that, by default, an open-ended + ** range query (e.g. col > ?) is assumed to match 1/4 of the rows in the + ** index. While a closed range (e.g. col BETWEEN ? AND ?) is estimated to + ** match 1/64 of the index. */ + if( pLower && pLower->truthProb>0 && pUpper && pUpper->truthProb>0 ){ + nNew -= 20; + } + + nOut -= (pLower!=0) + (pUpper!=0); + if( nNew<10 ) nNew = 10; + if( nNewnOut>nOut ){ + WHERETRACE(0x10,("Range scan lowers nOut from %d to %d\n", + pLoop->nOut, nOut)); + } +#endif + pLoop->nOut = (LogEst)nOut; + return rc; +} + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Estimate the number of rows that will be returned based on +** an equality constraint x=VALUE and where that VALUE occurs in +** the histogram data. This only works when x is the left-most +** column of an index and sqlite_stat4 histogram data is available +** for that index. When pExpr==NULL that means the constraint is +** "x IS NULL" instead of "x=VALUE". +** +** Write the estimated row count into *pnRow and return SQLITE_OK. +** If unable to make an estimate, leave *pnRow unchanged and return +** non-zero. +** +** This routine can fail if it is unable to load a collating sequence +** required for string comparison, or if unable to allocate memory +** for a UTF conversion required for comparison. The error is stored +** in the pParse structure. +*/ +static int whereEqualScanEst( + Parse *pParse, /* Parsing & code generating context */ + WhereLoopBuilder *pBuilder, + Expr *pExpr, /* Expression for VALUE in the x=VALUE constraint */ + tRowcnt *pnRow /* Write the revised row estimate here */ +){ + Index *p = pBuilder->pNew->u.btree.pIndex; + int nEq = pBuilder->pNew->u.btree.nEq; + UnpackedRecord *pRec = pBuilder->pRec; + int rc; /* Subfunction return code */ + tRowcnt a[2]; /* Statistics */ + int bOk; + + assert( nEq>=1 ); + assert( nEq<=p->nColumn ); + assert( p->aSample!=0 ); + assert( p->nSample>0 ); + assert( pBuilder->nRecValidnRecValid<(nEq-1) ){ + return SQLITE_NOTFOUND; + } + + /* This is an optimization only. The call to sqlite3Stat4ProbeSetValue() + ** below would return the same value. */ + if( nEq>=p->nColumn ){ + *pnRow = 1; + return SQLITE_OK; + } + + rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, 1, nEq-1, &bOk); + pBuilder->pRec = pRec; + if( rc!=SQLITE_OK ) return rc; + if( bOk==0 ) return SQLITE_NOTFOUND; + pBuilder->nRecValid = nEq; + + whereKeyStats(pParse, p, pRec, 0, a); + WHERETRACE(0x10,("equality scan regions %s(%d): %d\n", + p->zName, nEq-1, (int)a[1])); + *pnRow = a[1]; + + return rc; +} +#endif /* SQLITE_ENABLE_STAT4 */ + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Estimate the number of rows that will be returned based on +** an IN constraint where the right-hand side of the IN operator +** is a list of values. Example: +** +** WHERE x IN (1,2,3,4) +** +** Write the estimated row count into *pnRow and return SQLITE_OK. +** If unable to make an estimate, leave *pnRow unchanged and return +** non-zero. +** +** This routine can fail if it is unable to load a collating sequence +** required for string comparison, or if unable to allocate memory +** for a UTF conversion required for comparison. The error is stored +** in the pParse structure. +*/ +static int whereInScanEst( + Parse *pParse, /* Parsing & code generating context */ + WhereLoopBuilder *pBuilder, + ExprList *pList, /* The value list on the RHS of "x IN (v1,v2,v3,...)" */ + tRowcnt *pnRow /* Write the revised row estimate here */ +){ + Index *p = pBuilder->pNew->u.btree.pIndex; + i64 nRow0 = sqlite3LogEstToInt(p->aiRowLogEst[0]); + int nRecValid = pBuilder->nRecValid; + int rc = SQLITE_OK; /* Subfunction return code */ + tRowcnt nEst; /* Number of rows for a single term */ + tRowcnt nRowEst = 0; /* New estimate of the number of rows */ + int i; /* Loop counter */ + + assert( p->aSample!=0 ); + for(i=0; rc==SQLITE_OK && inExpr; i++){ + nEst = nRow0; + rc = whereEqualScanEst(pParse, pBuilder, pList->a[i].pExpr, &nEst); + nRowEst += nEst; + pBuilder->nRecValid = nRecValid; + } + + if( rc==SQLITE_OK ){ + if( nRowEst > nRow0 ) nRowEst = nRow0; + *pnRow = nRowEst; + WHERETRACE(0x10,("IN row estimate: est=%d\n", nRowEst)); + } + assert( pBuilder->nRecValid==nRecValid ); + return rc; +} +#endif /* SQLITE_ENABLE_STAT4 */ + + +#ifdef WHERETRACE_ENABLED +/* +** Print the content of a WhereTerm object +*/ +SQLITE_PRIVATE void sqlite3WhereTermPrint(WhereTerm *pTerm, int iTerm){ + if( pTerm==0 ){ + sqlite3DebugPrintf("TERM-%-3d NULL\n", iTerm); + }else{ + char zType[8]; + char zLeft[50]; + memcpy(zType, "....", 5); + if( pTerm->wtFlags & TERM_VIRTUAL ) zType[0] = 'V'; + if( pTerm->eOperator & WO_EQUIV ) zType[1] = 'E'; + if( ExprHasProperty(pTerm->pExpr, EP_FromJoin) ) zType[2] = 'L'; + if( pTerm->wtFlags & TERM_CODED ) zType[3] = 'C'; + if( pTerm->eOperator & WO_SINGLE ){ + sqlite3_snprintf(sizeof(zLeft),zLeft,"left={%d:%d}", + pTerm->leftCursor, pTerm->u.x.leftColumn); + }else if( (pTerm->eOperator & WO_OR)!=0 && pTerm->u.pOrInfo!=0 ){ + sqlite3_snprintf(sizeof(zLeft),zLeft,"indexable=0x%llx", + pTerm->u.pOrInfo->indexable); + }else{ + sqlite3_snprintf(sizeof(zLeft),zLeft,"left=%d", pTerm->leftCursor); + } + sqlite3DebugPrintf( + "TERM-%-3d %p %s %-12s op=%03x wtFlags=%04x", + iTerm, pTerm, zType, zLeft, pTerm->eOperator, pTerm->wtFlags); + /* The 0x10000 .wheretrace flag causes extra information to be + ** shown about each Term */ + if( sqlite3WhereTrace & 0x10000 ){ + sqlite3DebugPrintf(" prob=%-3d prereq=%llx,%llx", + pTerm->truthProb, (u64)pTerm->prereqAll, (u64)pTerm->prereqRight); + } + if( pTerm->u.x.iField ){ + sqlite3DebugPrintf(" iField=%d", pTerm->u.x.iField); + } + if( pTerm->iParent>=0 ){ + sqlite3DebugPrintf(" iParent=%d", pTerm->iParent); + } + sqlite3DebugPrintf("\n"); + sqlite3TreeViewExpr(0, pTerm->pExpr, 0); + } +} +#endif + +#ifdef WHERETRACE_ENABLED +/* +** Show the complete content of a WhereClause +*/ +SQLITE_PRIVATE void sqlite3WhereClausePrint(WhereClause *pWC){ + int i; + for(i=0; inTerm; i++){ + sqlite3WhereTermPrint(&pWC->a[i], i); + } +} +#endif + +#ifdef WHERETRACE_ENABLED +/* +** Print a WhereLoop object for debugging purposes +*/ +SQLITE_PRIVATE void sqlite3WhereLoopPrint(WhereLoop *p, WhereClause *pWC){ + WhereInfo *pWInfo = pWC->pWInfo; + int nb = 1+(pWInfo->pTabList->nSrc+3)/4; + struct SrcList_item *pItem = pWInfo->pTabList->a + p->iTab; + Table *pTab = pItem->pTab; + Bitmask mAll = (((Bitmask)1)<<(nb*4)) - 1; + sqlite3DebugPrintf("%c%2d.%0*llx.%0*llx", p->cId, + p->iTab, nb, p->maskSelf, nb, p->prereq & mAll); + sqlite3DebugPrintf(" %12s", + pItem->zAlias ? pItem->zAlias : pTab->zName); + if( (p->wsFlags & WHERE_VIRTUALTABLE)==0 ){ + const char *zName; + if( p->u.btree.pIndex && (zName = p->u.btree.pIndex->zName)!=0 ){ + if( strncmp(zName, "sqlite_autoindex_", 17)==0 ){ + int i = sqlite3Strlen30(zName) - 1; + while( zName[i]!='_' ) i--; + zName += i; + } + sqlite3DebugPrintf(".%-16s %2d", zName, p->u.btree.nEq); + }else{ + sqlite3DebugPrintf("%20s",""); + } + }else{ + char *z; + if( p->u.vtab.idxStr ){ + z = sqlite3_mprintf("(%d,\"%s\",%#x)", + p->u.vtab.idxNum, p->u.vtab.idxStr, p->u.vtab.omitMask); + }else{ + z = sqlite3_mprintf("(%d,%x)", p->u.vtab.idxNum, p->u.vtab.omitMask); + } + sqlite3DebugPrintf(" %-19s", z); + sqlite3_free(z); + } + if( p->wsFlags & WHERE_SKIPSCAN ){ + sqlite3DebugPrintf(" f %05x %d-%d", p->wsFlags, p->nLTerm,p->nSkip); + }else{ + sqlite3DebugPrintf(" f %05x N %d", p->wsFlags, p->nLTerm); + } + sqlite3DebugPrintf(" cost %d,%d,%d\n", p->rSetup, p->rRun, p->nOut); + if( p->nLTerm && (sqlite3WhereTrace & 0x100)!=0 ){ + int i; + for(i=0; inLTerm; i++){ + sqlite3WhereTermPrint(p->aLTerm[i], i); + } + } +} +#endif + +/* +** Convert bulk memory into a valid WhereLoop that can be passed +** to whereLoopClear harmlessly. +*/ +static void whereLoopInit(WhereLoop *p){ + p->aLTerm = p->aLTermSpace; + p->nLTerm = 0; + p->nLSlot = ArraySize(p->aLTermSpace); + p->wsFlags = 0; +} + +/* +** Clear the WhereLoop.u union. Leave WhereLoop.pLTerm intact. +*/ +static void whereLoopClearUnion(sqlite3 *db, WhereLoop *p){ + if( p->wsFlags & (WHERE_VIRTUALTABLE|WHERE_AUTO_INDEX) ){ + if( (p->wsFlags & WHERE_VIRTUALTABLE)!=0 && p->u.vtab.needFree ){ + sqlite3_free(p->u.vtab.idxStr); + p->u.vtab.needFree = 0; + p->u.vtab.idxStr = 0; + }else if( (p->wsFlags & WHERE_AUTO_INDEX)!=0 && p->u.btree.pIndex!=0 ){ + sqlite3DbFree(db, p->u.btree.pIndex->zColAff); + sqlite3DbFreeNN(db, p->u.btree.pIndex); + p->u.btree.pIndex = 0; + } + } +} + +/* +** Deallocate internal memory used by a WhereLoop object +*/ +static void whereLoopClear(sqlite3 *db, WhereLoop *p){ + if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFreeNN(db, p->aLTerm); + whereLoopClearUnion(db, p); + whereLoopInit(p); +} + +/* +** Increase the memory allocation for pLoop->aLTerm[] to be at least n. +*/ +static int whereLoopResize(sqlite3 *db, WhereLoop *p, int n){ + WhereTerm **paNew; + if( p->nLSlot>=n ) return SQLITE_OK; + n = (n+7)&~7; + paNew = sqlite3DbMallocRawNN(db, sizeof(p->aLTerm[0])*n); + if( paNew==0 ) return SQLITE_NOMEM_BKPT; + memcpy(paNew, p->aLTerm, sizeof(p->aLTerm[0])*p->nLSlot); + if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFreeNN(db, p->aLTerm); + p->aLTerm = paNew; + p->nLSlot = n; + return SQLITE_OK; +} + +/* +** Transfer content from the second pLoop into the first. +*/ +static int whereLoopXfer(sqlite3 *db, WhereLoop *pTo, WhereLoop *pFrom){ + whereLoopClearUnion(db, pTo); + if( whereLoopResize(db, pTo, pFrom->nLTerm) ){ + memset(&pTo->u, 0, sizeof(pTo->u)); + return SQLITE_NOMEM_BKPT; + } + memcpy(pTo, pFrom, WHERE_LOOP_XFER_SZ); + memcpy(pTo->aLTerm, pFrom->aLTerm, pTo->nLTerm*sizeof(pTo->aLTerm[0])); + if( pFrom->wsFlags & WHERE_VIRTUALTABLE ){ + pFrom->u.vtab.needFree = 0; + }else if( (pFrom->wsFlags & WHERE_AUTO_INDEX)!=0 ){ + pFrom->u.btree.pIndex = 0; + } + return SQLITE_OK; +} + +/* +** Delete a WhereLoop object +*/ +static void whereLoopDelete(sqlite3 *db, WhereLoop *p){ + whereLoopClear(db, p); + sqlite3DbFreeNN(db, p); +} + +/* +** Free a WhereInfo structure +*/ +static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){ + int i; + assert( pWInfo!=0 ); + for(i=0; inLevel; i++){ + WhereLevel *pLevel = &pWInfo->a[i]; + if( pLevel->pWLoop && (pLevel->pWLoop->wsFlags & WHERE_IN_ABLE) ){ + sqlite3DbFree(db, pLevel->u.in.aInLoop); + } + } + sqlite3WhereClauseClear(&pWInfo->sWC); + while( pWInfo->pLoops ){ + WhereLoop *p = pWInfo->pLoops; + pWInfo->pLoops = p->pNextLoop; + whereLoopDelete(db, p); + } + assert( pWInfo->pExprMods==0 ); + sqlite3DbFreeNN(db, pWInfo); +} + +/* +** Return TRUE if all of the following are true: +** +** (1) X has the same or lower cost that Y +** (2) X uses fewer WHERE clause terms than Y +** (3) Every WHERE clause term used by X is also used by Y +** (4) X skips at least as many columns as Y +** (5) If X is a covering index, than Y is too +** +** Conditions (2) and (3) mean that X is a "proper subset" of Y. +** If X is a proper subset of Y then Y is a better choice and ought +** to have a lower cost. This routine returns TRUE when that cost +** relationship is inverted and needs to be adjusted. Constraint (4) +** was added because if X uses skip-scan less than Y it still might +** deserve a lower cost even if it is a proper subset of Y. Constraint (5) +** was added because a covering index probably deserves to have a lower cost +** than a non-covering index even if it is a proper subset. +*/ +static int whereLoopCheaperProperSubset( + const WhereLoop *pX, /* First WhereLoop to compare */ + const WhereLoop *pY /* Compare against this WhereLoop */ +){ + int i, j; + if( pX->nLTerm-pX->nSkip >= pY->nLTerm-pY->nSkip ){ + return 0; /* X is not a subset of Y */ + } + if( pY->nSkip > pX->nSkip ) return 0; + if( pX->rRun >= pY->rRun ){ + if( pX->rRun > pY->rRun ) return 0; /* X costs more than Y */ + if( pX->nOut > pY->nOut ) return 0; /* X costs more than Y */ + } + for(i=pX->nLTerm-1; i>=0; i--){ + if( pX->aLTerm[i]==0 ) continue; + for(j=pY->nLTerm-1; j>=0; j--){ + if( pY->aLTerm[j]==pX->aLTerm[i] ) break; + } + if( j<0 ) return 0; /* X not a subset of Y since term X[i] not used by Y */ + } + if( (pX->wsFlags&WHERE_IDX_ONLY)!=0 + && (pY->wsFlags&WHERE_IDX_ONLY)==0 ){ + return 0; /* Constraint (5) */ + } + return 1; /* All conditions meet */ +} + +/* +** Try to adjust the cost of WhereLoop pTemplate upwards or downwards so +** that: +** +** (1) pTemplate costs less than any other WhereLoops that are a proper +** subset of pTemplate +** +** (2) pTemplate costs more than any other WhereLoops for which pTemplate +** is a proper subset. +** +** To say "WhereLoop X is a proper subset of Y" means that X uses fewer +** WHERE clause terms than Y and that every WHERE clause term used by X is +** also used by Y. +*/ +static void whereLoopAdjustCost(const WhereLoop *p, WhereLoop *pTemplate){ + if( (pTemplate->wsFlags & WHERE_INDEXED)==0 ) return; + for(; p; p=p->pNextLoop){ + if( p->iTab!=pTemplate->iTab ) continue; + if( (p->wsFlags & WHERE_INDEXED)==0 ) continue; + if( whereLoopCheaperProperSubset(p, pTemplate) ){ + /* Adjust pTemplate cost downward so that it is cheaper than its + ** subset p. */ + WHERETRACE(0x80,("subset cost adjustment %d,%d to %d,%d\n", + pTemplate->rRun, pTemplate->nOut, p->rRun, p->nOut-1)); + pTemplate->rRun = p->rRun; + pTemplate->nOut = p->nOut - 1; + }else if( whereLoopCheaperProperSubset(pTemplate, p) ){ + /* Adjust pTemplate cost upward so that it is costlier than p since + ** pTemplate is a proper subset of p */ + WHERETRACE(0x80,("subset cost adjustment %d,%d to %d,%d\n", + pTemplate->rRun, pTemplate->nOut, p->rRun, p->nOut+1)); + pTemplate->rRun = p->rRun; + pTemplate->nOut = p->nOut + 1; + } + } +} + +/* +** Search the list of WhereLoops in *ppPrev looking for one that can be +** replaced by pTemplate. +** +** Return NULL if pTemplate does not belong on the WhereLoop list. +** In other words if pTemplate ought to be dropped from further consideration. +** +** If pX is a WhereLoop that pTemplate can replace, then return the +** link that points to pX. +** +** If pTemplate cannot replace any existing element of the list but needs +** to be added to the list as a new entry, then return a pointer to the +** tail of the list. +*/ +static WhereLoop **whereLoopFindLesser( + WhereLoop **ppPrev, + const WhereLoop *pTemplate +){ + WhereLoop *p; + for(p=(*ppPrev); p; ppPrev=&p->pNextLoop, p=*ppPrev){ + if( p->iTab!=pTemplate->iTab || p->iSortIdx!=pTemplate->iSortIdx ){ + /* If either the iTab or iSortIdx values for two WhereLoop are different + ** then those WhereLoops need to be considered separately. Neither is + ** a candidate to replace the other. */ + continue; + } + /* In the current implementation, the rSetup value is either zero + ** or the cost of building an automatic index (NlogN) and the NlogN + ** is the same for compatible WhereLoops. */ + assert( p->rSetup==0 || pTemplate->rSetup==0 + || p->rSetup==pTemplate->rSetup ); + + /* whereLoopAddBtree() always generates and inserts the automatic index + ** case first. Hence compatible candidate WhereLoops never have a larger + ** rSetup. Call this SETUP-INVARIANT */ + assert( p->rSetup>=pTemplate->rSetup ); + + /* Any loop using an appliation-defined index (or PRIMARY KEY or + ** UNIQUE constraint) with one or more == constraints is better + ** than an automatic index. Unless it is a skip-scan. */ + if( (p->wsFlags & WHERE_AUTO_INDEX)!=0 + && (pTemplate->nSkip)==0 + && (pTemplate->wsFlags & WHERE_INDEXED)!=0 + && (pTemplate->wsFlags & WHERE_COLUMN_EQ)!=0 + && (p->prereq & pTemplate->prereq)==pTemplate->prereq + ){ + break; + } + + /* If existing WhereLoop p is better than pTemplate, pTemplate can be + ** discarded. WhereLoop p is better if: + ** (1) p has no more dependencies than pTemplate, and + ** (2) p has an equal or lower cost than pTemplate + */ + if( (p->prereq & pTemplate->prereq)==p->prereq /* (1) */ + && p->rSetup<=pTemplate->rSetup /* (2a) */ + && p->rRun<=pTemplate->rRun /* (2b) */ + && p->nOut<=pTemplate->nOut /* (2c) */ + ){ + return 0; /* Discard pTemplate */ + } + + /* If pTemplate is always better than p, then cause p to be overwritten + ** with pTemplate. pTemplate is better than p if: + ** (1) pTemplate has no more dependences than p, and + ** (2) pTemplate has an equal or lower cost than p. + */ + if( (p->prereq & pTemplate->prereq)==pTemplate->prereq /* (1) */ + && p->rRun>=pTemplate->rRun /* (2a) */ + && p->nOut>=pTemplate->nOut /* (2b) */ + ){ + assert( p->rSetup>=pTemplate->rSetup ); /* SETUP-INVARIANT above */ + break; /* Cause p to be overwritten by pTemplate */ + } + } + return ppPrev; +} + +/* +** Insert or replace a WhereLoop entry using the template supplied. +** +** An existing WhereLoop entry might be overwritten if the new template +** is better and has fewer dependencies. Or the template will be ignored +** and no insert will occur if an existing WhereLoop is faster and has +** fewer dependencies than the template. Otherwise a new WhereLoop is +** added based on the template. +** +** If pBuilder->pOrSet is not NULL then we care about only the +** prerequisites and rRun and nOut costs of the N best loops. That +** information is gathered in the pBuilder->pOrSet object. This special +** processing mode is used only for OR clause processing. +** +** When accumulating multiple loops (when pBuilder->pOrSet is NULL) we +** still might overwrite similar loops with the new template if the +** new template is better. Loops may be overwritten if the following +** conditions are met: +** +** (1) They have the same iTab. +** (2) They have the same iSortIdx. +** (3) The template has same or fewer dependencies than the current loop +** (4) The template has the same or lower cost than the current loop +*/ +static int whereLoopInsert(WhereLoopBuilder *pBuilder, WhereLoop *pTemplate){ + WhereLoop **ppPrev, *p; + WhereInfo *pWInfo = pBuilder->pWInfo; + sqlite3 *db = pWInfo->pParse->db; + int rc; + + /* Stop the search once we hit the query planner search limit */ + if( pBuilder->iPlanLimit==0 ){ + WHERETRACE(0xffffffff,("=== query planner search limit reached ===\n")); + if( pBuilder->pOrSet ) pBuilder->pOrSet->n = 0; + return SQLITE_DONE; + } + pBuilder->iPlanLimit--; + + whereLoopAdjustCost(pWInfo->pLoops, pTemplate); + + /* If pBuilder->pOrSet is defined, then only keep track of the costs + ** and prereqs. + */ + if( pBuilder->pOrSet!=0 ){ + if( pTemplate->nLTerm ){ +#if WHERETRACE_ENABLED + u16 n = pBuilder->pOrSet->n; + int x = +#endif + whereOrInsert(pBuilder->pOrSet, pTemplate->prereq, pTemplate->rRun, + pTemplate->nOut); +#if WHERETRACE_ENABLED /* 0x8 */ + if( sqlite3WhereTrace & 0x8 ){ + sqlite3DebugPrintf(x?" or-%d: ":" or-X: ", n); + sqlite3WhereLoopPrint(pTemplate, pBuilder->pWC); + } +#endif + } + return SQLITE_OK; + } + + /* Look for an existing WhereLoop to replace with pTemplate + */ + ppPrev = whereLoopFindLesser(&pWInfo->pLoops, pTemplate); + + if( ppPrev==0 ){ + /* There already exists a WhereLoop on the list that is better + ** than pTemplate, so just ignore pTemplate */ +#if WHERETRACE_ENABLED /* 0x8 */ + if( sqlite3WhereTrace & 0x8 ){ + sqlite3DebugPrintf(" skip: "); + sqlite3WhereLoopPrint(pTemplate, pBuilder->pWC); + } +#endif + return SQLITE_OK; + }else{ + p = *ppPrev; + } + + /* If we reach this point it means that either p[] should be overwritten + ** with pTemplate[] if p[] exists, or if p==NULL then allocate a new + ** WhereLoop and insert it. + */ +#if WHERETRACE_ENABLED /* 0x8 */ + if( sqlite3WhereTrace & 0x8 ){ + if( p!=0 ){ + sqlite3DebugPrintf("replace: "); + sqlite3WhereLoopPrint(p, pBuilder->pWC); + sqlite3DebugPrintf(" with: "); + }else{ + sqlite3DebugPrintf(" add: "); + } + sqlite3WhereLoopPrint(pTemplate, pBuilder->pWC); + } +#endif + if( p==0 ){ + /* Allocate a new WhereLoop to add to the end of the list */ + *ppPrev = p = sqlite3DbMallocRawNN(db, sizeof(WhereLoop)); + if( p==0 ) return SQLITE_NOMEM_BKPT; + whereLoopInit(p); + p->pNextLoop = 0; + }else{ + /* We will be overwriting WhereLoop p[]. But before we do, first + ** go through the rest of the list and delete any other entries besides + ** p[] that are also supplated by pTemplate */ + WhereLoop **ppTail = &p->pNextLoop; + WhereLoop *pToDel; + while( *ppTail ){ + ppTail = whereLoopFindLesser(ppTail, pTemplate); + if( ppTail==0 ) break; + pToDel = *ppTail; + if( pToDel==0 ) break; + *ppTail = pToDel->pNextLoop; +#if WHERETRACE_ENABLED /* 0x8 */ + if( sqlite3WhereTrace & 0x8 ){ + sqlite3DebugPrintf(" delete: "); + sqlite3WhereLoopPrint(pToDel, pBuilder->pWC); + } +#endif + whereLoopDelete(db, pToDel); + } + } + rc = whereLoopXfer(db, p, pTemplate); + if( (p->wsFlags & WHERE_VIRTUALTABLE)==0 ){ + Index *pIndex = p->u.btree.pIndex; + if( pIndex && pIndex->idxType==SQLITE_IDXTYPE_IPK ){ + p->u.btree.pIndex = 0; + } + } + return rc; +} + +/* +** Adjust the WhereLoop.nOut value downward to account for terms of the +** WHERE clause that reference the loop but which are not used by an +** index. +* +** For every WHERE clause term that is not used by the index +** and which has a truth probability assigned by one of the likelihood(), +** likely(), or unlikely() SQL functions, reduce the estimated number +** of output rows by the probability specified. +** +** TUNING: For every WHERE clause term that is not used by the index +** and which does not have an assigned truth probability, heuristics +** described below are used to try to estimate the truth probability. +** TODO --> Perhaps this is something that could be improved by better +** table statistics. +** +** Heuristic 1: Estimate the truth probability as 93.75%. The 93.75% +** value corresponds to -1 in LogEst notation, so this means decrement +** the WhereLoop.nOut field for every such WHERE clause term. +** +** Heuristic 2: If there exists one or more WHERE clause terms of the +** form "x==EXPR" and EXPR is not a constant 0 or 1, then make sure the +** final output row estimate is no greater than 1/4 of the total number +** of rows in the table. In other words, assume that x==EXPR will filter +** out at least 3 out of 4 rows. If EXPR is -1 or 0 or 1, then maybe the +** "x" column is boolean or else -1 or 0 or 1 is a common default value +** on the "x" column and so in that case only cap the output row estimate +** at 1/2 instead of 1/4. +*/ +static void whereLoopOutputAdjust( + WhereClause *pWC, /* The WHERE clause */ + WhereLoop *pLoop, /* The loop to adjust downward */ + LogEst nRow /* Number of rows in the entire table */ +){ + WhereTerm *pTerm, *pX; + Bitmask notAllowed = ~(pLoop->prereq|pLoop->maskSelf); + int i, j; + LogEst iReduce = 0; /* pLoop->nOut should not exceed nRow-iReduce */ + + assert( (pLoop->wsFlags & WHERE_AUTO_INDEX)==0 ); + for(i=pWC->nTerm, pTerm=pWC->a; i>0; i--, pTerm++){ + assert( pTerm!=0 ); + if( (pTerm->wtFlags & TERM_VIRTUAL)!=0 ) break; + if( (pTerm->prereqAll & pLoop->maskSelf)==0 ) continue; + if( (pTerm->prereqAll & notAllowed)!=0 ) continue; + for(j=pLoop->nLTerm-1; j>=0; j--){ + pX = pLoop->aLTerm[j]; + if( pX==0 ) continue; + if( pX==pTerm ) break; + if( pX->iParent>=0 && (&pWC->a[pX->iParent])==pTerm ) break; + } + if( j<0 ){ + if( pTerm->truthProb<=0 ){ + /* If a truth probability is specified using the likelihood() hints, + ** then use the probability provided by the application. */ + pLoop->nOut += pTerm->truthProb; + }else{ + /* In the absence of explicit truth probabilities, use heuristics to + ** guess a reasonable truth probability. */ + pLoop->nOut--; + if( (pTerm->eOperator&(WO_EQ|WO_IS))!=0 + && (pTerm->wtFlags & TERM_HIGHTRUTH)==0 /* tag-20200224-1 */ + ){ + Expr *pRight = pTerm->pExpr->pRight; + int k = 0; + testcase( pTerm->pExpr->op==TK_IS ); + if( sqlite3ExprIsInteger(pRight, &k) && k>=(-1) && k<=1 ){ + k = 10; + }else{ + k = 20; + } + if( iReducewtFlags |= TERM_HEURTRUTH; + iReduce = k; + } + } + } + } + } + if( pLoop->nOut > nRow-iReduce ) pLoop->nOut = nRow - iReduce; +} + +/* +** Term pTerm is a vector range comparison operation. The first comparison +** in the vector can be optimized using column nEq of the index. This +** function returns the total number of vector elements that can be used +** as part of the range comparison. +** +** For example, if the query is: +** +** WHERE a = ? AND (b, c, d) > (?, ?, ?) +** +** and the index: +** +** CREATE INDEX ... ON (a, b, c, d, e) +** +** then this function would be invoked with nEq=1. The value returned in +** this case is 3. +*/ +static int whereRangeVectorLen( + Parse *pParse, /* Parsing context */ + int iCur, /* Cursor open on pIdx */ + Index *pIdx, /* The index to be used for a inequality constraint */ + int nEq, /* Number of prior equality constraints on same index */ + WhereTerm *pTerm /* The vector inequality constraint */ +){ + int nCmp = sqlite3ExprVectorSize(pTerm->pExpr->pLeft); + int i; + + nCmp = MIN(nCmp, (pIdx->nColumn - nEq)); + for(i=1; ipExpr->pLeft->x.pList->a[i].pExpr; + Expr *pRhs = pTerm->pExpr->pRight; + if( pRhs->flags & EP_xIsSelect ){ + pRhs = pRhs->x.pSelect->pEList->a[i].pExpr; + }else{ + pRhs = pRhs->x.pList->a[i].pExpr; + } + + /* Check that the LHS of the comparison is a column reference to + ** the right column of the right source table. And that the sort + ** order of the index column is the same as the sort order of the + ** leftmost index column. */ + if( pLhs->op!=TK_COLUMN + || pLhs->iTable!=iCur + || pLhs->iColumn!=pIdx->aiColumn[i+nEq] + || pIdx->aSortOrder[i+nEq]!=pIdx->aSortOrder[nEq] + ){ + break; + } + + testcase( pLhs->iColumn==XN_ROWID ); + aff = sqlite3CompareAffinity(pRhs, sqlite3ExprAffinity(pLhs)); + idxaff = sqlite3TableColumnAffinity(pIdx->pTable, pLhs->iColumn); + if( aff!=idxaff ) break; + + pColl = sqlite3BinaryCompareCollSeq(pParse, pLhs, pRhs); + if( pColl==0 ) break; + if( sqlite3StrICmp(pColl->zName, pIdx->azColl[i+nEq]) ) break; + } + return i; +} + +/* +** Adjust the cost C by the costMult facter T. This only occurs if +** compiled with -DSQLITE_ENABLE_COSTMULT +*/ +#ifdef SQLITE_ENABLE_COSTMULT +# define ApplyCostMultiplier(C,T) C += T +#else +# define ApplyCostMultiplier(C,T) +#endif + +/* +** We have so far matched pBuilder->pNew->u.btree.nEq terms of the +** index pIndex. Try to match one more. +** +** When this function is called, pBuilder->pNew->nOut contains the +** number of rows expected to be visited by filtering using the nEq +** terms only. If it is modified, this value is restored before this +** function returns. +** +** If pProbe->idxType==SQLITE_IDXTYPE_IPK, that means pIndex is +** a fake index used for the INTEGER PRIMARY KEY. +*/ +static int whereLoopAddBtreeIndex( + WhereLoopBuilder *pBuilder, /* The WhereLoop factory */ + struct SrcList_item *pSrc, /* FROM clause term being analyzed */ + Index *pProbe, /* An index on pSrc */ + LogEst nInMul /* log(Number of iterations due to IN) */ +){ + WhereInfo *pWInfo = pBuilder->pWInfo; /* WHERE analyse context */ + Parse *pParse = pWInfo->pParse; /* Parsing context */ + sqlite3 *db = pParse->db; /* Database connection malloc context */ + WhereLoop *pNew; /* Template WhereLoop under construction */ + WhereTerm *pTerm; /* A WhereTerm under consideration */ + int opMask; /* Valid operators for constraints */ + WhereScan scan; /* Iterator for WHERE terms */ + Bitmask saved_prereq; /* Original value of pNew->prereq */ + u16 saved_nLTerm; /* Original value of pNew->nLTerm */ + u16 saved_nEq; /* Original value of pNew->u.btree.nEq */ + u16 saved_nBtm; /* Original value of pNew->u.btree.nBtm */ + u16 saved_nTop; /* Original value of pNew->u.btree.nTop */ + u16 saved_nSkip; /* Original value of pNew->nSkip */ + u32 saved_wsFlags; /* Original value of pNew->wsFlags */ + LogEst saved_nOut; /* Original value of pNew->nOut */ + int rc = SQLITE_OK; /* Return code */ + LogEst rSize; /* Number of rows in the table */ + LogEst rLogSize; /* Logarithm of table size */ + WhereTerm *pTop = 0, *pBtm = 0; /* Top and bottom range constraints */ + + pNew = pBuilder->pNew; + if( db->mallocFailed ) return SQLITE_NOMEM_BKPT; + WHERETRACE(0x800, ("BEGIN %s.addBtreeIdx(%s), nEq=%d, nSkip=%d, rRun=%d\n", + pProbe->pTable->zName,pProbe->zName, + pNew->u.btree.nEq, pNew->nSkip, pNew->rRun)); + + assert( (pNew->wsFlags & WHERE_VIRTUALTABLE)==0 ); + assert( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 ); + if( pNew->wsFlags & WHERE_BTM_LIMIT ){ + opMask = WO_LT|WO_LE; + }else{ + assert( pNew->u.btree.nBtm==0 ); + opMask = WO_EQ|WO_IN|WO_GT|WO_GE|WO_LT|WO_LE|WO_ISNULL|WO_IS; + } + if( pProbe->bUnordered ) opMask &= ~(WO_GT|WO_GE|WO_LT|WO_LE); + + assert( pNew->u.btree.nEqnColumn ); + + saved_nEq = pNew->u.btree.nEq; + saved_nBtm = pNew->u.btree.nBtm; + saved_nTop = pNew->u.btree.nTop; + saved_nSkip = pNew->nSkip; + saved_nLTerm = pNew->nLTerm; + saved_wsFlags = pNew->wsFlags; + saved_prereq = pNew->prereq; + saved_nOut = pNew->nOut; + pTerm = whereScanInit(&scan, pBuilder->pWC, pSrc->iCursor, saved_nEq, + opMask, pProbe); + pNew->rSetup = 0; + rSize = pProbe->aiRowLogEst[0]; + rLogSize = estLog(rSize); + for(; rc==SQLITE_OK && pTerm!=0; pTerm = whereScanNext(&scan)){ + u16 eOp = pTerm->eOperator; /* Shorthand for pTerm->eOperator */ + LogEst rCostIdx; + LogEst nOutUnadjusted; /* nOut before IN() and WHERE adjustments */ + int nIn = 0; +#ifdef SQLITE_ENABLE_STAT4 + int nRecValid = pBuilder->nRecValid; +#endif + if( (eOp==WO_ISNULL || (pTerm->wtFlags&TERM_VNULL)!=0) + && indexColumnNotNull(pProbe, saved_nEq) + ){ + continue; /* ignore IS [NOT] NULL constraints on NOT NULL columns */ + } + if( pTerm->prereqRight & pNew->maskSelf ) continue; + + /* Do not allow the upper bound of a LIKE optimization range constraint + ** to mix with a lower range bound from some other source */ + if( pTerm->wtFlags & TERM_LIKEOPT && pTerm->eOperator==WO_LT ) continue; + + /* tag-20191211-001: Do not allow constraints from the WHERE clause to + ** be used by the right table of a LEFT JOIN. Only constraints in the + ** ON clause are allowed. See tag-20191211-002 for the vtab equivalent. */ + if( (pSrc->fg.jointype & JT_LEFT)!=0 + && !ExprHasProperty(pTerm->pExpr, EP_FromJoin) + ){ + continue; + } + + if( IsUniqueIndex(pProbe) && saved_nEq==pProbe->nKeyCol-1 ){ + pBuilder->bldFlags1 |= SQLITE_BLDF1_UNIQUE; + }else{ + pBuilder->bldFlags1 |= SQLITE_BLDF1_INDEXED; + } + pNew->wsFlags = saved_wsFlags; + pNew->u.btree.nEq = saved_nEq; + pNew->u.btree.nBtm = saved_nBtm; + pNew->u.btree.nTop = saved_nTop; + pNew->nLTerm = saved_nLTerm; + if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */ + pNew->aLTerm[pNew->nLTerm++] = pTerm; + pNew->prereq = (saved_prereq | pTerm->prereqRight) & ~pNew->maskSelf; + + assert( nInMul==0 + || (pNew->wsFlags & WHERE_COLUMN_NULL)!=0 + || (pNew->wsFlags & WHERE_COLUMN_IN)!=0 + || (pNew->wsFlags & WHERE_SKIPSCAN)!=0 + ); + + if( eOp & WO_IN ){ + Expr *pExpr = pTerm->pExpr; + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + /* "x IN (SELECT ...)": TUNING: the SELECT returns 25 rows */ + int i; + nIn = 46; assert( 46==sqlite3LogEst(25) ); + + /* The expression may actually be of the form (x, y) IN (SELECT...). + ** In this case there is a separate term for each of (x) and (y). + ** However, the nIn multiplier should only be applied once, not once + ** for each such term. The following loop checks that pTerm is the + ** first such term in use, and sets nIn back to 0 if it is not. */ + for(i=0; inLTerm-1; i++){ + if( pNew->aLTerm[i] && pNew->aLTerm[i]->pExpr==pExpr ) nIn = 0; + } + }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){ + /* "x IN (value, value, ...)" */ + nIn = sqlite3LogEst(pExpr->x.pList->nExpr); + } + if( pProbe->hasStat1 && rLogSize>=10 ){ + LogEst M, logK, safetyMargin; + /* Let: + ** N = the total number of rows in the table + ** K = the number of entries on the RHS of the IN operator + ** M = the number of rows in the table that match terms to the + ** to the left in the same index. If the IN operator is on + ** the left-most index column, M==N. + ** + ** Given the definitions above, it is better to omit the IN operator + ** from the index lookup and instead do a scan of the M elements, + ** testing each scanned row against the IN operator separately, if: + ** + ** M*log(K) < K*log(N) + ** + ** Our estimates for M, K, and N might be inaccurate, so we build in + ** a safety margin of 2 (LogEst: 10) that favors using the IN operator + ** with the index, as using an index has better worst-case behavior. + ** If we do not have real sqlite_stat1 data, always prefer to use + ** the index. Do not bother with this optimization on very small + ** tables (less than 2 rows) as it is pointless in that case. + */ + M = pProbe->aiRowLogEst[saved_nEq]; + logK = estLog(nIn); + safetyMargin = 10; /* TUNING: extra weight for indexed IN */ + if( M + logK + safetyMargin < nIn + rLogSize ){ + WHERETRACE(0x40, + ("Scan preferred over IN operator on column %d of \"%s\" (%d<%d)\n", + saved_nEq, pProbe->zName, M+logK+10, nIn+rLogSize)); + pNew->wsFlags |= WHERE_IN_SEEKSCAN; + }else{ + WHERETRACE(0x40, + ("IN operator preferred on column %d of \"%s\" (%d>=%d)\n", + saved_nEq, pProbe->zName, M+logK+10, nIn+rLogSize)); + } + } + pNew->wsFlags |= WHERE_COLUMN_IN; + }else if( eOp & (WO_EQ|WO_IS) ){ + int iCol = pProbe->aiColumn[saved_nEq]; + pNew->wsFlags |= WHERE_COLUMN_EQ; + assert( saved_nEq==pNew->u.btree.nEq ); + if( iCol==XN_ROWID + || (iCol>=0 && nInMul==0 && saved_nEq==pProbe->nKeyCol-1) + ){ + if( iCol==XN_ROWID || pProbe->uniqNotNull + || (pProbe->nKeyCol==1 && pProbe->onError && eOp==WO_EQ) + ){ + pNew->wsFlags |= WHERE_ONEROW; + }else{ + pNew->wsFlags |= WHERE_UNQ_WANTED; + } + } + }else if( eOp & WO_ISNULL ){ + pNew->wsFlags |= WHERE_COLUMN_NULL; + }else if( eOp & (WO_GT|WO_GE) ){ + testcase( eOp & WO_GT ); + testcase( eOp & WO_GE ); + pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_BTM_LIMIT; + pNew->u.btree.nBtm = whereRangeVectorLen( + pParse, pSrc->iCursor, pProbe, saved_nEq, pTerm + ); + pBtm = pTerm; + pTop = 0; + if( pTerm->wtFlags & TERM_LIKEOPT ){ + /* Range contraints that come from the LIKE optimization are + ** always used in pairs. */ + pTop = &pTerm[1]; + assert( (pTop-(pTerm->pWC->a))pWC->nTerm ); + assert( pTop->wtFlags & TERM_LIKEOPT ); + assert( pTop->eOperator==WO_LT ); + if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */ + pNew->aLTerm[pNew->nLTerm++] = pTop; + pNew->wsFlags |= WHERE_TOP_LIMIT; + pNew->u.btree.nTop = 1; + } + }else{ + assert( eOp & (WO_LT|WO_LE) ); + testcase( eOp & WO_LT ); + testcase( eOp & WO_LE ); + pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_TOP_LIMIT; + pNew->u.btree.nTop = whereRangeVectorLen( + pParse, pSrc->iCursor, pProbe, saved_nEq, pTerm + ); + pTop = pTerm; + pBtm = (pNew->wsFlags & WHERE_BTM_LIMIT)!=0 ? + pNew->aLTerm[pNew->nLTerm-2] : 0; + } + + /* At this point pNew->nOut is set to the number of rows expected to + ** be visited by the index scan before considering term pTerm, or the + ** values of nIn and nInMul. In other words, assuming that all + ** "x IN(...)" terms are replaced with "x = ?". This block updates + ** the value of pNew->nOut to account for pTerm (but not nIn/nInMul). */ + assert( pNew->nOut==saved_nOut ); + if( pNew->wsFlags & WHERE_COLUMN_RANGE ){ + /* Adjust nOut using stat4 data. Or, if there is no stat4 + ** data, using some other estimate. */ + whereRangeScanEst(pParse, pBuilder, pBtm, pTop, pNew); + }else{ + int nEq = ++pNew->u.btree.nEq; + assert( eOp & (WO_ISNULL|WO_EQ|WO_IN|WO_IS) ); + + assert( pNew->nOut==saved_nOut ); + if( pTerm->truthProb<=0 && pProbe->aiColumn[saved_nEq]>=0 ){ + assert( (eOp & WO_IN) || nIn==0 ); + testcase( eOp & WO_IN ); + pNew->nOut += pTerm->truthProb; + pNew->nOut -= nIn; + }else{ +#ifdef SQLITE_ENABLE_STAT4 + tRowcnt nOut = 0; + if( nInMul==0 + && pProbe->nSample + && pNew->u.btree.nEq<=pProbe->nSampleCol + && ((eOp & WO_IN)==0 || !ExprHasProperty(pTerm->pExpr, EP_xIsSelect)) + && OptimizationEnabled(db, SQLITE_Stat4) + ){ + Expr *pExpr = pTerm->pExpr; + if( (eOp & (WO_EQ|WO_ISNULL|WO_IS))!=0 ){ + testcase( eOp & WO_EQ ); + testcase( eOp & WO_IS ); + testcase( eOp & WO_ISNULL ); + rc = whereEqualScanEst(pParse, pBuilder, pExpr->pRight, &nOut); + }else{ + rc = whereInScanEst(pParse, pBuilder, pExpr->x.pList, &nOut); + } + if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK; + if( rc!=SQLITE_OK ) break; /* Jump out of the pTerm loop */ + if( nOut ){ + pNew->nOut = sqlite3LogEst(nOut); + if( nEq==1 + /* TUNING: Mark terms as "low selectivity" if they seem likely + ** to be true for half or more of the rows in the table. + ** See tag-202002240-1 */ + && pNew->nOut+10 > pProbe->aiRowLogEst[0] + ){ +#if WHERETRACE_ENABLED /* 0x01 */ + if( sqlite3WhereTrace & 0x01 ){ + sqlite3DebugPrintf( + "STAT4 determines term has low selectivity:\n"); + sqlite3WhereTermPrint(pTerm, 999); + } +#endif + pTerm->wtFlags |= TERM_HIGHTRUTH; + if( pTerm->wtFlags & TERM_HEURTRUTH ){ + /* If the term has previously been used with an assumption of + ** higher selectivity, then set the flag to rerun the + ** loop computations. */ + pBuilder->bldFlags2 |= SQLITE_BLDF2_2NDPASS; + } + } + if( pNew->nOut>saved_nOut ) pNew->nOut = saved_nOut; + pNew->nOut -= nIn; + } + } + if( nOut==0 ) +#endif + { + pNew->nOut += (pProbe->aiRowLogEst[nEq] - pProbe->aiRowLogEst[nEq-1]); + if( eOp & WO_ISNULL ){ + /* TUNING: If there is no likelihood() value, assume that a + ** "col IS NULL" expression matches twice as many rows + ** as (col=?). */ + pNew->nOut += 10; + } + } + } + } + + /* Set rCostIdx to the cost of visiting selected rows in index. Add + ** it to pNew->rRun, which is currently set to the cost of the index + ** 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; + pNew->rRun = sqlite3LogEstAdd(rLogSize, rCostIdx); + if( (pNew->wsFlags & (WHERE_IDX_ONLY|WHERE_IPK))==0 ){ + pNew->rRun = sqlite3LogEstAdd(pNew->rRun, pNew->nOut + 16); + } + ApplyCostMultiplier(pNew->rRun, pProbe->pTable->costMult); + + nOutUnadjusted = pNew->nOut; + pNew->rRun += nInMul + nIn; + pNew->nOut += nInMul + nIn; + whereLoopOutputAdjust(pBuilder->pWC, pNew, rSize); + rc = whereLoopInsert(pBuilder, pNew); + + if( pNew->wsFlags & WHERE_COLUMN_RANGE ){ + pNew->nOut = saved_nOut; + }else{ + pNew->nOut = nOutUnadjusted; + } + + if( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 + && pNew->u.btree.nEqnColumn + ){ + whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, nInMul+nIn); + } + pNew->nOut = saved_nOut; +#ifdef SQLITE_ENABLE_STAT4 + pBuilder->nRecValid = nRecValid; +#endif + } + pNew->prereq = saved_prereq; + pNew->u.btree.nEq = saved_nEq; + pNew->u.btree.nBtm = saved_nBtm; + pNew->u.btree.nTop = saved_nTop; + pNew->nSkip = saved_nSkip; + pNew->wsFlags = saved_wsFlags; + pNew->nOut = saved_nOut; + pNew->nLTerm = saved_nLTerm; + + /* Consider using a skip-scan if there are no WHERE clause constraints + ** available for the left-most terms of the index, and if the average + ** number of repeats in the left-most terms is at least 18. + ** + ** The magic number 18 is selected on the basis that scanning 17 rows + ** is almost always quicker than an index seek (even though if the index + ** contains fewer than 2^17 rows we assume otherwise in other parts of + ** the code). And, even if it is not, it should not be too much slower. + ** On the other hand, the extra seeks could end up being significantly + ** more expensive. */ + assert( 42==sqlite3LogEst(18) ); + if( saved_nEq==saved_nSkip + && saved_nEq+1nKeyCol + && saved_nEq==pNew->nLTerm + && pProbe->noSkipScan==0 + && pProbe->hasStat1!=0 + && OptimizationEnabled(db, SQLITE_SkipScan) + && pProbe->aiRowLogEst[saved_nEq+1]>=42 /* TUNING: Minimum for skip-scan */ + && (rc = whereLoopResize(db, pNew, pNew->nLTerm+1))==SQLITE_OK + ){ + LogEst nIter; + pNew->u.btree.nEq++; + pNew->nSkip++; + pNew->aLTerm[pNew->nLTerm++] = 0; + pNew->wsFlags |= WHERE_SKIPSCAN; + nIter = pProbe->aiRowLogEst[saved_nEq] - pProbe->aiRowLogEst[saved_nEq+1]; + pNew->nOut -= nIter; + /* TUNING: Because uncertainties in the estimates for skip-scan queries, + ** add a 1.375 fudge factor to make skip-scan slightly less likely. */ + nIter += 5; + whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, nIter + nInMul); + pNew->nOut = saved_nOut; + pNew->u.btree.nEq = saved_nEq; + pNew->nSkip = saved_nSkip; + pNew->wsFlags = saved_wsFlags; + } + + WHERETRACE(0x800, ("END %s.addBtreeIdx(%s), nEq=%d, rc=%d\n", + pProbe->pTable->zName, pProbe->zName, saved_nEq, rc)); + return rc; +} + +/* +** Return True if it is possible that pIndex might be useful in +** implementing the ORDER BY clause in pBuilder. +** +** Return False if pBuilder does not contain an ORDER BY clause or +** if there is no way for pIndex to be useful in implementing that +** ORDER BY clause. +*/ +static int indexMightHelpWithOrderBy( + WhereLoopBuilder *pBuilder, + Index *pIndex, + int iCursor +){ + ExprList *pOB; + ExprList *aColExpr; + int ii, jj; + + if( pIndex->bUnordered ) return 0; + if( (pOB = pBuilder->pWInfo->pOrderBy)==0 ) return 0; + for(ii=0; iinExpr; ii++){ + Expr *pExpr = sqlite3ExprSkipCollateAndLikely(pOB->a[ii].pExpr); + if( NEVER(pExpr==0) ) continue; + if( pExpr->op==TK_COLUMN && pExpr->iTable==iCursor ){ + if( pExpr->iColumn<0 ) return 1; + for(jj=0; jjnKeyCol; jj++){ + if( pExpr->iColumn==pIndex->aiColumn[jj] ) return 1; + } + }else if( (aColExpr = pIndex->aColExpr)!=0 ){ + for(jj=0; jjnKeyCol; jj++){ + if( pIndex->aiColumn[jj]!=XN_EXPR ) continue; + if( sqlite3ExprCompareSkip(pExpr,aColExpr->a[jj].pExpr,iCursor)==0 ){ + return 1; + } + } + } + } + return 0; +} + +/* Check to see if a partial index with pPartIndexWhere can be used +** in the current query. Return true if it can be and false if not. +*/ +static int whereUsablePartialIndex( + int iTab, /* The table for which we want an index */ + int isLeft, /* True if iTab is the right table of a LEFT JOIN */ + WhereClause *pWC, /* The WHERE clause of the query */ + Expr *pWhere /* The WHERE clause from the partial index */ +){ + int i; + WhereTerm *pTerm; + Parse *pParse = pWC->pWInfo->pParse; + while( pWhere->op==TK_AND ){ + if( !whereUsablePartialIndex(iTab,isLeft,pWC,pWhere->pLeft) ) return 0; + pWhere = pWhere->pRight; + } + if( pParse->db->flags & SQLITE_EnableQPSG ) pParse = 0; + for(i=0, pTerm=pWC->a; inTerm; i++, pTerm++){ + Expr *pExpr; + pExpr = pTerm->pExpr; + if( (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->iRightJoinTable==iTab) + && (isLeft==0 || ExprHasProperty(pExpr, EP_FromJoin)) + && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab) + ){ + return 1; + } + } + return 0; +} + +/* +** Add all WhereLoop objects for a single table of the join where the table +** is identified by pBuilder->pNew->iTab. That table is guaranteed to be +** a b-tree table, not a virtual table. +** +** The costs (WhereLoop.rRun) of the b-tree loops added by this function +** are calculated as follows: +** +** For a full scan, assuming the table (or index) contains nRow rows: +** +** cost = nRow * 3.0 // full-table scan +** cost = nRow * K // scan of covering index +** cost = nRow * (K+3.0) // scan of non-covering index +** +** where K is a value between 1.1 and 3.0 set based on the relative +** estimated average size of the index and table records. +** +** For an index scan, where nVisit is the number of index rows visited +** by the scan, and nSeek is the number of seek operations required on +** the index b-tree: +** +** cost = nSeek * (log(nRow) + K * nVisit) // covering index +** cost = nSeek * (log(nRow) + (K+3.0) * nVisit) // non-covering index +** +** Normally, nSeek is 1. nSeek values greater than 1 come about if the +** WHERE clause includes "x IN (....)" terms used in place of "x=?". Or when +** implicit "x IN (SELECT x FROM tbl)" terms are added for skip-scans. +** +** The estimated values (nRow, nVisit, nSeek) often contain a large amount +** of uncertainty. For this reason, scoring is designed to pick plans that +** "do the least harm" if the estimates are inaccurate. For example, a +** log(nRow) factor is omitted from a non-covering index scan in order to +** bias the scoring in favor of using an index, since the worst-case +** performance of using an index is far better than the worst-case performance +** of a full table scan. +*/ +static int whereLoopAddBtree( + WhereLoopBuilder *pBuilder, /* WHERE clause information */ + Bitmask mPrereq /* Extra prerequesites for using this table */ +){ + WhereInfo *pWInfo; /* WHERE analysis context */ + Index *pProbe; /* An index we are evaluating */ + Index sPk; /* A fake index object for the primary key */ + LogEst aiRowEstPk[2]; /* The aiRowLogEst[] value for the sPk index */ + i16 aiColumnPk = -1; /* The aColumn[] value for the sPk index */ + SrcList *pTabList; /* The FROM clause */ + struct SrcList_item *pSrc; /* The FROM clause btree term to add */ + WhereLoop *pNew; /* Template WhereLoop object */ + int rc = SQLITE_OK; /* Return code */ + int iSortIdx = 1; /* Index number */ + int b; /* A boolean value */ + LogEst rSize; /* number of rows in the table */ + LogEst rLogSize; /* Logarithm of the number of rows in the table */ + WhereClause *pWC; /* The parsed WHERE clause */ + Table *pTab; /* Table being queried */ + + pNew = pBuilder->pNew; + pWInfo = pBuilder->pWInfo; + pTabList = pWInfo->pTabList; + pSrc = pTabList->a + pNew->iTab; + pTab = pSrc->pTab; + pWC = pBuilder->pWC; + assert( !IsVirtual(pSrc->pTab) ); + + if( pSrc->pIBIndex ){ + /* An INDEXED BY clause specifies a particular index to use */ + pProbe = pSrc->pIBIndex; + }else if( !HasRowid(pTab) ){ + pProbe = pTab->pIndex; + }else{ + /* There is no INDEXED BY clause. Create a fake Index object in local + ** variable sPk to represent the rowid primary key index. Make this + ** fake index the first in a chain of Index objects with all of the real + ** indices to follow */ + Index *pFirst; /* First of real indices on the table */ + memset(&sPk, 0, sizeof(Index)); + sPk.nKeyCol = 1; + sPk.nColumn = 1; + sPk.aiColumn = &aiColumnPk; + sPk.aiRowLogEst = aiRowEstPk; + sPk.onError = OE_Replace; + sPk.pTable = pTab; + sPk.szIdxRow = pTab->szTabRow; + sPk.idxType = SQLITE_IDXTYPE_IPK; + aiRowEstPk[0] = pTab->nRowLogEst; + aiRowEstPk[1] = 0; + pFirst = pSrc->pTab->pIndex; + if( pSrc->fg.notIndexed==0 ){ + /* The real indices of the table are only considered if the + ** NOT INDEXED qualifier is omitted from the FROM clause */ + sPk.pNext = pFirst; + } + pProbe = &sPk; + } + rSize = pTab->nRowLogEst; + rLogSize = estLog(rSize); + +#ifndef SQLITE_OMIT_AUTOMATIC_INDEX + /* Automatic indexes */ + if( !pBuilder->pOrSet /* Not part of an OR optimization */ + && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0 + && (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0 + && pSrc->pIBIndex==0 /* Has no INDEXED BY clause */ + && !pSrc->fg.notIndexed /* Has no NOT INDEXED clause */ + && HasRowid(pTab) /* Not WITHOUT ROWID table. (FIXME: Why not?) */ + && !pSrc->fg.isCorrelated /* Not a correlated subquery */ + && !pSrc->fg.isRecursive /* Not a recursive common table expression. */ + ){ + /* Generate auto-index WhereLoops */ + WhereTerm *pTerm; + WhereTerm *pWCEnd = pWC->a + pWC->nTerm; + for(pTerm=pWC->a; rc==SQLITE_OK && pTermprereqRight & pNew->maskSelf ) continue; + if( termCanDriveIndex(pTerm, pSrc, 0) ){ + pNew->u.btree.nEq = 1; + pNew->nSkip = 0; + pNew->u.btree.pIndex = 0; + pNew->nLTerm = 1; + pNew->aLTerm[0] = pTerm; + /* TUNING: One-time cost for computing the automatic index is + ** estimated to be X*N*log2(N) where N is the number of rows in + ** the table being indexed and where X is 7 (LogEst=28) for normal + ** tables or 0.5 (LogEst=-10) for views and subqueries. The value + ** of X is smaller for views and subqueries so that the query planner + ** will be more aggressive about generating automatic indexes for + ** those objects, since there is no opportunity to add schema + ** indexes on subqueries and views. */ + pNew->rSetup = rLogSize + rSize; + if( pTab->pSelect==0 && (pTab->tabFlags & TF_Ephemeral)==0 ){ + pNew->rSetup += 28; + }else{ + pNew->rSetup -= 10; + } + ApplyCostMultiplier(pNew->rSetup, pTab->costMult); + if( pNew->rSetup<0 ) pNew->rSetup = 0; + /* TUNING: Each index lookup yields 20 rows in the table. This + ** is more than the usual guess of 10 rows, since we have no way + ** of knowing how selective the index will ultimately be. It would + ** not be unreasonable to make this value much larger. */ + pNew->nOut = 43; assert( 43==sqlite3LogEst(20) ); + pNew->rRun = sqlite3LogEstAdd(rLogSize,pNew->nOut); + pNew->wsFlags = WHERE_AUTO_INDEX; + pNew->prereq = mPrereq | pTerm->prereqRight; + rc = whereLoopInsert(pBuilder, pNew); + } + } + } +#endif /* SQLITE_OMIT_AUTOMATIC_INDEX */ + + /* Loop over all indices. If there was an INDEXED BY clause, then only + ** consider index pProbe. */ + for(; rc==SQLITE_OK && pProbe; + pProbe=(pSrc->pIBIndex ? 0 : pProbe->pNext), iSortIdx++ + ){ + int isLeft = (pSrc->fg.jointype & JT_OUTER)!=0; + if( pProbe->pPartIdxWhere!=0 + && !whereUsablePartialIndex(pSrc->iCursor, isLeft, pWC, + pProbe->pPartIdxWhere) + ){ + testcase( pNew->iTab!=pSrc->iCursor ); /* See ticket [98d973b8f5] */ + continue; /* Partial index inappropriate for this query */ + } + if( pProbe->bNoQuery ) continue; + rSize = pProbe->aiRowLogEst[0]; + pNew->u.btree.nEq = 0; + pNew->u.btree.nBtm = 0; + pNew->u.btree.nTop = 0; + pNew->nSkip = 0; + pNew->nLTerm = 0; + pNew->iSortIdx = 0; + pNew->rSetup = 0; + pNew->prereq = mPrereq; + pNew->nOut = rSize; + pNew->u.btree.pIndex = pProbe; + b = indexMightHelpWithOrderBy(pBuilder, pProbe, pSrc->iCursor); + + /* The ONEPASS_DESIRED flags never occurs together with ORDER BY */ + assert( (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || b==0 ); + if( pProbe->idxType==SQLITE_IDXTYPE_IPK ){ + /* Integer primary key index */ + pNew->wsFlags = WHERE_IPK; + + /* Full table scan */ + pNew->iSortIdx = b ? iSortIdx : 0; + /* TUNING: Cost of full table scan is 3.0*N. The 3.0 factor is an + ** extra cost designed to discourage the use of full table scans, + ** since index lookups have better worst-case performance if our + ** stat guesses are wrong. Reduce the 3.0 penalty slightly + ** (to 2.75) if we have valid STAT4 information for the table. + ** At 2.75, a full table scan is preferred over using an index on + ** a column with just two distinct values where each value has about + ** an equal number of appearances. Without STAT4 data, we still want + ** to use an index in that case, since the constraint might be for + ** the scarcer of the two values, and in that case an index lookup is + ** better. + */ +#ifdef SQLITE_ENABLE_STAT4 + pNew->rRun = rSize + 16 - 2*((pTab->tabFlags & TF_HasStat4)!=0); +#else + pNew->rRun = rSize + 16; +#endif + ApplyCostMultiplier(pNew->rRun, pTab->costMult); + whereLoopOutputAdjust(pWC, pNew, rSize); + rc = whereLoopInsert(pBuilder, pNew); + pNew->nOut = rSize; + if( rc ) break; + }else{ + Bitmask m; + if( pProbe->isCovering ){ + pNew->wsFlags = WHERE_IDX_ONLY | WHERE_INDEXED; + m = 0; + }else{ + m = pSrc->colUsed & pProbe->colNotIdxed; + pNew->wsFlags = (m==0) ? (WHERE_IDX_ONLY|WHERE_INDEXED) : WHERE_INDEXED; + } + + /* Full scan via index */ + if( b + || !HasRowid(pTab) + || pProbe->pPartIdxWhere!=0 + || pSrc->fg.isIndexedBy + || ( m==0 + && pProbe->bUnordered==0 + && (pProbe->szIdxRowszTabRow) + && (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 + && sqlite3GlobalConfig.bUseCis + && OptimizationEnabled(pWInfo->pParse->db, SQLITE_CoverIdxScan) + ) + ){ + pNew->iSortIdx = b ? iSortIdx : 0; + + /* The cost of visiting the index rows is N*K, where K is + ** between 1.1 and 3.0, depending on the relative sizes of the + ** index and table rows. */ + pNew->rRun = rSize + 1 + (15*pProbe->szIdxRow)/pTab->szTabRow; + if( m!=0 ){ + /* If this is a non-covering index scan, add in the cost of + ** doing table lookups. The cost will be 3x the number of + ** lookups. Take into account WHERE clause terms that can be + ** satisfied using just the index, and that do not require a + ** table lookup. */ + LogEst nLookup = rSize + 16; /* Base cost: N*3 */ + int ii; + int iCur = pSrc->iCursor; + WhereClause *pWC2 = &pWInfo->sWC; + for(ii=0; iinTerm; ii++){ + WhereTerm *pTerm = &pWC2->a[ii]; + if( !sqlite3ExprCoveredByIndex(pTerm->pExpr, iCur, pProbe) ){ + break; + } + /* pTerm can be evaluated using just the index. So reduce + ** the expected number of table lookups accordingly */ + if( pTerm->truthProb<=0 ){ + nLookup += pTerm->truthProb; + }else{ + nLookup--; + if( pTerm->eOperator & (WO_EQ|WO_IS) ) nLookup -= 19; + } + } + + pNew->rRun = sqlite3LogEstAdd(pNew->rRun, nLookup); + } + ApplyCostMultiplier(pNew->rRun, pTab->costMult); + whereLoopOutputAdjust(pWC, pNew, rSize); + rc = whereLoopInsert(pBuilder, pNew); + pNew->nOut = rSize; + if( rc ) break; + } + } + + pBuilder->bldFlags1 = 0; + rc = whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, 0); + if( pBuilder->bldFlags1==SQLITE_BLDF1_INDEXED ){ + /* If a non-unique index is used, or if a prefix of the key for + ** unique index is used (making the index functionally non-unique) + ** then the sqlite_stat1 data becomes important for scoring the + ** plan */ + pTab->tabFlags |= TF_StatsUsed; + } +#ifdef SQLITE_ENABLE_STAT4 + sqlite3Stat4ProbeFree(pBuilder->pRec); + pBuilder->nRecValid = 0; + pBuilder->pRec = 0; +#endif + } + return rc; +} + +#ifndef SQLITE_OMIT_VIRTUALTABLE + +/* +** Argument pIdxInfo is already populated with all constraints that may +** be used by the virtual table identified by pBuilder->pNew->iTab. This +** function marks a subset of those constraints usable, invokes the +** xBestIndex method and adds the returned plan to pBuilder. +** +** A constraint is marked usable if: +** +** * Argument mUsable indicates that its prerequisites are available, and +** +** * It is not one of the operators specified in the mExclude mask passed +** as the fourth argument (which in practice is either WO_IN or 0). +** +** Argument mPrereq is a mask of tables that must be scanned before the +** virtual table in question. These are added to the plans prerequisites +** before it is added to pBuilder. +** +** Output parameter *pbIn is set to true if the plan added to pBuilder +** uses one or more WO_IN terms, or false otherwise. +*/ +static int whereLoopAddVirtualOne( + WhereLoopBuilder *pBuilder, + Bitmask mPrereq, /* Mask of tables that must be used. */ + Bitmask mUsable, /* Mask of usable tables */ + u16 mExclude, /* Exclude terms using these operators */ + sqlite3_index_info *pIdxInfo, /* Populated object for xBestIndex */ + u16 mNoOmit, /* Do not omit these constraints */ + int *pbIn /* OUT: True if plan uses an IN(...) op */ +){ + WhereClause *pWC = pBuilder->pWC; + struct sqlite3_index_constraint *pIdxCons; + struct sqlite3_index_constraint_usage *pUsage = pIdxInfo->aConstraintUsage; + int i; + int mxTerm; + int rc = SQLITE_OK; + WhereLoop *pNew = pBuilder->pNew; + Parse *pParse = pBuilder->pWInfo->pParse; + struct SrcList_item *pSrc = &pBuilder->pWInfo->pTabList->a[pNew->iTab]; + int nConstraint = pIdxInfo->nConstraint; + + assert( (mUsable & mPrereq)==mPrereq ); + *pbIn = 0; + pNew->prereq = mPrereq; + + /* Set the usable flag on the subset of constraints identified by + ** arguments mUsable and mExclude. */ + pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint; + for(i=0; ia[pIdxCons->iTermOffset]; + pIdxCons->usable = 0; + if( (pTerm->prereqRight & mUsable)==pTerm->prereqRight + && (pTerm->eOperator & mExclude)==0 + ){ + pIdxCons->usable = 1; + } + } + + /* Initialize the output fields of the sqlite3_index_info structure */ + memset(pUsage, 0, sizeof(pUsage[0])*nConstraint); + assert( pIdxInfo->needToFreeIdxStr==0 ); + pIdxInfo->idxStr = 0; + pIdxInfo->idxNum = 0; + pIdxInfo->orderByConsumed = 0; + pIdxInfo->estimatedCost = SQLITE_BIG_DBL / (double)2; + pIdxInfo->estimatedRows = 25; + pIdxInfo->idxFlags = 0; + pIdxInfo->colUsed = (sqlite3_int64)pSrc->colUsed; + + /* Invoke the virtual table xBestIndex() method */ + rc = vtabBestIndex(pParse, pSrc->pTab, pIdxInfo); + if( rc ){ + if( rc==SQLITE_CONSTRAINT ){ + /* If the xBestIndex method returns SQLITE_CONSTRAINT, that means + ** that the particular combination of parameters provided is unusable. + ** Make no entries in the loop table. + */ + WHERETRACE(0xffff, (" ^^^^--- non-viable plan rejected!\n")); + return SQLITE_OK; + } + return rc; + } + + mxTerm = -1; + assert( pNew->nLSlot>=nConstraint ); + for(i=0; iaLTerm[i] = 0; + pNew->u.vtab.omitMask = 0; + pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint; + for(i=0; i=0 ){ + WhereTerm *pTerm; + int j = pIdxCons->iTermOffset; + if( iTerm>=nConstraint + || j<0 + || j>=pWC->nTerm + || pNew->aLTerm[iTerm]!=0 + || pIdxCons->usable==0 + ){ + sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName); + testcase( pIdxInfo->needToFreeIdxStr ); + return SQLITE_ERROR; + } + testcase( iTerm==nConstraint-1 ); + testcase( j==0 ); + testcase( j==pWC->nTerm-1 ); + pTerm = &pWC->a[j]; + pNew->prereq |= pTerm->prereqRight; + assert( iTermnLSlot ); + pNew->aLTerm[iTerm] = pTerm; + if( iTerm>mxTerm ) mxTerm = iTerm; + testcase( iTerm==15 ); + testcase( iTerm==16 ); + if( pUsage[i].omit ){ + if( i<16 && ((1<u.vtab.omitMask |= 1<eOperator & WO_IN)!=0 ){ + /* A virtual table that is constrained by an IN clause may not + ** consume the ORDER BY clause because (1) the order of IN terms + ** is not necessarily related to the order of output terms and + ** (2) Multiple outputs from a single IN value will not merge + ** together. */ + pIdxInfo->orderByConsumed = 0; + pIdxInfo->idxFlags &= ~SQLITE_INDEX_SCAN_UNIQUE; + *pbIn = 1; assert( (mExclude & WO_IN)==0 ); + } + } + } + + pNew->nLTerm = mxTerm+1; + for(i=0; i<=mxTerm; i++){ + if( pNew->aLTerm[i]==0 ){ + /* The non-zero argvIdx values must be contiguous. Raise an + ** error if they are not */ + sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName); + testcase( pIdxInfo->needToFreeIdxStr ); + return SQLITE_ERROR; + } + } + assert( pNew->nLTerm<=pNew->nLSlot ); + pNew->u.vtab.idxNum = pIdxInfo->idxNum; + pNew->u.vtab.needFree = pIdxInfo->needToFreeIdxStr; + pIdxInfo->needToFreeIdxStr = 0; + pNew->u.vtab.idxStr = pIdxInfo->idxStr; + pNew->u.vtab.isOrdered = (i8)(pIdxInfo->orderByConsumed ? + pIdxInfo->nOrderBy : 0); + pNew->rSetup = 0; + pNew->rRun = sqlite3LogEstFromDouble(pIdxInfo->estimatedCost); + pNew->nOut = sqlite3LogEst(pIdxInfo->estimatedRows); + + /* Set the WHERE_ONEROW flag if the xBestIndex() method indicated + ** that the scan will visit at most one row. Clear it otherwise. */ + if( pIdxInfo->idxFlags & SQLITE_INDEX_SCAN_UNIQUE ){ + pNew->wsFlags |= WHERE_ONEROW; + }else{ + pNew->wsFlags &= ~WHERE_ONEROW; + } + rc = whereLoopInsert(pBuilder, pNew); + if( pNew->u.vtab.needFree ){ + sqlite3_free(pNew->u.vtab.idxStr); + pNew->u.vtab.needFree = 0; + } + WHERETRACE(0xffff, (" bIn=%d prereqIn=%04llx prereqOut=%04llx\n", + *pbIn, (sqlite3_uint64)mPrereq, + (sqlite3_uint64)(pNew->prereq & ~mPrereq))); + + return rc; +} + +/* +** If this function is invoked from within an xBestIndex() callback, it +** returns a pointer to a buffer containing the name of the collation +** sequence associated with element iCons of the sqlite3_index_info.aConstraint +** array. Or, if iCons is out of range or there is no active xBestIndex +** call, return NULL. +*/ +SQLITE_API const char *sqlite3_vtab_collation(sqlite3_index_info *pIdxInfo, int iCons){ + HiddenIndexInfo *pHidden = (HiddenIndexInfo*)&pIdxInfo[1]; + const char *zRet = 0; + if( iCons>=0 && iConsnConstraint ){ + CollSeq *pC = 0; + int iTerm = pIdxInfo->aConstraint[iCons].iTermOffset; + Expr *pX = pHidden->pWC->a[iTerm].pExpr; + if( pX->pLeft ){ + pC = sqlite3ExprCompareCollSeq(pHidden->pParse, pX); + } + zRet = (pC ? pC->zName : sqlite3StrBINARY); + } + return zRet; +} + +/* +** Add all WhereLoop objects for a table of the join identified by +** pBuilder->pNew->iTab. That table is guaranteed to be a virtual table. +** +** If there are no LEFT or CROSS JOIN joins in the query, both mPrereq and +** mUnusable are set to 0. Otherwise, mPrereq is a mask of all FROM clause +** entries that occur before the virtual table in the FROM clause and are +** separated from it by at least one LEFT or CROSS JOIN. Similarly, the +** mUnusable mask contains all FROM clause entries that occur after the +** virtual table and are separated from it by at least one LEFT or +** CROSS JOIN. +** +** For example, if the query were: +** +** ... FROM t1, t2 LEFT JOIN t3, t4, vt CROSS JOIN t5, t6; +** +** then mPrereq corresponds to (t1, t2) and mUnusable to (t5, t6). +** +** All the tables in mPrereq must be scanned before the current virtual +** table. So any terms for which all prerequisites are satisfied by +** mPrereq may be specified as "usable" in all calls to xBestIndex. +** Conversely, all tables in mUnusable must be scanned after the current +** virtual table, so any terms for which the prerequisites overlap with +** mUnusable should always be configured as "not-usable" for xBestIndex. +*/ +static int whereLoopAddVirtual( + WhereLoopBuilder *pBuilder, /* WHERE clause information */ + Bitmask mPrereq, /* Tables that must be scanned before this one */ + Bitmask mUnusable /* Tables that must be scanned after this one */ +){ + int rc = SQLITE_OK; /* Return code */ + WhereInfo *pWInfo; /* WHERE analysis context */ + Parse *pParse; /* The parsing context */ + WhereClause *pWC; /* The WHERE clause */ + struct SrcList_item *pSrc; /* The FROM clause term to search */ + sqlite3_index_info *p; /* Object to pass to xBestIndex() */ + int nConstraint; /* Number of constraints in p */ + int bIn; /* True if plan uses IN(...) operator */ + WhereLoop *pNew; + Bitmask mBest; /* Tables used by best possible plan */ + u16 mNoOmit; + + assert( (mPrereq & mUnusable)==0 ); + pWInfo = pBuilder->pWInfo; + pParse = pWInfo->pParse; + pWC = pBuilder->pWC; + pNew = pBuilder->pNew; + pSrc = &pWInfo->pTabList->a[pNew->iTab]; + assert( IsVirtual(pSrc->pTab) ); + p = allocateIndexInfo(pParse, pWC, mUnusable, pSrc, pBuilder->pOrderBy, + &mNoOmit); + if( p==0 ) return SQLITE_NOMEM_BKPT; + pNew->rSetup = 0; + pNew->wsFlags = WHERE_VIRTUALTABLE; + pNew->nLTerm = 0; + pNew->u.vtab.needFree = 0; + nConstraint = p->nConstraint; + if( whereLoopResize(pParse->db, pNew, nConstraint) ){ + sqlite3DbFree(pParse->db, p); + return SQLITE_NOMEM_BKPT; + } + + /* First call xBestIndex() with all constraints usable. */ + WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pTab->zName)); + WHERETRACE(0x40, (" VirtualOne: all usable\n")); + rc = whereLoopAddVirtualOne(pBuilder, mPrereq, ALLBITS, 0, p, mNoOmit, &bIn); + + /* If the call to xBestIndex() with all terms enabled produced a plan + ** that does not require any source tables (IOW: a plan with mBest==0) + ** and does not use an IN(...) operator, then there is no point in making + ** any further calls to xBestIndex() since they will all return the same + ** result (if the xBestIndex() implementation is sane). */ + if( rc==SQLITE_OK && ((mBest = (pNew->prereq & ~mPrereq))!=0 || bIn) ){ + int seenZero = 0; /* True if a plan with no prereqs seen */ + int seenZeroNoIN = 0; /* Plan with no prereqs and no IN(...) seen */ + Bitmask mPrev = 0; + Bitmask mBestNoIn = 0; + + /* If the plan produced by the earlier call uses an IN(...) term, call + ** xBestIndex again, this time with IN(...) terms disabled. */ + if( bIn ){ + WHERETRACE(0x40, (" VirtualOne: all usable w/o IN\n")); + rc = whereLoopAddVirtualOne( + pBuilder, mPrereq, ALLBITS, WO_IN, p, mNoOmit, &bIn); + assert( bIn==0 ); + mBestNoIn = pNew->prereq & ~mPrereq; + if( mBestNoIn==0 ){ + seenZero = 1; + seenZeroNoIN = 1; + } + } + + /* Call xBestIndex once for each distinct value of (prereqRight & ~mPrereq) + ** in the set of terms that apply to the current virtual table. */ + while( rc==SQLITE_OK ){ + int i; + Bitmask mNext = ALLBITS; + assert( mNext>0 ); + for(i=0; ia[p->aConstraint[i].iTermOffset].prereqRight & ~mPrereq + ); + if( mThis>mPrev && mThisprereq==mPrereq ){ + seenZero = 1; + if( bIn==0 ) seenZeroNoIN = 1; + } + } + + /* If the calls to xBestIndex() in the above loop did not find a plan + ** that requires no source tables at all (i.e. one guaranteed to be + ** usable), make a call here with all source tables disabled */ + if( rc==SQLITE_OK && seenZero==0 ){ + WHERETRACE(0x40, (" VirtualOne: all disabled\n")); + rc = whereLoopAddVirtualOne( + pBuilder, mPrereq, mPrereq, 0, p, mNoOmit, &bIn); + if( bIn==0 ) seenZeroNoIN = 1; + } + + /* If the calls to xBestIndex() have so far failed to find a plan + ** that requires no source tables at all and does not use an IN(...) + ** operator, make a final call to obtain one here. */ + if( rc==SQLITE_OK && seenZeroNoIN==0 ){ + WHERETRACE(0x40, (" VirtualOne: all disabled and w/o IN\n")); + rc = whereLoopAddVirtualOne( + pBuilder, mPrereq, mPrereq, WO_IN, p, mNoOmit, &bIn); + } + } + + if( p->needToFreeIdxStr ) sqlite3_free(p->idxStr); + sqlite3DbFreeNN(pParse->db, p); + WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pTab->zName, rc)); + return rc; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +/* +** Add WhereLoop entries to handle OR terms. This works for either +** btrees or virtual tables. +*/ +static int whereLoopAddOr( + WhereLoopBuilder *pBuilder, + Bitmask mPrereq, + Bitmask mUnusable +){ + WhereInfo *pWInfo = pBuilder->pWInfo; + WhereClause *pWC; + WhereLoop *pNew; + WhereTerm *pTerm, *pWCEnd; + int rc = SQLITE_OK; + int iCur; + WhereClause tempWC; + WhereLoopBuilder sSubBuild; + WhereOrSet sSum, sCur; + struct SrcList_item *pItem; + + pWC = pBuilder->pWC; + pWCEnd = pWC->a + pWC->nTerm; + pNew = pBuilder->pNew; + memset(&sSum, 0, sizeof(sSum)); + pItem = pWInfo->pTabList->a + pNew->iTab; + iCur = pItem->iCursor; + + for(pTerm=pWC->a; pTermeOperator & WO_OR)!=0 + && (pTerm->u.pOrInfo->indexable & pNew->maskSelf)!=0 + ){ + WhereClause * const pOrWC = &pTerm->u.pOrInfo->wc; + WhereTerm * const pOrWCEnd = &pOrWC->a[pOrWC->nTerm]; + WhereTerm *pOrTerm; + int once = 1; + int i, j; + + sSubBuild = *pBuilder; + sSubBuild.pOrderBy = 0; + sSubBuild.pOrSet = &sCur; + + WHERETRACE(0x200, ("Begin processing OR-clause %p\n", pTerm)); + for(pOrTerm=pOrWC->a; pOrTermeOperator & WO_AND)!=0 ){ + sSubBuild.pWC = &pOrTerm->u.pAndInfo->wc; + }else if( pOrTerm->leftCursor==iCur ){ + tempWC.pWInfo = pWC->pWInfo; + tempWC.pOuter = pWC; + tempWC.op = TK_AND; + tempWC.nTerm = 1; + tempWC.a = pOrTerm; + sSubBuild.pWC = &tempWC; + }else{ + continue; + } + sCur.n = 0; +#ifdef WHERETRACE_ENABLED + WHERETRACE(0x200, ("OR-term %d of %p has %d subterms:\n", + (int)(pOrTerm-pOrWC->a), pTerm, sSubBuild.pWC->nTerm)); + if( sqlite3WhereTrace & 0x400 ){ + sqlite3WhereClausePrint(sSubBuild.pWC); + } +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pItem->pTab) ){ + rc = whereLoopAddVirtual(&sSubBuild, mPrereq, mUnusable); + }else +#endif + { + rc = whereLoopAddBtree(&sSubBuild, mPrereq); + } + if( rc==SQLITE_OK ){ + rc = whereLoopAddOr(&sSubBuild, mPrereq, mUnusable); + } + assert( rc==SQLITE_OK || rc==SQLITE_DONE || sCur.n==0 ); + testcase( rc==SQLITE_DONE ); + if( sCur.n==0 ){ + sSum.n = 0; + break; + }else if( once ){ + whereOrMove(&sSum, &sCur); + once = 0; + }else{ + WhereOrSet sPrev; + whereOrMove(&sPrev, &sSum); + sSum.n = 0; + for(i=0; inLTerm = 1; + pNew->aLTerm[0] = pTerm; + pNew->wsFlags = WHERE_MULTI_OR; + pNew->rSetup = 0; + pNew->iSortIdx = 0; + memset(&pNew->u, 0, sizeof(pNew->u)); + for(i=0; rc==SQLITE_OK && irRun = sSum.a[i].rRun + 1; + pNew->nOut = sSum.a[i].nOut; + pNew->prereq = sSum.a[i].prereq; + rc = whereLoopInsert(pBuilder, pNew); + } + WHERETRACE(0x200, ("End processing OR-clause %p\n", pTerm)); + } + } + return rc; +} + +/* +** Add all WhereLoop objects for all tables +*/ +static int whereLoopAddAll(WhereLoopBuilder *pBuilder){ + WhereInfo *pWInfo = pBuilder->pWInfo; + Bitmask mPrereq = 0; + Bitmask mPrior = 0; + int iTab; + SrcList *pTabList = pWInfo->pTabList; + struct SrcList_item *pItem; + struct SrcList_item *pEnd = &pTabList->a[pWInfo->nLevel]; + sqlite3 *db = pWInfo->pParse->db; + int rc = SQLITE_OK; + WhereLoop *pNew; + + /* Loop over the tables in the join, from left to right */ + pNew = pBuilder->pNew; + whereLoopInit(pNew); + pBuilder->iPlanLimit = SQLITE_QUERY_PLANNER_LIMIT; + for(iTab=0, pItem=pTabList->a; pItemiTab = iTab; + pBuilder->iPlanLimit += SQLITE_QUERY_PLANNER_LIMIT_INCR; + pNew->maskSelf = sqlite3WhereGetMask(&pWInfo->sMaskSet, pItem->iCursor); + if( (pItem->fg.jointype & (JT_LEFT|JT_CROSS))!=0 ){ + /* This condition is true when pItem is the FROM clause term on the + ** right-hand-side of a LEFT or CROSS JOIN. */ + mPrereq = mPrior; + }else{ + mPrereq = 0; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pItem->pTab) ){ + struct SrcList_item *p; + for(p=&pItem[1]; pfg.jointype & (JT_LEFT|JT_CROSS)) ){ + mUnusable |= sqlite3WhereGetMask(&pWInfo->sMaskSet, p->iCursor); + } + } + rc = whereLoopAddVirtual(pBuilder, mPrereq, mUnusable); + }else +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + { + rc = whereLoopAddBtree(pBuilder, mPrereq); + } + if( rc==SQLITE_OK && pBuilder->pWC->hasOr ){ + rc = whereLoopAddOr(pBuilder, mPrereq, mUnusable); + } + mPrior |= pNew->maskSelf; + if( rc || db->mallocFailed ){ + if( rc==SQLITE_DONE ){ + /* We hit the query planner search limit set by iPlanLimit */ + sqlite3_log(SQLITE_WARNING, "abbreviated query algorithm search"); + rc = SQLITE_OK; + }else{ + break; + } + } + } + + whereLoopClear(db, pNew); + return rc; +} + +/* +** Examine a WherePath (with the addition of the extra WhereLoop of the 6th +** parameters) to see if it outputs rows in the requested ORDER BY +** (or GROUP BY) without requiring a separate sort operation. Return N: +** +** N>0: N terms of the ORDER BY clause are satisfied +** N==0: No terms of the ORDER BY clause are satisfied +** N<0: Unknown yet how many terms of ORDER BY might be satisfied. +** +** Note that processing for WHERE_GROUPBY and WHERE_DISTINCTBY is not as +** strict. With GROUP BY and DISTINCT the only requirement is that +** equivalent rows appear immediately adjacent to one another. GROUP BY +** and DISTINCT do not require rows to appear in any particular order as long +** as equivalent rows are grouped together. Thus for GROUP BY and DISTINCT +** the pOrderBy terms can be matched in any order. With ORDER BY, the +** pOrderBy terms must be matched in strict left-to-right order. +*/ +static i8 wherePathSatisfiesOrderBy( + WhereInfo *pWInfo, /* The WHERE clause */ + ExprList *pOrderBy, /* ORDER BY or GROUP BY or DISTINCT clause to check */ + WherePath *pPath, /* The WherePath to check */ + u16 wctrlFlags, /* WHERE_GROUPBY or _DISTINCTBY or _ORDERBY_LIMIT */ + u16 nLoop, /* Number of entries in pPath->aLoop[] */ + WhereLoop *pLast, /* Add this WhereLoop to the end of pPath->aLoop[] */ + Bitmask *pRevMask /* OUT: Mask of WhereLoops to run in reverse order */ +){ + u8 revSet; /* True if rev is known */ + u8 rev; /* Composite sort order */ + u8 revIdx; /* Index sort order */ + u8 isOrderDistinct; /* All prior WhereLoops are order-distinct */ + u8 distinctColumns; /* True if the loop has UNIQUE NOT NULL columns */ + u8 isMatch; /* iColumn matches a term of the ORDER BY clause */ + u16 eqOpMask; /* Allowed equality operators */ + u16 nKeyCol; /* Number of key columns in pIndex */ + u16 nColumn; /* Total number of ordered columns in the index */ + u16 nOrderBy; /* Number terms in the ORDER BY clause */ + int iLoop; /* Index of WhereLoop in pPath being processed */ + int i, j; /* Loop counters */ + int iCur; /* Cursor number for current WhereLoop */ + int iColumn; /* A column number within table iCur */ + WhereLoop *pLoop = 0; /* Current WhereLoop being processed. */ + WhereTerm *pTerm; /* A single term of the WHERE clause */ + Expr *pOBExpr; /* An expression from the ORDER BY clause */ + CollSeq *pColl; /* COLLATE function from an ORDER BY clause term */ + Index *pIndex; /* The index associated with pLoop */ + sqlite3 *db = pWInfo->pParse->db; /* Database connection */ + Bitmask obSat = 0; /* Mask of ORDER BY terms satisfied so far */ + Bitmask obDone; /* Mask of all ORDER BY terms */ + Bitmask orderDistinctMask; /* Mask of all well-ordered loops */ + Bitmask ready; /* Mask of inner loops */ + + /* + ** We say the WhereLoop is "one-row" if it generates no more than one + ** row of output. A WhereLoop is one-row if all of the following are true: + ** (a) All index columns match with WHERE_COLUMN_EQ. + ** (b) The index is unique + ** Any WhereLoop with an WHERE_COLUMN_EQ constraint on the rowid is one-row. + ** Every one-row WhereLoop will have the WHERE_ONEROW bit set in wsFlags. + ** + ** We say the WhereLoop is "order-distinct" if the set of columns from + ** that WhereLoop that are in the ORDER BY clause are different for every + ** row of the WhereLoop. Every one-row WhereLoop is automatically + ** order-distinct. A WhereLoop that has no columns in the ORDER BY clause + ** is not order-distinct. To be order-distinct is not quite the same as being + ** UNIQUE since a UNIQUE column or index can have multiple rows that + ** are NULL and NULL values are equivalent for the purpose of order-distinct. + ** To be order-distinct, the columns must be UNIQUE and NOT NULL. + ** + ** The rowid for a table is always UNIQUE and NOT NULL so whenever the + ** rowid appears in the ORDER BY clause, the corresponding WhereLoop is + ** automatically order-distinct. + */ + + assert( pOrderBy!=0 ); + if( nLoop && OptimizationDisabled(db, SQLITE_OrderByIdxJoin) ) return 0; + + nOrderBy = pOrderBy->nExpr; + testcase( nOrderBy==BMS-1 ); + if( nOrderBy>BMS-1 ) return 0; /* Cannot optimize overly large ORDER BYs */ + isOrderDistinct = 1; + obDone = MASKBIT(nOrderBy)-1; + orderDistinctMask = 0; + ready = 0; + eqOpMask = WO_EQ | WO_IS | WO_ISNULL; + if( wctrlFlags & (WHERE_ORDERBY_LIMIT|WHERE_ORDERBY_MAX|WHERE_ORDERBY_MIN) ){ + eqOpMask |= WO_IN; + } + for(iLoop=0; isOrderDistinct && obSat0 ) ready |= pLoop->maskSelf; + if( iLoopaLoop[iLoop]; + if( wctrlFlags & WHERE_ORDERBY_LIMIT ) continue; + }else{ + pLoop = pLast; + } + if( pLoop->wsFlags & WHERE_VIRTUALTABLE ){ + if( pLoop->u.vtab.isOrdered && (wctrlFlags & WHERE_DISTINCTBY)==0 ){ + obSat = obDone; + } + break; + }else if( wctrlFlags & WHERE_DISTINCTBY ){ + pLoop->u.btree.nDistinctCol = 0; + } + iCur = pWInfo->pTabList->a[pLoop->iTab].iCursor; + + /* Mark off any ORDER BY term X that is a column in the table of + ** the current loop for which there is term in the WHERE + ** clause of the form X IS NULL or X=? that reference only outer + ** loops. + */ + for(i=0; ia[i].pExpr); + if( NEVER(pOBExpr==0) ) continue; + if( pOBExpr->op!=TK_COLUMN ) continue; + if( pOBExpr->iTable!=iCur ) continue; + pTerm = sqlite3WhereFindTerm(&pWInfo->sWC, iCur, pOBExpr->iColumn, + ~ready, eqOpMask, 0); + if( pTerm==0 ) continue; + if( pTerm->eOperator==WO_IN ){ + /* IN terms are only valid for sorting in the ORDER BY LIMIT + ** optimization, and then only if they are actually used + ** by the query plan */ + assert( wctrlFlags & + (WHERE_ORDERBY_LIMIT|WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX) ); + for(j=0; jnLTerm && pTerm!=pLoop->aLTerm[j]; j++){} + if( j>=pLoop->nLTerm ) continue; + } + if( (pTerm->eOperator&(WO_EQ|WO_IS))!=0 && pOBExpr->iColumn>=0 ){ + Parse *pParse = pWInfo->pParse; + CollSeq *pColl1 = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[i].pExpr); + CollSeq *pColl2 = sqlite3ExprCompareCollSeq(pParse, pTerm->pExpr); + assert( pColl1 ); + if( pColl2==0 || sqlite3StrICmp(pColl1->zName, pColl2->zName) ){ + continue; + } + testcase( pTerm->pExpr->op==TK_IS ); + } + obSat |= MASKBIT(i); + } + + if( (pLoop->wsFlags & WHERE_ONEROW)==0 ){ + if( pLoop->wsFlags & WHERE_IPK ){ + pIndex = 0; + nKeyCol = 0; + nColumn = 1; + }else if( (pIndex = pLoop->u.btree.pIndex)==0 || pIndex->bUnordered ){ + return 0; + }else{ + nKeyCol = pIndex->nKeyCol; + nColumn = pIndex->nColumn; + assert( nColumn==nKeyCol+1 || !HasRowid(pIndex->pTable) ); + assert( pIndex->aiColumn[nColumn-1]==XN_ROWID + || !HasRowid(pIndex->pTable)); + isOrderDistinct = IsUniqueIndex(pIndex) + && (pLoop->wsFlags & WHERE_SKIPSCAN)==0; + } + + /* Loop through all columns of the index and deal with the ones + ** that are not constrained by == or IN. + */ + rev = revSet = 0; + distinctColumns = 0; + for(j=0; j=pLoop->u.btree.nEq + || (pLoop->aLTerm[j]==0)==(jnSkip) + ); + if( ju.btree.nEq && j>=pLoop->nSkip ){ + u16 eOp = pLoop->aLTerm[j]->eOperator; + + /* Skip over == and IS and ISNULL terms. (Also skip IN terms when + ** doing WHERE_ORDERBY_LIMIT processing). Except, IS and ISNULL + ** terms imply that the index is not UNIQUE NOT NULL in which case + ** the loop need to be marked as not order-distinct because it can + ** have repeated NULL rows. + ** + ** If the current term is a column of an ((?,?) IN (SELECT...)) + ** expression for which the SELECT returns more than one column, + ** check that it is the only column used by this loop. Otherwise, + ** if it is one of two or more, none of the columns can be + ** considered to match an ORDER BY term. + */ + if( (eOp & eqOpMask)!=0 ){ + if( eOp & (WO_ISNULL|WO_IS) ){ + testcase( eOp & WO_ISNULL ); + testcase( eOp & WO_IS ); + testcase( isOrderDistinct ); + isOrderDistinct = 0; + } + continue; + }else if( ALWAYS(eOp & WO_IN) ){ + /* ALWAYS() justification: eOp is an equality operator due to the + ** ju.btree.nEq constraint above. Any equality other + ** than WO_IN is captured by the previous "if". So this one + ** always has to be WO_IN. */ + Expr *pX = pLoop->aLTerm[j]->pExpr; + for(i=j+1; iu.btree.nEq; i++){ + if( pLoop->aLTerm[i]->pExpr==pX ){ + assert( (pLoop->aLTerm[i]->eOperator & WO_IN) ); + bOnce = 0; + break; + } + } + } + } + + /* Get the column number in the table (iColumn) and sort order + ** (revIdx) for the j-th column of the index. + */ + if( pIndex ){ + iColumn = pIndex->aiColumn[j]; + revIdx = pIndex->aSortOrder[j] & KEYINFO_ORDER_DESC; + if( iColumn==pIndex->pTable->iPKey ) iColumn = XN_ROWID; + }else{ + iColumn = XN_ROWID; + revIdx = 0; + } + + /* An unconstrained column that might be NULL means that this + ** WhereLoop is not well-ordered + */ + if( isOrderDistinct + && iColumn>=0 + && j>=pLoop->u.btree.nEq + && pIndex->pTable->aCol[iColumn].notNull==0 + ){ + isOrderDistinct = 0; + } + + /* Find the ORDER BY term that corresponds to the j-th column + ** of the index and mark that ORDER BY term off + */ + isMatch = 0; + for(i=0; bOnce && ia[i].pExpr); + testcase( wctrlFlags & WHERE_GROUPBY ); + testcase( wctrlFlags & WHERE_DISTINCTBY ); + if( NEVER(pOBExpr==0) ) continue; + if( (wctrlFlags & (WHERE_GROUPBY|WHERE_DISTINCTBY))==0 ) bOnce = 0; + if( iColumn>=XN_ROWID ){ + if( pOBExpr->op!=TK_COLUMN ) continue; + if( pOBExpr->iTable!=iCur ) continue; + if( pOBExpr->iColumn!=iColumn ) continue; + }else{ + Expr *pIdxExpr = pIndex->aColExpr->a[j].pExpr; + if( sqlite3ExprCompareSkip(pOBExpr, pIdxExpr, iCur) ){ + continue; + } + } + if( iColumn!=XN_ROWID ){ + pColl = sqlite3ExprNNCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr); + if( sqlite3StrICmp(pColl->zName, pIndex->azColl[j])!=0 ) continue; + } + if( wctrlFlags & WHERE_DISTINCTBY ){ + pLoop->u.btree.nDistinctCol = j+1; + } + isMatch = 1; + break; + } + if( isMatch && (wctrlFlags & WHERE_GROUPBY)==0 ){ + /* Make sure the sort order is compatible in an ORDER BY clause. + ** Sort order is irrelevant for a GROUP BY clause. */ + if( revSet ){ + if( (rev ^ revIdx)!=(pOrderBy->a[i].sortFlags&KEYINFO_ORDER_DESC) ){ + isMatch = 0; + } + }else{ + rev = revIdx ^ (pOrderBy->a[i].sortFlags & KEYINFO_ORDER_DESC); + if( rev ) *pRevMask |= MASKBIT(iLoop); + revSet = 1; + } + } + if( isMatch && (pOrderBy->a[i].sortFlags & KEYINFO_ORDER_BIGNULL) ){ + if( j==pLoop->u.btree.nEq ){ + pLoop->wsFlags |= WHERE_BIGNULL_SORT; + }else{ + isMatch = 0; + } + } + if( isMatch ){ + if( iColumn==XN_ROWID ){ + testcase( distinctColumns==0 ); + distinctColumns = 1; + } + obSat |= MASKBIT(i); + }else{ + /* No match found */ + if( j==0 || jmaskSelf; + for(i=0; ia[i].pExpr; + mTerm = sqlite3WhereExprUsage(&pWInfo->sMaskSet,p); + if( mTerm==0 && !sqlite3ExprIsConstant(p) ) continue; + if( (mTerm&~orderDistinctMask)==0 ){ + obSat |= MASKBIT(i); + } + } + } + } /* End the loop over all WhereLoops from outer-most down to inner-most */ + if( obSat==obDone ) return (i8)nOrderBy; + if( !isOrderDistinct ){ + for(i=nOrderBy-1; i>0; i--){ + Bitmask m = MASKBIT(i) - 1; + if( (obSat&m)==m ) return i; + } + return 0; + } + return -1; +} + + +/* +** If the WHERE_GROUPBY flag is set in the mask passed to sqlite3WhereBegin(), +** the planner assumes that the specified pOrderBy list is actually a GROUP +** BY clause - and so any order that groups rows as required satisfies the +** request. +** +** Normally, in this case it is not possible for the caller to determine +** whether or not the rows are really being delivered in sorted order, or +** just in some other order that provides the required grouping. However, +** if the WHERE_SORTBYGROUP flag is also passed to sqlite3WhereBegin(), then +** this function may be called on the returned WhereInfo object. It returns +** true if the rows really will be sorted in the specified order, or false +** otherwise. +** +** For example, assuming: +** +** CREATE INDEX i1 ON t1(x, Y); +** +** then +** +** SELECT * FROM t1 GROUP BY x,y ORDER BY x,y; -- IsSorted()==1 +** SELECT * FROM t1 GROUP BY y,x ORDER BY y,x; -- IsSorted()==0 +*/ +SQLITE_PRIVATE int sqlite3WhereIsSorted(WhereInfo *pWInfo){ + assert( pWInfo->wctrlFlags & WHERE_GROUPBY ); + assert( pWInfo->wctrlFlags & WHERE_SORTBYGROUP ); + return pWInfo->sorted; +} + +#ifdef WHERETRACE_ENABLED +/* For debugging use only: */ +static const char *wherePathName(WherePath *pPath, int nLoop, WhereLoop *pLast){ + static char zName[65]; + int i; + for(i=0; iaLoop[i]->cId; } + if( pLast ) zName[i++] = pLast->cId; + zName[i] = 0; + return zName; +} +#endif + +/* +** Return the cost of sorting nRow rows, assuming that the keys have +** nOrderby columns and that the first nSorted columns are already in +** order. +*/ +static LogEst whereSortingCost( + WhereInfo *pWInfo, + LogEst nRow, + int nOrderBy, + int nSorted +){ + /* TUNING: Estimated cost of a full external sort, where N is + ** the number of rows to sort is: + ** + ** cost = (3.0 * 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) + ** + ** The (Y/X) term is implemented using stack variable rScale + ** below. + */ + LogEst rScale, rSortCost; + assert( nOrderBy>0 && 66==sqlite3LogEst(100) ); + rScale = sqlite3LogEst((nOrderBy-nSorted)*100/nOrderBy) - 66; + rSortCost = nRow + rScale + 16; + + /* 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->iLimitiLimit; + }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 */ + if( nRow>10 ) nRow -= 10; assert( 10==sqlite3LogEst(2) ); + } + rSortCost += estLog(nRow); + return rSortCost; +} + +/* +** Given the list of WhereLoop objects at pWInfo->pLoops, this routine +** attempts to find the lowest cost path that visits each WhereLoop +** once. This path is then loaded into the pWInfo->a[].pWLoop fields. +** +** Assume that the total number of output rows that will need to be sorted +** will be nRowEst (in the 10*log2 representation). Or, ignore sorting +** costs if nRowEst==0. +** +** Return SQLITE_OK on success or SQLITE_NOMEM of a memory allocation +** error occurs. +*/ +static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){ + int mxChoice; /* Maximum number of simultaneous paths tracked */ + int nLoop; /* Number of terms in the join */ + Parse *pParse; /* Parsing context */ + sqlite3 *db; /* The database connection */ + int iLoop; /* Loop counter over the terms of the join */ + int ii, jj; /* Loop counters */ + int mxI = 0; /* Index of next entry to replace */ + int nOrderBy; /* Number of ORDER BY clause terms */ + LogEst mxCost = 0; /* Maximum cost of a set of paths */ + LogEst mxUnsorted = 0; /* Maximum unsorted cost of a set of path */ + int nTo, nFrom; /* Number of valid entries in aTo[] and aFrom[] */ + WherePath *aFrom; /* All nFrom paths at the previous level */ + WherePath *aTo; /* The nTo best paths at the current level */ + WherePath *pFrom; /* An element of aFrom[] that we are working on */ + WherePath *pTo; /* An element of aTo[] that we are working on */ + WhereLoop *pWLoop; /* One of the WhereLoop objects */ + WhereLoop **pX; /* Used to divy up the pSpace memory */ + LogEst *aSortCost = 0; /* Sorting and partial sorting costs */ + char *pSpace; /* Temporary memory used by this routine */ + int nSpace; /* Bytes of space allocated at pSpace */ + + pParse = pWInfo->pParse; + db = pParse->db; + nLoop = pWInfo->nLevel; + /* TUNING: For simple queries, only the best path is tracked. + ** For 2-way joins, the 5 best paths are followed. + ** For joins of 3 or more tables, track the 10 best paths */ + mxChoice = (nLoop<=1) ? 1 : (nLoop==2 ? 5 : 10); + assert( nLoop<=pWInfo->pTabList->nSrc ); + WHERETRACE(0x002, ("---- begin solver. (nRowEst=%d)\n", nRowEst)); + + /* If nRowEst is zero and there is an ORDER BY clause, ignore it. In this + ** case the purpose of this call is to estimate the number of rows returned + ** by the overall query. Once this estimate has been obtained, the caller + ** will invoke this function a second time, passing the estimate as the + ** nRowEst parameter. */ + if( pWInfo->pOrderBy==0 || nRowEst==0 ){ + nOrderBy = 0; + }else{ + nOrderBy = pWInfo->pOrderBy->nExpr; + } + + /* Allocate and initialize space for aTo, aFrom and aSortCost[] */ + nSpace = (sizeof(WherePath)+sizeof(WhereLoop*)*nLoop)*mxChoice*2; + nSpace += sizeof(LogEst) * nOrderBy; + pSpace = sqlite3DbMallocRawNN(db, nSpace); + if( pSpace==0 ) return SQLITE_NOMEM_BKPT; + aTo = (WherePath*)pSpace; + aFrom = aTo+mxChoice; + memset(aFrom, 0, sizeof(aFrom[0])); + pX = (WhereLoop**)(aFrom+mxChoice); + for(ii=mxChoice*2, pFrom=aTo; ii>0; ii--, pFrom++, pX += nLoop){ + pFrom->aLoop = pX; + } + if( nOrderBy ){ + /* If there is an ORDER BY clause and it is not being ignored, set up + ** space for the aSortCost[] array. Each element of the aSortCost array + ** is either zero - meaning it has not yet been initialized - or the + ** cost of sorting nRowEst rows of data where the first X terms of + ** the ORDER BY clause are already in order, where X is the array + ** index. */ + aSortCost = (LogEst*)pX; + memset(aSortCost, 0, sizeof(LogEst) * nOrderBy); + } + assert( aSortCost==0 || &pSpace[nSpace]==(char*)&aSortCost[nOrderBy] ); + assert( aSortCost!=0 || &pSpace[nSpace]==(char*)pX ); + + /* Seed the search with a single WherePath containing zero WhereLoops. + ** + ** TUNING: Do not let the number of iterations go above 28. If the cost + ** of computing an automatic index is not paid back within the first 28 + ** rows, then do not use the automatic index. */ + aFrom[0].nRow = MIN(pParse->nQueryLoop, 48); assert( 48==sqlite3LogEst(28) ); + nFrom = 1; + assert( aFrom[0].isOrdered==0 ); + if( nOrderBy ){ + /* If nLoop is zero, then there are no FROM terms in the query. Since + ** in this case the query may return a maximum of one row, the results + ** are already in the requested order. Set isOrdered to nOrderBy to + ** indicate this. Or, if nLoop is greater than zero, set isOrdered to + ** -1, indicating that the result set may or may not be ordered, + ** depending on the loops added to the current plan. */ + aFrom[0].isOrdered = nLoop>0 ? -1 : nOrderBy; + } + + /* Compute successively longer WherePaths using the previous generation + ** of WherePaths as the basis for the next. Keep track of the mxChoice + ** best paths at each generation */ + for(iLoop=0; iLooppLoops; pWLoop; pWLoop=pWLoop->pNextLoop){ + LogEst nOut; /* Rows visited by (pFrom+pWLoop) */ + LogEst rCost; /* Cost of path (pFrom+pWLoop) */ + LogEst rUnsorted; /* Unsorted cost of (pFrom+pWLoop) */ + i8 isOrdered = pFrom->isOrdered; /* isOrdered for (pFrom+pWLoop) */ + Bitmask maskNew; /* Mask of src visited by (..) */ + Bitmask revMask = 0; /* Mask of rev-order loops for (..) */ + + if( (pWLoop->prereq & ~pFrom->maskLoop)!=0 ) continue; + if( (pWLoop->maskSelf & pFrom->maskLoop)!=0 ) continue; + if( (pWLoop->wsFlags & WHERE_AUTO_INDEX)!=0 && pFrom->nRow<3 ){ + /* Do not use an automatic index if the this loop is expected + ** to run less than 1.25 times. It is tempting to also exclude + ** automatic index usage on an outer loop, but sometimes an automatic + ** index is useful in the outer loop of a correlated subquery. */ + assert( 10==sqlite3LogEst(2) ); + continue; + } + + /* At this point, pWLoop is a candidate to be the next loop. + ** Compute its cost */ + rUnsorted = sqlite3LogEstAdd(pWLoop->rSetup,pWLoop->rRun + pFrom->nRow); + rUnsorted = sqlite3LogEstAdd(rUnsorted, pFrom->rUnsorted); + nOut = pFrom->nRow + pWLoop->nOut; + maskNew = pFrom->maskLoop | pWLoop->maskSelf; + if( isOrdered<0 ){ + isOrdered = wherePathSatisfiesOrderBy(pWInfo, + pWInfo->pOrderBy, pFrom, pWInfo->wctrlFlags, + iLoop, pWLoop, &revMask); + }else{ + revMask = pFrom->revLoop; + } + if( isOrdered>=0 && isOrderedisOrdered^isOrdered)&0x80)==0" is equivalent + ** to (pTo->isOrdered==(-1))==(isOrdered==(-1))" for the range + ** of legal values for isOrdered, -1..64. + */ + for(jj=0, pTo=aTo; jjmaskLoop==maskNew + && ((pTo->isOrdered^isOrdered)&0x80)==0 + ){ + testcase( jj==nTo-1 ); + break; + } + } + if( jj>=nTo ){ + /* None of the existing best-so-far paths match the candidate. */ + if( nTo>=mxChoice + && (rCost>mxCost || (rCost==mxCost && rUnsorted>=mxUnsorted)) + ){ + /* The current candidate is no better than any of the mxChoice + ** paths currently in the best-so-far buffer. So discard + ** this candidate as not viable. */ +#ifdef WHERETRACE_ENABLED /* 0x4 */ + if( sqlite3WhereTrace&0x4 ){ + sqlite3DebugPrintf("Skip %s cost=%-3d,%3d,%3d order=%c\n", + wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsorted, + isOrdered>=0 ? isOrdered+'0' : '?'); + } +#endif + continue; + } + /* If we reach this points it means that the new candidate path + ** needs to be added to the set of best-so-far paths. */ + if( nTo=0 ? isOrdered+'0' : '?'); + } +#endif + }else{ + /* Control reaches here if best-so-far path pTo=aTo[jj] covers the + ** same set of loops and has the same isOrdered setting as the + ** candidate path. Check to see if the candidate should replace + ** pTo or if the candidate should be skipped. + ** + ** The conditional is an expanded vector comparison equivalent to: + ** (pTo->rCost,pTo->nRow,pTo->rUnsorted) <= (rCost,nOut,rUnsorted) + */ + if( pTo->rCostrCost==rCost + && (pTo->nRownRow==nOut && pTo->rUnsorted<=rUnsorted) + ) + ) + ){ +#ifdef WHERETRACE_ENABLED /* 0x4 */ + if( sqlite3WhereTrace&0x4 ){ + sqlite3DebugPrintf( + "Skip %s cost=%-3d,%3d,%3d order=%c", + wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsorted, + isOrdered>=0 ? isOrdered+'0' : '?'); + sqlite3DebugPrintf(" vs %s cost=%-3d,%3d,%3d order=%c\n", + wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow, + pTo->rUnsorted, pTo->isOrdered>=0 ? pTo->isOrdered+'0' : '?'); + } +#endif + /* Discard the candidate path from further consideration */ + testcase( pTo->rCost==rCost ); + continue; + } + testcase( pTo->rCost==rCost+1 ); + /* Control reaches here if the candidate path is better than the + ** pTo path. Replace pTo with the candidate. */ +#ifdef WHERETRACE_ENABLED /* 0x4 */ + if( sqlite3WhereTrace&0x4 ){ + sqlite3DebugPrintf( + "Update %s cost=%-3d,%3d,%3d order=%c", + wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsorted, + isOrdered>=0 ? isOrdered+'0' : '?'); + sqlite3DebugPrintf(" was %s cost=%-3d,%3d,%3d order=%c\n", + wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow, + pTo->rUnsorted, pTo->isOrdered>=0 ? pTo->isOrdered+'0' : '?'); + } +#endif + } + /* pWLoop is a winner. Add it to the set of best so far */ + pTo->maskLoop = pFrom->maskLoop | pWLoop->maskSelf; + pTo->revLoop = revMask; + pTo->nRow = nOut; + pTo->rCost = rCost; + pTo->rUnsorted = rUnsorted; + pTo->isOrdered = isOrdered; + memcpy(pTo->aLoop, pFrom->aLoop, sizeof(WhereLoop*)*iLoop); + pTo->aLoop[iLoop] = pWLoop; + if( nTo>=mxChoice ){ + mxI = 0; + mxCost = aTo[0].rCost; + mxUnsorted = aTo[0].nRow; + for(jj=1, pTo=&aTo[1]; jjrCost>mxCost + || (pTo->rCost==mxCost && pTo->rUnsorted>mxUnsorted) + ){ + mxCost = pTo->rCost; + mxUnsorted = pTo->rUnsorted; + mxI = jj; + } + } + } + } + } + +#ifdef WHERETRACE_ENABLED /* >=2 */ + if( sqlite3WhereTrace & 0x02 ){ + sqlite3DebugPrintf("---- after round %d ----\n", iLoop); + for(ii=0, pTo=aTo; iirCost, pTo->nRow, + pTo->isOrdered>=0 ? (pTo->isOrdered+'0') : '?'); + if( pTo->isOrdered>0 ){ + sqlite3DebugPrintf(" rev=0x%llx\n", pTo->revLoop); + }else{ + sqlite3DebugPrintf("\n"); + } + } + } +#endif + + /* Swap the roles of aFrom and aTo for the next generation */ + pFrom = aTo; + aTo = aFrom; + aFrom = pFrom; + nFrom = nTo; + } + + if( nFrom==0 ){ + sqlite3ErrorMsg(pParse, "no query solution"); + sqlite3DbFreeNN(db, pSpace); + return SQLITE_ERROR; + } + + /* Find the lowest cost path. pFrom will be left pointing to that path */ + pFrom = aFrom; + for(ii=1; iirCost>aFrom[ii].rCost ) pFrom = &aFrom[ii]; + } + assert( pWInfo->nLevel==nLoop ); + /* Load the lowest cost path into pWInfo */ + for(iLoop=0; iLoopa + iLoop; + pLevel->pWLoop = pWLoop = pFrom->aLoop[iLoop]; + pLevel->iFrom = pWLoop->iTab; + pLevel->iTabCur = pWInfo->pTabList->a[pLevel->iFrom].iCursor; + } + if( (pWInfo->wctrlFlags & WHERE_WANT_DISTINCT)!=0 + && (pWInfo->wctrlFlags & WHERE_DISTINCTBY)==0 + && pWInfo->eDistinct==WHERE_DISTINCT_NOOP + && nRowEst + ){ + Bitmask notUsed; + int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pResultSet, pFrom, + WHERE_DISTINCTBY, nLoop-1, pFrom->aLoop[nLoop-1], ¬Used); + if( rc==pWInfo->pResultSet->nExpr ){ + pWInfo->eDistinct = WHERE_DISTINCT_ORDERED; + } + } + pWInfo->bOrderedInnerLoop = 0; + if( pWInfo->pOrderBy ){ + if( pWInfo->wctrlFlags & WHERE_DISTINCTBY ){ + if( pFrom->isOrdered==pWInfo->pOrderBy->nExpr ){ + pWInfo->eDistinct = WHERE_DISTINCT_ORDERED; + } + }else{ + pWInfo->nOBSat = pFrom->isOrdered; + pWInfo->revMask = pFrom->revLoop; + if( pWInfo->nOBSat<=0 ){ + pWInfo->nOBSat = 0; + if( nLoop>0 ){ + u32 wsFlags = pFrom->aLoop[nLoop-1]->wsFlags; + if( (wsFlags & WHERE_ONEROW)==0 + && (wsFlags&(WHERE_IPK|WHERE_COLUMN_IN))!=(WHERE_IPK|WHERE_COLUMN_IN) + ){ + Bitmask m = 0; + int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pOrderBy, pFrom, + WHERE_ORDERBY_LIMIT, nLoop-1, pFrom->aLoop[nLoop-1], &m); + testcase( wsFlags & WHERE_IPK ); + testcase( wsFlags & WHERE_COLUMN_IN ); + if( rc==pWInfo->pOrderBy->nExpr ){ + pWInfo->bOrderedInnerLoop = 1; + pWInfo->revMask = m; + } + } + } + }else if( nLoop + && pWInfo->nOBSat==1 + && (pWInfo->wctrlFlags & (WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX))!=0 + ){ + pWInfo->bOrderedInnerLoop = 1; + } + } + if( (pWInfo->wctrlFlags & WHERE_SORTBYGROUP) + && pWInfo->nOBSat==pWInfo->pOrderBy->nExpr && nLoop>0 + ){ + Bitmask revMask = 0; + int nOrder = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pOrderBy, + pFrom, 0, nLoop-1, pFrom->aLoop[nLoop-1], &revMask + ); + assert( pWInfo->sorted==0 ); + if( nOrder==pWInfo->pOrderBy->nExpr ){ + pWInfo->sorted = 1; + pWInfo->revMask = revMask; + } + } + } + + + pWInfo->nRowOut = pFrom->nRow; + + /* Free temporary memory and return success */ + sqlite3DbFreeNN(db, pSpace); + return SQLITE_OK; +} + +/* +** Most queries use only a single table (they are not joins) and have +** simple == constraints against indexed fields. This routine attempts +** to plan those simple cases using much less ceremony than the +** general-purpose query planner, and thereby yield faster sqlite3_prepare() +** times for the common case. +** +** Return non-zero on success, if this query can be handled by this +** no-frills query planner. Return zero if this query needs the +** general-purpose query planner. +*/ +static int whereShortCut(WhereLoopBuilder *pBuilder){ + WhereInfo *pWInfo; + struct SrcList_item *pItem; + WhereClause *pWC; + WhereTerm *pTerm; + WhereLoop *pLoop; + int iCur; + int j; + Table *pTab; + Index *pIdx; + + pWInfo = pBuilder->pWInfo; + if( pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE ) return 0; + assert( pWInfo->pTabList->nSrc>=1 ); + pItem = pWInfo->pTabList->a; + pTab = pItem->pTab; + if( IsVirtual(pTab) ) return 0; + if( pItem->fg.isIndexedBy ) return 0; + iCur = pItem->iCursor; + pWC = &pWInfo->sWC; + pLoop = pBuilder->pNew; + pLoop->wsFlags = 0; + pLoop->nSkip = 0; + pTerm = sqlite3WhereFindTerm(pWC, iCur, -1, 0, WO_EQ|WO_IS, 0); + if( pTerm ){ + testcase( pTerm->eOperator & WO_IS ); + pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_IPK|WHERE_ONEROW; + pLoop->aLTerm[0] = pTerm; + pLoop->nLTerm = 1; + pLoop->u.btree.nEq = 1; + /* TUNING: Cost of a rowid lookup is 10 */ + pLoop->rRun = 33; /* 33==sqlite3LogEst(10) */ + }else{ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int opMask; + assert( pLoop->aLTermSpace==pLoop->aLTerm ); + if( !IsUniqueIndex(pIdx) + || pIdx->pPartIdxWhere!=0 + || pIdx->nKeyCol>ArraySize(pLoop->aLTermSpace) + ) continue; + opMask = pIdx->uniqNotNull ? (WO_EQ|WO_IS) : WO_EQ; + for(j=0; jnKeyCol; j++){ + pTerm = sqlite3WhereFindTerm(pWC, iCur, j, 0, opMask, pIdx); + if( pTerm==0 ) break; + testcase( pTerm->eOperator & WO_IS ); + pLoop->aLTerm[j] = pTerm; + } + if( j!=pIdx->nKeyCol ) continue; + pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_ONEROW|WHERE_INDEXED; + if( pIdx->isCovering || (pItem->colUsed & pIdx->colNotIdxed)==0 ){ + pLoop->wsFlags |= WHERE_IDX_ONLY; + } + pLoop->nLTerm = j; + pLoop->u.btree.nEq = j; + pLoop->u.btree.pIndex = pIdx; + /* TUNING: Cost of a unique index lookup is 15 */ + pLoop->rRun = 39; /* 39==sqlite3LogEst(15) */ + break; + } + } + if( pLoop->wsFlags ){ + pLoop->nOut = (LogEst)1; + pWInfo->a[0].pWLoop = pLoop; + assert( pWInfo->sMaskSet.n==1 && iCur==pWInfo->sMaskSet.ix[0] ); + pLoop->maskSelf = 1; /* sqlite3WhereGetMask(&pWInfo->sMaskSet, iCur); */ + pWInfo->a[0].iTabCur = iCur; + pWInfo->nRowOut = 1; + if( pWInfo->pOrderBy ) pWInfo->nOBSat = pWInfo->pOrderBy->nExpr; + if( pWInfo->wctrlFlags & WHERE_WANT_DISTINCT ){ + pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE; + } +#ifdef SQLITE_DEBUG + pLoop->cId = '0'; +#endif + return 1; + } + return 0; +} + +/* +** Helper function for exprIsDeterministic(). +*/ +static int exprNodeIsDeterministic(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_ConstFunc)==0 ){ + pWalker->eCode = 0; + return WRC_Abort; + } + return WRC_Continue; +} + +/* +** Return true if the expression contains no non-deterministic SQL +** functions. Do not consider non-deterministic SQL functions that are +** part of sub-select statements. +*/ +static int exprIsDeterministic(Expr *p){ + Walker w; + memset(&w, 0, sizeof(w)); + w.eCode = 1; + w.xExprCallback = exprNodeIsDeterministic; + w.xSelectCallback = sqlite3SelectWalkFail; + sqlite3WalkExpr(&w, p); + return w.eCode; +} + + +#ifdef WHERETRACE_ENABLED +/* +** Display all WhereLoops in pWInfo +*/ +static void showAllWhereLoops(WhereInfo *pWInfo, WhereClause *pWC){ + if( sqlite3WhereTrace ){ /* Display all of the WhereLoop objects */ + WhereLoop *p; + int i; + static const char zLabel[] = "0123456789abcdefghijklmnopqrstuvwyxz" + "ABCDEFGHIJKLMNOPQRSTUVWYXZ"; + for(p=pWInfo->pLoops, i=0; p; p=p->pNextLoop, i++){ + p->cId = zLabel[i%(sizeof(zLabel)-1)]; + sqlite3WhereLoopPrint(p, pWC); + } + } +} +# define WHERETRACE_ALL_LOOPS(W,C) showAllWhereLoops(W,C) +#else +# define WHERETRACE_ALL_LOOPS(W,C) +#endif + +/* +** Generate the beginning of the loop used for WHERE clause processing. +** The return value is a pointer to an opaque structure that contains +** information needed to terminate the loop. Later, the calling routine +** should invoke sqlite3WhereEnd() with the return value of this function +** in order to complete the WHERE clause processing. +** +** If an error occurs, this routine returns NULL. +** +** The basic idea is to do a nested loop, one loop for each table in +** the FROM clause of a select. (INSERT and UPDATE statements are the +** same as a SELECT with only a single table in the FROM clause.) For +** example, if the SQL is this: +** +** SELECT * FROM t1, t2, t3 WHERE ...; +** +** Then the code generated is conceptually like the following: +** +** foreach row1 in t1 do \ Code generated +** foreach row2 in t2 do |-- by sqlite3WhereBegin() +** foreach row3 in t3 do / +** ... +** end \ Code generated +** end |-- by sqlite3WhereEnd() +** end / +** +** Note that the loops might not be nested in the order in which they +** appear in the FROM clause if a different order is better able to make +** use of indices. Note also that when the IN operator appears in +** the WHERE clause, it might result in additional nested loops for +** scanning through all values on the right-hand side of the IN. +** +** There are Btree cursors associated with each table. t1 uses cursor +** number pTabList->a[0].iCursor. t2 uses the cursor pTabList->a[1].iCursor. +** And so forth. This routine generates code to open those VDBE cursors +** and sqlite3WhereEnd() generates the code to close them. +** +** The code that sqlite3WhereBegin() generates leaves the cursors named +** in pTabList pointing at their appropriate entries. The [...] code +** can use OP_Column and OP_Rowid opcodes on these cursors to extract +** data from the various tables of the loop. +** +** If the WHERE clause is empty, the foreach loops must each scan their +** entire tables. Thus a three-way join is an O(N^3) operation. But if +** the tables have indices and there are terms in the WHERE clause that +** refer to those indices, a complete table scan can be avoided and the +** code will run much faster. Most of the work of this routine is checking +** to see if there are indices that can be used to speed up the loop. +** +** Terms of the WHERE clause are also used to limit which rows actually +** make it to the "..." in the middle of the loop. After each "foreach", +** terms of the WHERE clause that use only terms in that loop and outer +** loops are evaluated and if false a jump is made around all subsequent +** inner loops (or around the "..." if the test occurs within the inner- +** most loop) +** +** OUTER JOINS +** +** An outer join of tables t1 and t2 is conceptally coded as follows: +** +** foreach row1 in t1 do +** flag = 0 +** foreach row2 in t2 do +** start: +** ... +** flag = 1 +** end +** if flag==0 then +** move the row2 cursor to a null row +** goto start +** fi +** end +** +** ORDER BY CLAUSE PROCESSING +** +** pOrderBy is a pointer to the ORDER BY clause (or the GROUP BY clause +** if the WHERE_GROUPBY flag is set in wctrlFlags) of a SELECT statement +** if there is one. If there is no ORDER BY clause or if this routine +** is called from an UPDATE or DELETE statement, then pOrderBy is NULL. +** +** The iIdxCur parameter is the cursor number of an index. If +** WHERE_OR_SUBCLAUSE is set, iIdxCur is the cursor number of an index +** to use for OR clause processing. The WHERE clause should use this +** specific cursor. If WHERE_ONEPASS_DESIRED is set, then iIdxCur is +** the first cursor in an array of cursors for all indices. iIdxCur should +** be used to compute the appropriate cursor depending on which index is +** used. +*/ +SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin( + Parse *pParse, /* The parser context */ + SrcList *pTabList, /* FROM clause: A list of all tables to be scanned */ + Expr *pWhere, /* The WHERE clause */ + ExprList *pOrderBy, /* An ORDER BY (or GROUP BY) clause, or NULL */ + ExprList *pResultSet, /* Query result set. Req'd for DISTINCT */ + u16 wctrlFlags, /* The WHERE_* flags defined in sqliteInt.h */ + int iAuxArg /* If WHERE_OR_SUBCLAUSE is set, index cursor number + ** If WHERE_USE_LIMIT, then the limit amount */ +){ + int nByteWInfo; /* Num. bytes allocated for WhereInfo struct */ + int nTabList; /* Number of elements in pTabList */ + WhereInfo *pWInfo; /* Will become the return value of this function */ + Vdbe *v = pParse->pVdbe; /* The virtual database engine */ + Bitmask notReady; /* Cursors that are not yet positioned */ + WhereLoopBuilder sWLB; /* The WhereLoop builder */ + WhereMaskSet *pMaskSet; /* The expression mask set */ + WhereLevel *pLevel; /* A single level in pWInfo->a[] */ + WhereLoop *pLoop; /* Pointer to a single WhereLoop object */ + int ii; /* Loop counter */ + sqlite3 *db; /* Database connection */ + int rc; /* Return code */ + u8 bFordelete = 0; /* OPFLAG_FORDELETE or zero, as appropriate */ + + assert( (wctrlFlags & WHERE_ONEPASS_MULTIROW)==0 || ( + (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0 + && (wctrlFlags & WHERE_OR_SUBCLAUSE)==0 + )); + + /* Only one of WHERE_OR_SUBCLAUSE or WHERE_USE_LIMIT */ + assert( (wctrlFlags & WHERE_OR_SUBCLAUSE)==0 + || (wctrlFlags & WHERE_USE_LIMIT)==0 ); + + /* Variable initialization */ + db = pParse->db; + memset(&sWLB, 0, sizeof(sWLB)); + + /* An ORDER/GROUP BY clause of more than 63 terms cannot be optimized */ + testcase( pOrderBy && pOrderBy->nExpr==BMS-1 ); + if( pOrderBy && pOrderBy->nExpr>=BMS ) pOrderBy = 0; + sWLB.pOrderBy = pOrderBy; + + /* Disable the DISTINCT optimization if SQLITE_DistinctOpt is set via + ** sqlite3_test_ctrl(SQLITE_TESTCTRL_OPTIMIZATIONS,...) */ + if( OptimizationDisabled(db, SQLITE_DistinctOpt) ){ + wctrlFlags &= ~WHERE_WANT_DISTINCT; + } + + /* The number of tables in the FROM clause is limited by the number of + ** bits in a Bitmask + */ + testcase( pTabList->nSrc==BMS ); + if( pTabList->nSrc>BMS ){ + sqlite3ErrorMsg(pParse, "at most %d tables in a join", BMS); + return 0; + } + + /* This function normally generates a nested loop for all tables in + ** pTabList. But if the WHERE_OR_SUBCLAUSE flag is set, then we should + ** only generate code for the first table in pTabList and assume that + ** any cursors associated with subsequent tables are uninitialized. + */ + nTabList = (wctrlFlags & WHERE_OR_SUBCLAUSE) ? 1 : pTabList->nSrc; + + /* Allocate and initialize the WhereInfo structure that will become the + ** return value. A single allocation is used to store the WhereInfo + ** struct, the contents of WhereInfo.a[], the WhereClause structure + ** and the WhereMaskSet structure. Since WhereClause contains an 8-byte + ** field (type Bitmask) it must be aligned on an 8-byte boundary on + ** some architectures. Hence the ROUND8() below. + */ + nByteWInfo = ROUND8(sizeof(WhereInfo)+(nTabList-1)*sizeof(WhereLevel)); + pWInfo = sqlite3DbMallocRawNN(db, nByteWInfo + sizeof(WhereLoop)); + if( db->mallocFailed ){ + sqlite3DbFree(db, pWInfo); + pWInfo = 0; + goto whereBeginError; + } + pWInfo->pParse = pParse; + pWInfo->pTabList = pTabList; + pWInfo->pOrderBy = pOrderBy; + pWInfo->pWhere = pWhere; + pWInfo->pResultSet = pResultSet; + pWInfo->aiCurOnePass[0] = pWInfo->aiCurOnePass[1] = -1; + pWInfo->nLevel = nTabList; + pWInfo->iBreak = pWInfo->iContinue = sqlite3VdbeMakeLabel(pParse); + pWInfo->wctrlFlags = wctrlFlags; + pWInfo->iLimit = iAuxArg; + pWInfo->savedNQueryLoop = pParse->nQueryLoop; + memset(&pWInfo->nOBSat, 0, + offsetof(WhereInfo,sWC) - offsetof(WhereInfo,nOBSat)); + memset(&pWInfo->a[0], 0, sizeof(WhereLoop)+nTabList*sizeof(WhereLevel)); + assert( pWInfo->eOnePass==ONEPASS_OFF ); /* ONEPASS defaults to OFF */ + pMaskSet = &pWInfo->sMaskSet; + sWLB.pWInfo = pWInfo; + sWLB.pWC = &pWInfo->sWC; + sWLB.pNew = (WhereLoop*)(((char*)pWInfo)+nByteWInfo); + assert( EIGHT_BYTE_ALIGNMENT(sWLB.pNew) ); + whereLoopInit(sWLB.pNew); +#ifdef SQLITE_DEBUG + sWLB.pNew->cId = '*'; +#endif + + /* Split the WHERE clause into separate subexpressions where each + ** subexpression is separated by an AND operator. + */ + initMaskSet(pMaskSet); + sqlite3WhereClauseInit(&pWInfo->sWC, pWInfo); + sqlite3WhereSplit(&pWInfo->sWC, pWhere, TK_AND); + + /* Special case: No FROM clause + */ + if( nTabList==0 ){ + if( pOrderBy ) pWInfo->nOBSat = pOrderBy->nExpr; + if( wctrlFlags & WHERE_WANT_DISTINCT ){ + pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE; + } + ExplainQueryPlan((pParse, 0, "SCAN CONSTANT ROW")); + }else{ + /* Assign a bit from the bitmask to every term in the FROM clause. + ** + ** The N-th term of the FROM clause is assigned a bitmask of 1<nSrc tables in + ** pTabList, not just the first nTabList tables. nTabList is normally + ** equal to pTabList->nSrc but might be shortened to 1 if the + ** WHERE_OR_SUBCLAUSE flag is set. + */ + ii = 0; + do{ + createMask(pMaskSet, pTabList->a[ii].iCursor); + sqlite3WhereTabFuncArgs(pParse, &pTabList->a[ii], &pWInfo->sWC); + }while( (++ii)nSrc ); + #ifdef SQLITE_DEBUG + { + Bitmask mx = 0; + for(ii=0; iinSrc; ii++){ + Bitmask m = sqlite3WhereGetMask(pMaskSet, pTabList->a[ii].iCursor); + assert( m>=mx ); + mx = m; + } + } + #endif + } + + /* Analyze all of the subexpressions. */ + sqlite3WhereExprAnalyze(pTabList, &pWInfo->sWC); + if( db->mallocFailed ) goto whereBeginError; + + /* Special case: WHERE terms that do not refer to any tables in the join + ** (constant expressions). Evaluate each such term, and jump over all the + ** generated code if the result is not true. + ** + ** Do not do this if the expression contains non-deterministic functions + ** that are not within a sub-select. This is not strictly required, but + ** preserves SQLite's legacy behaviour in the following two cases: + ** + ** FROM ... WHERE random()>0; -- eval random() once per row + ** FROM ... WHERE (SELECT random())>0; -- eval random() once overall + */ + for(ii=0; iinTerm; ii++){ + WhereTerm *pT = &sWLB.pWC->a[ii]; + if( pT->wtFlags & TERM_VIRTUAL ) continue; + if( pT->prereqAll==0 && (nTabList==0 || exprIsDeterministic(pT->pExpr)) ){ + sqlite3ExprIfFalse(pParse, pT->pExpr, pWInfo->iBreak, SQLITE_JUMPIFNULL); + pT->wtFlags |= TERM_CODED; + } + } + + if( wctrlFlags & WHERE_WANT_DISTINCT ){ + if( isDistinctRedundant(pParse, pTabList, &pWInfo->sWC, pResultSet) ){ + /* The DISTINCT marking is pointless. Ignore it. */ + pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE; + }else if( pOrderBy==0 ){ + /* Try to ORDER BY the result set to make distinct processing easier */ + pWInfo->wctrlFlags |= WHERE_DISTINCTBY; + pWInfo->pOrderBy = pResultSet; + } + } + + /* Construct the WhereLoop objects */ +#if defined(WHERETRACE_ENABLED) + if( sqlite3WhereTrace & 0xffff ){ + sqlite3DebugPrintf("*** Optimizer Start *** (wctrlFlags: 0x%x",wctrlFlags); + if( wctrlFlags & WHERE_USE_LIMIT ){ + sqlite3DebugPrintf(", limit: %d", iAuxArg); + } + sqlite3DebugPrintf(")\n"); + if( sqlite3WhereTrace & 0x100 ){ + Select sSelect; + memset(&sSelect, 0, sizeof(sSelect)); + sSelect.selFlags = SF_WhereBegin; + sSelect.pSrc = pTabList; + sSelect.pWhere = pWhere; + sSelect.pOrderBy = pOrderBy; + sSelect.pEList = pResultSet; + sqlite3TreeViewSelect(0, &sSelect, 0); + } + } + if( sqlite3WhereTrace & 0x100 ){ /* Display all terms of the WHERE clause */ + sqlite3DebugPrintf("---- WHERE clause at start of analysis:\n"); + sqlite3WhereClausePrint(sWLB.pWC); + } +#endif + + if( nTabList!=1 || whereShortCut(&sWLB)==0 ){ + rc = whereLoopAddAll(&sWLB); + if( rc ) goto whereBeginError; + +#ifdef SQLITE_ENABLE_STAT4 + /* If one or more WhereTerm.truthProb values were used in estimating + ** loop parameters, but then those truthProb values were subsequently + ** changed based on STAT4 information while computing subsequent loops, + ** then we need to rerun the whole loop building process so that all + ** loops will be built using the revised truthProb values. */ + if( sWLB.bldFlags2 & SQLITE_BLDF2_2NDPASS ){ + WHERETRACE_ALL_LOOPS(pWInfo, sWLB.pWC); + WHERETRACE(0xffff, + ("**** Redo all loop computations due to" + " TERM_HIGHTRUTH changes ****\n")); + while( pWInfo->pLoops ){ + WhereLoop *p = pWInfo->pLoops; + pWInfo->pLoops = p->pNextLoop; + whereLoopDelete(db, p); + } + rc = whereLoopAddAll(&sWLB); + if( rc ) goto whereBeginError; + } +#endif + WHERETRACE_ALL_LOOPS(pWInfo, sWLB.pWC); + + wherePathSolver(pWInfo, 0); + if( db->mallocFailed ) goto whereBeginError; + if( pWInfo->pOrderBy ){ + wherePathSolver(pWInfo, pWInfo->nRowOut+1); + if( db->mallocFailed ) goto whereBeginError; + } + } + if( pWInfo->pOrderBy==0 && (db->flags & SQLITE_ReverseOrder)!=0 ){ + pWInfo->revMask = ALLBITS; + } + if( pParse->nErr || NEVER(db->mallocFailed) ){ + goto whereBeginError; + } +#ifdef WHERETRACE_ENABLED + if( sqlite3WhereTrace ){ + sqlite3DebugPrintf("---- Solution nRow=%d", pWInfo->nRowOut); + if( pWInfo->nOBSat>0 ){ + sqlite3DebugPrintf(" ORDERBY=%d,0x%llx", pWInfo->nOBSat, pWInfo->revMask); + } + switch( pWInfo->eDistinct ){ + case WHERE_DISTINCT_UNIQUE: { + sqlite3DebugPrintf(" DISTINCT=unique"); + break; + } + case WHERE_DISTINCT_ORDERED: { + sqlite3DebugPrintf(" DISTINCT=ordered"); + break; + } + case WHERE_DISTINCT_UNORDERED: { + sqlite3DebugPrintf(" DISTINCT=unordered"); + break; + } + } + sqlite3DebugPrintf("\n"); + for(ii=0; iinLevel; ii++){ + sqlite3WhereLoopPrint(pWInfo->a[ii].pWLoop, sWLB.pWC); + } + } +#endif + + /* Attempt to omit tables from the join that do not affect the result. + ** For a table to not affect the result, the following must be true: + ** + ** 1) The query must not be an aggregate. + ** 2) The table must be the RHS of a LEFT JOIN. + ** 3) Either the query must be DISTINCT, or else the ON or USING clause + ** must contain a constraint that limits the scan of the table to + ** at most a single row. + ** 4) The table must not be referenced by any part of the query apart + ** from its own USING or ON clause. + ** + ** For example, given: + ** + ** CREATE TABLE t1(ipk INTEGER PRIMARY KEY, v1); + ** CREATE TABLE t2(ipk INTEGER PRIMARY KEY, v2); + ** CREATE TABLE t3(ipk INTEGER PRIMARY KEY, v3); + ** + ** then table t2 can be omitted from the following: + ** + ** SELECT v1, v3 FROM t1 + ** LEFT JOIN t2 ON (t1.ipk=t2.ipk) + ** LEFT JOIN t3 ON (t1.ipk=t3.ipk) + ** + ** or from: + ** + ** SELECT DISTINCT v1, v3 FROM t1 + ** LEFT JOIN t2 + ** LEFT JOIN t3 ON (t1.ipk=t3.ipk) + */ + notReady = ~(Bitmask)0; + if( pWInfo->nLevel>=2 + && pResultSet!=0 /* guarantees condition (1) above */ + && OptimizationEnabled(db, SQLITE_OmitNoopJoin) + ){ + int i; + Bitmask tabUsed = sqlite3WhereExprListUsage(pMaskSet, pResultSet); + if( sWLB.pOrderBy ){ + tabUsed |= sqlite3WhereExprListUsage(pMaskSet, sWLB.pOrderBy); + } + for(i=pWInfo->nLevel-1; i>=1; i--){ + WhereTerm *pTerm, *pEnd; + struct SrcList_item *pItem; + pLoop = pWInfo->a[i].pWLoop; + pItem = &pWInfo->pTabList->a[pLoop->iTab]; + if( (pItem->fg.jointype & JT_LEFT)==0 ) continue; + if( (wctrlFlags & WHERE_WANT_DISTINCT)==0 + && (pLoop->wsFlags & WHERE_ONEROW)==0 + ){ + continue; + } + if( (tabUsed & pLoop->maskSelf)!=0 ) continue; + pEnd = sWLB.pWC->a + sWLB.pWC->nTerm; + for(pTerm=sWLB.pWC->a; pTermprereqAll & pLoop->maskSelf)!=0 ){ + if( !ExprHasProperty(pTerm->pExpr, EP_FromJoin) + || pTerm->pExpr->iRightJoinTable!=pItem->iCursor + ){ + break; + } + } + } + if( pTerm drop loop %c not used\n", pLoop->cId)); + notReady &= ~pLoop->maskSelf; + for(pTerm=sWLB.pWC->a; pTermprereqAll & pLoop->maskSelf)!=0 ){ + pTerm->wtFlags |= TERM_CODED; + } + } + if( i!=pWInfo->nLevel-1 ){ + int nByte = (pWInfo->nLevel-1-i) * sizeof(WhereLevel); + memmove(&pWInfo->a[i], &pWInfo->a[i+1], nByte); + } + pWInfo->nLevel--; + nTabList--; + } + } +#if defined(WHERETRACE_ENABLED) + if( sqlite3WhereTrace & 0x100 ){ /* Display all terms of the WHERE clause */ + sqlite3DebugPrintf("---- WHERE clause at end of analysis:\n"); + sqlite3WhereClausePrint(sWLB.pWC); + } + WHERETRACE(0xffff,("*** Optimizer Finished ***\n")); +#endif + pWInfo->pParse->nQueryLoop += pWInfo->nRowOut; + + /* If the caller is an UPDATE or DELETE statement that is requesting + ** to use a one-pass algorithm, determine if this is appropriate. + ** + ** A one-pass approach can be used if the caller has requested one + ** and either (a) the scan visits at most one row or (b) each + ** of the following are true: + ** + ** * the caller has indicated that a one-pass approach can be used + ** with multiple rows (by setting WHERE_ONEPASS_MULTIROW), and + ** * the table is not a virtual table, and + ** * either the scan does not use the OR optimization or the caller + ** is a DELETE operation (WHERE_DUPLICATES_OK is only specified + ** for DELETE). + ** + ** The last qualification is because an UPDATE statement uses + ** WhereInfo.aiCurOnePass[1] to determine whether or not it really can + ** use a one-pass approach, and this is not set accurately for scans + ** that use the OR optimization. + */ + assert( (wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || pWInfo->nLevel==1 ); + if( (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0 ){ + int wsFlags = pWInfo->a[0].pWLoop->wsFlags; + int bOnerow = (wsFlags & WHERE_ONEROW)!=0; + assert( !(wsFlags & WHERE_VIRTUALTABLE) || IsVirtual(pTabList->a[0].pTab) ); + if( bOnerow || ( + 0!=(wctrlFlags & WHERE_ONEPASS_MULTIROW) + && !IsVirtual(pTabList->a[0].pTab) + && (0==(wsFlags & WHERE_MULTI_OR) || (wctrlFlags & WHERE_DUPLICATES_OK)) + )){ + pWInfo->eOnePass = bOnerow ? ONEPASS_SINGLE : ONEPASS_MULTI; + if( HasRowid(pTabList->a[0].pTab) && (wsFlags & WHERE_IDX_ONLY) ){ + if( wctrlFlags & WHERE_ONEPASS_MULTIROW ){ + bFordelete = OPFLAG_FORDELETE; + } + pWInfo->a[0].pWLoop->wsFlags = (wsFlags & ~WHERE_IDX_ONLY); + } + } + } + + /* Open all tables in the pTabList and any indices selected for + ** searching those tables. + */ + for(ii=0, pLevel=pWInfo->a; iia[pLevel->iFrom]; + pTab = pTabItem->pTab; + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + pLoop = pLevel->pWLoop; + if( (pTab->tabFlags & TF_Ephemeral)!=0 || pTab->pSelect ){ + /* Do nothing */ + }else +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 ){ + const char *pVTab = (const char *)sqlite3GetVTable(db, pTab); + int iCur = pTabItem->iCursor; + sqlite3VdbeAddOp4(v, OP_VOpen, iCur, 0, 0, pVTab, P4_VTAB); + }else if( IsVirtual(pTab) ){ + /* noop */ + }else +#endif + if( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 + && (wctrlFlags & WHERE_OR_SUBCLAUSE)==0 ){ + int op = OP_OpenRead; + if( pWInfo->eOnePass!=ONEPASS_OFF ){ + op = OP_OpenWrite; + pWInfo->aiCurOnePass[0] = pTabItem->iCursor; + }; + sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op); + assert( pTabItem->iCursor==pLevel->iTabCur ); + testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 ); + testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS ); + if( pWInfo->eOnePass==ONEPASS_OFF + && pTab->nColtabFlags & (TF_HasGenerated|TF_WithoutRowid))==0 + ){ + /* If we know that only a prefix of the record will be used, + ** it is advantageous to reduce the "column count" field in + ** the P4 operand of the OP_OpenRead/Write opcode. */ + Bitmask b = pTabItem->colUsed; + int n = 0; + for(; b; b=b>>1, n++){} + sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(n), P4_INT32); + assert( n<=pTab->nCol ); + } +#ifdef SQLITE_ENABLE_CURSOR_HINTS + if( pLoop->u.btree.pIndex!=0 ){ + sqlite3VdbeChangeP5(v, OPFLAG_SEEKEQ|bFordelete); + }else +#endif + { + sqlite3VdbeChangeP5(v, bFordelete); + } +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK + sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed, pTabItem->iCursor, 0, 0, + (const u8*)&pTabItem->colUsed, P4_INT64); +#endif + }else{ + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + } + if( pLoop->wsFlags & WHERE_INDEXED ){ + Index *pIx = pLoop->u.btree.pIndex; + int iIndexCur; + int op = OP_OpenRead; + /* iAuxArg is always set to a positive value if ONEPASS is possible */ + assert( iAuxArg!=0 || (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 ); + if( !HasRowid(pTab) && IsPrimaryKeyIndex(pIx) + && (wctrlFlags & WHERE_OR_SUBCLAUSE)!=0 + ){ + /* This is one term of an OR-optimization using the PRIMARY KEY of a + ** WITHOUT ROWID table. No need for a separate index */ + iIndexCur = pLevel->iTabCur; + op = 0; + }else if( pWInfo->eOnePass!=ONEPASS_OFF ){ + Index *pJ = pTabItem->pTab->pIndex; + iIndexCur = iAuxArg; + assert( wctrlFlags & WHERE_ONEPASS_DESIRED ); + while( ALWAYS(pJ) && pJ!=pIx ){ + iIndexCur++; + pJ = pJ->pNext; + } + op = OP_OpenWrite; + pWInfo->aiCurOnePass[1] = iIndexCur; + }else if( iAuxArg && (wctrlFlags & WHERE_OR_SUBCLAUSE)!=0 ){ + iIndexCur = iAuxArg; + op = OP_ReopenIdx; + }else{ + iIndexCur = pParse->nTab++; + } + pLevel->iIdxCur = iIndexCur; + assert( pIx->pSchema==pTab->pSchema ); + assert( iIndexCur>=0 ); + if( op ){ + sqlite3VdbeAddOp3(v, op, iIndexCur, pIx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIx); + if( (pLoop->wsFlags & WHERE_CONSTRAINT)!=0 + && (pLoop->wsFlags & (WHERE_COLUMN_RANGE|WHERE_SKIPSCAN))==0 + && (pLoop->wsFlags & WHERE_BIGNULL_SORT)==0 + && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)==0 + && (pWInfo->wctrlFlags&WHERE_ORDERBY_MIN)==0 + && pWInfo->eDistinct!=WHERE_DISTINCT_ORDERED + ){ + sqlite3VdbeChangeP5(v, OPFLAG_SEEKEQ); + } + VdbeComment((v, "%s", pIx->zName)); +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK + { + u64 colUsed = 0; + int ii, jj; + for(ii=0; iinColumn; ii++){ + jj = pIx->aiColumn[ii]; + if( jj<0 ) continue; + if( jj>63 ) jj = 63; + if( (pTabItem->colUsed & MASKBIT(jj))==0 ) continue; + colUsed |= ((u64)1)<<(ii<63 ? ii : 63); + } + sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed, iIndexCur, 0, 0, + (u8*)&colUsed, P4_INT64); + } +#endif /* SQLITE_ENABLE_COLUMN_USED_MASK */ + } + } + if( iDb>=0 ) sqlite3CodeVerifySchema(pParse, iDb); + } + pWInfo->iTop = sqlite3VdbeCurrentAddr(v); + if( db->mallocFailed ) goto whereBeginError; + + /* Generate the code to do the search. Each iteration of the for + ** loop below generates code for a single nested loop of the VM + ** program. + */ + for(ii=0; iia[ii]; + wsFlags = pLevel->pWLoop->wsFlags; +#ifndef SQLITE_OMIT_AUTOMATIC_INDEX + if( (pLevel->pWLoop->wsFlags & WHERE_AUTO_INDEX)!=0 ){ + constructAutomaticIndex(pParse, &pWInfo->sWC, + &pTabList->a[pLevel->iFrom], notReady, pLevel); + if( db->mallocFailed ) goto whereBeginError; + } +#endif + addrExplain = sqlite3WhereExplainOneScan( + pParse, pTabList, pLevel, wctrlFlags + ); + pLevel->addrBody = sqlite3VdbeCurrentAddr(v); + notReady = sqlite3WhereCodeOneLoopStart(pParse,v,pWInfo,ii,pLevel,notReady); + pWInfo->iContinue = pLevel->addrCont; + if( (wsFlags&WHERE_MULTI_OR)==0 && (wctrlFlags&WHERE_OR_SUBCLAUSE)==0 ){ + sqlite3WhereAddScanStatus(v, pTabList, pLevel, addrExplain); + } + } + + /* Done. */ + VdbeModuleComment((v, "Begin WHERE-core")); + pWInfo->iEndWhere = sqlite3VdbeCurrentAddr(v); + return pWInfo; + + /* Jump here if malloc fails */ +whereBeginError: + if( pWInfo ){ + pParse->nQueryLoop = pWInfo->savedNQueryLoop; + whereInfoFree(db, pWInfo); + } + return 0; +} + +/* +** Part of sqlite3WhereEnd() will rewrite opcodes to reference the +** index rather than the main table. In SQLITE_DEBUG mode, we want +** to trace those changes if PRAGMA vdbe_addoptrace=on. This routine +** does that. +*/ +#ifndef SQLITE_DEBUG +# define OpcodeRewriteTrace(D,K,P) /* no-op */ +#else +# define OpcodeRewriteTrace(D,K,P) sqlite3WhereOpcodeRewriteTrace(D,K,P) + static void sqlite3WhereOpcodeRewriteTrace( + sqlite3 *db, + int pc, + VdbeOp *pOp + ){ + if( (db->flags & SQLITE_VdbeAddopTrace)==0 ) return; + sqlite3VdbePrintOp(0, pc, pOp); + } +#endif + +/* +** Generate the end of the WHERE loop. See comments on +** sqlite3WhereBegin() for additional information. +*/ +SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){ + Parse *pParse = pWInfo->pParse; + Vdbe *v = pParse->pVdbe; + int i; + WhereLevel *pLevel; + WhereLoop *pLoop; + SrcList *pTabList = pWInfo->pTabList; + sqlite3 *db = pParse->db; + int iEnd = sqlite3VdbeCurrentAddr(v); + + /* Generate loop termination code. + */ + VdbeModuleComment((v, "End WHERE-core")); + for(i=pWInfo->nLevel-1; i>=0; i--){ + int addr; + pLevel = &pWInfo->a[i]; + pLoop = pLevel->pWLoop; + if( pLevel->op!=OP_Noop ){ +#ifndef SQLITE_DISABLE_SKIPAHEAD_DISTINCT + int addrSeek = 0; + Index *pIdx; + int n; + if( pWInfo->eDistinct==WHERE_DISTINCT_ORDERED + && i==pWInfo->nLevel-1 /* Ticket [ef9318757b152e3] 2017-10-21 */ + && (pLoop->wsFlags & WHERE_INDEXED)!=0 + && (pIdx = pLoop->u.btree.pIndex)->hasStat1 + && (n = pLoop->u.btree.nDistinctCol)>0 + && pIdx->aiRowLogEst[n]>=36 + ){ + int r1 = pParse->nMem+1; + int j, op; + for(j=0; jiIdxCur, j, r1+j); + } + pParse->nMem += n+1; + op = pLevel->op==OP_Prev ? OP_SeekLT : OP_SeekGT; + addrSeek = sqlite3VdbeAddOp4Int(v, op, pLevel->iIdxCur, 0, r1, n); + VdbeCoverageIf(v, op==OP_SeekLT); + VdbeCoverageIf(v, op==OP_SeekGT); + sqlite3VdbeAddOp2(v, OP_Goto, 1, pLevel->p2); + } +#endif /* SQLITE_DISABLE_SKIPAHEAD_DISTINCT */ + /* The common case: Advance to the next row */ + sqlite3VdbeResolveLabel(v, pLevel->addrCont); + sqlite3VdbeAddOp3(v, pLevel->op, pLevel->p1, pLevel->p2, pLevel->p3); + sqlite3VdbeChangeP5(v, pLevel->p5); + VdbeCoverage(v); + VdbeCoverageIf(v, pLevel->op==OP_Next); + VdbeCoverageIf(v, pLevel->op==OP_Prev); + VdbeCoverageIf(v, pLevel->op==OP_VNext); + if( pLevel->regBignull ){ + sqlite3VdbeResolveLabel(v, pLevel->addrBignull); + sqlite3VdbeAddOp2(v, OP_DecrJumpZero, pLevel->regBignull, pLevel->p2-1); + VdbeCoverage(v); + } +#ifndef SQLITE_DISABLE_SKIPAHEAD_DISTINCT + if( addrSeek ) sqlite3VdbeJumpHere(v, addrSeek); +#endif + }else{ + sqlite3VdbeResolveLabel(v, pLevel->addrCont); + } + if( pLoop->wsFlags & WHERE_IN_ABLE && pLevel->u.in.nIn>0 ){ + struct InLoop *pIn; + int j; + sqlite3VdbeResolveLabel(v, pLevel->addrNxt); + for(j=pLevel->u.in.nIn, pIn=&pLevel->u.in.aInLoop[j-1]; j>0; j--, pIn--){ + sqlite3VdbeJumpHere(v, pIn->addrInTop+1); + if( pIn->eEndLoopOp!=OP_Noop ){ + if( pIn->nPrefix ){ + int bEarlyOut = + (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 + && (pLoop->wsFlags & WHERE_IN_EARLYOUT)!=0; + if( pLevel->iLeftJoin ){ + /* For LEFT JOIN queries, cursor pIn->iCur may not have been + ** opened yet. This occurs for WHERE clauses such as + ** "a = ? AND b IN (...)", where the index is on (a, b). If + ** the RHS of the (a=?) is NULL, then the "b IN (...)" may + ** never have been coded, but the body of the loop run to + ** return the null-row. So, if the cursor is not open yet, + ** jump over the OP_Next or OP_Prev instruction about to + ** be coded. */ + sqlite3VdbeAddOp2(v, OP_IfNotOpen, pIn->iCur, + sqlite3VdbeCurrentAddr(v) + 2 + bEarlyOut); + VdbeCoverage(v); + } + if( bEarlyOut ){ + sqlite3VdbeAddOp4Int(v, OP_IfNoHope, pLevel->iIdxCur, + sqlite3VdbeCurrentAddr(v)+2, + pIn->iBase, pIn->nPrefix); + VdbeCoverage(v); + } + } + sqlite3VdbeAddOp2(v, pIn->eEndLoopOp, pIn->iCur, pIn->addrInTop); + VdbeCoverage(v); + VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Prev); + VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Next); + } + sqlite3VdbeJumpHere(v, pIn->addrInTop-1); + } + } + sqlite3VdbeResolveLabel(v, pLevel->addrBrk); + if( pLevel->addrSkip ){ + sqlite3VdbeGoto(v, pLevel->addrSkip); + VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName)); + sqlite3VdbeJumpHere(v, pLevel->addrSkip); + sqlite3VdbeJumpHere(v, pLevel->addrSkip-2); + } +#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS + if( pLevel->addrLikeRep ){ + sqlite3VdbeAddOp2(v, OP_DecrJumpZero, (int)(pLevel->iLikeRepCntr>>1), + pLevel->addrLikeRep); + VdbeCoverage(v); + } +#endif + if( pLevel->iLeftJoin ){ + int ws = pLoop->wsFlags; + addr = sqlite3VdbeAddOp1(v, OP_IfPos, pLevel->iLeftJoin); VdbeCoverage(v); + assert( (ws & WHERE_IDX_ONLY)==0 || (ws & WHERE_INDEXED)!=0 ); + if( (ws & WHERE_IDX_ONLY)==0 ){ + assert( pLevel->iTabCur==pTabList->a[pLevel->iFrom].iCursor ); + sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iTabCur); + } + if( (ws & WHERE_INDEXED) + || ((ws & WHERE_MULTI_OR) && pLevel->u.pCovidx) + ){ + sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iIdxCur); + } + if( pLevel->op==OP_Return ){ + sqlite3VdbeAddOp2(v, OP_Gosub, pLevel->p1, pLevel->addrFirst); + }else{ + sqlite3VdbeGoto(v, pLevel->addrFirst); + } + sqlite3VdbeJumpHere(v, addr); + } + VdbeModuleComment((v, "End WHERE-loop%d: %s", i, + pWInfo->pTabList->a[pLevel->iFrom].pTab->zName)); + } + + /* The "break" point is here, just past the end of the outer loop. + ** Set it. + */ + sqlite3VdbeResolveLabel(v, pWInfo->iBreak); + + assert( pWInfo->nLevel<=pTabList->nSrc ); + for(i=0, pLevel=pWInfo->a; inLevel; i++, pLevel++){ + int k, last; + VdbeOp *pOp, *pLastOp; + Index *pIdx = 0; + struct SrcList_item *pTabItem = &pTabList->a[pLevel->iFrom]; + Table *pTab = pTabItem->pTab; + assert( pTab!=0 ); + pLoop = pLevel->pWLoop; + + /* For a co-routine, change all OP_Column references to the table of + ** the co-routine into OP_Copy of result contained in a register. + ** OP_Rowid becomes OP_Null. + */ + if( pTabItem->fg.viaCoroutine ){ + testcase( pParse->db->mallocFailed ); + translateColumnToCopy(pParse, pLevel->addrBody, pLevel->iTabCur, + pTabItem->regResult, 0); + continue; + } + +#ifdef SQLITE_ENABLE_EARLY_CURSOR_CLOSE + /* Close all of the cursors that were opened by sqlite3WhereBegin. + ** Except, do not close cursors that will be reused by the OR optimization + ** (WHERE_OR_SUBCLAUSE). And do not close the OP_OpenWrite cursors + ** created for the ONEPASS optimization. + */ + if( (pTab->tabFlags & TF_Ephemeral)==0 + && pTab->pSelect==0 + && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0 + ){ + int ws = pLoop->wsFlags; + if( pWInfo->eOnePass==ONEPASS_OFF && (ws & WHERE_IDX_ONLY)==0 ){ + sqlite3VdbeAddOp1(v, OP_Close, pTabItem->iCursor); + } + if( (ws & WHERE_INDEXED)!=0 + && (ws & (WHERE_IPK|WHERE_AUTO_INDEX))==0 + && pLevel->iIdxCur!=pWInfo->aiCurOnePass[1] + ){ + sqlite3VdbeAddOp1(v, OP_Close, pLevel->iIdxCur); + } + } +#endif + + /* If this scan uses an index, make VDBE code substitutions to read data + ** from the index instead of from the table where possible. In some cases + ** this optimization prevents the table from ever being read, which can + ** yield a significant performance boost. + ** + ** Calls to the code generator in between sqlite3WhereBegin and + ** sqlite3WhereEnd will have created code that references the table + ** directly. This loop scans all that code looking for opcodes + ** that reference the table and converts them into opcodes that + ** reference the index. + */ + if( pLoop->wsFlags & (WHERE_INDEXED|WHERE_IDX_ONLY) ){ + pIdx = pLoop->u.btree.pIndex; + }else if( pLoop->wsFlags & WHERE_MULTI_OR ){ + pIdx = pLevel->u.pCovidx; + } + if( pIdx + && !db->mallocFailed + ){ + if( pWInfo->eOnePass==ONEPASS_OFF || !HasRowid(pIdx->pTable) ){ + last = iEnd; + }else{ + last = pWInfo->iEndWhere; + } + k = pLevel->addrBody + 1; +#ifdef SQLITE_DEBUG + if( db->flags & SQLITE_VdbeAddopTrace ){ + printf("TRANSLATE opcodes in range %d..%d\n", k, last-1); + } + /* Proof that the "+1" on the k value above is safe */ + pOp = sqlite3VdbeGetOp(v, k - 1); + assert( pOp->opcode!=OP_Column || pOp->p1!=pLevel->iTabCur ); + assert( pOp->opcode!=OP_Rowid || pOp->p1!=pLevel->iTabCur ); + assert( pOp->opcode!=OP_IfNullRow || pOp->p1!=pLevel->iTabCur ); +#endif + pOp = sqlite3VdbeGetOp(v, k); + pLastOp = pOp + (last - k); + assert( pOpp1!=pLevel->iTabCur ){ + /* no-op */ + }else if( pOp->opcode==OP_Column +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC + || pOp->opcode==OP_Offset +#endif + ){ + int x = pOp->p2; + assert( pIdx->pTable==pTab ); + if( !HasRowid(pTab) ){ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + x = pPk->aiColumn[x]; + assert( x>=0 ); + }else{ + testcase( x!=sqlite3StorageColumnToTable(pTab,x) ); + x = sqlite3StorageColumnToTable(pTab,x); + } + x = sqlite3TableColumnToIndex(pIdx, x); + if( x>=0 ){ + pOp->p2 = x; + pOp->p1 = pLevel->iIdxCur; + OpcodeRewriteTrace(db, k, pOp); + } + assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 || x>=0 + || pWInfo->eOnePass ); + }else if( pOp->opcode==OP_Rowid ){ + pOp->p1 = pLevel->iIdxCur; + pOp->opcode = OP_IdxRowid; + OpcodeRewriteTrace(db, k, pOp); + }else if( pOp->opcode==OP_IfNullRow ){ + pOp->p1 = pLevel->iIdxCur; + OpcodeRewriteTrace(db, k, pOp); + } +#ifdef SQLITE_DEBUG + k++; +#endif + }while( (++pOp)flags & SQLITE_VdbeAddopTrace ) printf("TRANSLATE complete\n"); +#endif + } + } + + /* Undo all Expr node modifications */ + while( pWInfo->pExprMods ){ + WhereExprMod *p = pWInfo->pExprMods; + pWInfo->pExprMods = p->pNext; + memcpy(p->pExpr, &p->orig, sizeof(p->orig)); + sqlite3DbFree(db, p); + } + + /* Final cleanup + */ + pParse->nQueryLoop = pWInfo->savedNQueryLoop; + whereInfoFree(db, pWInfo); + return; +} + +/************** End of where.c ***********************************************/ +/************** Begin file window.c ******************************************/ +/* +** 2018 May 08 +** +** 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. +** +************************************************************************* +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_WINDOWFUNC + +/* +** SELECT REWRITING +** +** Any SELECT statement that contains one or more window functions in +** either the select list or ORDER BY clause (the only two places window +** functions may be used) is transformed by function sqlite3WindowRewrite() +** in order to support window function processing. For example, with the +** schema: +** +** CREATE TABLE t1(a, b, c, d, e, f, g); +** +** the statement: +** +** SELECT a+1, max(b) OVER (PARTITION BY c ORDER BY d) FROM t1 ORDER BY e; +** +** is transformed to: +** +** SELECT a+1, max(b) OVER (PARTITION BY c ORDER BY d) FROM ( +** SELECT a, e, c, d, b FROM t1 ORDER BY c, d +** ) ORDER BY e; +** +** The flattening optimization is disabled when processing this transformed +** SELECT statement. This allows the implementation of the window function +** (in this case max()) to process rows sorted in order of (c, d), which +** makes things easier for obvious reasons. More generally: +** +** * FROM, WHERE, GROUP BY and HAVING clauses are all moved to +** the sub-query. +** +** * ORDER BY, LIMIT and OFFSET remain part of the parent query. +** +** * Terminals from each of the expression trees that make up the +** select-list and ORDER BY expressions in the parent query are +** selected by the sub-query. For the purposes of the transformation, +** terminals are column references and aggregate functions. +** +** If there is more than one window function in the SELECT that uses +** the same window declaration (the OVER bit), then a single scan may +** be used to process more than one window function. For example: +** +** SELECT max(b) OVER (PARTITION BY c ORDER BY d), +** min(e) OVER (PARTITION BY c ORDER BY d) +** FROM t1; +** +** is transformed in the same way as the example above. However: +** +** SELECT max(b) OVER (PARTITION BY c ORDER BY d), +** min(e) OVER (PARTITION BY a ORDER BY b) +** FROM t1; +** +** Must be transformed to: +** +** SELECT max(b) OVER (PARTITION BY c ORDER BY d) FROM ( +** SELECT e, min(e) OVER (PARTITION BY a ORDER BY b), c, d, b FROM +** SELECT a, e, c, d, b FROM t1 ORDER BY a, b +** ) ORDER BY c, d +** ) ORDER BY e; +** +** so that both min() and max() may process rows in the order defined by +** their respective window declarations. +** +** INTERFACE WITH SELECT.C +** +** When processing the rewritten SELECT statement, code in select.c calls +** sqlite3WhereBegin() to begin iterating through the results of the +** sub-query, which is always implemented as a co-routine. It then calls +** sqlite3WindowCodeStep() to process rows and finish the scan by calling +** sqlite3WhereEnd(). +** +** sqlite3WindowCodeStep() generates VM code so that, for each row returned +** by the sub-query a sub-routine (OP_Gosub) coded by select.c is invoked. +** When the sub-routine is invoked: +** +** * The results of all window-functions for the row are stored +** in the associated Window.regResult registers. +** +** * The required terminal values are stored in the current row of +** temp table Window.iEphCsr. +** +** In some cases, depending on the window frame and the specific window +** functions invoked, sqlite3WindowCodeStep() caches each entire partition +** in a temp table before returning any rows. In other cases it does not. +** This detail is encapsulated within this file, the code generated by +** select.c is the same in either case. +** +** BUILT-IN WINDOW FUNCTIONS +** +** This implementation features the following built-in window functions: +** +** row_number() +** rank() +** dense_rank() +** percent_rank() +** cume_dist() +** ntile(N) +** lead(expr [, offset [, default]]) +** lag(expr [, offset [, default]]) +** first_value(expr) +** last_value(expr) +** nth_value(expr, N) +** +** These are the same built-in window functions supported by Postgres. +** Although the behaviour of aggregate window functions (functions that +** can be used as either aggregates or window funtions) allows them to +** be implemented using an API, built-in window functions are much more +** esoteric. Additionally, some window functions (e.g. nth_value()) +** may only be implemented by caching the entire partition in memory. +** As such, some built-in window functions use the same API as aggregate +** window functions and some are implemented directly using VDBE +** instructions. Additionally, for those functions that use the API, the +** window frame is sometimes modified before the SELECT statement is +** rewritten. For example, regardless of the specified window frame, the +** row_number() function always uses: +** +** ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW +** +** See sqlite3WindowUpdate() for details. +** +** As well as some of the built-in window functions, aggregate window +** functions min() and max() are implemented using VDBE instructions if +** the start of the window frame is declared as anything other than +** UNBOUNDED PRECEDING. +*/ + +/* +** Implementation of built-in window function row_number(). Assumes that the +** window frame has been coerced to: +** +** ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW +*/ +static void row_numberStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + i64 *p = (i64*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ) (*p)++; + UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(apArg); +} +static void row_numberValueFunc(sqlite3_context *pCtx){ + i64 *p = (i64*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + sqlite3_result_int64(pCtx, (p ? *p : 0)); +} + +/* +** Context object type used by rank(), dense_rank(), percent_rank() and +** cume_dist(). +*/ +struct CallCount { + i64 nValue; + i64 nStep; + i64 nTotal; +}; + +/* +** Implementation of built-in window function dense_rank(). Assumes that +** the window frame has been set to: +** +** RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW +*/ +static void dense_rankStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct CallCount *p; + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ) p->nStep = 1; + UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(apArg); +} +static void dense_rankValueFunc(sqlite3_context *pCtx){ + struct CallCount *p; + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + if( p->nStep ){ + p->nValue++; + p->nStep = 0; + } + sqlite3_result_int64(pCtx, p->nValue); + } +} + +/* +** Implementation of built-in window function nth_value(). This +** implementation is used in "slow mode" only - when the EXCLUDE clause +** is not set to the default value "NO OTHERS". +*/ +struct NthValueCtx { + i64 nStep; + sqlite3_value *pValue; +}; +static void nth_valueStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct NthValueCtx *p; + p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + i64 iVal; + switch( sqlite3_value_numeric_type(apArg[1]) ){ + case SQLITE_INTEGER: + iVal = sqlite3_value_int64(apArg[1]); + break; + case SQLITE_FLOAT: { + double fVal = sqlite3_value_double(apArg[1]); + if( ((i64)fVal)!=fVal ) goto error_out; + iVal = (i64)fVal; + break; + } + default: + goto error_out; + } + if( iVal<=0 ) goto error_out; + + p->nStep++; + if( iVal==p->nStep ){ + p->pValue = sqlite3_value_dup(apArg[0]); + if( !p->pValue ){ + sqlite3_result_error_nomem(pCtx); + } + } + } + UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(apArg); + return; + + error_out: + sqlite3_result_error( + pCtx, "second argument to nth_value must be a positive integer", -1 + ); +} +static void nth_valueFinalizeFunc(sqlite3_context *pCtx){ + struct NthValueCtx *p; + p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, 0); + if( p && p->pValue ){ + sqlite3_result_value(pCtx, p->pValue); + sqlite3_value_free(p->pValue); + p->pValue = 0; + } +} +#define nth_valueInvFunc noopStepFunc +#define nth_valueValueFunc noopValueFunc + +static void first_valueStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct NthValueCtx *p; + p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p && p->pValue==0 ){ + p->pValue = sqlite3_value_dup(apArg[0]); + if( !p->pValue ){ + sqlite3_result_error_nomem(pCtx); + } + } + UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(apArg); +} +static void first_valueFinalizeFunc(sqlite3_context *pCtx){ + struct NthValueCtx *p; + p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p && p->pValue ){ + sqlite3_result_value(pCtx, p->pValue); + sqlite3_value_free(p->pValue); + p->pValue = 0; + } +} +#define first_valueInvFunc noopStepFunc +#define first_valueValueFunc noopValueFunc + +/* +** Implementation of built-in window function rank(). Assumes that +** the window frame has been set to: +** +** RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW +*/ +static void rankStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct CallCount *p; + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + p->nStep++; + if( p->nValue==0 ){ + p->nValue = p->nStep; + } + } + UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(apArg); +} +static void rankValueFunc(sqlite3_context *pCtx){ + struct CallCount *p; + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + sqlite3_result_int64(pCtx, p->nValue); + p->nValue = 0; + } +} + +/* +** Implementation of built-in window function percent_rank(). Assumes that +** the window frame has been set to: +** +** GROUPS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING +*/ +static void percent_rankStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct CallCount *p; + UNUSED_PARAMETER(nArg); assert( nArg==0 ); + UNUSED_PARAMETER(apArg); + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + p->nTotal++; + } +} +static void percent_rankInvFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct CallCount *p; + UNUSED_PARAMETER(nArg); assert( nArg==0 ); + UNUSED_PARAMETER(apArg); + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + p->nStep++; +} +static void percent_rankValueFunc(sqlite3_context *pCtx){ + struct CallCount *p; + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + p->nValue = p->nStep; + if( p->nTotal>1 ){ + double r = (double)p->nValue / (double)(p->nTotal-1); + sqlite3_result_double(pCtx, r); + }else{ + sqlite3_result_double(pCtx, 0.0); + } + } +} +#define percent_rankFinalizeFunc percent_rankValueFunc + +/* +** Implementation of built-in window function cume_dist(). Assumes that +** the window frame has been set to: +** +** GROUPS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING +*/ +static void cume_distStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct CallCount *p; + UNUSED_PARAMETER(nArg); assert( nArg==0 ); + UNUSED_PARAMETER(apArg); + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + p->nTotal++; + } +} +static void cume_distInvFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct CallCount *p; + UNUSED_PARAMETER(nArg); assert( nArg==0 ); + UNUSED_PARAMETER(apArg); + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + p->nStep++; +} +static void cume_distValueFunc(sqlite3_context *pCtx){ + struct CallCount *p; + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, 0); + if( p ){ + double r = (double)(p->nStep) / (double)(p->nTotal); + sqlite3_result_double(pCtx, r); + } +} +#define cume_distFinalizeFunc cume_distValueFunc + +/* +** Context object for ntile() window function. +*/ +struct NtileCtx { + i64 nTotal; /* Total rows in partition */ + i64 nParam; /* Parameter passed to ntile(N) */ + i64 iRow; /* Current row */ +}; + +/* +** Implementation of ntile(). This assumes that the window frame has +** been coerced to: +** +** ROWS CURRENT ROW AND UNBOUNDED FOLLOWING +*/ +static void ntileStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct NtileCtx *p; + assert( nArg==1 ); UNUSED_PARAMETER(nArg); + p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + if( p->nTotal==0 ){ + p->nParam = sqlite3_value_int64(apArg[0]); + if( p->nParam<=0 ){ + sqlite3_result_error( + pCtx, "argument of ntile must be a positive integer", -1 + ); + } + } + p->nTotal++; + } +} +static void ntileInvFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct NtileCtx *p; + assert( nArg==1 ); UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(apArg); + p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + p->iRow++; +} +static void ntileValueFunc(sqlite3_context *pCtx){ + struct NtileCtx *p; + p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p && p->nParam>0 ){ + int nSize = (p->nTotal / p->nParam); + if( nSize==0 ){ + sqlite3_result_int64(pCtx, p->iRow+1); + }else{ + i64 nLarge = p->nTotal - p->nParam*nSize; + i64 iSmall = nLarge*(nSize+1); + i64 iRow = p->iRow; + + assert( (nLarge*(nSize+1) + (p->nParam-nLarge)*nSize)==p->nTotal ); + + if( iRowpVal); + p->pVal = sqlite3_value_dup(apArg[0]); + if( p->pVal==0 ){ + sqlite3_result_error_nomem(pCtx); + }else{ + p->nVal++; + } + } +} +static void last_valueInvFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct LastValueCtx *p; + UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(apArg); + p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( ALWAYS(p) ){ + p->nVal--; + if( p->nVal==0 ){ + sqlite3_value_free(p->pVal); + p->pVal = 0; + } + } +} +static void last_valueValueFunc(sqlite3_context *pCtx){ + struct LastValueCtx *p; + p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, 0); + if( p && p->pVal ){ + sqlite3_result_value(pCtx, p->pVal); + } +} +static void last_valueFinalizeFunc(sqlite3_context *pCtx){ + struct LastValueCtx *p; + p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p && p->pVal ){ + sqlite3_result_value(pCtx, p->pVal); + sqlite3_value_free(p->pVal); + p->pVal = 0; + } +} + +/* +** Static names for the built-in window function names. These static +** names are used, rather than string literals, so that FuncDef objects +** can be associated with a particular window function by direct +** comparison of the zName pointer. Example: +** +** if( pFuncDef->zName==row_valueName ){ ... } +*/ +static const char row_numberName[] = "row_number"; +static const char dense_rankName[] = "dense_rank"; +static const char rankName[] = "rank"; +static const char percent_rankName[] = "percent_rank"; +static const char cume_distName[] = "cume_dist"; +static const char ntileName[] = "ntile"; +static const char last_valueName[] = "last_value"; +static const char nth_valueName[] = "nth_value"; +static const char first_valueName[] = "first_value"; +static const char leadName[] = "lead"; +static const char lagName[] = "lag"; + +/* +** No-op implementations of xStep() and xFinalize(). Used as place-holders +** for built-in window functions that never call those interfaces. +** +** The noopValueFunc() is called but is expected to do nothing. The +** noopStepFunc() is never called, and so it is marked with NO_TEST to +** let the test coverage routine know not to expect this function to be +** invoked. +*/ +static void noopStepFunc( /*NO_TEST*/ + sqlite3_context *p, /*NO_TEST*/ + int n, /*NO_TEST*/ + sqlite3_value **a /*NO_TEST*/ +){ /*NO_TEST*/ + UNUSED_PARAMETER(p); /*NO_TEST*/ + UNUSED_PARAMETER(n); /*NO_TEST*/ + UNUSED_PARAMETER(a); /*NO_TEST*/ + assert(0); /*NO_TEST*/ +} /*NO_TEST*/ +static void noopValueFunc(sqlite3_context *p){ UNUSED_PARAMETER(p); /*no-op*/ } + +/* Window functions that use all window interfaces: xStep, xFinal, +** xValue, and xInverse */ +#define WINDOWFUNCALL(name,nArg,extra) { \ + nArg, (SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0, \ + name ## StepFunc, name ## FinalizeFunc, name ## ValueFunc, \ + name ## InvFunc, name ## Name, {0} \ +} + +/* Window functions that are implemented using bytecode and thus have +** no-op routines for their methods */ +#define WINDOWFUNCNOOP(name,nArg,extra) { \ + nArg, (SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0, \ + noopStepFunc, noopValueFunc, noopValueFunc, \ + noopStepFunc, name ## Name, {0} \ +} + +/* Window functions that use all window interfaces: xStep, the +** same routine for xFinalize and xValue and which never call +** xInverse. */ +#define WINDOWFUNCX(name,nArg,extra) { \ + nArg, (SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0, \ + name ## StepFunc, name ## ValueFunc, name ## ValueFunc, \ + noopStepFunc, name ## Name, {0} \ +} + + +/* +** Register those built-in window functions that are not also aggregates. +*/ +SQLITE_PRIVATE void sqlite3WindowFunctions(void){ + static FuncDef aWindowFuncs[] = { + WINDOWFUNCX(row_number, 0, 0), + WINDOWFUNCX(dense_rank, 0, 0), + WINDOWFUNCX(rank, 0, 0), + WINDOWFUNCALL(percent_rank, 0, 0), + WINDOWFUNCALL(cume_dist, 0, 0), + WINDOWFUNCALL(ntile, 1, 0), + WINDOWFUNCALL(last_value, 1, 0), + WINDOWFUNCALL(nth_value, 2, 0), + WINDOWFUNCALL(first_value, 1, 0), + WINDOWFUNCNOOP(lead, 1, 0), + WINDOWFUNCNOOP(lead, 2, 0), + WINDOWFUNCNOOP(lead, 3, 0), + WINDOWFUNCNOOP(lag, 1, 0), + WINDOWFUNCNOOP(lag, 2, 0), + WINDOWFUNCNOOP(lag, 3, 0), + }; + sqlite3InsertBuiltinFuncs(aWindowFuncs, ArraySize(aWindowFuncs)); +} + +static Window *windowFind(Parse *pParse, Window *pList, const char *zName){ + Window *p; + for(p=pList; p; p=p->pNextWin){ + if( sqlite3StrICmp(p->zName, zName)==0 ) break; + } + if( p==0 ){ + sqlite3ErrorMsg(pParse, "no such window: %s", zName); + } + return p; +} + +/* +** This function is called immediately after resolving the function name +** for a window function within a SELECT statement. Argument pList is a +** linked list of WINDOW definitions for the current SELECT statement. +** Argument pFunc is the function definition just resolved and pWin +** is the Window object representing the associated OVER clause. This +** function updates the contents of pWin as follows: +** +** * If the OVER clause refered to a named window (as in "max(x) OVER win"), +** search list pList for a matching WINDOW definition, and update pWin +** accordingly. If no such WINDOW clause can be found, leave an error +** in pParse. +** +** * If the function is a built-in window function that requires the +** window to be coerced (see "BUILT-IN WINDOW FUNCTIONS" at the top +** of this file), pWin is updated here. +*/ +SQLITE_PRIVATE void sqlite3WindowUpdate( + Parse *pParse, + Window *pList, /* List of named windows for this SELECT */ + Window *pWin, /* Window frame to update */ + FuncDef *pFunc /* Window function definition */ +){ + if( pWin->zName && pWin->eFrmType==0 ){ + Window *p = windowFind(pParse, pList, pWin->zName); + if( p==0 ) return; + pWin->pPartition = sqlite3ExprListDup(pParse->db, p->pPartition, 0); + pWin->pOrderBy = sqlite3ExprListDup(pParse->db, p->pOrderBy, 0); + pWin->pStart = sqlite3ExprDup(pParse->db, p->pStart, 0); + pWin->pEnd = sqlite3ExprDup(pParse->db, p->pEnd, 0); + pWin->eStart = p->eStart; + pWin->eEnd = p->eEnd; + pWin->eFrmType = p->eFrmType; + pWin->eExclude = p->eExclude; + }else{ + sqlite3WindowChain(pParse, pWin, pList); + } + if( (pWin->eFrmType==TK_RANGE) + && (pWin->pStart || pWin->pEnd) + && (pWin->pOrderBy==0 || pWin->pOrderBy->nExpr!=1) + ){ + sqlite3ErrorMsg(pParse, + "RANGE with offset PRECEDING/FOLLOWING requires one ORDER BY expression" + ); + }else + if( pFunc->funcFlags & SQLITE_FUNC_WINDOW ){ + sqlite3 *db = pParse->db; + if( pWin->pFilter ){ + sqlite3ErrorMsg(pParse, + "FILTER clause may only be used with aggregate window functions" + ); + }else{ + struct WindowUpdate { + const char *zFunc; + int eFrmType; + int eStart; + int eEnd; + } aUp[] = { + { row_numberName, TK_ROWS, TK_UNBOUNDED, TK_CURRENT }, + { dense_rankName, TK_RANGE, TK_UNBOUNDED, TK_CURRENT }, + { rankName, TK_RANGE, TK_UNBOUNDED, TK_CURRENT }, + { percent_rankName, TK_GROUPS, TK_CURRENT, TK_UNBOUNDED }, + { cume_distName, TK_GROUPS, TK_FOLLOWING, TK_UNBOUNDED }, + { ntileName, TK_ROWS, TK_CURRENT, TK_UNBOUNDED }, + { leadName, TK_ROWS, TK_UNBOUNDED, TK_UNBOUNDED }, + { lagName, TK_ROWS, TK_UNBOUNDED, TK_CURRENT }, + }; + int i; + for(i=0; izName==aUp[i].zFunc ){ + sqlite3ExprDelete(db, pWin->pStart); + sqlite3ExprDelete(db, pWin->pEnd); + pWin->pEnd = pWin->pStart = 0; + pWin->eFrmType = aUp[i].eFrmType; + pWin->eStart = aUp[i].eStart; + pWin->eEnd = aUp[i].eEnd; + pWin->eExclude = 0; + if( pWin->eStart==TK_FOLLOWING ){ + pWin->pStart = sqlite3Expr(db, TK_INTEGER, "1"); + } + break; + } + } + } + } + pWin->pFunc = pFunc; +} + +/* +** Context object passed through sqlite3WalkExprList() to +** selectWindowRewriteExprCb() by selectWindowRewriteEList(). +*/ +typedef struct WindowRewrite WindowRewrite; +struct WindowRewrite { + Window *pWin; + SrcList *pSrc; + ExprList *pSub; + Table *pTab; + Select *pSubSelect; /* Current sub-select, if any */ +}; + +/* +** Callback function used by selectWindowRewriteEList(). If necessary, +** this function appends to the output expression-list and updates +** expression (*ppExpr) in place. +*/ +static int selectWindowRewriteExprCb(Walker *pWalker, Expr *pExpr){ + struct WindowRewrite *p = pWalker->u.pRewrite; + Parse *pParse = pWalker->pParse; + assert( p!=0 ); + assert( p->pWin!=0 ); + + /* If this function is being called from within a scalar sub-select + ** that used by the SELECT statement being processed, only process + ** TK_COLUMN expressions that refer to it (the outer SELECT). Do + ** not process aggregates or window functions at all, as they belong + ** to the scalar sub-select. */ + if( p->pSubSelect ){ + if( pExpr->op!=TK_COLUMN ){ + return WRC_Continue; + }else{ + int nSrc = p->pSrc->nSrc; + int i; + for(i=0; iiTable==p->pSrc->a[i].iCursor ) break; + } + if( i==nSrc ) return WRC_Continue; + } + } + + switch( pExpr->op ){ + + case TK_FUNCTION: + if( !ExprHasProperty(pExpr, EP_WinFunc) ){ + break; + }else{ + Window *pWin; + for(pWin=p->pWin; pWin; pWin=pWin->pNextWin){ + if( pExpr->y.pWin==pWin ){ + assert( pWin->pOwner==pExpr ); + return WRC_Prune; + } + } + } + /* no break */ deliberate_fall_through + + case TK_AGG_FUNCTION: + case TK_COLUMN: { + int iCol = -1; + if( p->pSub ){ + int i; + for(i=0; ipSub->nExpr; i++){ + if( 0==sqlite3ExprCompare(0, p->pSub->a[i].pExpr, pExpr, -1) ){ + iCol = i; + break; + } + } + } + if( iCol<0 ){ + Expr *pDup = sqlite3ExprDup(pParse->db, pExpr, 0); + if( pDup && pDup->op==TK_AGG_FUNCTION ) pDup->op = TK_FUNCTION; + p->pSub = sqlite3ExprListAppend(pParse, p->pSub, pDup); + } + if( p->pSub ){ + int f = pExpr->flags & EP_Collate; + assert( ExprHasProperty(pExpr, EP_Static)==0 ); + ExprSetProperty(pExpr, EP_Static); + sqlite3ExprDelete(pParse->db, pExpr); + ExprClearProperty(pExpr, EP_Static); + memset(pExpr, 0, sizeof(Expr)); + + pExpr->op = TK_COLUMN; + pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol); + pExpr->iTable = p->pWin->iEphCsr; + pExpr->y.pTab = p->pTab; + pExpr->flags = f; + } + if( pParse->db->mallocFailed ) return WRC_Abort; + break; + } + + default: /* no-op */ + break; + } + + return WRC_Continue; +} +static int selectWindowRewriteSelectCb(Walker *pWalker, Select *pSelect){ + struct WindowRewrite *p = pWalker->u.pRewrite; + Select *pSave = p->pSubSelect; + if( pSave==pSelect ){ + return WRC_Continue; + }else{ + p->pSubSelect = pSelect; + sqlite3WalkSelect(pWalker, pSelect); + p->pSubSelect = pSave; + } + return WRC_Prune; +} + + +/* +** Iterate through each expression in expression-list pEList. For each: +** +** * TK_COLUMN, +** * aggregate function, or +** * window function with a Window object that is not a member of the +** Window list passed as the second argument (pWin). +** +** Append the node to output expression-list (*ppSub). And replace it +** with a TK_COLUMN that reads the (N-1)th element of table +** pWin->iEphCsr, where N is the number of elements in (*ppSub) after +** appending the new one. +*/ +static void selectWindowRewriteEList( + Parse *pParse, + Window *pWin, + SrcList *pSrc, + ExprList *pEList, /* Rewrite expressions in this list */ + Table *pTab, + ExprList **ppSub /* IN/OUT: Sub-select expression-list */ +){ + Walker sWalker; + WindowRewrite sRewrite; + + assert( pWin!=0 ); + memset(&sWalker, 0, sizeof(Walker)); + memset(&sRewrite, 0, sizeof(WindowRewrite)); + + sRewrite.pSub = *ppSub; + sRewrite.pWin = pWin; + sRewrite.pSrc = pSrc; + sRewrite.pTab = pTab; + + sWalker.pParse = pParse; + sWalker.xExprCallback = selectWindowRewriteExprCb; + sWalker.xSelectCallback = selectWindowRewriteSelectCb; + sWalker.u.pRewrite = &sRewrite; + + (void)sqlite3WalkExprList(&sWalker, pEList); + + *ppSub = sRewrite.pSub; +} + +/* +** Append a copy of each expression in expression-list pAppend to +** expression list pList. Return a pointer to the result list. +*/ +static ExprList *exprListAppendList( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List to which to append. Might be NULL */ + ExprList *pAppend, /* List of values to append. Might be NULL */ + int bIntToNull +){ + if( pAppend ){ + int i; + int nInit = pList ? pList->nExpr : 0; + for(i=0; inExpr; i++){ + Expr *pDup = sqlite3ExprDup(pParse->db, pAppend->a[i].pExpr, 0); + assert( pDup==0 || !ExprHasProperty(pDup, EP_MemToken) ); + if( bIntToNull && pDup ){ + int iDummy; + Expr *pSub; + for(pSub=pDup; ExprHasProperty(pSub, EP_Skip); pSub=pSub->pLeft){ + assert( pSub ); + } + if( sqlite3ExprIsInteger(pSub, &iDummy) ){ + pSub->op = TK_NULL; + pSub->flags &= ~(EP_IntValue|EP_IsTrue|EP_IsFalse); + pSub->u.zToken = 0; + } + } + pList = sqlite3ExprListAppend(pParse, pList, pDup); + if( pList ) pList->a[nInit+i].sortFlags = pAppend->a[i].sortFlags; + } + } + return pList; +} + +/* +** When rewriting a query, if the new subquery in the FROM clause +** contains TK_AGG_FUNCTION nodes that refer to an outer query, +** then we have to increase the Expr->op2 values of those nodes +** due to the extra subquery layer that was added. +** +** See also the incrAggDepth() routine in resolve.c +*/ +static int sqlite3WindowExtraAggFuncDepth(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_AGG_FUNCTION + && pExpr->op2>=pWalker->walkerDepth + ){ + pExpr->op2++; + } + return WRC_Continue; +} + +/* +** If the SELECT statement passed as the second argument does not invoke +** any SQL window functions, this function is a no-op. Otherwise, it +** rewrites the SELECT statement so that window function xStep functions +** are invoked in the correct order as described under "SELECT REWRITING" +** at the top of this file. +*/ +SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){ + int rc = SQLITE_OK; + if( p->pWin && p->pPrior==0 && (p->selFlags & SF_WinRewrite)==0 ){ + Vdbe *v = sqlite3GetVdbe(pParse); + sqlite3 *db = pParse->db; + Select *pSub = 0; /* The subquery */ + SrcList *pSrc = p->pSrc; + Expr *pWhere = p->pWhere; + ExprList *pGroupBy = p->pGroupBy; + Expr *pHaving = p->pHaving; + ExprList *pSort = 0; + + ExprList *pSublist = 0; /* Expression list for sub-query */ + Window *pMWin = p->pWin; /* Main window object */ + Window *pWin; /* Window object iterator */ + Table *pTab; + Walker w; + + u32 selFlags = p->selFlags; + + pTab = sqlite3DbMallocZero(db, sizeof(Table)); + if( pTab==0 ){ + return sqlite3ErrorToParser(db, SQLITE_NOMEM); + } + sqlite3AggInfoPersistWalkerInit(&w, pParse); + sqlite3WalkSelect(&w, p); + + p->pSrc = 0; + p->pWhere = 0; + p->pGroupBy = 0; + p->pHaving = 0; + p->selFlags &= ~SF_Aggregate; + p->selFlags |= SF_WinRewrite; + + /* Create the ORDER BY clause for the sub-select. This is the concatenation + ** of the window PARTITION and ORDER BY clauses. Then, if this makes it + ** redundant, remove the ORDER BY from the parent SELECT. */ + pSort = exprListAppendList(pParse, 0, pMWin->pPartition, 1); + pSort = exprListAppendList(pParse, pSort, pMWin->pOrderBy, 1); + if( pSort && p->pOrderBy && p->pOrderBy->nExpr<=pSort->nExpr ){ + int nSave = pSort->nExpr; + pSort->nExpr = p->pOrderBy->nExpr; + if( sqlite3ExprListCompare(pSort, p->pOrderBy, -1)==0 ){ + sqlite3ExprListDelete(db, p->pOrderBy); + p->pOrderBy = 0; + } + pSort->nExpr = nSave; + } + + /* Assign a cursor number for the ephemeral table used to buffer rows. + ** The OpenEphemeral instruction is coded later, after it is known how + ** many columns the table will have. */ + pMWin->iEphCsr = pParse->nTab++; + pParse->nTab += 3; + + selectWindowRewriteEList(pParse, pMWin, pSrc, p->pEList, pTab, &pSublist); + selectWindowRewriteEList(pParse, pMWin, pSrc, p->pOrderBy, pTab, &pSublist); + pMWin->nBufferCol = (pSublist ? pSublist->nExpr : 0); + + /* Append the PARTITION BY and ORDER BY expressions to the to the + ** sub-select expression list. They are required to figure out where + ** boundaries for partitions and sets of peer rows lie. */ + pSublist = exprListAppendList(pParse, pSublist, pMWin->pPartition, 0); + pSublist = exprListAppendList(pParse, pSublist, pMWin->pOrderBy, 0); + + /* Append the arguments passed to each window function to the + ** sub-select expression list. Also allocate two registers for each + ** window function - one for the accumulator, another for interim + ** results. */ + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + ExprList *pArgs = pWin->pOwner->x.pList; + if( pWin->pFunc->funcFlags & SQLITE_FUNC_SUBTYPE ){ + selectWindowRewriteEList(pParse, pMWin, pSrc, pArgs, pTab, &pSublist); + pWin->iArgCol = (pSublist ? pSublist->nExpr : 0); + pWin->bExprArgs = 1; + }else{ + pWin->iArgCol = (pSublist ? pSublist->nExpr : 0); + pSublist = exprListAppendList(pParse, pSublist, pArgs, 0); + } + if( pWin->pFilter ){ + Expr *pFilter = sqlite3ExprDup(db, pWin->pFilter, 0); + pSublist = sqlite3ExprListAppend(pParse, pSublist, pFilter); + } + pWin->regAccum = ++pParse->nMem; + pWin->regResult = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum); + } + + /* If there is no ORDER BY or PARTITION BY clause, and the window + ** function accepts zero arguments, and there are no other columns + ** selected (e.g. "SELECT row_number() OVER () FROM t1"), it is possible + ** that pSublist is still NULL here. Add a constant expression here to + ** keep everything legal in this case. + */ + if( pSublist==0 ){ + pSublist = sqlite3ExprListAppend(pParse, 0, + sqlite3Expr(db, TK_INTEGER, "0") + ); + } + + pSub = sqlite3SelectNew( + pParse, pSublist, pSrc, pWhere, pGroupBy, pHaving, pSort, 0, 0 + ); + SELECTTRACE(1,pParse,pSub, + ("New window-function subquery in FROM clause of (%u/%p)\n", + p->selId, p)); + p->pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); + if( p->pSrc ){ + Table *pTab2; + p->pSrc->a[0].pSelect = pSub; + sqlite3SrcListAssignCursors(pParse, p->pSrc); + pSub->selFlags |= SF_Expanded; + pTab2 = sqlite3ResultSetOfSelect(pParse, pSub, SQLITE_AFF_NONE); + pSub->selFlags |= (selFlags & SF_Aggregate); + if( pTab2==0 ){ + /* Might actually be some other kind of error, but in that case + ** pParse->nErr will be set, so if SQLITE_NOMEM is set, we will get + ** the correct error message regardless. */ + rc = SQLITE_NOMEM; + }else{ + memcpy(pTab, pTab2, sizeof(Table)); + pTab->tabFlags |= TF_Ephemeral; + p->pSrc->a[0].pTab = pTab; + pTab = pTab2; + memset(&w, 0, sizeof(w)); + w.xExprCallback = sqlite3WindowExtraAggFuncDepth; + w.xSelectCallback = sqlite3WalkerDepthIncrease; + w.xSelectCallback2 = sqlite3WalkerDepthDecrease; + sqlite3WalkSelect(&w, pSub); + } + }else{ + sqlite3SelectDelete(db, pSub); + } + if( db->mallocFailed ) rc = SQLITE_NOMEM; + sqlite3DbFree(db, pTab); + } + + if( rc ){ + if( pParse->nErr==0 ){ + assert( pParse->db->mallocFailed ); + sqlite3ErrorToParser(pParse->db, SQLITE_NOMEM); + } + } + return rc; +} + +/* +** Unlink the Window object from the Select to which it is attached, +** if it is attached. +*/ +SQLITE_PRIVATE void sqlite3WindowUnlinkFromSelect(Window *p){ + if( p->ppThis ){ + *p->ppThis = p->pNextWin; + if( p->pNextWin ) p->pNextWin->ppThis = p->ppThis; + p->ppThis = 0; + } +} + +/* +** Free the Window object passed as the second argument. +*/ +SQLITE_PRIVATE void sqlite3WindowDelete(sqlite3 *db, Window *p){ + if( p ){ + sqlite3WindowUnlinkFromSelect(p); + sqlite3ExprDelete(db, p->pFilter); + sqlite3ExprListDelete(db, p->pPartition); + sqlite3ExprListDelete(db, p->pOrderBy); + sqlite3ExprDelete(db, p->pEnd); + sqlite3ExprDelete(db, p->pStart); + sqlite3DbFree(db, p->zName); + sqlite3DbFree(db, p->zBase); + sqlite3DbFree(db, p); + } +} + +/* +** Free the linked list of Window objects starting at the second argument. +*/ +SQLITE_PRIVATE void sqlite3WindowListDelete(sqlite3 *db, Window *p){ + while( p ){ + Window *pNext = p->pNextWin; + sqlite3WindowDelete(db, p); + p = pNext; + } +} + +/* +** The argument expression is an PRECEDING or FOLLOWING offset. The +** value should be a non-negative integer. If the value is not a +** constant, change it to NULL. The fact that it is then a non-negative +** integer will be caught later. But it is important not to leave +** variable values in the expression tree. +*/ +static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){ + if( 0==sqlite3ExprIsConstant(pExpr) ){ + if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr); + sqlite3ExprDelete(pParse->db, pExpr); + pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0); + } + return pExpr; +} + +/* +** Allocate and return a new Window object describing a Window Definition. +*/ +SQLITE_PRIVATE Window *sqlite3WindowAlloc( + Parse *pParse, /* Parsing context */ + int eType, /* Frame type. TK_RANGE, TK_ROWS, TK_GROUPS, or 0 */ + int eStart, /* Start type: CURRENT, PRECEDING, FOLLOWING, UNBOUNDED */ + Expr *pStart, /* Start window size if TK_PRECEDING or FOLLOWING */ + int eEnd, /* End type: CURRENT, FOLLOWING, TK_UNBOUNDED, PRECEDING */ + Expr *pEnd, /* End window size if TK_FOLLOWING or PRECEDING */ + u8 eExclude /* EXCLUDE clause */ +){ + Window *pWin = 0; + int bImplicitFrame = 0; + + /* Parser assures the following: */ + assert( eType==0 || eType==TK_RANGE || eType==TK_ROWS || eType==TK_GROUPS ); + assert( eStart==TK_CURRENT || eStart==TK_PRECEDING + || eStart==TK_UNBOUNDED || eStart==TK_FOLLOWING ); + assert( eEnd==TK_CURRENT || eEnd==TK_FOLLOWING + || eEnd==TK_UNBOUNDED || eEnd==TK_PRECEDING ); + assert( (eStart==TK_PRECEDING || eStart==TK_FOLLOWING)==(pStart!=0) ); + assert( (eEnd==TK_FOLLOWING || eEnd==TK_PRECEDING)==(pEnd!=0) ); + + if( eType==0 ){ + bImplicitFrame = 1; + eType = TK_RANGE; + } + + /* Additionally, the + ** starting boundary type may not occur earlier in the following list than + ** the ending boundary type: + ** + ** UNBOUNDED PRECEDING + ** PRECEDING + ** CURRENT ROW + ** FOLLOWING + ** UNBOUNDED FOLLOWING + ** + ** The parser ensures that "UNBOUNDED PRECEDING" cannot be used as an ending + ** boundary, and than "UNBOUNDED FOLLOWING" cannot be used as a starting + ** frame boundary. + */ + if( (eStart==TK_CURRENT && eEnd==TK_PRECEDING) + || (eStart==TK_FOLLOWING && (eEnd==TK_PRECEDING || eEnd==TK_CURRENT)) + ){ + sqlite3ErrorMsg(pParse, "unsupported frame specification"); + goto windowAllocErr; + } + + pWin = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); + if( pWin==0 ) goto windowAllocErr; + pWin->eFrmType = eType; + pWin->eStart = eStart; + pWin->eEnd = eEnd; + if( eExclude==0 && OptimizationDisabled(pParse->db, SQLITE_WindowFunc) ){ + eExclude = TK_NO; + } + pWin->eExclude = eExclude; + pWin->bImplicitFrame = bImplicitFrame; + pWin->pEnd = sqlite3WindowOffsetExpr(pParse, pEnd); + pWin->pStart = sqlite3WindowOffsetExpr(pParse, pStart); + return pWin; + +windowAllocErr: + sqlite3ExprDelete(pParse->db, pEnd); + sqlite3ExprDelete(pParse->db, pStart); + return 0; +} + +/* +** Attach PARTITION and ORDER BY clauses pPartition and pOrderBy to window +** pWin. Also, if parameter pBase is not NULL, set pWin->zBase to the +** equivalent nul-terminated string. +*/ +SQLITE_PRIVATE Window *sqlite3WindowAssemble( + Parse *pParse, + Window *pWin, + ExprList *pPartition, + ExprList *pOrderBy, + Token *pBase +){ + if( pWin ){ + pWin->pPartition = pPartition; + pWin->pOrderBy = pOrderBy; + if( pBase ){ + pWin->zBase = sqlite3DbStrNDup(pParse->db, pBase->z, pBase->n); + } + }else{ + sqlite3ExprListDelete(pParse->db, pPartition); + sqlite3ExprListDelete(pParse->db, pOrderBy); + } + return pWin; +} + +/* +** Window *pWin has just been created from a WINDOW clause. Tokne pBase +** is the base window. Earlier windows from the same WINDOW clause are +** stored in the linked list starting at pWin->pNextWin. This function +** either updates *pWin according to the base specification, or else +** leaves an error in pParse. +*/ +SQLITE_PRIVATE void sqlite3WindowChain(Parse *pParse, Window *pWin, Window *pList){ + if( pWin->zBase ){ + sqlite3 *db = pParse->db; + Window *pExist = windowFind(pParse, pList, pWin->zBase); + if( pExist ){ + const char *zErr = 0; + /* Check for errors */ + if( pWin->pPartition ){ + zErr = "PARTITION clause"; + }else if( pExist->pOrderBy && pWin->pOrderBy ){ + zErr = "ORDER BY clause"; + }else if( pExist->bImplicitFrame==0 ){ + zErr = "frame specification"; + } + if( zErr ){ + sqlite3ErrorMsg(pParse, + "cannot override %s of window: %s", zErr, pWin->zBase + ); + }else{ + pWin->pPartition = sqlite3ExprListDup(db, pExist->pPartition, 0); + if( pExist->pOrderBy ){ + assert( pWin->pOrderBy==0 ); + pWin->pOrderBy = sqlite3ExprListDup(db, pExist->pOrderBy, 0); + } + sqlite3DbFree(db, pWin->zBase); + pWin->zBase = 0; + } + } + } +} + +/* +** Attach window object pWin to expression p. +*/ +SQLITE_PRIVATE void sqlite3WindowAttach(Parse *pParse, Expr *p, Window *pWin){ + if( p ){ + assert( p->op==TK_FUNCTION ); + assert( pWin ); + p->y.pWin = pWin; + ExprSetProperty(p, EP_WinFunc); + pWin->pOwner = p; + if( (p->flags & EP_Distinct) && pWin->eFrmType!=TK_FILTER ){ + sqlite3ErrorMsg(pParse, + "DISTINCT is not supported for window functions" + ); + } + }else{ + sqlite3WindowDelete(pParse->db, pWin); + } +} + +/* +** Possibly link window pWin into the list at pSel->pWin (window functions +** to be processed as part of SELECT statement pSel). The window is linked +** in if either (a) there are no other windows already linked to this +** SELECT, or (b) the windows already linked use a compatible window frame. +*/ +SQLITE_PRIVATE void sqlite3WindowLink(Select *pSel, Window *pWin){ + if( pSel!=0 + && (0==pSel->pWin || 0==sqlite3WindowCompare(0, pSel->pWin, pWin, 0)) + ){ + pWin->pNextWin = pSel->pWin; + if( pSel->pWin ){ + pSel->pWin->ppThis = &pWin->pNextWin; + } + pSel->pWin = pWin; + pWin->ppThis = &pSel->pWin; + } +} + +/* +** Return 0 if the two window objects are identical, 1 if they are +** different, or 2 if it cannot be determined if the objects are identical +** or not. Identical window objects can be processed in a single scan. +*/ +SQLITE_PRIVATE int sqlite3WindowCompare(Parse *pParse, Window *p1, Window *p2, int bFilter){ + int res; + if( NEVER(p1==0) || NEVER(p2==0) ) return 1; + if( p1->eFrmType!=p2->eFrmType ) return 1; + if( p1->eStart!=p2->eStart ) return 1; + if( p1->eEnd!=p2->eEnd ) return 1; + if( p1->eExclude!=p2->eExclude ) return 1; + if( sqlite3ExprCompare(pParse, p1->pStart, p2->pStart, -1) ) return 1; + if( sqlite3ExprCompare(pParse, p1->pEnd, p2->pEnd, -1) ) return 1; + if( (res = sqlite3ExprListCompare(p1->pPartition, p2->pPartition, -1)) ){ + return res; + } + if( (res = sqlite3ExprListCompare(p1->pOrderBy, p2->pOrderBy, -1)) ){ + return res; + } + if( bFilter ){ + if( (res = sqlite3ExprCompare(pParse, p1->pFilter, p2->pFilter, -1)) ){ + return res; + } + } + return 0; +} + + +/* +** This is called by code in select.c before it calls sqlite3WhereBegin() +** to begin iterating through the sub-query results. It is used to allocate +** and initialize registers and cursors used by sqlite3WindowCodeStep(). +*/ +SQLITE_PRIVATE void sqlite3WindowCodeInit(Parse *pParse, Select *pSelect){ + int nEphExpr = pSelect->pSrc->a[0].pSelect->pEList->nExpr; + Window *pMWin = pSelect->pWin; + Window *pWin; + Vdbe *v = sqlite3GetVdbe(pParse); + + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pMWin->iEphCsr, nEphExpr); + sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+1, pMWin->iEphCsr); + sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+2, pMWin->iEphCsr); + sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+3, pMWin->iEphCsr); + + /* Allocate registers to use for PARTITION BY values, if any. Initialize + ** said registers to NULL. */ + if( pMWin->pPartition ){ + int nExpr = pMWin->pPartition->nExpr; + pMWin->regPart = pParse->nMem+1; + pParse->nMem += nExpr; + sqlite3VdbeAddOp3(v, OP_Null, 0, pMWin->regPart, pMWin->regPart+nExpr-1); + } + + pMWin->regOne = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regOne); + + if( pMWin->eExclude ){ + pMWin->regStartRowid = ++pParse->nMem; + pMWin->regEndRowid = ++pParse->nMem; + pMWin->csrApp = pParse->nTab++; + sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid); + sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regEndRowid); + sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->csrApp, pMWin->iEphCsr); + return; + } + + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + FuncDef *p = pWin->pFunc; + if( (p->funcFlags & SQLITE_FUNC_MINMAX) && pWin->eStart!=TK_UNBOUNDED ){ + /* The inline versions of min() and max() require a single ephemeral + ** table and 3 registers. The registers are used as follows: + ** + ** regApp+0: slot to copy min()/max() argument to for MakeRecord + ** regApp+1: integer value used to ensure keys are unique + ** regApp+2: output of MakeRecord + */ + ExprList *pList = pWin->pOwner->x.pList; + KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pList, 0, 0); + pWin->csrApp = pParse->nTab++; + pWin->regApp = pParse->nMem+1; + pParse->nMem += 3; + if( pKeyInfo && pWin->pFunc->zName[1]=='i' ){ + assert( pKeyInfo->aSortFlags[0]==0 ); + pKeyInfo->aSortFlags[0] = KEYINFO_ORDER_DESC; + } + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pWin->csrApp, 2); + sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO); + sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1); + } + else if( p->zName==nth_valueName || p->zName==first_valueName ){ + /* Allocate two registers at pWin->regApp. These will be used to + ** store the start and end index of the current frame. */ + pWin->regApp = pParse->nMem+1; + pWin->csrApp = pParse->nTab++; + pParse->nMem += 2; + sqlite3VdbeAddOp2(v, OP_OpenDup, pWin->csrApp, pMWin->iEphCsr); + } + else if( p->zName==leadName || p->zName==lagName ){ + pWin->csrApp = pParse->nTab++; + sqlite3VdbeAddOp2(v, OP_OpenDup, pWin->csrApp, pMWin->iEphCsr); + } + } +} + +#define WINDOW_STARTING_INT 0 +#define WINDOW_ENDING_INT 1 +#define WINDOW_NTH_VALUE_INT 2 +#define WINDOW_STARTING_NUM 3 +#define WINDOW_ENDING_NUM 4 + +/* +** A "PRECEDING " (eCond==0) or "FOLLOWING " (eCond==1) or the +** value of the second argument to nth_value() (eCond==2) has just been +** evaluated and the result left in register reg. This function generates VM +** code to check that the value is a non-negative integer and throws an +** exception if it is not. +*/ +static void windowCheckValue(Parse *pParse, int reg, int eCond){ + static const char *azErr[] = { + "frame starting offset must be a non-negative integer", + "frame ending offset must be a non-negative integer", + "second argument to nth_value must be a positive integer", + "frame starting offset must be a non-negative number", + "frame ending offset must be a non-negative number", + }; + static int aOp[] = { OP_Ge, OP_Ge, OP_Gt, OP_Ge, OP_Ge }; + Vdbe *v = sqlite3GetVdbe(pParse); + int regZero = sqlite3GetTempReg(pParse); + assert( eCond>=0 && eCond=WINDOW_STARTING_NUM ){ + int regString = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC); + sqlite3VdbeAddOp3(v, OP_Ge, regString, sqlite3VdbeCurrentAddr(v)+2, reg); + sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC|SQLITE_JUMPIFNULL); + VdbeCoverage(v); + assert( eCond==3 || eCond==4 ); + VdbeCoverageIf(v, eCond==3); + VdbeCoverageIf(v, eCond==4); + }else{ + sqlite3VdbeAddOp2(v, OP_MustBeInt, reg, sqlite3VdbeCurrentAddr(v)+2); + VdbeCoverage(v); + assert( eCond==0 || eCond==1 || eCond==2 ); + VdbeCoverageIf(v, eCond==0); + VdbeCoverageIf(v, eCond==1); + VdbeCoverageIf(v, eCond==2); + } + sqlite3VdbeAddOp3(v, aOp[eCond], regZero, sqlite3VdbeCurrentAddr(v)+2, reg); + VdbeCoverageNeverNullIf(v, eCond==0); /* NULL case captured by */ + VdbeCoverageNeverNullIf(v, eCond==1); /* the OP_MustBeInt */ + VdbeCoverageNeverNullIf(v, eCond==2); + VdbeCoverageNeverNullIf(v, eCond==3); /* NULL case caught by */ + VdbeCoverageNeverNullIf(v, eCond==4); /* the OP_Ge */ + sqlite3MayAbort(pParse); + sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_ERROR, OE_Abort); + sqlite3VdbeAppendP4(v, (void*)azErr[eCond], P4_STATIC); + sqlite3ReleaseTempReg(pParse, regZero); +} + +/* +** Return the number of arguments passed to the window-function associated +** with the object passed as the only argument to this function. +*/ +static int windowArgCount(Window *pWin){ + ExprList *pList = pWin->pOwner->x.pList; + return (pList ? pList->nExpr : 0); +} + +typedef struct WindowCodeArg WindowCodeArg; +typedef struct WindowCsrAndReg WindowCsrAndReg; + +/* +** See comments above struct WindowCodeArg. +*/ +struct WindowCsrAndReg { + int csr; /* Cursor number */ + int reg; /* First in array of peer values */ +}; + +/* +** A single instance of this structure is allocated on the stack by +** sqlite3WindowCodeStep() and a pointer to it passed to the various helper +** routines. This is to reduce the number of arguments required by each +** helper function. +** +** regArg: +** Each window function requires an accumulator register (just as an +** ordinary aggregate function does). This variable is set to the first +** in an array of accumulator registers - one for each window function +** in the WindowCodeArg.pMWin list. +** +** eDelete: +** The window functions implementation sometimes caches the input rows +** that it processes in a temporary table. If it is not zero, this +** variable indicates when rows may be removed from the temp table (in +** order to reduce memory requirements - it would always be safe just +** to leave them there). Possible values for eDelete are: +** +** WINDOW_RETURN_ROW: +** An input row can be discarded after it is returned to the caller. +** +** WINDOW_AGGINVERSE: +** An input row can be discarded after the window functions xInverse() +** callbacks have been invoked in it. +** +** WINDOW_AGGSTEP: +** An input row can be discarded after the window functions xStep() +** callbacks have been invoked in it. +** +** start,current,end +** Consider a window-frame similar to the following: +** +** (ORDER BY a, b GROUPS BETWEEN 2 PRECEDING AND 2 FOLLOWING) +** +** The windows functions implmentation caches the input rows in a temp +** table, sorted by "a, b" (it actually populates the cache lazily, and +** aggressively removes rows once they are no longer required, but that's +** a mere detail). It keeps three cursors open on the temp table. One +** (current) that points to the next row to return to the query engine +** once its window function values have been calculated. Another (end) +** points to the next row to call the xStep() method of each window function +** on (so that it is 2 groups ahead of current). And a third (start) that +** points to the next row to call the xInverse() method of each window +** function on. +** +** Each cursor (start, current and end) consists of a VDBE cursor +** (WindowCsrAndReg.csr) and an array of registers (starting at +** WindowCodeArg.reg) that always contains a copy of the peer values +** read from the corresponding cursor. +** +** Depending on the window-frame in question, all three cursors may not +** be required. In this case both WindowCodeArg.csr and reg are set to +** 0. +*/ +struct WindowCodeArg { + Parse *pParse; /* Parse context */ + Window *pMWin; /* First in list of functions being processed */ + Vdbe *pVdbe; /* VDBE object */ + int addrGosub; /* OP_Gosub to this address to return one row */ + int regGosub; /* Register used with OP_Gosub(addrGosub) */ + int regArg; /* First in array of accumulator registers */ + int eDelete; /* See above */ + + WindowCsrAndReg start; + WindowCsrAndReg current; + WindowCsrAndReg end; +}; + +/* +** Generate VM code to read the window frames peer values from cursor csr into +** an array of registers starting at reg. +*/ +static void windowReadPeerValues( + WindowCodeArg *p, + int csr, + int reg +){ + Window *pMWin = p->pMWin; + ExprList *pOrderBy = pMWin->pOrderBy; + if( pOrderBy ){ + Vdbe *v = sqlite3GetVdbe(p->pParse); + ExprList *pPart = pMWin->pPartition; + int iColOff = pMWin->nBufferCol + (pPart ? pPart->nExpr : 0); + int i; + for(i=0; inExpr; i++){ + sqlite3VdbeAddOp3(v, OP_Column, csr, iColOff+i, reg+i); + } + } +} + +/* +** Generate VM code to invoke either xStep() (if bInverse is 0) or +** xInverse (if bInverse is non-zero) for each window function in the +** linked list starting at pMWin. Or, for built-in window functions +** that do not use the standard function API, generate the required +** inline VM code. +** +** If argument csr is greater than or equal to 0, then argument reg is +** the first register in an array of registers guaranteed to be large +** enough to hold the array of arguments for each function. In this case +** the arguments are extracted from the current row of csr into the +** array of registers before invoking OP_AggStep or OP_AggInverse +** +** Or, if csr is less than zero, then the array of registers at reg is +** already populated with all columns from the current row of the sub-query. +** +** If argument regPartSize is non-zero, then it is a register containing the +** number of rows in the current partition. +*/ +static void windowAggStep( + WindowCodeArg *p, + Window *pMWin, /* Linked list of window functions */ + int csr, /* Read arguments from this cursor */ + int bInverse, /* True to invoke xInverse instead of xStep */ + int reg /* Array of registers */ +){ + Parse *pParse = p->pParse; + Vdbe *v = sqlite3GetVdbe(pParse); + Window *pWin; + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + FuncDef *pFunc = pWin->pFunc; + int regArg; + int nArg = pWin->bExprArgs ? 0 : windowArgCount(pWin); + int i; + + assert( bInverse==0 || pWin->eStart!=TK_UNBOUNDED ); + + /* All OVER clauses in the same window function aggregate step must + ** be the same. */ + assert( pWin==pMWin || sqlite3WindowCompare(pParse,pWin,pMWin,0)!=1 ); + + for(i=0; izName!=nth_valueName ){ + sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+i, reg+i); + }else{ + sqlite3VdbeAddOp3(v, OP_Column, pMWin->iEphCsr, pWin->iArgCol+i, reg+i); + } + } + regArg = reg; + + if( pMWin->regStartRowid==0 + && (pFunc->funcFlags & SQLITE_FUNC_MINMAX) + && (pWin->eStart!=TK_UNBOUNDED) + ){ + int addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, regArg); + VdbeCoverage(v); + if( bInverse==0 ){ + sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1, 1); + sqlite3VdbeAddOp2(v, OP_SCopy, regArg, pWin->regApp); + sqlite3VdbeAddOp3(v, OP_MakeRecord, pWin->regApp, 2, pWin->regApp+2); + sqlite3VdbeAddOp2(v, OP_IdxInsert, pWin->csrApp, pWin->regApp+2); + }else{ + sqlite3VdbeAddOp4Int(v, OP_SeekGE, pWin->csrApp, 0, regArg, 1); + VdbeCoverageNeverTaken(v); + sqlite3VdbeAddOp1(v, OP_Delete, pWin->csrApp); + sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2); + } + sqlite3VdbeJumpHere(v, addrIsNull); + }else if( pWin->regApp ){ + assert( pFunc->zName==nth_valueName + || pFunc->zName==first_valueName + ); + assert( bInverse==0 || bInverse==1 ); + sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1-bInverse, 1); + }else if( pFunc->xSFunc!=noopStepFunc ){ + int addrIf = 0; + if( pWin->pFilter ){ + int regTmp; + assert( pWin->bExprArgs || !nArg ||nArg==pWin->pOwner->x.pList->nExpr ); + assert( pWin->bExprArgs || nArg ||pWin->pOwner->x.pList==0 ); + regTmp = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+nArg,regTmp); + addrIf = sqlite3VdbeAddOp3(v, OP_IfNot, regTmp, 0, 1); + VdbeCoverage(v); + sqlite3ReleaseTempReg(pParse, regTmp); + } + + if( pWin->bExprArgs ){ + int iStart = sqlite3VdbeCurrentAddr(v); + VdbeOp *pOp, *pEnd; + + nArg = pWin->pOwner->x.pList->nExpr; + regArg = sqlite3GetTempRange(pParse, nArg); + sqlite3ExprCodeExprList(pParse, pWin->pOwner->x.pList, regArg, 0, 0); + + pEnd = sqlite3VdbeGetOp(v, -1); + for(pOp=sqlite3VdbeGetOp(v, iStart); pOp<=pEnd; pOp++){ + if( pOp->opcode==OP_Column && pOp->p1==pWin->iEphCsr ){ + pOp->p1 = csr; + } + } + } + if( pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){ + CollSeq *pColl; + assert( nArg>0 ); + pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr); + sqlite3VdbeAddOp4(v, OP_CollSeq, 0,0,0, (const char*)pColl, P4_COLLSEQ); + } + sqlite3VdbeAddOp3(v, bInverse? OP_AggInverse : OP_AggStep, + bInverse, regArg, pWin->regAccum); + sqlite3VdbeAppendP4(v, pFunc, P4_FUNCDEF); + sqlite3VdbeChangeP5(v, (u8)nArg); + if( pWin->bExprArgs ){ + sqlite3ReleaseTempRange(pParse, regArg, nArg); + } + if( addrIf ) sqlite3VdbeJumpHere(v, addrIf); + } + } +} + +/* +** Values that may be passed as the second argument to windowCodeOp(). +*/ +#define WINDOW_RETURN_ROW 1 +#define WINDOW_AGGINVERSE 2 +#define WINDOW_AGGSTEP 3 + +/* +** Generate VM code to invoke either xValue() (bFin==0) or xFinalize() +** (bFin==1) for each window function in the linked list starting at +** pMWin. Or, for built-in window-functions that do not use the standard +** API, generate the equivalent VM code. +*/ +static void windowAggFinal(WindowCodeArg *p, int bFin){ + Parse *pParse = p->pParse; + Window *pMWin = p->pMWin; + Vdbe *v = sqlite3GetVdbe(pParse); + Window *pWin; + + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + if( pMWin->regStartRowid==0 + && (pWin->pFunc->funcFlags & SQLITE_FUNC_MINMAX) + && (pWin->eStart!=TK_UNBOUNDED) + ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult); + sqlite3VdbeAddOp1(v, OP_Last, pWin->csrApp); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_Column, pWin->csrApp, 0, pWin->regResult); + sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2); + }else if( pWin->regApp ){ + assert( pMWin->regStartRowid==0 ); + }else{ + int nArg = windowArgCount(pWin); + if( bFin ){ + sqlite3VdbeAddOp2(v, OP_AggFinal, pWin->regAccum, nArg); + sqlite3VdbeAppendP4(v, pWin->pFunc, P4_FUNCDEF); + sqlite3VdbeAddOp2(v, OP_Copy, pWin->regAccum, pWin->regResult); + sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum); + }else{ + sqlite3VdbeAddOp3(v, OP_AggValue,pWin->regAccum,nArg,pWin->regResult); + sqlite3VdbeAppendP4(v, pWin->pFunc, P4_FUNCDEF); + } + } + } +} + +/* +** Generate code to calculate the current values of all window functions in the +** p->pMWin list by doing a full scan of the current window frame. Store the +** results in the Window.regResult registers, ready to return the upper +** layer. +*/ +static void windowFullScan(WindowCodeArg *p){ + Window *pWin; + Parse *pParse = p->pParse; + Window *pMWin = p->pMWin; + Vdbe *v = p->pVdbe; + + int regCRowid = 0; /* Current rowid value */ + int regCPeer = 0; /* Current peer values */ + int regRowid = 0; /* AggStep rowid value */ + int regPeer = 0; /* AggStep peer values */ + + int nPeer; + int lblNext; + int lblBrk; + int addrNext; + int csr; + + VdbeModuleComment((v, "windowFullScan begin")); + + assert( pMWin!=0 ); + csr = pMWin->csrApp; + nPeer = (pMWin->pOrderBy ? pMWin->pOrderBy->nExpr : 0); + + lblNext = sqlite3VdbeMakeLabel(pParse); + lblBrk = sqlite3VdbeMakeLabel(pParse); + + regCRowid = sqlite3GetTempReg(pParse); + regRowid = sqlite3GetTempReg(pParse); + if( nPeer ){ + regCPeer = sqlite3GetTempRange(pParse, nPeer); + regPeer = sqlite3GetTempRange(pParse, nPeer); + } + + sqlite3VdbeAddOp2(v, OP_Rowid, pMWin->iEphCsr, regCRowid); + windowReadPeerValues(p, pMWin->iEphCsr, regCPeer); + + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum); + } + + sqlite3VdbeAddOp3(v, OP_SeekGE, csr, lblBrk, pMWin->regStartRowid); + VdbeCoverage(v); + addrNext = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp2(v, OP_Rowid, csr, regRowid); + sqlite3VdbeAddOp3(v, OP_Gt, pMWin->regEndRowid, lblBrk, regRowid); + VdbeCoverageNeverNull(v); + + if( pMWin->eExclude==TK_CURRENT ){ + sqlite3VdbeAddOp3(v, OP_Eq, regCRowid, lblNext, regRowid); + VdbeCoverageNeverNull(v); + }else if( pMWin->eExclude!=TK_NO ){ + int addr; + int addrEq = 0; + KeyInfo *pKeyInfo = 0; + + if( pMWin->pOrderBy ){ + pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pMWin->pOrderBy, 0, 0); + } + if( pMWin->eExclude==TK_TIES ){ + addrEq = sqlite3VdbeAddOp3(v, OP_Eq, regCRowid, 0, regRowid); + VdbeCoverageNeverNull(v); + } + if( pKeyInfo ){ + windowReadPeerValues(p, csr, regPeer); + sqlite3VdbeAddOp3(v, OP_Compare, regPeer, regCPeer, nPeer); + sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO); + addr = sqlite3VdbeCurrentAddr(v)+1; + sqlite3VdbeAddOp3(v, OP_Jump, addr, lblNext, addr); + VdbeCoverageEqNe(v); + }else{ + sqlite3VdbeAddOp2(v, OP_Goto, 0, lblNext); + } + if( addrEq ) sqlite3VdbeJumpHere(v, addrEq); + } + + windowAggStep(p, pMWin, csr, 0, p->regArg); + + sqlite3VdbeResolveLabel(v, lblNext); + sqlite3VdbeAddOp2(v, OP_Next, csr, addrNext); + VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addrNext-1); + sqlite3VdbeJumpHere(v, addrNext+1); + sqlite3ReleaseTempReg(pParse, regRowid); + sqlite3ReleaseTempReg(pParse, regCRowid); + if( nPeer ){ + sqlite3ReleaseTempRange(pParse, regPeer, nPeer); + sqlite3ReleaseTempRange(pParse, regCPeer, nPeer); + } + + windowAggFinal(p, 1); + VdbeModuleComment((v, "windowFullScan end")); +} + +/* +** Invoke the sub-routine at regGosub (generated by code in select.c) to +** return the current row of Window.iEphCsr. If all window functions are +** aggregate window functions that use the standard API, a single +** OP_Gosub instruction is all that this routine generates. Extra VM code +** for per-row processing is only generated for the following built-in window +** functions: +** +** nth_value() +** first_value() +** lag() +** lead() +*/ +static void windowReturnOneRow(WindowCodeArg *p){ + Window *pMWin = p->pMWin; + Vdbe *v = p->pVdbe; + + if( pMWin->regStartRowid ){ + windowFullScan(p); + }else{ + Parse *pParse = p->pParse; + Window *pWin; + + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + FuncDef *pFunc = pWin->pFunc; + if( pFunc->zName==nth_valueName + || pFunc->zName==first_valueName + ){ + int csr = pWin->csrApp; + int lbl = sqlite3VdbeMakeLabel(pParse); + int tmpReg = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult); + + if( pFunc->zName==nth_valueName ){ + sqlite3VdbeAddOp3(v, OP_Column,pMWin->iEphCsr,pWin->iArgCol+1,tmpReg); + windowCheckValue(pParse, tmpReg, 2); + }else{ + sqlite3VdbeAddOp2(v, OP_Integer, 1, tmpReg); + } + sqlite3VdbeAddOp3(v, OP_Add, tmpReg, pWin->regApp, tmpReg); + sqlite3VdbeAddOp3(v, OP_Gt, pWin->regApp+1, lbl, tmpReg); + VdbeCoverageNeverNull(v); + sqlite3VdbeAddOp3(v, OP_SeekRowid, csr, 0, tmpReg); + VdbeCoverageNeverTaken(v); + sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult); + sqlite3VdbeResolveLabel(v, lbl); + sqlite3ReleaseTempReg(pParse, tmpReg); + } + else if( pFunc->zName==leadName || pFunc->zName==lagName ){ + int nArg = pWin->pOwner->x.pList->nExpr; + int csr = pWin->csrApp; + int lbl = sqlite3VdbeMakeLabel(pParse); + int tmpReg = sqlite3GetTempReg(pParse); + int iEph = pMWin->iEphCsr; + + if( nArg<3 ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult); + }else{ + sqlite3VdbeAddOp3(v, OP_Column, iEph,pWin->iArgCol+2,pWin->regResult); + } + sqlite3VdbeAddOp2(v, OP_Rowid, iEph, tmpReg); + if( nArg<2 ){ + int val = (pFunc->zName==leadName ? 1 : -1); + sqlite3VdbeAddOp2(v, OP_AddImm, tmpReg, val); + }else{ + int op = (pFunc->zName==leadName ? OP_Add : OP_Subtract); + int tmpReg2 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_Column, iEph, pWin->iArgCol+1, tmpReg2); + sqlite3VdbeAddOp3(v, op, tmpReg2, tmpReg, tmpReg); + sqlite3ReleaseTempReg(pParse, tmpReg2); + } + + sqlite3VdbeAddOp3(v, OP_SeekRowid, csr, lbl, tmpReg); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult); + sqlite3VdbeResolveLabel(v, lbl); + sqlite3ReleaseTempReg(pParse, tmpReg); + } + } + } + sqlite3VdbeAddOp2(v, OP_Gosub, p->regGosub, p->addrGosub); +} + +/* +** Generate code to set the accumulator register for each window function +** in the linked list passed as the second argument to NULL. And perform +** any equivalent initialization required by any built-in window functions +** in the list. +*/ +static int windowInitAccum(Parse *pParse, Window *pMWin){ + Vdbe *v = sqlite3GetVdbe(pParse); + int regArg; + int nArg = 0; + Window *pWin; + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + FuncDef *pFunc = pWin->pFunc; + assert( pWin->regAccum ); + sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum); + nArg = MAX(nArg, windowArgCount(pWin)); + if( pMWin->regStartRowid==0 ){ + if( pFunc->zName==nth_valueName || pFunc->zName==first_valueName ){ + sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp); + sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1); + } + + if( (pFunc->funcFlags & SQLITE_FUNC_MINMAX) && pWin->csrApp ){ + assert( pWin->eStart!=TK_UNBOUNDED ); + sqlite3VdbeAddOp1(v, OP_ResetSorter, pWin->csrApp); + sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1); + } + } + } + regArg = pParse->nMem+1; + pParse->nMem += nArg; + return regArg; +} + +/* +** Return true if the current frame should be cached in the ephemeral table, +** even if there are no xInverse() calls required. +*/ +static int windowCacheFrame(Window *pMWin){ + Window *pWin; + if( pMWin->regStartRowid ) return 1; + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + FuncDef *pFunc = pWin->pFunc; + if( (pFunc->zName==nth_valueName) + || (pFunc->zName==first_valueName) + || (pFunc->zName==leadName) + || (pFunc->zName==lagName) + ){ + return 1; + } + } + return 0; +} + +/* +** regOld and regNew are each the first register in an array of size +** pOrderBy->nExpr. This function generates code to compare the two +** arrays of registers using the collation sequences and other comparison +** parameters specified by pOrderBy. +** +** If the two arrays are not equal, the contents of regNew is copied to +** regOld and control falls through. Otherwise, if the contents of the arrays +** are equal, an OP_Goto is executed. The address of the OP_Goto is returned. +*/ +static void windowIfNewPeer( + Parse *pParse, + ExprList *pOrderBy, + int regNew, /* First in array of new values */ + int regOld, /* First in array of old values */ + int addr /* Jump here */ +){ + Vdbe *v = sqlite3GetVdbe(pParse); + if( pOrderBy ){ + int nVal = pOrderBy->nExpr; + KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pOrderBy, 0, 0); + sqlite3VdbeAddOp3(v, OP_Compare, regOld, regNew, nVal); + sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO); + sqlite3VdbeAddOp3(v, OP_Jump, + sqlite3VdbeCurrentAddr(v)+1, addr, sqlite3VdbeCurrentAddr(v)+1 + ); + VdbeCoverageEqNe(v); + sqlite3VdbeAddOp3(v, OP_Copy, regNew, regOld, nVal-1); + }else{ + sqlite3VdbeAddOp2(v, OP_Goto, 0, addr); + } +} + +/* +** This function is called as part of generating VM programs for RANGE +** offset PRECEDING/FOLLOWING frame boundaries. Assuming "ASC" order for +** the ORDER BY term in the window, and that argument op is OP_Ge, it generates +** code equivalent to: +** +** if( csr1.peerVal + regVal >= csr2.peerVal ) goto lbl; +** +** The value of parameter op may also be OP_Gt or OP_Le. In these cases the +** operator in the above pseudo-code is replaced with ">" or "<=", respectively. +** +** If the sort-order for the ORDER BY term in the window is DESC, then the +** comparison is reversed. Instead of adding regVal to csr1.peerVal, it is +** subtracted. And the comparison operator is inverted to - ">=" becomes "<=", +** ">" becomes "<", and so on. So, with DESC sort order, if the argument op +** is OP_Ge, the generated code is equivalent to: +** +** if( csr1.peerVal - regVal <= csr2.peerVal ) goto lbl; +** +** A special type of arithmetic is used such that if csr1.peerVal is not +** a numeric type (real or integer), then the result of the addition addition +** or subtraction is a a copy of csr1.peerVal. +*/ +static void windowCodeRangeTest( + WindowCodeArg *p, + int op, /* OP_Ge, OP_Gt, or OP_Le */ + int csr1, /* Cursor number for cursor 1 */ + int regVal, /* Register containing non-negative number */ + int csr2, /* Cursor number for cursor 2 */ + int lbl /* Jump destination if condition is true */ +){ + Parse *pParse = p->pParse; + Vdbe *v = sqlite3GetVdbe(pParse); + ExprList *pOrderBy = p->pMWin->pOrderBy; /* ORDER BY clause for window */ + int reg1 = sqlite3GetTempReg(pParse); /* Reg. for csr1.peerVal+regVal */ + int reg2 = sqlite3GetTempReg(pParse); /* Reg. for csr2.peerVal */ + int regString = ++pParse->nMem; /* Reg. for constant value '' */ + int arith = OP_Add; /* OP_Add or OP_Subtract */ + int addrGe; /* Jump destination */ + + assert( op==OP_Ge || op==OP_Gt || op==OP_Le ); + assert( pOrderBy && pOrderBy->nExpr==1 ); + if( pOrderBy->a[0].sortFlags & KEYINFO_ORDER_DESC ){ + switch( op ){ + case OP_Ge: op = OP_Le; break; + case OP_Gt: op = OP_Lt; break; + default: assert( op==OP_Le ); op = OP_Ge; break; + } + arith = OP_Subtract; + } + + /* Read the peer-value from each cursor into a register */ + windowReadPeerValues(p, csr1, reg1); + windowReadPeerValues(p, csr2, reg2); + + VdbeModuleComment((v, "CodeRangeTest: if( R%d %s R%d %s R%d ) goto lbl", + reg1, (arith==OP_Add ? "+" : "-"), regVal, + ((op==OP_Ge) ? ">=" : (op==OP_Le) ? "<=" : (op==OP_Gt) ? ">" : "<"), reg2 + )); + + /* Register reg1 currently contains csr1.peerVal (the peer-value from csr1). + ** This block adds (or subtracts for DESC) the numeric value in regVal + ** from it. Or, if reg1 is not numeric (it is a NULL, a text value or a blob), + ** then leave reg1 as it is. In pseudo-code, this is implemented as: + ** + ** if( reg1>='' ) goto addrGe; + ** reg1 = reg1 +/- regVal + ** addrGe: + ** + ** Since all strings and blobs are greater-than-or-equal-to an empty string, + ** the add/subtract is skipped for these, as required. If reg1 is a NULL, + ** then the arithmetic is performed, but since adding or subtracting from + ** NULL is always NULL anyway, this case is handled as required too. */ + sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC); + addrGe = sqlite3VdbeAddOp3(v, OP_Ge, regString, 0, reg1); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, arith, regVal, reg1, reg1); + sqlite3VdbeJumpHere(v, addrGe); + + /* If the BIGNULL flag is set for the ORDER BY, then it is required to + ** consider NULL values to be larger than all other values, instead of + ** the usual smaller. The VDBE opcodes OP_Ge and so on do not handle this + ** (and adding that capability causes a performance regression), so + ** instead if the BIGNULL flag is set then cases where either reg1 or + ** reg2 are NULL are handled separately in the following block. The code + ** generated is equivalent to: + ** + ** if( reg1 IS NULL ){ + ** if( op==OP_Ge ) goto lbl; + ** if( op==OP_Gt && reg2 IS NOT NULL ) goto lbl; + ** if( op==OP_Le && reg2 IS NULL ) goto lbl; + ** }else if( reg2 IS NULL ){ + ** if( op==OP_Le ) goto lbl; + ** } + ** + ** Additionally, if either reg1 or reg2 are NULL but the jump to lbl is + ** not taken, control jumps over the comparison operator coded below this + ** block. */ + if( pOrderBy->a[0].sortFlags & KEYINFO_ORDER_BIGNULL ){ + /* This block runs if reg1 contains a NULL. */ + int addr = sqlite3VdbeAddOp1(v, OP_NotNull, reg1); VdbeCoverage(v); + switch( op ){ + case OP_Ge: + sqlite3VdbeAddOp2(v, OP_Goto, 0, lbl); + break; + case OP_Gt: + sqlite3VdbeAddOp2(v, OP_NotNull, reg2, lbl); + VdbeCoverage(v); + break; + case OP_Le: + sqlite3VdbeAddOp2(v, OP_IsNull, reg2, lbl); + VdbeCoverage(v); + break; + default: assert( op==OP_Lt ); /* no-op */ break; + } + sqlite3VdbeAddOp2(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+3); + + /* This block runs if reg1 is not NULL, but reg2 is. */ + sqlite3VdbeJumpHere(v, addr); + sqlite3VdbeAddOp2(v, OP_IsNull, reg2, lbl); VdbeCoverage(v); + if( op==OP_Gt || op==OP_Ge ){ + sqlite3VdbeChangeP2(v, -1, sqlite3VdbeCurrentAddr(v)+1); + } + } + + /* Compare registers reg2 and reg1, taking the jump if required. Note that + ** control skips over this test if the BIGNULL flag is set and either + ** reg1 or reg2 contain a NULL value. */ + sqlite3VdbeAddOp3(v, op, reg2, lbl, reg1); VdbeCoverage(v); + sqlite3VdbeChangeP5(v, SQLITE_NULLEQ); + + assert( op==OP_Ge || op==OP_Gt || op==OP_Lt || op==OP_Le ); + testcase(op==OP_Ge); VdbeCoverageIf(v, op==OP_Ge); + testcase(op==OP_Lt); VdbeCoverageIf(v, op==OP_Lt); + testcase(op==OP_Le); VdbeCoverageIf(v, op==OP_Le); + testcase(op==OP_Gt); VdbeCoverageIf(v, op==OP_Gt); + sqlite3ReleaseTempReg(pParse, reg1); + sqlite3ReleaseTempReg(pParse, reg2); + + VdbeModuleComment((v, "CodeRangeTest: end")); +} + +/* +** Helper function for sqlite3WindowCodeStep(). Each call to this function +** generates VM code for a single RETURN_ROW, AGGSTEP or AGGINVERSE +** operation. Refer to the header comment for sqlite3WindowCodeStep() for +** details. +*/ +static int windowCodeOp( + WindowCodeArg *p, /* Context object */ + int op, /* WINDOW_RETURN_ROW, AGGSTEP or AGGINVERSE */ + int regCountdown, /* Register for OP_IfPos countdown */ + int jumpOnEof /* Jump here if stepped cursor reaches EOF */ +){ + int csr, reg; + Parse *pParse = p->pParse; + Window *pMWin = p->pMWin; + int ret = 0; + Vdbe *v = p->pVdbe; + int addrContinue = 0; + int bPeer = (pMWin->eFrmType!=TK_ROWS); + + int lblDone = sqlite3VdbeMakeLabel(pParse); + int addrNextRange = 0; + + /* Special case - WINDOW_AGGINVERSE is always a no-op if the frame + ** starts with UNBOUNDED PRECEDING. */ + if( op==WINDOW_AGGINVERSE && pMWin->eStart==TK_UNBOUNDED ){ + assert( regCountdown==0 && jumpOnEof==0 ); + return 0; + } + + if( regCountdown>0 ){ + if( pMWin->eFrmType==TK_RANGE ){ + addrNextRange = sqlite3VdbeCurrentAddr(v); + assert( op==WINDOW_AGGINVERSE || op==WINDOW_AGGSTEP ); + if( op==WINDOW_AGGINVERSE ){ + if( pMWin->eStart==TK_FOLLOWING ){ + windowCodeRangeTest( + p, OP_Le, p->current.csr, regCountdown, p->start.csr, lblDone + ); + }else{ + windowCodeRangeTest( + p, OP_Ge, p->start.csr, regCountdown, p->current.csr, lblDone + ); + } + }else{ + windowCodeRangeTest( + p, OP_Gt, p->end.csr, regCountdown, p->current.csr, lblDone + ); + } + }else{ + sqlite3VdbeAddOp3(v, OP_IfPos, regCountdown, lblDone, 1); + VdbeCoverage(v); + } + } + + if( op==WINDOW_RETURN_ROW && pMWin->regStartRowid==0 ){ + windowAggFinal(p, 0); + } + addrContinue = sqlite3VdbeCurrentAddr(v); + + /* If this is a (RANGE BETWEEN a FOLLOWING AND b FOLLOWING) or + ** (RANGE BETWEEN b PRECEDING AND a PRECEDING) frame, ensure the + ** start cursor does not advance past the end cursor within the + ** temporary table. It otherwise might, if (a>b). */ + if( pMWin->eStart==pMWin->eEnd && regCountdown + && pMWin->eFrmType==TK_RANGE && op==WINDOW_AGGINVERSE + ){ + int regRowid1 = sqlite3GetTempReg(pParse); + int regRowid2 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp2(v, OP_Rowid, p->start.csr, regRowid1); + sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid2); + sqlite3VdbeAddOp3(v, OP_Ge, regRowid2, lblDone, regRowid1); + VdbeCoverage(v); + sqlite3ReleaseTempReg(pParse, regRowid1); + sqlite3ReleaseTempReg(pParse, regRowid2); + assert( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_FOLLOWING ); + } + + switch( op ){ + case WINDOW_RETURN_ROW: + csr = p->current.csr; + reg = p->current.reg; + windowReturnOneRow(p); + break; + + case WINDOW_AGGINVERSE: + csr = p->start.csr; + reg = p->start.reg; + if( pMWin->regStartRowid ){ + assert( pMWin->regEndRowid ); + sqlite3VdbeAddOp2(v, OP_AddImm, pMWin->regStartRowid, 1); + }else{ + windowAggStep(p, pMWin, csr, 1, p->regArg); + } + break; + + default: + assert( op==WINDOW_AGGSTEP ); + csr = p->end.csr; + reg = p->end.reg; + if( pMWin->regStartRowid ){ + assert( pMWin->regEndRowid ); + sqlite3VdbeAddOp2(v, OP_AddImm, pMWin->regEndRowid, 1); + }else{ + windowAggStep(p, pMWin, csr, 0, p->regArg); + } + break; + } + + if( op==p->eDelete ){ + sqlite3VdbeAddOp1(v, OP_Delete, csr); + sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION); + } + + if( jumpOnEof ){ + sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+2); + VdbeCoverage(v); + ret = sqlite3VdbeAddOp0(v, OP_Goto); + }else{ + sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+1+bPeer); + VdbeCoverage(v); + if( bPeer ){ + sqlite3VdbeAddOp2(v, OP_Goto, 0, lblDone); + } + } + + if( bPeer ){ + int nReg = (pMWin->pOrderBy ? pMWin->pOrderBy->nExpr : 0); + int regTmp = (nReg ? sqlite3GetTempRange(pParse, nReg) : 0); + windowReadPeerValues(p, csr, regTmp); + windowIfNewPeer(pParse, pMWin->pOrderBy, regTmp, reg, addrContinue); + sqlite3ReleaseTempRange(pParse, regTmp, nReg); + } + + if( addrNextRange ){ + sqlite3VdbeAddOp2(v, OP_Goto, 0, addrNextRange); + } + sqlite3VdbeResolveLabel(v, lblDone); + return ret; +} + + +/* +** Allocate and return a duplicate of the Window object indicated by the +** third argument. Set the Window.pOwner field of the new object to +** pOwner. +*/ +SQLITE_PRIVATE Window *sqlite3WindowDup(sqlite3 *db, Expr *pOwner, Window *p){ + Window *pNew = 0; + if( ALWAYS(p) ){ + pNew = sqlite3DbMallocZero(db, sizeof(Window)); + if( pNew ){ + pNew->zName = sqlite3DbStrDup(db, p->zName); + pNew->zBase = sqlite3DbStrDup(db, p->zBase); + pNew->pFilter = sqlite3ExprDup(db, p->pFilter, 0); + pNew->pFunc = p->pFunc; + pNew->pPartition = sqlite3ExprListDup(db, p->pPartition, 0); + pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, 0); + pNew->eFrmType = p->eFrmType; + pNew->eEnd = p->eEnd; + pNew->eStart = p->eStart; + pNew->eExclude = p->eExclude; + pNew->regResult = p->regResult; + pNew->regAccum = p->regAccum; + pNew->iArgCol = p->iArgCol; + pNew->iEphCsr = p->iEphCsr; + pNew->bExprArgs = p->bExprArgs; + pNew->pStart = sqlite3ExprDup(db, p->pStart, 0); + pNew->pEnd = sqlite3ExprDup(db, p->pEnd, 0); + pNew->pOwner = pOwner; + pNew->bImplicitFrame = p->bImplicitFrame; + } + } + return pNew; +} + +/* +** Return a copy of the linked list of Window objects passed as the +** second argument. +*/ +SQLITE_PRIVATE Window *sqlite3WindowListDup(sqlite3 *db, Window *p){ + Window *pWin; + Window *pRet = 0; + Window **pp = &pRet; + + for(pWin=p; pWin; pWin=pWin->pNextWin){ + *pp = sqlite3WindowDup(db, 0, pWin); + if( *pp==0 ) break; + pp = &((*pp)->pNextWin); + } + + return pRet; +} + +/* +** Return true if it can be determined at compile time that expression +** pExpr evaluates to a value that, when cast to an integer, is greater +** than zero. False otherwise. +** +** If an OOM error occurs, this function sets the Parse.db.mallocFailed +** flag and returns zero. +*/ +static int windowExprGtZero(Parse *pParse, Expr *pExpr){ + int ret = 0; + sqlite3 *db = pParse->db; + sqlite3_value *pVal = 0; + sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal); + if( pVal && sqlite3_value_int(pVal)>0 ){ + ret = 1; + } + sqlite3ValueFree(pVal); + return ret; +} + +/* +** sqlite3WhereBegin() has already been called for the SELECT statement +** passed as the second argument when this function is invoked. It generates +** code to populate the Window.regResult register for each window function +** and invoke the sub-routine at instruction addrGosub once for each row. +** sqlite3WhereEnd() is always called before returning. +** +** This function handles several different types of window frames, which +** require slightly different processing. The following pseudo code is +** used to implement window frames of the form: +** +** ROWS BETWEEN PRECEDING AND FOLLOWING +** +** Other window frame types use variants of the following: +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** +** if( first row of partition ){ +** // Rewind three cursors, all open on the eph table. +** Rewind(csrEnd); +** Rewind(csrStart); +** Rewind(csrCurrent); +** +** regEnd = // FOLLOWING expression +** regStart = // PRECEDING expression +** }else{ +** // First time this branch is taken, the eph table contains two +** // rows. The first row in the partition, which all three cursors +** // currently point to, and the following row. +** AGGSTEP +** if( (regEnd--)<=0 ){ +** RETURN_ROW +** if( (regStart--)<=0 ){ +** AGGINVERSE +** } +** } +** } +** } +** flush: +** AGGSTEP +** while( 1 ){ +** RETURN ROW +** if( csrCurrent is EOF ) break; +** if( (regStart--)<=0 ){ +** AggInverse(csrStart) +** Next(csrStart) +** } +** } +** +** The pseudo-code above uses the following shorthand: +** +** AGGSTEP: invoke the aggregate xStep() function for each window function +** with arguments read from the current row of cursor csrEnd, then +** step cursor csrEnd forward one row (i.e. sqlite3BtreeNext()). +** +** RETURN_ROW: return a row to the caller based on the contents of the +** current row of csrCurrent and the current state of all +** aggregates. Then step cursor csrCurrent forward one row. +** +** AGGINVERSE: invoke the aggregate xInverse() function for each window +** functions with arguments read from the current row of cursor +** csrStart. Then step csrStart forward one row. +** +** There are two other ROWS window frames that are handled significantly +** differently from the above - "BETWEEN PRECEDING AND PRECEDING" +** and "BETWEEN FOLLOWING AND FOLLOWING". These are special +** cases because they change the order in which the three cursors (csrStart, +** csrCurrent and csrEnd) iterate through the ephemeral table. Cases that +** use UNBOUNDED or CURRENT ROW are much simpler variations on one of these +** three. +** +** ROWS BETWEEN PRECEDING AND PRECEDING +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regEnd = +** regStart = +** }else{ +** if( (regEnd--)<=0 ){ +** AGGSTEP +** } +** RETURN_ROW +** if( (regStart--)<=0 ){ +** AGGINVERSE +** } +** } +** } +** flush: +** if( (regEnd--)<=0 ){ +** AGGSTEP +** } +** RETURN_ROW +** +** +** ROWS BETWEEN FOLLOWING AND FOLLOWING +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regEnd = +** regStart = regEnd - +** }else{ +** AGGSTEP +** if( (regEnd--)<=0 ){ +** RETURN_ROW +** } +** if( (regStart--)<=0 ){ +** AGGINVERSE +** } +** } +** } +** flush: +** AGGSTEP +** while( 1 ){ +** if( (regEnd--)<=0 ){ +** RETURN_ROW +** if( eof ) break; +** } +** if( (regStart--)<=0 ){ +** AGGINVERSE +** if( eof ) break +** } +** } +** while( !eof csrCurrent ){ +** RETURN_ROW +** } +** +** For the most part, the patterns above are adapted to support UNBOUNDED by +** assuming that it is equivalent to "infinity PRECEDING/FOLLOWING" and +** CURRENT ROW by assuming that it is equivilent to "0 PRECEDING/FOLLOWING". +** This is optimized of course - branches that will never be taken and +** conditions that are always true are omitted from the VM code. The only +** exceptional case is: +** +** ROWS BETWEEN FOLLOWING AND UNBOUNDED FOLLOWING +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regStart = +** }else{ +** AGGSTEP +** } +** } +** flush: +** AGGSTEP +** while( 1 ){ +** if( (regStart--)<=0 ){ +** AGGINVERSE +** if( eof ) break +** } +** RETURN_ROW +** } +** while( !eof csrCurrent ){ +** RETURN_ROW +** } +** +** Also requiring special handling are the cases: +** +** ROWS BETWEEN PRECEDING AND PRECEDING +** ROWS BETWEEN FOLLOWING AND FOLLOWING +** +** when (expr1 < expr2). This is detected at runtime, not by this function. +** To handle this case, the pseudo-code programs depicted above are modified +** slightly to be: +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regEnd = +** regStart = +** if( regEnd < regStart ){ +** RETURN_ROW +** delete eph table contents +** continue +** } +** ... +** +** The new "continue" statement in the above jumps to the next iteration +** of the outer loop - the one started by sqlite3WhereBegin(). +** +** The various GROUPS cases are implemented using the same patterns as +** ROWS. The VM code is modified slightly so that: +** +** 1. The else branch in the main loop is only taken if the row just +** added to the ephemeral table is the start of a new group. In +** other words, it becomes: +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regEnd = +** regStart = +** }else if( new group ){ +** ... +** } +** } +** +** 2. Instead of processing a single row, each RETURN_ROW, AGGSTEP or +** AGGINVERSE step processes the current row of the relevant cursor and +** all subsequent rows belonging to the same group. +** +** RANGE window frames are a little different again. As for GROUPS, the +** main loop runs once per group only. And RETURN_ROW, AGGSTEP and AGGINVERSE +** deal in groups instead of rows. As for ROWS and GROUPS, there are three +** basic cases: +** +** RANGE BETWEEN PRECEDING AND FOLLOWING +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regEnd = +** regStart = +** }else{ +** AGGSTEP +** while( (csrCurrent.key + regEnd) < csrEnd.key ){ +** RETURN_ROW +** while( csrStart.key + regStart) < csrCurrent.key ){ +** AGGINVERSE +** } +** } +** } +** } +** flush: +** AGGSTEP +** while( 1 ){ +** RETURN ROW +** if( csrCurrent is EOF ) break; +** while( csrStart.key + regStart) < csrCurrent.key ){ +** AGGINVERSE +** } +** } +** } +** +** In the above notation, "csr.key" means the current value of the ORDER BY +** expression (there is only ever 1 for a RANGE that uses an FOLLOWING +** or PRECEDING AND PRECEDING +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regEnd = +** regStart = +** }else{ +** while( (csrEnd.key + regEnd) <= csrCurrent.key ){ +** AGGSTEP +** } +** while( (csrStart.key + regStart) < csrCurrent.key ){ +** AGGINVERSE +** } +** RETURN_ROW +** } +** } +** flush: +** while( (csrEnd.key + regEnd) <= csrCurrent.key ){ +** AGGSTEP +** } +** while( (csrStart.key + regStart) < csrCurrent.key ){ +** AGGINVERSE +** } +** RETURN_ROW +** +** RANGE BETWEEN FOLLOWING AND FOLLOWING +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regEnd = +** regStart = +** }else{ +** AGGSTEP +** while( (csrCurrent.key + regEnd) < csrEnd.key ){ +** while( (csrCurrent.key + regStart) > csrStart.key ){ +** AGGINVERSE +** } +** RETURN_ROW +** } +** } +** } +** flush: +** AGGSTEP +** while( 1 ){ +** while( (csrCurrent.key + regStart) > csrStart.key ){ +** AGGINVERSE +** if( eof ) break "while( 1 )" loop. +** } +** RETURN_ROW +** } +** while( !eof csrCurrent ){ +** RETURN_ROW +** } +** +** The text above leaves out many details. Refer to the code and comments +** below for a more complete picture. +*/ +SQLITE_PRIVATE void sqlite3WindowCodeStep( + Parse *pParse, /* Parse context */ + Select *p, /* Rewritten SELECT statement */ + WhereInfo *pWInfo, /* Context returned by sqlite3WhereBegin() */ + int regGosub, /* Register for OP_Gosub */ + int addrGosub /* OP_Gosub here to return each row */ +){ + Window *pMWin = p->pWin; + ExprList *pOrderBy = pMWin->pOrderBy; + Vdbe *v = sqlite3GetVdbe(pParse); + int csrWrite; /* Cursor used to write to eph. table */ + int csrInput = p->pSrc->a[0].iCursor; /* Cursor of sub-select */ + int nInput = p->pSrc->a[0].pTab->nCol; /* Number of cols returned by sub */ + int iInput; /* To iterate through sub cols */ + int addrNe; /* Address of OP_Ne */ + int addrGosubFlush = 0; /* Address of OP_Gosub to flush: */ + int addrInteger = 0; /* Address of OP_Integer */ + int addrEmpty; /* Address of OP_Rewind in flush: */ + int regNew; /* Array of registers holding new input row */ + int regRecord; /* regNew array in record form */ + int regRowid; /* Rowid for regRecord in eph table */ + int regNewPeer = 0; /* Peer values for new row (part of regNew) */ + int regPeer = 0; /* Peer values for current row */ + int regFlushPart = 0; /* Register for "Gosub flush_partition" */ + WindowCodeArg s; /* Context object for sub-routines */ + int lblWhereEnd; /* Label just before sqlite3WhereEnd() code */ + int regStart = 0; /* Value of PRECEDING */ + int regEnd = 0; /* Value of FOLLOWING */ + + assert( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_CURRENT + || pMWin->eStart==TK_FOLLOWING || pMWin->eStart==TK_UNBOUNDED + ); + assert( pMWin->eEnd==TK_FOLLOWING || pMWin->eEnd==TK_CURRENT + || pMWin->eEnd==TK_UNBOUNDED || pMWin->eEnd==TK_PRECEDING + ); + assert( pMWin->eExclude==0 || pMWin->eExclude==TK_CURRENT + || pMWin->eExclude==TK_GROUP || pMWin->eExclude==TK_TIES + || pMWin->eExclude==TK_NO + ); + + lblWhereEnd = sqlite3VdbeMakeLabel(pParse); + + /* Fill in the context object */ + memset(&s, 0, sizeof(WindowCodeArg)); + s.pParse = pParse; + s.pMWin = pMWin; + s.pVdbe = v; + s.regGosub = regGosub; + s.addrGosub = addrGosub; + s.current.csr = pMWin->iEphCsr; + csrWrite = s.current.csr+1; + s.start.csr = s.current.csr+2; + s.end.csr = s.current.csr+3; + + /* Figure out when rows may be deleted from the ephemeral table. There + ** are four options - they may never be deleted (eDelete==0), they may + ** be deleted as soon as they are no longer part of the window frame + ** (eDelete==WINDOW_AGGINVERSE), they may be deleted as after the row + ** has been returned to the caller (WINDOW_RETURN_ROW), or they may + ** be deleted after they enter the frame (WINDOW_AGGSTEP). */ + switch( pMWin->eStart ){ + case TK_FOLLOWING: + if( pMWin->eFrmType!=TK_RANGE + && windowExprGtZero(pParse, pMWin->pStart) + ){ + s.eDelete = WINDOW_RETURN_ROW; + } + break; + case TK_UNBOUNDED: + if( windowCacheFrame(pMWin)==0 ){ + if( pMWin->eEnd==TK_PRECEDING ){ + if( pMWin->eFrmType!=TK_RANGE + && windowExprGtZero(pParse, pMWin->pEnd) + ){ + s.eDelete = WINDOW_AGGSTEP; + } + }else{ + s.eDelete = WINDOW_RETURN_ROW; + } + } + break; + default: + s.eDelete = WINDOW_AGGINVERSE; + break; + } + + /* Allocate registers for the array of values from the sub-query, the + ** samve values in record form, and the rowid used to insert said record + ** into the ephemeral table. */ + regNew = pParse->nMem+1; + pParse->nMem += nInput; + regRecord = ++pParse->nMem; + regRowid = ++pParse->nMem; + + /* If the window frame contains an " PRECEDING" or " FOLLOWING" + ** clause, allocate registers to store the results of evaluating each + ** . */ + if( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_FOLLOWING ){ + regStart = ++pParse->nMem; + } + if( pMWin->eEnd==TK_PRECEDING || pMWin->eEnd==TK_FOLLOWING ){ + regEnd = ++pParse->nMem; + } + + /* If this is not a "ROWS BETWEEN ..." frame, then allocate arrays of + ** registers to store copies of the ORDER BY expressions (peer values) + ** for the main loop, and for each cursor (start, current and end). */ + if( pMWin->eFrmType!=TK_ROWS ){ + int nPeer = (pOrderBy ? pOrderBy->nExpr : 0); + regNewPeer = regNew + pMWin->nBufferCol; + if( pMWin->pPartition ) regNewPeer += pMWin->pPartition->nExpr; + regPeer = pParse->nMem+1; pParse->nMem += nPeer; + s.start.reg = pParse->nMem+1; pParse->nMem += nPeer; + s.current.reg = pParse->nMem+1; pParse->nMem += nPeer; + s.end.reg = pParse->nMem+1; pParse->nMem += nPeer; + } + + /* Load the column values for the row returned by the sub-select + ** into an array of registers starting at regNew. Assemble them into + ** a record in register regRecord. */ + for(iInput=0; iInputpPartition ){ + int addr; + ExprList *pPart = pMWin->pPartition; + int nPart = pPart->nExpr; + int regNewPart = regNew + pMWin->nBufferCol; + KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pPart, 0, 0); + + regFlushPart = ++pParse->nMem; + addr = sqlite3VdbeAddOp3(v, OP_Compare, regNewPart, pMWin->regPart, nPart); + sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO); + sqlite3VdbeAddOp3(v, OP_Jump, addr+2, addr+4, addr+2); + VdbeCoverageEqNe(v); + addrGosubFlush = sqlite3VdbeAddOp1(v, OP_Gosub, regFlushPart); + VdbeComment((v, "call flush_partition")); + sqlite3VdbeAddOp3(v, OP_Copy, regNewPart, pMWin->regPart, nPart-1); + } + + /* Insert the new row into the ephemeral table */ + sqlite3VdbeAddOp2(v, OP_NewRowid, csrWrite, regRowid); + sqlite3VdbeAddOp3(v, OP_Insert, csrWrite, regRecord, regRowid); + addrNe = sqlite3VdbeAddOp3(v, OP_Ne, pMWin->regOne, 0, regRowid); + VdbeCoverageNeverNull(v); + + /* This block is run for the first row of each partition */ + s.regArg = windowInitAccum(pParse, pMWin); + + if( regStart ){ + sqlite3ExprCode(pParse, pMWin->pStart, regStart); + windowCheckValue(pParse, regStart, 0 + (pMWin->eFrmType==TK_RANGE?3:0)); + } + if( regEnd ){ + sqlite3ExprCode(pParse, pMWin->pEnd, regEnd); + windowCheckValue(pParse, regEnd, 1 + (pMWin->eFrmType==TK_RANGE?3:0)); + } + + if( pMWin->eFrmType!=TK_RANGE && pMWin->eStart==pMWin->eEnd && regStart ){ + int op = ((pMWin->eStart==TK_FOLLOWING) ? OP_Ge : OP_Le); + int addrGe = sqlite3VdbeAddOp3(v, op, regStart, 0, regEnd); + VdbeCoverageNeverNullIf(v, op==OP_Ge); /* NeverNull because bound */ + VdbeCoverageNeverNullIf(v, op==OP_Le); /* values previously checked */ + windowAggFinal(&s, 0); + sqlite3VdbeAddOp2(v, OP_Rewind, s.current.csr, 1); + VdbeCoverageNeverTaken(v); + windowReturnOneRow(&s); + sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr); + sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd); + sqlite3VdbeJumpHere(v, addrGe); + } + if( pMWin->eStart==TK_FOLLOWING && pMWin->eFrmType!=TK_RANGE && regEnd ){ + assert( pMWin->eEnd==TK_FOLLOWING ); + sqlite3VdbeAddOp3(v, OP_Subtract, regStart, regEnd, regStart); + } + + if( pMWin->eStart!=TK_UNBOUNDED ){ + sqlite3VdbeAddOp2(v, OP_Rewind, s.start.csr, 1); + VdbeCoverageNeverTaken(v); + } + sqlite3VdbeAddOp2(v, OP_Rewind, s.current.csr, 1); + VdbeCoverageNeverTaken(v); + sqlite3VdbeAddOp2(v, OP_Rewind, s.end.csr, 1); + VdbeCoverageNeverTaken(v); + if( regPeer && pOrderBy ){ + sqlite3VdbeAddOp3(v, OP_Copy, regNewPeer, regPeer, pOrderBy->nExpr-1); + sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.start.reg, pOrderBy->nExpr-1); + sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.current.reg, pOrderBy->nExpr-1); + sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.end.reg, pOrderBy->nExpr-1); + } + + sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd); + + sqlite3VdbeJumpHere(v, addrNe); + + /* Beginning of the block executed for the second and subsequent rows. */ + if( regPeer ){ + windowIfNewPeer(pParse, pOrderBy, regNewPeer, regPeer, lblWhereEnd); + } + if( pMWin->eStart==TK_FOLLOWING ){ + windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0); + if( pMWin->eEnd!=TK_UNBOUNDED ){ + if( pMWin->eFrmType==TK_RANGE ){ + int lbl = sqlite3VdbeMakeLabel(pParse); + int addrNext = sqlite3VdbeCurrentAddr(v); + windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl); + windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0); + sqlite3VdbeAddOp2(v, OP_Goto, 0, addrNext); + sqlite3VdbeResolveLabel(v, lbl); + }else{ + windowCodeOp(&s, WINDOW_RETURN_ROW, regEnd, 0); + windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + } + } + }else + if( pMWin->eEnd==TK_PRECEDING ){ + int bRPS = (pMWin->eStart==TK_PRECEDING && pMWin->eFrmType==TK_RANGE); + windowCodeOp(&s, WINDOW_AGGSTEP, regEnd, 0); + if( bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0); + if( !bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + }else{ + int addr = 0; + windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0); + if( pMWin->eEnd!=TK_UNBOUNDED ){ + if( pMWin->eFrmType==TK_RANGE ){ + int lbl = 0; + addr = sqlite3VdbeCurrentAddr(v); + if( regEnd ){ + lbl = sqlite3VdbeMakeLabel(pParse); + windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl); + } + windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0); + windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + if( regEnd ){ + sqlite3VdbeAddOp2(v, OP_Goto, 0, addr); + sqlite3VdbeResolveLabel(v, lbl); + } + }else{ + if( regEnd ){ + addr = sqlite3VdbeAddOp3(v, OP_IfPos, regEnd, 0, 1); + VdbeCoverage(v); + } + windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0); + windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + if( regEnd ) sqlite3VdbeJumpHere(v, addr); + } + } + } + + /* End of the main input loop */ + sqlite3VdbeResolveLabel(v, lblWhereEnd); + sqlite3WhereEnd(pWInfo); + + /* Fall through */ + if( pMWin->pPartition ){ + addrInteger = sqlite3VdbeAddOp2(v, OP_Integer, 0, regFlushPart); + sqlite3VdbeJumpHere(v, addrGosubFlush); + } + + addrEmpty = sqlite3VdbeAddOp1(v, OP_Rewind, csrWrite); + VdbeCoverage(v); + if( pMWin->eEnd==TK_PRECEDING ){ + int bRPS = (pMWin->eStart==TK_PRECEDING && pMWin->eFrmType==TK_RANGE); + windowCodeOp(&s, WINDOW_AGGSTEP, regEnd, 0); + if( bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0); + }else if( pMWin->eStart==TK_FOLLOWING ){ + int addrStart; + int addrBreak1; + int addrBreak2; + int addrBreak3; + windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0); + if( pMWin->eFrmType==TK_RANGE ){ + addrStart = sqlite3VdbeCurrentAddr(v); + addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 1); + addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1); + }else + if( pMWin->eEnd==TK_UNBOUNDED ){ + addrStart = sqlite3VdbeCurrentAddr(v); + addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, regStart, 1); + addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, 0, 1); + }else{ + assert( pMWin->eEnd==TK_FOLLOWING ); + addrStart = sqlite3VdbeCurrentAddr(v); + addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, regEnd, 1); + addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 1); + } + sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart); + sqlite3VdbeJumpHere(v, addrBreak2); + addrStart = sqlite3VdbeCurrentAddr(v); + addrBreak3 = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1); + sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart); + sqlite3VdbeJumpHere(v, addrBreak1); + sqlite3VdbeJumpHere(v, addrBreak3); + }else{ + int addrBreak; + int addrStart; + windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0); + addrStart = sqlite3VdbeCurrentAddr(v); + addrBreak = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1); + windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart); + sqlite3VdbeJumpHere(v, addrBreak); + } + sqlite3VdbeJumpHere(v, addrEmpty); + + sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr); + if( pMWin->pPartition ){ + if( pMWin->regStartRowid ){ + sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid); + sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regEndRowid); + } + sqlite3VdbeChangeP1(v, addrInteger, sqlite3VdbeCurrentAddr(v)); + sqlite3VdbeAddOp1(v, OP_Return, regFlushPart); + } +} + +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +/************** End of window.c **********************************************/ +/************** Begin file parse.c *******************************************/ +/* This file is automatically generated by Lemon from input grammar +** source file "parse.y". */ +/* +** 2001-09-15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains SQLite's SQL parser. +** +** The canonical source code to this file ("parse.y") is a Lemon grammar +** file that specifies the input grammar and actions to take while parsing. +** That input file is processed by Lemon to generate a C-language +** implementation of a parser for the given grammer. You might be reading +** this comment as part of the translated C-code. Edits should be made +** to the original parse.y sources. +*/ + +/* #include "sqliteInt.h" */ + +/* +** Disable all error recovery processing in the parser push-down +** automaton. +*/ +#define YYNOERRORRECOVERY 1 + +/* +** Make yytestcase() the same as testcase() +*/ +#define yytestcase(X) testcase(X) + +/* +** Indicate that sqlite3ParserFree() will never be called with a null +** pointer. +*/ +#define YYPARSEFREENEVERNULL 1 + +/* +** In the amalgamation, the parse.c file generated by lemon and the +** tokenize.c file are concatenated. In that case, sqlite3RunParser() +** has access to the the size of the yyParser object and so the parser +** engine can be allocated from stack. In that case, only the +** sqlite3ParserInit() and sqlite3ParserFinalize() routines are invoked +** and the sqlite3ParserAlloc() and sqlite3ParserFree() routines can be +** omitted. +*/ +#ifdef SQLITE_AMALGAMATION +# define sqlite3Parser_ENGINEALWAYSONSTACK 1 +#endif + +/* +** Alternative datatype for the argument to the malloc() routine passed +** into sqlite3ParserAlloc(). The default is size_t. +*/ +#define YYMALLOCARGTYPE u64 + +/* +** An instance of the following structure describes the event of a +** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT, +** TK_DELETE, or TK_INSTEAD. If the event is of the form +** +** UPDATE ON (a,b,c) +** +** Then the "b" IdList records the list "a,b,c". +*/ +struct TrigEvent { int a; IdList * b; }; + +struct FrameBound { int eType; Expr *pExpr; }; + +/* +** Disable lookaside memory allocation for objects that might be +** shared across database connections. +*/ +static void disableLookaside(Parse *pParse){ + sqlite3 *db = pParse->db; + pParse->disableLookaside++; + DisableLookaside; +} + +#if !defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) \ + && defined(SQLITE_UDL_CAPABLE_PARSER) +/* +** Issue an error message if an ORDER BY or LIMIT clause occurs on an +** UPDATE or DELETE statement. +*/ +static void updateDeleteLimitError( + Parse *pParse, + ExprList *pOrderBy, + Expr *pLimit +){ + if( pOrderBy ){ + sqlite3ErrorMsg(pParse, "syntax error near \"ORDER BY\""); + }else{ + sqlite3ErrorMsg(pParse, "syntax error near \"LIMIT\""); + } + sqlite3ExprListDelete(pParse->db, pOrderBy); + sqlite3ExprDelete(pParse->db, pLimit); +} +#endif /* SQLITE_ENABLE_UPDATE_DELETE_LIMIT */ + + + /* + ** For a compound SELECT statement, make sure p->pPrior->pNext==p for + ** all elements in the list. And make sure list length does not exceed + ** SQLITE_LIMIT_COMPOUND_SELECT. + */ + static void parserDoubleLinkSelect(Parse *pParse, Select *p){ + assert( p!=0 ); + if( p->pPrior ){ + Select *pNext = 0, *pLoop; + int mxSelect, cnt = 0; + for(pLoop=p; pLoop; pNext=pLoop, pLoop=pLoop->pPrior, cnt++){ + pLoop->pNext = pNext; + pLoop->selFlags |= SF_Compound; + } + if( (p->selFlags & SF_MultiValue)==0 && + (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0 && + cnt>mxSelect + ){ + sqlite3ErrorMsg(pParse, "too many terms in compound SELECT"); + } + } + } + + + /* Construct a new Expr object from a single identifier. Use the + ** new Expr to populate pOut. Set the span of pOut to be the identifier + ** that created the expression. + */ + static Expr *tokenExpr(Parse *pParse, int op, Token t){ + Expr *p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)+t.n+1); + if( p ){ + /* memset(p, 0, sizeof(Expr)); */ + p->op = (u8)op; + p->affExpr = 0; + p->flags = EP_Leaf; + ExprClearVVAProperties(p); + p->iAgg = -1; + p->pLeft = p->pRight = 0; + p->x.pList = 0; + p->pAggInfo = 0; + p->y.pTab = 0; + p->op2 = 0; + p->iTable = 0; + p->iColumn = 0; + p->u.zToken = (char*)&p[1]; + memcpy(p->u.zToken, t.z, t.n); + p->u.zToken[t.n] = 0; + if( sqlite3Isquote(p->u.zToken[0]) ){ + sqlite3DequoteExpr(p); + } +#if SQLITE_MAX_EXPR_DEPTH>0 + p->nHeight = 1; +#endif + if( IN_RENAME_OBJECT ){ + return (Expr*)sqlite3RenameTokenMap(pParse, (void*)p, &t); + } + } + return p; + } + + + /* A routine to convert a binary TK_IS or TK_ISNOT expression into a + ** unary TK_ISNULL or TK_NOTNULL expression. */ + static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){ + sqlite3 *db = pParse->db; + if( pA && pY && pY->op==TK_NULL && !IN_RENAME_OBJECT ){ + pA->op = (u8)op; + sqlite3ExprDelete(db, pA->pRight); + pA->pRight = 0; + } + } + + /* Add a single new term to an ExprList that is used to store a + ** list of identifiers. Report an error if the ID list contains + ** a COLLATE clause or an ASC or DESC keyword, except ignore the + ** error while parsing a legacy schema. + */ + static ExprList *parserAddExprIdListTerm( + Parse *pParse, + ExprList *pPrior, + Token *pIdToken, + int hasCollate, + int sortOrder + ){ + ExprList *p = sqlite3ExprListAppend(pParse, pPrior, 0); + if( (hasCollate || sortOrder!=SQLITE_SO_UNDEFINED) + && pParse->db->init.busy==0 + ){ + sqlite3ErrorMsg(pParse, "syntax error after column name \"%.*s\"", + pIdToken->n, pIdToken->z); + } + sqlite3ExprListSetName(pParse, p, pIdToken, 1); + return p; + } + +#if TK_SPAN>255 +# error too many tokens in the grammar +#endif +/**************** End of %include directives **********************************/ +/* These constants specify the various numeric values for terminal symbols. +***************** Begin token definitions *************************************/ +#ifndef TK_SEMI +#define TK_SEMI 1 +#define TK_EXPLAIN 2 +#define TK_QUERY 3 +#define TK_PLAN 4 +#define TK_BEGIN 5 +#define TK_TRANSACTION 6 +#define TK_DEFERRED 7 +#define TK_IMMEDIATE 8 +#define TK_EXCLUSIVE 9 +#define TK_COMMIT 10 +#define TK_END 11 +#define TK_ROLLBACK 12 +#define TK_SAVEPOINT 13 +#define TK_RELEASE 14 +#define TK_TO 15 +#define TK_TABLE 16 +#define TK_CREATE 17 +#define TK_IF 18 +#define TK_NOT 19 +#define TK_EXISTS 20 +#define TK_TEMP 21 +#define TK_LP 22 +#define TK_RP 23 +#define TK_AS 24 +#define TK_WITHOUT 25 +#define TK_COMMA 26 +#define TK_ABORT 27 +#define TK_ACTION 28 +#define TK_AFTER 29 +#define TK_ANALYZE 30 +#define TK_ASC 31 +#define TK_ATTACH 32 +#define TK_BEFORE 33 +#define TK_BY 34 +#define TK_CASCADE 35 +#define TK_CAST 36 +#define TK_CONFLICT 37 +#define TK_DATABASE 38 +#define TK_DESC 39 +#define TK_DETACH 40 +#define TK_EACH 41 +#define TK_FAIL 42 +#define TK_OR 43 +#define TK_AND 44 +#define TK_IS 45 +#define TK_MATCH 46 +#define TK_LIKE_KW 47 +#define TK_BETWEEN 48 +#define TK_IN 49 +#define TK_ISNULL 50 +#define TK_NOTNULL 51 +#define TK_NE 52 +#define TK_EQ 53 +#define TK_GT 54 +#define TK_LE 55 +#define TK_LT 56 +#define TK_GE 57 +#define TK_ESCAPE 58 +#define TK_ID 59 +#define TK_COLUMNKW 60 +#define TK_DO 61 +#define TK_FOR 62 +#define TK_IGNORE 63 +#define TK_INITIALLY 64 +#define TK_INSTEAD 65 +#define TK_NO 66 +#define TK_KEY 67 +#define TK_OF 68 +#define TK_OFFSET 69 +#define TK_PRAGMA 70 +#define TK_RAISE 71 +#define TK_RECURSIVE 72 +#define TK_REPLACE 73 +#define TK_RESTRICT 74 +#define TK_ROW 75 +#define TK_ROWS 76 +#define TK_TRIGGER 77 +#define TK_VACUUM 78 +#define TK_VIEW 79 +#define TK_VIRTUAL 80 +#define TK_WITH 81 +#define TK_NULLS 82 +#define TK_FIRST 83 +#define TK_LAST 84 +#define TK_CURRENT 85 +#define TK_FOLLOWING 86 +#define TK_PARTITION 87 +#define TK_PRECEDING 88 +#define TK_RANGE 89 +#define TK_UNBOUNDED 90 +#define TK_EXCLUDE 91 +#define TK_GROUPS 92 +#define TK_OTHERS 93 +#define TK_TIES 94 +#define TK_GENERATED 95 +#define TK_ALWAYS 96 +#define TK_REINDEX 97 +#define TK_RENAME 98 +#define TK_CTIME_KW 99 +#define TK_ANY 100 +#define TK_BITAND 101 +#define TK_BITOR 102 +#define TK_LSHIFT 103 +#define TK_RSHIFT 104 +#define TK_PLUS 105 +#define TK_MINUS 106 +#define TK_STAR 107 +#define TK_SLASH 108 +#define TK_REM 109 +#define TK_CONCAT 110 +#define TK_COLLATE 111 +#define TK_BITNOT 112 +#define TK_ON 113 +#define TK_INDEXED 114 +#define TK_STRING 115 +#define TK_JOIN_KW 116 +#define TK_CONSTRAINT 117 +#define TK_DEFAULT 118 +#define TK_NULL 119 +#define TK_PRIMARY 120 +#define TK_UNIQUE 121 +#define TK_CHECK 122 +#define TK_REFERENCES 123 +#define TK_AUTOINCR 124 +#define TK_INSERT 125 +#define TK_DELETE 126 +#define TK_UPDATE 127 +#define TK_SET 128 +#define TK_DEFERRABLE 129 +#define TK_FOREIGN 130 +#define TK_DROP 131 +#define TK_UNION 132 +#define TK_ALL 133 +#define TK_EXCEPT 134 +#define TK_INTERSECT 135 +#define TK_SELECT 136 +#define TK_VALUES 137 +#define TK_DISTINCT 138 +#define TK_DOT 139 +#define TK_FROM 140 +#define TK_JOIN 141 +#define TK_USING 142 +#define TK_ORDER 143 +#define TK_GROUP 144 +#define TK_HAVING 145 +#define TK_LIMIT 146 +#define TK_WHERE 147 +#define TK_INTO 148 +#define TK_NOTHING 149 +#define TK_FLOAT 150 +#define TK_BLOB 151 +#define TK_INTEGER 152 +#define TK_VARIABLE 153 +#define TK_CASE 154 +#define TK_WHEN 155 +#define TK_THEN 156 +#define TK_ELSE 157 +#define TK_INDEX 158 +#define TK_ALTER 159 +#define TK_ADD 160 +#define TK_WINDOW 161 +#define TK_OVER 162 +#define TK_FILTER 163 +#define TK_COLUMN 164 +#define TK_AGG_FUNCTION 165 +#define TK_AGG_COLUMN 166 +#define TK_TRUEFALSE 167 +#define TK_ISNOT 168 +#define TK_FUNCTION 169 +#define TK_UMINUS 170 +#define TK_UPLUS 171 +#define TK_TRUTH 172 +#define TK_REGISTER 173 +#define TK_VECTOR 174 +#define TK_SELECT_COLUMN 175 +#define TK_IF_NULL_ROW 176 +#define TK_ASTERISK 177 +#define TK_SPAN 178 +#define TK_SPACE 179 +#define TK_ILLEGAL 180 +#endif +/**************** End token definitions ***************************************/ + +/* The next sections is a series of control #defines. +** various aspects of the generated parser. +** YYCODETYPE is the data type used to store the integer codes +** that represent terminal and non-terminal symbols. +** "unsigned char" is used if there are fewer than +** 256 symbols. Larger types otherwise. +** YYNOCODE is a number of type YYCODETYPE that is not used for +** any terminal or nonterminal symbol. +** YYFALLBACK If defined, this indicates that one or more tokens +** (also known as: "terminal symbols") have fall-back +** values which should be used if the original symbol +** would not parse. This permits keywords to sometimes +** be used as identifiers, for example. +** YYACTIONTYPE is the data type used for "action codes" - numbers +** that indicate what to do in response to the next +** token. +** sqlite3ParserTOKENTYPE is the data type used for minor type for terminal +** symbols. Background: A "minor type" is a semantic +** value associated with a terminal or non-terminal +** symbols. For example, for an "ID" terminal symbol, +** the minor type might be the name of the identifier. +** Each non-terminal can have a different minor type. +** Terminal symbols all have the same minor type, though. +** This macros defines the minor type for terminal +** symbols. +** YYMINORTYPE is the data type used for all minor types. +** This is typically a union of many types, one of +** which is sqlite3ParserTOKENTYPE. The entry in the union +** for terminal symbols is called "yy0". +** YYSTACKDEPTH is the maximum depth of the parser's stack. If +** zero the stack is dynamically sized using realloc() +** sqlite3ParserARG_SDECL A static variable declaration for the %extra_argument +** sqlite3ParserARG_PDECL A parameter declaration for the %extra_argument +** sqlite3ParserARG_PARAM Code to pass %extra_argument as a subroutine parameter +** sqlite3ParserARG_STORE Code to store %extra_argument into yypParser +** sqlite3ParserARG_FETCH Code to extract %extra_argument from yypParser +** sqlite3ParserCTX_* As sqlite3ParserARG_ except for %extra_context +** YYERRORSYMBOL is the code number of the error symbol. If not +** defined, then do no error processing. +** YYNSTATE the combined number of states. +** YYNRULE the number of rules in the grammar +** YYNTOKEN Number of terminal symbols +** YY_MAX_SHIFT Maximum value for shift actions +** YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions +** YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions +** YY_ERROR_ACTION The yy_action[] code for syntax error +** YY_ACCEPT_ACTION The yy_action[] code for accept +** YY_NO_ACTION The yy_action[] code for no-op +** YY_MIN_REDUCE Minimum value for reduce actions +** YY_MAX_REDUCE Maximum value for reduce actions +*/ +#ifndef INTERFACE +# define INTERFACE 1 +#endif +/************* Begin control #defines *****************************************/ +#define YYCODETYPE unsigned short int +#define YYNOCODE 310 +#define YYACTIONTYPE unsigned short int +#define YYWILDCARD 100 +#define sqlite3ParserTOKENTYPE Token +typedef union { + int yyinit; + sqlite3ParserTOKENTYPE yy0; + SrcList* yy47; + u8 yy58; + struct FrameBound yy77; + With* yy131; + int yy192; + Expr* yy202; + struct {int value; int mask;} yy207; + struct TrigEvent yy230; + ExprList* yy242; + Window* yy303; + Upsert* yy318; + const char* yy436; + TriggerStep* yy447; + Select* yy539; + IdList* yy600; +} YYMINORTYPE; +#ifndef YYSTACKDEPTH +#define YYSTACKDEPTH 100 +#endif +#define sqlite3ParserARG_SDECL +#define sqlite3ParserARG_PDECL +#define sqlite3ParserARG_PARAM +#define sqlite3ParserARG_FETCH +#define sqlite3ParserARG_STORE +#define sqlite3ParserCTX_SDECL Parse *pParse; +#define sqlite3ParserCTX_PDECL ,Parse *pParse +#define sqlite3ParserCTX_PARAM ,pParse +#define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse; +#define sqlite3ParserCTX_STORE yypParser->pParse=pParse; +#define YYFALLBACK 1 +#define YYNSTATE 553 +#define YYNRULE 385 +#define YYNRULE_WITH_ACTION 325 +#define YYNTOKEN 181 +#define YY_MAX_SHIFT 552 +#define YY_MIN_SHIFTREDUCE 803 +#define YY_MAX_SHIFTREDUCE 1187 +#define YY_ERROR_ACTION 1188 +#define YY_ACCEPT_ACTION 1189 +#define YY_NO_ACTION 1190 +#define YY_MIN_REDUCE 1191 +#define YY_MAX_REDUCE 1575 +/************* End control #defines *******************************************/ +#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) + +/* Define the yytestcase() macro to be a no-op if is not already defined +** otherwise. +** +** Applications can choose to define yytestcase() in the %include section +** to a macro that can assist in verifying code coverage. For production +** code the yytestcase() macro should be turned off. But it is useful +** for testing. +*/ +#ifndef yytestcase +# define yytestcase(X) +#endif + + +/* Next are the tables used to determine what action to take based on the +** current state and lookahead token. These tables are used to implement +** functions that take a state number and lookahead value and return an +** action integer. +** +** Suppose the action integer is N. Then the action is determined as +** follows +** +** 0 <= N <= YY_MAX_SHIFT Shift N. That is, push the lookahead +** token onto the stack and goto state N. +** +** N between YY_MIN_SHIFTREDUCE Shift to an arbitrary state then +** and YY_MAX_SHIFTREDUCE reduce by rule N-YY_MIN_SHIFTREDUCE. +** +** N == YY_ERROR_ACTION A syntax error has occurred. +** +** N == YY_ACCEPT_ACTION The parser accepts its input. +** +** N == YY_NO_ACTION No such action. Denotes unused +** slots in the yy_action[] table. +** +** N between YY_MIN_REDUCE Reduce by rule N-YY_MIN_REDUCE +** and YY_MAX_REDUCE +** +** The action table is constructed as a single large table named yy_action[]. +** Given state S and lookahead X, the action is computed as either: +** +** (A) N = yy_action[ yy_shift_ofst[S] + X ] +** (B) N = yy_default[S] +** +** The (A) formula is preferred. The B formula is used instead if +** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X. +** +** The formulas above are for computing the action when the lookahead is +** a terminal symbol. If the lookahead is a non-terminal (as occurs after +** a reduce action) then the yy_reduce_ofst[] array is used in place of +** the yy_shift_ofst[] array. +** +** The following are the tables generated in this section: +** +** yy_action[] A single table containing all actions. +** yy_lookahead[] A table containing the lookahead for each entry in +** yy_action. Used to detect hash collisions. +** yy_shift_ofst[] For each state, the offset into yy_action for +** shifting terminals. +** yy_reduce_ofst[] For each state, the offset into yy_action for +** shifting non-terminals after a reduce. +** yy_default[] Default action for each state. +** +*********** Begin parsing tables **********************************************/ +#define YY_ACTTAB_COUNT (1962) +static const YYACTIONTYPE yy_action[] = { + /* 0 */ 546, 1222, 546, 451, 1260, 546, 1239, 546, 114, 111, + /* 10 */ 211, 546, 1537, 546, 1260, 523, 114, 111, 211, 392, + /* 20 */ 1232, 344, 42, 42, 42, 42, 1225, 42, 42, 71, + /* 30 */ 71, 937, 1224, 71, 71, 71, 71, 1462, 1493, 938, + /* 40 */ 820, 453, 6, 121, 122, 112, 1165, 1165, 1006, 1009, + /* 50 */ 999, 999, 119, 119, 120, 120, 120, 120, 1543, 392, + /* 60 */ 1358, 1517, 552, 2, 1193, 194, 528, 436, 143, 291, + /* 70 */ 528, 136, 528, 371, 261, 504, 272, 385, 1273, 527, + /* 80 */ 503, 493, 164, 121, 122, 112, 1165, 1165, 1006, 1009, + /* 90 */ 999, 999, 119, 119, 120, 120, 120, 120, 1358, 442, + /* 100 */ 1514, 118, 118, 118, 118, 117, 117, 116, 116, 116, + /* 110 */ 115, 424, 266, 266, 266, 266, 1498, 358, 1500, 435, + /* 120 */ 357, 1498, 517, 524, 1485, 543, 1114, 543, 1114, 392, + /* 130 */ 405, 241, 208, 114, 111, 211, 98, 290, 537, 221, + /* 140 */ 1029, 118, 118, 118, 118, 117, 117, 116, 116, 116, + /* 150 */ 115, 424, 1142, 121, 122, 112, 1165, 1165, 1006, 1009, + /* 160 */ 999, 999, 119, 119, 120, 120, 120, 120, 406, 428, + /* 170 */ 117, 117, 116, 116, 116, 115, 424, 1418, 468, 123, + /* 180 */ 118, 118, 118, 118, 117, 117, 116, 116, 116, 115, + /* 190 */ 424, 116, 116, 116, 115, 424, 540, 540, 540, 392, + /* 200 */ 505, 120, 120, 120, 120, 113, 1051, 1142, 1143, 1144, + /* 210 */ 1051, 118, 118, 118, 118, 117, 117, 116, 116, 116, + /* 220 */ 115, 424, 1461, 121, 122, 112, 1165, 1165, 1006, 1009, + /* 230 */ 999, 999, 119, 119, 120, 120, 120, 120, 392, 444, + /* 240 */ 316, 83, 463, 81, 359, 382, 1142, 80, 118, 118, + /* 250 */ 118, 118, 117, 117, 116, 116, 116, 115, 424, 179, + /* 260 */ 434, 424, 121, 122, 112, 1165, 1165, 1006, 1009, 999, + /* 270 */ 999, 119, 119, 120, 120, 120, 120, 434, 433, 266, + /* 280 */ 266, 118, 118, 118, 118, 117, 117, 116, 116, 116, + /* 290 */ 115, 424, 543, 1109, 903, 506, 1142, 114, 111, 211, + /* 300 */ 1431, 1142, 1143, 1144, 206, 491, 1109, 392, 449, 1109, + /* 310 */ 545, 330, 120, 120, 120, 120, 298, 1431, 1433, 17, + /* 320 */ 118, 118, 118, 118, 117, 117, 116, 116, 116, 115, + /* 330 */ 424, 121, 122, 112, 1165, 1165, 1006, 1009, 999, 999, + /* 340 */ 119, 119, 120, 120, 120, 120, 392, 1358, 434, 1142, + /* 350 */ 482, 1142, 1143, 1144, 996, 996, 1007, 1010, 445, 118, + /* 360 */ 118, 118, 118, 117, 117, 116, 116, 116, 115, 424, + /* 370 */ 121, 122, 112, 1165, 1165, 1006, 1009, 999, 999, 119, + /* 380 */ 119, 120, 120, 120, 120, 1054, 1054, 465, 1431, 118, + /* 390 */ 118, 118, 118, 117, 117, 116, 116, 116, 115, 424, + /* 400 */ 1142, 451, 546, 1426, 1142, 1143, 1144, 233, 966, 1142, + /* 410 */ 481, 478, 477, 171, 360, 392, 164, 407, 414, 842, + /* 420 */ 476, 164, 185, 334, 71, 71, 1243, 1000, 118, 118, + /* 430 */ 118, 118, 117, 117, 116, 116, 116, 115, 424, 121, + /* 440 */ 122, 112, 1165, 1165, 1006, 1009, 999, 999, 119, 119, + /* 450 */ 120, 120, 120, 120, 392, 1142, 1143, 1144, 835, 12, + /* 460 */ 314, 509, 163, 356, 1142, 1143, 1144, 114, 111, 211, + /* 470 */ 508, 290, 537, 546, 276, 180, 290, 537, 121, 122, + /* 480 */ 112, 1165, 1165, 1006, 1009, 999, 999, 119, 119, 120, + /* 490 */ 120, 120, 120, 345, 484, 71, 71, 118, 118, 118, + /* 500 */ 118, 117, 117, 116, 116, 116, 115, 424, 1142, 209, + /* 510 */ 411, 523, 1142, 1109, 1571, 378, 252, 269, 342, 487, + /* 520 */ 337, 486, 238, 392, 513, 364, 1109, 1127, 333, 1109, + /* 530 */ 191, 409, 286, 32, 457, 443, 118, 118, 118, 118, + /* 540 */ 117, 117, 116, 116, 116, 115, 424, 121, 122, 112, + /* 550 */ 1165, 1165, 1006, 1009, 999, 999, 119, 119, 120, 120, + /* 560 */ 120, 120, 392, 1142, 1143, 1144, 987, 1142, 1143, 1144, + /* 570 */ 1142, 233, 492, 1492, 481, 478, 477, 6, 163, 546, + /* 580 */ 512, 546, 115, 424, 476, 5, 121, 122, 112, 1165, + /* 590 */ 1165, 1006, 1009, 999, 999, 119, 119, 120, 120, 120, + /* 600 */ 120, 13, 13, 13, 13, 118, 118, 118, 118, 117, + /* 610 */ 117, 116, 116, 116, 115, 424, 403, 502, 408, 546, + /* 620 */ 1486, 544, 1142, 892, 892, 1142, 1143, 1144, 1473, 1142, + /* 630 */ 275, 392, 808, 809, 810, 971, 422, 422, 422, 16, + /* 640 */ 16, 55, 55, 1242, 118, 118, 118, 118, 117, 117, + /* 650 */ 116, 116, 116, 115, 424, 121, 122, 112, 1165, 1165, + /* 660 */ 1006, 1009, 999, 999, 119, 119, 120, 120, 120, 120, + /* 670 */ 392, 1189, 1, 1, 552, 2, 1193, 1142, 1143, 1144, + /* 680 */ 194, 291, 898, 136, 1142, 1143, 1144, 897, 521, 1492, + /* 690 */ 1273, 3, 380, 6, 121, 122, 112, 1165, 1165, 1006, + /* 700 */ 1009, 999, 999, 119, 119, 120, 120, 120, 120, 858, + /* 710 */ 546, 924, 546, 118, 118, 118, 118, 117, 117, 116, + /* 720 */ 116, 116, 115, 424, 266, 266, 1092, 1569, 1142, 551, + /* 730 */ 1569, 1193, 13, 13, 13, 13, 291, 543, 136, 392, + /* 740 */ 485, 421, 420, 966, 344, 1273, 468, 410, 859, 279, + /* 750 */ 140, 221, 118, 118, 118, 118, 117, 117, 116, 116, + /* 760 */ 116, 115, 424, 121, 122, 112, 1165, 1165, 1006, 1009, + /* 770 */ 999, 999, 119, 119, 120, 120, 120, 120, 546, 266, + /* 780 */ 266, 428, 392, 1142, 1143, 1144, 1172, 830, 1172, 468, + /* 790 */ 431, 145, 543, 1146, 401, 314, 439, 302, 838, 1490, + /* 800 */ 71, 71, 412, 6, 1090, 473, 221, 100, 112, 1165, + /* 810 */ 1165, 1006, 1009, 999, 999, 119, 119, 120, 120, 120, + /* 820 */ 120, 118, 118, 118, 118, 117, 117, 116, 116, 116, + /* 830 */ 115, 424, 237, 1425, 546, 451, 428, 287, 986, 546, + /* 840 */ 236, 235, 234, 830, 97, 529, 429, 1265, 1265, 1146, + /* 850 */ 494, 307, 430, 838, 977, 546, 71, 71, 976, 1241, + /* 860 */ 546, 51, 51, 300, 118, 118, 118, 118, 117, 117, + /* 870 */ 116, 116, 116, 115, 424, 194, 103, 70, 70, 266, + /* 880 */ 266, 546, 71, 71, 266, 266, 30, 391, 344, 976, + /* 890 */ 976, 978, 543, 528, 1109, 328, 392, 543, 495, 397, + /* 900 */ 1470, 195, 530, 13, 13, 1358, 240, 1109, 277, 280, + /* 910 */ 1109, 280, 304, 457, 306, 333, 392, 31, 188, 419, + /* 920 */ 121, 122, 112, 1165, 1165, 1006, 1009, 999, 999, 119, + /* 930 */ 119, 120, 120, 120, 120, 142, 392, 365, 457, 986, + /* 940 */ 121, 122, 112, 1165, 1165, 1006, 1009, 999, 999, 119, + /* 950 */ 119, 120, 120, 120, 120, 977, 323, 1142, 326, 976, + /* 960 */ 121, 110, 112, 1165, 1165, 1006, 1009, 999, 999, 119, + /* 970 */ 119, 120, 120, 120, 120, 464, 377, 1185, 118, 118, + /* 980 */ 118, 118, 117, 117, 116, 116, 116, 115, 424, 1142, + /* 990 */ 976, 976, 978, 305, 9, 366, 244, 362, 118, 118, + /* 1000 */ 118, 118, 117, 117, 116, 116, 116, 115, 424, 313, + /* 1010 */ 546, 344, 1142, 1143, 1144, 299, 290, 537, 118, 118, + /* 1020 */ 118, 118, 117, 117, 116, 116, 116, 115, 424, 1263, + /* 1030 */ 1263, 1163, 13, 13, 278, 421, 420, 468, 392, 923, + /* 1040 */ 260, 260, 289, 1169, 1142, 1143, 1144, 189, 1171, 266, + /* 1050 */ 266, 468, 390, 543, 1186, 546, 1170, 263, 144, 489, + /* 1060 */ 922, 546, 543, 122, 112, 1165, 1165, 1006, 1009, 999, + /* 1070 */ 999, 119, 119, 120, 120, 120, 120, 71, 71, 1142, + /* 1080 */ 1172, 1272, 1172, 13, 13, 898, 1070, 1163, 546, 468, + /* 1090 */ 897, 107, 538, 1491, 4, 1268, 1109, 6, 525, 1049, + /* 1100 */ 12, 1071, 1092, 1570, 312, 455, 1570, 520, 541, 1109, + /* 1110 */ 56, 56, 1109, 1489, 423, 1358, 1072, 6, 345, 285, + /* 1120 */ 118, 118, 118, 118, 117, 117, 116, 116, 116, 115, + /* 1130 */ 424, 425, 1271, 321, 1142, 1143, 1144, 878, 266, 266, + /* 1140 */ 1277, 107, 538, 535, 4, 1488, 293, 879, 1211, 6, + /* 1150 */ 210, 543, 543, 164, 294, 496, 416, 204, 541, 267, + /* 1160 */ 267, 1214, 398, 511, 499, 204, 266, 266, 396, 531, + /* 1170 */ 8, 986, 543, 519, 546, 922, 458, 105, 105, 543, + /* 1180 */ 1090, 425, 266, 266, 106, 417, 425, 548, 547, 266, + /* 1190 */ 266, 976, 518, 535, 1373, 543, 15, 15, 266, 266, + /* 1200 */ 456, 1120, 543, 266, 266, 1070, 1372, 515, 290, 537, + /* 1210 */ 546, 543, 514, 97, 444, 316, 543, 546, 922, 125, + /* 1220 */ 1071, 986, 976, 976, 978, 979, 27, 105, 105, 401, + /* 1230 */ 343, 1511, 44, 44, 106, 1072, 425, 548, 547, 57, + /* 1240 */ 57, 976, 343, 1511, 107, 538, 546, 4, 462, 401, + /* 1250 */ 214, 1120, 459, 297, 377, 1091, 534, 1309, 546, 539, + /* 1260 */ 398, 541, 290, 537, 104, 244, 102, 526, 58, 58, + /* 1270 */ 546, 199, 976, 976, 978, 979, 27, 1516, 1131, 427, + /* 1280 */ 59, 59, 270, 237, 425, 138, 95, 375, 375, 374, + /* 1290 */ 255, 372, 60, 60, 817, 1180, 535, 546, 273, 546, + /* 1300 */ 1163, 1308, 389, 388, 546, 438, 546, 215, 210, 296, + /* 1310 */ 515, 849, 546, 265, 208, 516, 1476, 295, 274, 61, + /* 1320 */ 61, 62, 62, 308, 986, 109, 45, 45, 46, 46, + /* 1330 */ 105, 105, 1186, 922, 47, 47, 341, 106, 546, 425, + /* 1340 */ 548, 547, 1542, 546, 976, 867, 340, 217, 546, 937, + /* 1350 */ 397, 107, 538, 218, 4, 156, 1163, 938, 158, 546, + /* 1360 */ 49, 49, 1162, 546, 268, 50, 50, 546, 541, 1450, + /* 1370 */ 63, 63, 546, 1449, 216, 976, 976, 978, 979, 27, + /* 1380 */ 446, 64, 64, 546, 460, 65, 65, 546, 318, 14, + /* 1390 */ 14, 425, 1305, 546, 66, 66, 1087, 546, 141, 379, + /* 1400 */ 38, 546, 963, 535, 322, 127, 127, 546, 393, 67, + /* 1410 */ 67, 546, 325, 290, 537, 52, 52, 515, 546, 68, + /* 1420 */ 68, 845, 514, 69, 69, 399, 165, 857, 856, 53, + /* 1430 */ 53, 986, 311, 151, 151, 97, 432, 105, 105, 327, + /* 1440 */ 152, 152, 526, 1048, 106, 1048, 425, 548, 547, 1131, + /* 1450 */ 427, 976, 1032, 270, 968, 239, 329, 243, 375, 375, + /* 1460 */ 374, 255, 372, 940, 941, 817, 1296, 546, 220, 546, + /* 1470 */ 107, 538, 546, 4, 546, 1256, 199, 845, 215, 1036, + /* 1480 */ 296, 1530, 976, 976, 978, 979, 27, 541, 295, 76, + /* 1490 */ 76, 54, 54, 980, 72, 72, 128, 128, 864, 865, + /* 1500 */ 107, 538, 546, 4, 1047, 546, 1047, 533, 469, 546, + /* 1510 */ 425, 546, 450, 1240, 546, 243, 546, 541, 217, 546, + /* 1520 */ 452, 197, 535, 243, 73, 73, 156, 129, 129, 158, + /* 1530 */ 336, 130, 130, 126, 126, 1036, 150, 150, 149, 149, + /* 1540 */ 425, 134, 134, 317, 474, 216, 97, 239, 331, 980, + /* 1550 */ 986, 97, 535, 346, 347, 546, 105, 105, 902, 931, + /* 1560 */ 546, 895, 243, 106, 109, 425, 548, 547, 546, 1505, + /* 1570 */ 976, 828, 99, 538, 139, 4, 546, 133, 133, 393, + /* 1580 */ 986, 1317, 131, 131, 290, 537, 105, 105, 1357, 541, + /* 1590 */ 132, 132, 1292, 106, 1303, 425, 548, 547, 75, 75, + /* 1600 */ 976, 976, 976, 978, 979, 27, 546, 432, 896, 1289, + /* 1610 */ 532, 109, 425, 1363, 546, 1221, 1213, 1202, 258, 546, + /* 1620 */ 349, 546, 1201, 11, 535, 1203, 1524, 351, 77, 77, + /* 1630 */ 376, 976, 976, 978, 979, 27, 74, 74, 353, 213, + /* 1640 */ 301, 43, 43, 48, 48, 437, 310, 201, 303, 1350, + /* 1650 */ 315, 355, 986, 454, 479, 1239, 339, 192, 105, 105, + /* 1660 */ 1422, 1421, 193, 536, 205, 106, 1527, 425, 548, 547, + /* 1670 */ 1180, 167, 976, 270, 247, 1469, 1467, 1177, 375, 375, + /* 1680 */ 374, 255, 372, 200, 369, 817, 400, 83, 79, 82, + /* 1690 */ 1427, 448, 177, 95, 1342, 161, 169, 1339, 215, 440, + /* 1700 */ 296, 172, 173, 976, 976, 978, 979, 27, 295, 174, + /* 1710 */ 175, 441, 472, 223, 1347, 383, 35, 381, 36, 461, + /* 1720 */ 88, 1353, 181, 447, 384, 1416, 227, 467, 259, 229, + /* 1730 */ 186, 488, 470, 324, 1250, 230, 231, 320, 217, 1204, + /* 1740 */ 1438, 1259, 386, 1258, 413, 90, 156, 849, 1541, 158, + /* 1750 */ 206, 415, 1540, 507, 1300, 1257, 94, 348, 1229, 1301, + /* 1760 */ 387, 1510, 1228, 338, 1227, 216, 350, 1539, 498, 283, + /* 1770 */ 284, 1249, 501, 1299, 352, 245, 246, 418, 1298, 354, + /* 1780 */ 1496, 1495, 124, 10, 526, 363, 101, 1324, 253, 96, + /* 1790 */ 510, 1210, 34, 549, 1137, 254, 256, 257, 166, 393, + /* 1800 */ 550, 1199, 1282, 361, 290, 537, 1281, 196, 367, 368, + /* 1810 */ 1194, 153, 1454, 137, 281, 1323, 1455, 804, 154, 426, + /* 1820 */ 198, 155, 1453, 1452, 292, 212, 202, 432, 1402, 203, + /* 1830 */ 271, 135, 288, 78, 1046, 1044, 960, 168, 157, 881, + /* 1840 */ 170, 219, 309, 222, 1060, 176, 964, 159, 402, 84, + /* 1850 */ 178, 404, 85, 86, 87, 160, 1063, 224, 394, 395, + /* 1860 */ 225, 1059, 146, 18, 226, 319, 243, 1174, 466, 228, + /* 1870 */ 1052, 182, 183, 37, 819, 471, 340, 232, 332, 483, + /* 1880 */ 184, 89, 162, 19, 20, 475, 91, 480, 847, 335, + /* 1890 */ 147, 860, 282, 92, 490, 93, 1125, 148, 1012, 1095, + /* 1900 */ 39, 497, 1096, 40, 500, 262, 207, 264, 930, 187, + /* 1910 */ 925, 109, 1111, 1115, 1113, 7, 1099, 242, 33, 1119, + /* 1920 */ 21, 522, 22, 23, 24, 1118, 25, 190, 97, 26, + /* 1930 */ 1027, 1013, 1011, 1015, 1069, 1016, 1068, 249, 248, 28, + /* 1940 */ 41, 891, 981, 829, 108, 29, 250, 542, 251, 370, + /* 1950 */ 373, 1133, 1132, 1190, 1190, 1190, 1190, 1190, 1190, 1190, + /* 1960 */ 1532, 1531, +}; +static const YYCODETYPE yy_lookahead[] = { + /* 0 */ 189, 211, 189, 189, 218, 189, 220, 189, 267, 268, + /* 10 */ 269, 189, 210, 189, 228, 189, 267, 268, 269, 19, + /* 20 */ 218, 189, 211, 212, 211, 212, 211, 211, 212, 211, + /* 30 */ 212, 31, 211, 211, 212, 211, 212, 288, 300, 39, + /* 40 */ 21, 189, 304, 43, 44, 45, 46, 47, 48, 49, + /* 50 */ 50, 51, 52, 53, 54, 55, 56, 57, 225, 19, + /* 60 */ 189, 183, 184, 185, 186, 189, 248, 263, 236, 191, + /* 70 */ 248, 193, 248, 197, 208, 257, 262, 201, 200, 257, + /* 80 */ 200, 257, 81, 43, 44, 45, 46, 47, 48, 49, + /* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 189, 80, + /* 100 */ 189, 101, 102, 103, 104, 105, 106, 107, 108, 109, + /* 110 */ 110, 111, 234, 235, 234, 235, 305, 306, 305, 118, + /* 120 */ 307, 305, 306, 297, 298, 247, 86, 247, 88, 19, + /* 130 */ 259, 251, 252, 267, 268, 269, 26, 136, 137, 261, + /* 140 */ 121, 101, 102, 103, 104, 105, 106, 107, 108, 109, + /* 150 */ 110, 111, 59, 43, 44, 45, 46, 47, 48, 49, + /* 160 */ 50, 51, 52, 53, 54, 55, 56, 57, 259, 291, + /* 170 */ 105, 106, 107, 108, 109, 110, 111, 158, 189, 69, + /* 180 */ 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + /* 190 */ 111, 107, 108, 109, 110, 111, 205, 206, 207, 19, + /* 200 */ 19, 54, 55, 56, 57, 58, 29, 114, 115, 116, + /* 210 */ 33, 101, 102, 103, 104, 105, 106, 107, 108, 109, + /* 220 */ 110, 111, 233, 43, 44, 45, 46, 47, 48, 49, + /* 230 */ 50, 51, 52, 53, 54, 55, 56, 57, 19, 126, + /* 240 */ 127, 148, 65, 24, 214, 200, 59, 67, 101, 102, + /* 250 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 22, + /* 260 */ 189, 111, 43, 44, 45, 46, 47, 48, 49, 50, + /* 270 */ 51, 52, 53, 54, 55, 56, 57, 206, 207, 234, + /* 280 */ 235, 101, 102, 103, 104, 105, 106, 107, 108, 109, + /* 290 */ 110, 111, 247, 76, 107, 114, 59, 267, 268, 269, + /* 300 */ 189, 114, 115, 116, 162, 163, 89, 19, 263, 92, + /* 310 */ 189, 23, 54, 55, 56, 57, 189, 206, 207, 22, + /* 320 */ 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + /* 330 */ 111, 43, 44, 45, 46, 47, 48, 49, 50, 51, + /* 340 */ 52, 53, 54, 55, 56, 57, 19, 189, 277, 59, + /* 350 */ 23, 114, 115, 116, 46, 47, 48, 49, 61, 101, + /* 360 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + /* 370 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + /* 380 */ 53, 54, 55, 56, 57, 125, 126, 127, 277, 101, + /* 390 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + /* 400 */ 59, 189, 189, 276, 114, 115, 116, 117, 73, 59, + /* 410 */ 120, 121, 122, 72, 214, 19, 81, 259, 19, 23, + /* 420 */ 130, 81, 72, 24, 211, 212, 221, 119, 101, 102, + /* 430 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 43, + /* 440 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + /* 450 */ 54, 55, 56, 57, 19, 114, 115, 116, 23, 208, + /* 460 */ 125, 248, 189, 189, 114, 115, 116, 267, 268, 269, + /* 470 */ 189, 136, 137, 189, 262, 22, 136, 137, 43, 44, + /* 480 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + /* 490 */ 55, 56, 57, 189, 95, 211, 212, 101, 102, 103, + /* 500 */ 104, 105, 106, 107, 108, 109, 110, 111, 59, 189, + /* 510 */ 111, 189, 59, 76, 294, 295, 117, 118, 119, 120, + /* 520 */ 121, 122, 123, 19, 87, 189, 89, 23, 129, 92, + /* 530 */ 279, 227, 248, 22, 189, 284, 101, 102, 103, 104, + /* 540 */ 105, 106, 107, 108, 109, 110, 111, 43, 44, 45, + /* 550 */ 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + /* 560 */ 56, 57, 19, 114, 115, 116, 23, 114, 115, 116, + /* 570 */ 59, 117, 299, 300, 120, 121, 122, 304, 189, 189, + /* 580 */ 143, 189, 110, 111, 130, 22, 43, 44, 45, 46, + /* 590 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + /* 600 */ 57, 211, 212, 211, 212, 101, 102, 103, 104, 105, + /* 610 */ 106, 107, 108, 109, 110, 111, 226, 189, 226, 189, + /* 620 */ 298, 132, 59, 134, 135, 114, 115, 116, 189, 59, + /* 630 */ 285, 19, 7, 8, 9, 23, 205, 206, 207, 211, + /* 640 */ 212, 211, 212, 221, 101, 102, 103, 104, 105, 106, + /* 650 */ 107, 108, 109, 110, 111, 43, 44, 45, 46, 47, + /* 660 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + /* 670 */ 19, 181, 182, 183, 184, 185, 186, 114, 115, 116, + /* 680 */ 189, 191, 133, 193, 114, 115, 116, 138, 299, 300, + /* 690 */ 200, 22, 201, 304, 43, 44, 45, 46, 47, 48, + /* 700 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 35, + /* 710 */ 189, 141, 189, 101, 102, 103, 104, 105, 106, 107, + /* 720 */ 108, 109, 110, 111, 234, 235, 22, 23, 59, 184, + /* 730 */ 26, 186, 211, 212, 211, 212, 191, 247, 193, 19, + /* 740 */ 66, 105, 106, 73, 189, 200, 189, 226, 74, 226, + /* 750 */ 22, 261, 101, 102, 103, 104, 105, 106, 107, 108, + /* 760 */ 109, 110, 111, 43, 44, 45, 46, 47, 48, 49, + /* 770 */ 50, 51, 52, 53, 54, 55, 56, 57, 189, 234, + /* 780 */ 235, 291, 19, 114, 115, 116, 150, 59, 152, 189, + /* 790 */ 233, 236, 247, 59, 189, 125, 126, 127, 59, 300, + /* 800 */ 211, 212, 128, 304, 100, 19, 261, 156, 45, 46, + /* 810 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + /* 820 */ 57, 101, 102, 103, 104, 105, 106, 107, 108, 109, + /* 830 */ 110, 111, 46, 233, 189, 189, 291, 248, 99, 189, + /* 840 */ 125, 126, 127, 115, 26, 200, 289, 230, 231, 115, + /* 850 */ 200, 16, 189, 114, 115, 189, 211, 212, 119, 221, + /* 860 */ 189, 211, 212, 258, 101, 102, 103, 104, 105, 106, + /* 870 */ 107, 108, 109, 110, 111, 189, 156, 211, 212, 234, + /* 880 */ 235, 189, 211, 212, 234, 235, 22, 201, 189, 150, + /* 890 */ 151, 152, 247, 248, 76, 16, 19, 247, 248, 113, + /* 900 */ 189, 24, 257, 211, 212, 189, 26, 89, 262, 223, + /* 910 */ 92, 225, 77, 189, 79, 129, 19, 53, 226, 248, + /* 920 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + /* 930 */ 53, 54, 55, 56, 57, 236, 19, 271, 189, 99, + /* 940 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + /* 950 */ 53, 54, 55, 56, 57, 115, 77, 59, 79, 119, + /* 960 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + /* 970 */ 53, 54, 55, 56, 57, 259, 22, 23, 101, 102, + /* 980 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 59, + /* 990 */ 150, 151, 152, 158, 22, 244, 24, 246, 101, 102, + /* 1000 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 285, + /* 1010 */ 189, 189, 114, 115, 116, 200, 136, 137, 101, 102, + /* 1020 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 230, + /* 1030 */ 231, 59, 211, 212, 285, 105, 106, 189, 19, 141, + /* 1040 */ 234, 235, 239, 113, 114, 115, 116, 226, 118, 234, + /* 1050 */ 235, 189, 249, 247, 100, 189, 126, 23, 236, 107, + /* 1060 */ 26, 189, 247, 44, 45, 46, 47, 48, 49, 50, + /* 1070 */ 51, 52, 53, 54, 55, 56, 57, 211, 212, 59, + /* 1080 */ 150, 233, 152, 211, 212, 133, 12, 115, 189, 189, + /* 1090 */ 138, 19, 20, 300, 22, 233, 76, 304, 226, 11, + /* 1100 */ 208, 27, 22, 23, 200, 19, 26, 87, 36, 89, + /* 1110 */ 211, 212, 92, 300, 248, 189, 42, 304, 189, 250, + /* 1120 */ 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + /* 1130 */ 111, 59, 200, 233, 114, 115, 116, 63, 234, 235, + /* 1140 */ 235, 19, 20, 71, 22, 300, 189, 73, 200, 304, + /* 1150 */ 116, 247, 247, 81, 189, 200, 227, 26, 36, 234, + /* 1160 */ 235, 203, 204, 143, 200, 26, 234, 235, 194, 200, + /* 1170 */ 48, 99, 247, 66, 189, 141, 284, 105, 106, 247, + /* 1180 */ 100, 59, 234, 235, 112, 259, 114, 115, 116, 234, + /* 1190 */ 235, 119, 85, 71, 266, 247, 211, 212, 234, 235, + /* 1200 */ 114, 94, 247, 234, 235, 12, 266, 85, 136, 137, + /* 1210 */ 189, 247, 90, 26, 126, 127, 247, 189, 26, 22, + /* 1220 */ 27, 99, 150, 151, 152, 153, 154, 105, 106, 189, + /* 1230 */ 302, 303, 211, 212, 112, 42, 114, 115, 116, 211, + /* 1240 */ 212, 119, 302, 303, 19, 20, 189, 22, 274, 189, + /* 1250 */ 15, 144, 278, 189, 22, 23, 63, 189, 189, 203, + /* 1260 */ 204, 36, 136, 137, 155, 24, 157, 143, 211, 212, + /* 1270 */ 189, 140, 150, 151, 152, 153, 154, 0, 1, 2, + /* 1280 */ 211, 212, 5, 46, 59, 161, 147, 10, 11, 12, + /* 1290 */ 13, 14, 211, 212, 17, 60, 71, 189, 258, 189, + /* 1300 */ 59, 189, 105, 106, 189, 189, 189, 30, 116, 32, + /* 1310 */ 85, 124, 189, 251, 252, 90, 189, 40, 258, 211, + /* 1320 */ 212, 211, 212, 189, 99, 26, 211, 212, 211, 212, + /* 1330 */ 105, 106, 100, 141, 211, 212, 119, 112, 189, 114, + /* 1340 */ 115, 116, 23, 189, 119, 26, 129, 70, 189, 31, + /* 1350 */ 113, 19, 20, 24, 22, 78, 115, 39, 81, 189, + /* 1360 */ 211, 212, 26, 189, 22, 211, 212, 189, 36, 189, + /* 1370 */ 211, 212, 189, 189, 97, 150, 151, 152, 153, 154, + /* 1380 */ 127, 211, 212, 189, 189, 211, 212, 189, 189, 211, + /* 1390 */ 212, 59, 189, 189, 211, 212, 23, 189, 22, 26, + /* 1400 */ 24, 189, 149, 71, 189, 211, 212, 189, 131, 211, + /* 1410 */ 212, 189, 189, 136, 137, 211, 212, 85, 189, 211, + /* 1420 */ 212, 59, 90, 211, 212, 292, 293, 118, 119, 211, + /* 1430 */ 212, 99, 23, 211, 212, 26, 159, 105, 106, 189, + /* 1440 */ 211, 212, 143, 150, 112, 152, 114, 115, 116, 1, + /* 1450 */ 2, 119, 23, 5, 23, 26, 189, 26, 10, 11, + /* 1460 */ 12, 13, 14, 83, 84, 17, 253, 189, 139, 189, + /* 1470 */ 19, 20, 189, 22, 189, 189, 140, 115, 30, 59, + /* 1480 */ 32, 139, 150, 151, 152, 153, 154, 36, 40, 211, + /* 1490 */ 212, 211, 212, 59, 211, 212, 211, 212, 7, 8, + /* 1500 */ 19, 20, 189, 22, 150, 189, 152, 231, 281, 189, + /* 1510 */ 59, 189, 23, 189, 189, 26, 189, 36, 70, 189, + /* 1520 */ 23, 237, 71, 26, 211, 212, 78, 211, 212, 81, + /* 1530 */ 189, 211, 212, 211, 212, 115, 211, 212, 211, 212, + /* 1540 */ 59, 211, 212, 23, 23, 97, 26, 26, 23, 115, + /* 1550 */ 99, 26, 71, 189, 189, 189, 105, 106, 107, 23, + /* 1560 */ 189, 23, 26, 112, 26, 114, 115, 116, 189, 309, + /* 1570 */ 119, 23, 19, 20, 26, 22, 189, 211, 212, 131, + /* 1580 */ 99, 189, 211, 212, 136, 137, 105, 106, 189, 36, + /* 1590 */ 211, 212, 189, 112, 189, 114, 115, 116, 211, 212, + /* 1600 */ 119, 150, 151, 152, 153, 154, 189, 159, 23, 250, + /* 1610 */ 189, 26, 59, 189, 189, 189, 189, 189, 280, 189, + /* 1620 */ 250, 189, 189, 238, 71, 189, 189, 250, 211, 212, + /* 1630 */ 187, 150, 151, 152, 153, 154, 211, 212, 250, 290, + /* 1640 */ 240, 211, 212, 211, 212, 254, 286, 209, 254, 241, + /* 1650 */ 240, 254, 99, 286, 215, 220, 214, 244, 105, 106, + /* 1660 */ 214, 214, 244, 273, 224, 112, 192, 114, 115, 116, + /* 1670 */ 60, 290, 119, 5, 139, 196, 196, 38, 10, 11, + /* 1680 */ 12, 13, 14, 238, 240, 17, 196, 148, 287, 287, + /* 1690 */ 276, 113, 22, 147, 241, 43, 229, 241, 30, 18, + /* 1700 */ 32, 232, 232, 150, 151, 152, 153, 154, 40, 232, + /* 1710 */ 232, 196, 18, 195, 265, 265, 264, 241, 264, 196, + /* 1720 */ 155, 229, 229, 241, 241, 241, 195, 62, 196, 195, + /* 1730 */ 22, 113, 216, 196, 222, 195, 195, 282, 70, 196, + /* 1740 */ 283, 213, 216, 213, 64, 22, 78, 124, 219, 81, + /* 1750 */ 162, 111, 219, 142, 256, 213, 113, 255, 213, 256, + /* 1760 */ 216, 303, 215, 213, 213, 97, 255, 213, 216, 275, + /* 1770 */ 275, 222, 216, 256, 255, 196, 91, 82, 256, 255, + /* 1780 */ 308, 308, 146, 22, 143, 196, 155, 260, 25, 145, + /* 1790 */ 144, 199, 26, 198, 13, 190, 190, 6, 293, 131, + /* 1800 */ 188, 188, 245, 244, 136, 137, 245, 243, 242, 241, + /* 1810 */ 188, 202, 208, 217, 217, 260, 208, 4, 202, 3, + /* 1820 */ 22, 202, 208, 208, 160, 15, 209, 159, 270, 209, + /* 1830 */ 98, 16, 272, 208, 23, 23, 137, 148, 128, 20, + /* 1840 */ 140, 24, 16, 142, 1, 140, 149, 128, 61, 53, + /* 1850 */ 148, 37, 53, 53, 53, 128, 114, 34, 296, 296, + /* 1860 */ 139, 1, 5, 22, 113, 158, 26, 75, 41, 139, + /* 1870 */ 68, 68, 113, 24, 20, 19, 129, 123, 23, 96, + /* 1880 */ 22, 22, 37, 22, 22, 67, 22, 67, 59, 24, + /* 1890 */ 23, 28, 67, 147, 22, 26, 23, 23, 23, 23, + /* 1900 */ 22, 24, 23, 22, 24, 23, 139, 23, 114, 22, + /* 1910 */ 141, 26, 88, 75, 86, 44, 23, 34, 22, 75, + /* 1920 */ 34, 24, 34, 34, 34, 93, 34, 26, 26, 34, + /* 1930 */ 23, 23, 23, 23, 23, 11, 23, 22, 26, 22, + /* 1940 */ 22, 133, 23, 23, 22, 22, 139, 26, 139, 23, + /* 1950 */ 15, 1, 1, 310, 310, 310, 310, 310, 310, 310, + /* 1960 */ 139, 139, 310, 310, 310, 310, 310, 310, 310, 310, + /* 1970 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 1980 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 1990 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 2000 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 2010 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 2020 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 2030 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 2040 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 2050 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 2060 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 2070 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 2080 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 2090 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 2100 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 2110 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 2120 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 2130 */ 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + /* 2140 */ 310, 310, 310, +}; +#define YY_SHIFT_COUNT (552) +#define YY_SHIFT_MIN (0) +#define YY_SHIFT_MAX (1951) +static const unsigned short int yy_shift_ofst[] = { + /* 0 */ 1448, 1277, 1668, 1072, 1072, 340, 1122, 1225, 1332, 1481, + /* 10 */ 1481, 1481, 335, 0, 0, 180, 897, 1481, 1481, 1481, + /* 20 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 30 */ 930, 930, 1020, 1020, 290, 1, 340, 340, 340, 340, + /* 40 */ 340, 340, 40, 110, 219, 288, 327, 396, 435, 504, + /* 50 */ 543, 612, 651, 720, 877, 897, 897, 897, 897, 897, + /* 60 */ 897, 897, 897, 897, 897, 897, 897, 897, 897, 897, + /* 70 */ 897, 897, 897, 917, 897, 1019, 763, 763, 1451, 1481, + /* 80 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 90 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 100 */ 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 110 */ 1481, 1481, 1553, 1481, 1481, 1481, 1481, 1481, 1481, 1481, + /* 120 */ 1481, 1481, 1481, 1481, 1481, 1481, 147, 258, 258, 258, + /* 130 */ 258, 258, 79, 65, 84, 449, 19, 786, 449, 636, + /* 140 */ 636, 449, 880, 880, 880, 880, 113, 142, 142, 472, + /* 150 */ 150, 1962, 1962, 399, 399, 399, 93, 237, 341, 237, + /* 160 */ 237, 1074, 1074, 437, 350, 704, 1080, 449, 449, 449, + /* 170 */ 449, 449, 449, 449, 449, 449, 449, 449, 449, 449, + /* 180 */ 449, 449, 449, 449, 449, 449, 449, 449, 818, 818, + /* 190 */ 449, 1088, 217, 217, 734, 734, 1124, 1126, 1962, 1962, + /* 200 */ 1962, 739, 840, 840, 453, 454, 511, 187, 563, 570, + /* 210 */ 898, 669, 449, 449, 449, 449, 449, 449, 449, 449, + /* 220 */ 449, 670, 449, 449, 449, 449, 449, 449, 449, 449, + /* 230 */ 449, 449, 449, 449, 674, 674, 674, 449, 449, 449, + /* 240 */ 449, 1034, 449, 449, 449, 972, 1107, 449, 449, 1193, + /* 250 */ 449, 449, 449, 449, 449, 449, 449, 449, 260, 177, + /* 260 */ 489, 1241, 1241, 1241, 1241, 1192, 489, 489, 952, 1197, + /* 270 */ 625, 1235, 1131, 181, 181, 1086, 1139, 1131, 1086, 1187, + /* 280 */ 1319, 1237, 1318, 1318, 1318, 181, 1299, 1299, 1109, 1336, + /* 290 */ 549, 1376, 1610, 1535, 1535, 1639, 1639, 1535, 1539, 1578, + /* 300 */ 1670, 1546, 1652, 1546, 1681, 1681, 1681, 1681, 1535, 1694, + /* 310 */ 1546, 1546, 1578, 1670, 1652, 1546, 1652, 1546, 1535, 1694, + /* 320 */ 1565, 1665, 1535, 1694, 1708, 1535, 1694, 1535, 1694, 1708, + /* 330 */ 1618, 1618, 1618, 1680, 1723, 1723, 1708, 1618, 1623, 1618, + /* 340 */ 1680, 1618, 1618, 1588, 1708, 1640, 1640, 1708, 1611, 1643, + /* 350 */ 1611, 1643, 1611, 1643, 1611, 1643, 1535, 1685, 1685, 1695, + /* 360 */ 1695, 1636, 1641, 1761, 1535, 1631, 1636, 1644, 1646, 1546, + /* 370 */ 1763, 1766, 1781, 1781, 1791, 1791, 1791, 1962, 1962, 1962, + /* 380 */ 1962, 1962, 1962, 1962, 1962, 1962, 1962, 1962, 1962, 1962, + /* 390 */ 1962, 1962, 308, 835, 954, 1232, 879, 715, 728, 1373, + /* 400 */ 864, 1329, 1253, 1409, 297, 1431, 1489, 1497, 1520, 1521, + /* 410 */ 1525, 1362, 1309, 1491, 1217, 1420, 1429, 1536, 1380, 1538, + /* 420 */ 1293, 1354, 1548, 1585, 1434, 1342, 1813, 1816, 1798, 1664, + /* 430 */ 1810, 1732, 1815, 1811, 1812, 1699, 1689, 1710, 1817, 1700, + /* 440 */ 1819, 1701, 1826, 1843, 1705, 1697, 1719, 1787, 1814, 1702, + /* 450 */ 1796, 1799, 1800, 1801, 1727, 1742, 1823, 1721, 1860, 1857, + /* 460 */ 1841, 1751, 1707, 1802, 1840, 1803, 1792, 1827, 1730, 1759, + /* 470 */ 1849, 1854, 1856, 1747, 1754, 1858, 1818, 1859, 1861, 1855, + /* 480 */ 1862, 1820, 1829, 1865, 1783, 1863, 1864, 1825, 1845, 1867, + /* 490 */ 1746, 1872, 1873, 1874, 1875, 1869, 1876, 1878, 1877, 1879, + /* 500 */ 1881, 1880, 1767, 1882, 1884, 1794, 1883, 1887, 1769, 1885, + /* 510 */ 1886, 1888, 1889, 1890, 1824, 1838, 1828, 1871, 1844, 1832, + /* 520 */ 1892, 1893, 1896, 1897, 1901, 1902, 1895, 1907, 1885, 1908, + /* 530 */ 1909, 1910, 1911, 1912, 1913, 1915, 1924, 1917, 1918, 1919, + /* 540 */ 1920, 1922, 1923, 1921, 1808, 1807, 1809, 1821, 1822, 1926, + /* 550 */ 1935, 1950, 1951, +}; +#define YY_REDUCE_COUNT (391) +#define YY_REDUCE_MIN (-262) +#define YY_REDUCE_MAX (1625) +static const short yy_reduce_ofst[] = { + /* 0 */ 490, -122, 545, 645, 650, -120, -189, -187, -184, -182, + /* 10 */ -178, -176, 45, 30, 200, -251, -134, 390, 392, 521, + /* 20 */ 523, 213, 692, 821, 284, 589, 872, 666, 671, 866, + /* 30 */ 71, 111, 273, 389, 686, 815, 904, 932, 948, 955, + /* 40 */ 964, 969, -259, -259, -259, -259, -259, -259, -259, -259, + /* 50 */ -259, -259, -259, -259, -259, -259, -259, -259, -259, -259, + /* 60 */ -259, -259, -259, -259, -259, -259, -259, -259, -259, -259, + /* 70 */ -259, -259, -259, -259, -259, -259, -259, -259, 428, 430, + /* 80 */ 899, 985, 1021, 1028, 1057, 1069, 1081, 1108, 1110, 1115, + /* 90 */ 1117, 1123, 1149, 1154, 1159, 1170, 1174, 1178, 1183, 1194, + /* 100 */ 1198, 1204, 1208, 1212, 1218, 1222, 1229, 1278, 1280, 1283, + /* 110 */ 1285, 1313, 1316, 1320, 1322, 1325, 1327, 1330, 1366, 1371, + /* 120 */ 1379, 1387, 1417, 1425, 1430, 1432, -259, -259, -259, -259, + /* 130 */ -259, -259, -259, -259, -259, 557, 974, -214, -174, -9, + /* 140 */ 431, -124, 806, 925, 806, 925, 251, 928, 940, -259, + /* 150 */ -259, -259, -259, -198, -198, -198, 127, -186, -168, 212, + /* 160 */ 646, 617, 799, -262, 555, 220, 220, 491, 605, 1040, + /* 170 */ 1060, 699, -11, 600, 848, 862, 345, -129, 724, -91, + /* 180 */ 158, 749, 716, 900, 304, 822, 929, 926, 499, 793, + /* 190 */ 322, 892, 813, 845, 958, 1056, 751, 905, 1133, 1062, + /* 200 */ 803, -210, -185, -179, -148, -167, -89, 121, 274, 281, + /* 210 */ 320, 336, 439, 663, 711, 957, 965, 1064, 1068, 1112, + /* 220 */ 1116, -196, 1127, 1134, 1180, 1184, 1195, 1199, 1203, 1215, + /* 230 */ 1223, 1250, 1267, 1286, 205, 422, 638, 1324, 1341, 1364, + /* 240 */ 1365, 1213, 1392, 1399, 1403, 869, 1260, 1405, 1421, 1276, + /* 250 */ 1424, 121, 1426, 1427, 1428, 1433, 1436, 1437, 1227, 1338, + /* 260 */ 1284, 1359, 1370, 1377, 1388, 1213, 1284, 1284, 1385, 1438, + /* 270 */ 1443, 1349, 1400, 1391, 1394, 1360, 1408, 1410, 1367, 1439, + /* 280 */ 1440, 1435, 1442, 1446, 1447, 1397, 1413, 1418, 1390, 1444, + /* 290 */ 1445, 1474, 1381, 1479, 1480, 1401, 1402, 1490, 1414, 1449, + /* 300 */ 1452, 1453, 1467, 1456, 1469, 1470, 1477, 1478, 1515, 1518, + /* 310 */ 1476, 1482, 1450, 1454, 1492, 1483, 1493, 1484, 1523, 1531, + /* 320 */ 1457, 1455, 1532, 1534, 1516, 1537, 1540, 1543, 1541, 1526, + /* 330 */ 1528, 1530, 1542, 1512, 1529, 1533, 1544, 1545, 1547, 1550, + /* 340 */ 1549, 1551, 1554, 1458, 1552, 1494, 1495, 1556, 1498, 1502, + /* 350 */ 1503, 1511, 1517, 1519, 1522, 1524, 1579, 1472, 1473, 1527, + /* 360 */ 1555, 1557, 1559, 1558, 1589, 1560, 1561, 1564, 1566, 1568, + /* 370 */ 1592, 1595, 1605, 1606, 1612, 1613, 1622, 1562, 1563, 1505, + /* 380 */ 1609, 1604, 1608, 1614, 1615, 1616, 1596, 1597, 1617, 1620, + /* 390 */ 1625, 1619, +}; +static const YYACTIONTYPE yy_default[] = { + /* 0 */ 1575, 1575, 1575, 1411, 1188, 1297, 1188, 1188, 1188, 1411, + /* 10 */ 1411, 1411, 1188, 1327, 1327, 1464, 1219, 1188, 1188, 1188, + /* 20 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1410, 1188, 1188, + /* 30 */ 1188, 1188, 1494, 1494, 1188, 1188, 1188, 1188, 1188, 1188, + /* 40 */ 1188, 1188, 1188, 1336, 1188, 1188, 1188, 1188, 1188, 1188, + /* 50 */ 1412, 1413, 1188, 1188, 1188, 1463, 1465, 1428, 1346, 1345, + /* 60 */ 1344, 1343, 1446, 1314, 1341, 1334, 1338, 1406, 1407, 1405, + /* 70 */ 1409, 1413, 1412, 1188, 1337, 1377, 1391, 1376, 1188, 1188, + /* 80 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 90 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 100 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 110 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 120 */ 1188, 1188, 1188, 1188, 1188, 1188, 1385, 1390, 1396, 1389, + /* 130 */ 1386, 1379, 1378, 1380, 1381, 1188, 1209, 1261, 1188, 1188, + /* 140 */ 1188, 1188, 1482, 1481, 1188, 1188, 1219, 1371, 1370, 1382, + /* 150 */ 1383, 1393, 1392, 1471, 1529, 1528, 1429, 1188, 1188, 1188, + /* 160 */ 1188, 1188, 1188, 1494, 1188, 1188, 1188, 1188, 1188, 1188, + /* 170 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 180 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1494, 1494, + /* 190 */ 1188, 1219, 1494, 1494, 1215, 1215, 1321, 1188, 1477, 1297, + /* 200 */ 1288, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 210 */ 1188, 1188, 1188, 1188, 1188, 1468, 1466, 1188, 1188, 1188, + /* 220 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 230 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 240 */ 1188, 1188, 1188, 1188, 1188, 1293, 1188, 1188, 1188, 1188, + /* 250 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1523, 1188, 1441, + /* 260 */ 1275, 1293, 1293, 1293, 1293, 1295, 1276, 1274, 1287, 1220, + /* 270 */ 1195, 1567, 1294, 1316, 1316, 1564, 1340, 1294, 1564, 1236, + /* 280 */ 1545, 1231, 1327, 1327, 1327, 1316, 1321, 1321, 1408, 1294, + /* 290 */ 1287, 1188, 1567, 1302, 1302, 1566, 1566, 1302, 1429, 1349, + /* 300 */ 1355, 1340, 1264, 1340, 1270, 1270, 1270, 1270, 1302, 1206, + /* 310 */ 1340, 1340, 1349, 1355, 1264, 1340, 1264, 1340, 1302, 1206, + /* 320 */ 1445, 1561, 1302, 1206, 1419, 1302, 1206, 1302, 1206, 1419, + /* 330 */ 1262, 1262, 1262, 1251, 1188, 1188, 1419, 1262, 1236, 1262, + /* 340 */ 1251, 1262, 1262, 1512, 1419, 1423, 1423, 1419, 1320, 1315, + /* 350 */ 1320, 1315, 1320, 1315, 1320, 1315, 1302, 1504, 1504, 1330, + /* 360 */ 1330, 1335, 1321, 1414, 1302, 1188, 1335, 1333, 1331, 1340, + /* 370 */ 1212, 1254, 1526, 1526, 1522, 1522, 1522, 1572, 1572, 1477, + /* 380 */ 1538, 1219, 1219, 1219, 1219, 1538, 1238, 1238, 1220, 1220, + /* 390 */ 1219, 1538, 1188, 1188, 1188, 1188, 1188, 1188, 1533, 1188, + /* 400 */ 1430, 1306, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 410 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 420 */ 1188, 1188, 1188, 1188, 1188, 1360, 1188, 1191, 1474, 1188, + /* 430 */ 1188, 1472, 1188, 1188, 1188, 1188, 1188, 1188, 1307, 1188, + /* 440 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 450 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1563, 1188, 1188, + /* 460 */ 1188, 1188, 1188, 1188, 1444, 1443, 1188, 1188, 1304, 1188, + /* 470 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 480 */ 1188, 1188, 1234, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 490 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 500 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1332, + /* 510 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 520 */ 1188, 1188, 1188, 1188, 1509, 1322, 1188, 1188, 1554, 1188, + /* 530 */ 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, + /* 540 */ 1188, 1188, 1188, 1549, 1278, 1362, 1188, 1361, 1365, 1188, + /* 550 */ 1200, 1188, 1188, +}; +/********** End of lemon-generated parsing tables *****************************/ + +/* The next table maps tokens (terminal symbols) into fallback tokens. +** If a construct like the following: +** +** %fallback ID X Y Z. +** +** appears in the grammar, then ID becomes a fallback token for X, Y, +** and Z. Whenever one of the tokens X, Y, or Z is input to the parser +** but it does not parse, the type of the token is changed to ID and +** the parse is retried before an error is thrown. +** +** This feature can be used, for example, to cause some keywords in a language +** to revert to identifiers if they keyword does not apply in the context where +** it appears. +*/ +#ifdef YYFALLBACK +static const YYCODETYPE yyFallback[] = { + 0, /* $ => nothing */ + 0, /* SEMI => nothing */ + 59, /* EXPLAIN => ID */ + 59, /* QUERY => ID */ + 59, /* PLAN => ID */ + 59, /* BEGIN => ID */ + 0, /* TRANSACTION => nothing */ + 59, /* DEFERRED => ID */ + 59, /* IMMEDIATE => ID */ + 59, /* EXCLUSIVE => ID */ + 0, /* COMMIT => nothing */ + 59, /* END => ID */ + 59, /* ROLLBACK => ID */ + 59, /* SAVEPOINT => ID */ + 59, /* RELEASE => ID */ + 0, /* TO => nothing */ + 0, /* TABLE => nothing */ + 0, /* CREATE => nothing */ + 59, /* IF => ID */ + 0, /* NOT => nothing */ + 0, /* EXISTS => nothing */ + 59, /* TEMP => ID */ + 0, /* LP => nothing */ + 0, /* RP => nothing */ + 0, /* AS => nothing */ + 59, /* WITHOUT => ID */ + 0, /* COMMA => nothing */ + 59, /* ABORT => ID */ + 59, /* ACTION => ID */ + 59, /* AFTER => ID */ + 59, /* ANALYZE => ID */ + 59, /* ASC => ID */ + 59, /* ATTACH => ID */ + 59, /* BEFORE => ID */ + 59, /* BY => ID */ + 59, /* CASCADE => ID */ + 59, /* CAST => ID */ + 59, /* CONFLICT => ID */ + 59, /* DATABASE => ID */ + 59, /* DESC => ID */ + 59, /* DETACH => ID */ + 59, /* EACH => ID */ + 59, /* FAIL => ID */ + 0, /* OR => nothing */ + 0, /* AND => nothing */ + 0, /* IS => nothing */ + 59, /* MATCH => ID */ + 59, /* LIKE_KW => ID */ + 0, /* BETWEEN => nothing */ + 0, /* IN => nothing */ + 0, /* ISNULL => nothing */ + 0, /* NOTNULL => nothing */ + 0, /* NE => nothing */ + 0, /* EQ => nothing */ + 0, /* GT => nothing */ + 0, /* LE => nothing */ + 0, /* LT => nothing */ + 0, /* GE => nothing */ + 0, /* ESCAPE => nothing */ + 0, /* ID => nothing */ + 59, /* COLUMNKW => ID */ + 59, /* DO => ID */ + 59, /* FOR => ID */ + 59, /* IGNORE => ID */ + 59, /* INITIALLY => ID */ + 59, /* INSTEAD => ID */ + 59, /* NO => ID */ + 59, /* KEY => ID */ + 59, /* OF => ID */ + 59, /* OFFSET => ID */ + 59, /* PRAGMA => ID */ + 59, /* RAISE => ID */ + 59, /* RECURSIVE => ID */ + 59, /* REPLACE => ID */ + 59, /* RESTRICT => ID */ + 59, /* ROW => ID */ + 59, /* ROWS => ID */ + 59, /* TRIGGER => ID */ + 59, /* VACUUM => ID */ + 59, /* VIEW => ID */ + 59, /* VIRTUAL => ID */ + 59, /* WITH => ID */ + 59, /* NULLS => ID */ + 59, /* FIRST => ID */ + 59, /* LAST => ID */ + 59, /* CURRENT => ID */ + 59, /* FOLLOWING => ID */ + 59, /* PARTITION => ID */ + 59, /* PRECEDING => ID */ + 59, /* RANGE => ID */ + 59, /* UNBOUNDED => ID */ + 59, /* EXCLUDE => ID */ + 59, /* GROUPS => ID */ + 59, /* OTHERS => ID */ + 59, /* TIES => ID */ + 59, /* GENERATED => ID */ + 59, /* ALWAYS => ID */ + 59, /* REINDEX => ID */ + 59, /* RENAME => ID */ + 59, /* CTIME_KW => ID */ + 0, /* ANY => nothing */ + 0, /* BITAND => nothing */ + 0, /* BITOR => nothing */ + 0, /* LSHIFT => nothing */ + 0, /* RSHIFT => nothing */ + 0, /* PLUS => nothing */ + 0, /* MINUS => nothing */ + 0, /* STAR => nothing */ + 0, /* SLASH => nothing */ + 0, /* REM => nothing */ + 0, /* CONCAT => nothing */ + 0, /* COLLATE => nothing */ + 0, /* BITNOT => nothing */ + 0, /* ON => nothing */ + 0, /* INDEXED => nothing */ + 0, /* STRING => nothing */ + 0, /* JOIN_KW => nothing */ + 0, /* CONSTRAINT => nothing */ + 0, /* DEFAULT => nothing */ + 0, /* NULL => nothing */ + 0, /* PRIMARY => nothing */ + 0, /* UNIQUE => nothing */ + 0, /* CHECK => nothing */ + 0, /* REFERENCES => nothing */ + 0, /* AUTOINCR => nothing */ + 0, /* INSERT => nothing */ + 0, /* DELETE => nothing */ + 0, /* UPDATE => nothing */ + 0, /* SET => nothing */ + 0, /* DEFERRABLE => nothing */ + 0, /* FOREIGN => nothing */ + 0, /* DROP => nothing */ + 0, /* UNION => nothing */ + 0, /* ALL => nothing */ + 0, /* EXCEPT => nothing */ + 0, /* INTERSECT => nothing */ + 0, /* SELECT => nothing */ + 0, /* VALUES => nothing */ + 0, /* DISTINCT => nothing */ + 0, /* DOT => nothing */ + 0, /* FROM => nothing */ + 0, /* JOIN => nothing */ + 0, /* USING => nothing */ + 0, /* ORDER => nothing */ + 0, /* GROUP => nothing */ + 0, /* HAVING => nothing */ + 0, /* LIMIT => nothing */ + 0, /* WHERE => nothing */ + 0, /* INTO => nothing */ + 0, /* NOTHING => nothing */ + 0, /* FLOAT => nothing */ + 0, /* BLOB => nothing */ + 0, /* INTEGER => nothing */ + 0, /* VARIABLE => nothing */ + 0, /* CASE => nothing */ + 0, /* WHEN => nothing */ + 0, /* THEN => nothing */ + 0, /* ELSE => nothing */ + 0, /* INDEX => nothing */ + 0, /* ALTER => nothing */ + 0, /* ADD => nothing */ + 0, /* WINDOW => nothing */ + 0, /* OVER => nothing */ + 0, /* FILTER => nothing */ + 0, /* COLUMN => nothing */ + 0, /* AGG_FUNCTION => nothing */ + 0, /* AGG_COLUMN => nothing */ + 0, /* TRUEFALSE => nothing */ + 0, /* ISNOT => nothing */ + 0, /* FUNCTION => nothing */ + 0, /* UMINUS => nothing */ + 0, /* UPLUS => nothing */ + 0, /* TRUTH => nothing */ + 0, /* REGISTER => nothing */ + 0, /* VECTOR => nothing */ + 0, /* SELECT_COLUMN => nothing */ + 0, /* IF_NULL_ROW => nothing */ + 0, /* ASTERISK => nothing */ + 0, /* SPAN => nothing */ + 0, /* SPACE => nothing */ + 0, /* ILLEGAL => nothing */ +}; +#endif /* YYFALLBACK */ + +/* The following structure represents a single element of the +** parser's stack. Information stored includes: +** +** + The state number for the parser at this level of the stack. +** +** + The value of the token stored at this level of the stack. +** (In other words, the "major" token.) +** +** + The semantic value stored at this level of the stack. This is +** the information used by the action routines in the grammar. +** It is sometimes called the "minor" token. +** +** After the "shift" half of a SHIFTREDUCE action, the stateno field +** actually contains the reduce action for the second half of the +** SHIFTREDUCE. +*/ +struct yyStackEntry { + YYACTIONTYPE stateno; /* The state-number, or reduce action in SHIFTREDUCE */ + YYCODETYPE major; /* The major token value. This is the code + ** number for the token at this stack level */ + YYMINORTYPE minor; /* The user-supplied minor token value. This + ** is the value of the token */ +}; +typedef struct yyStackEntry yyStackEntry; + +/* The state of the parser is completely contained in an instance of +** the following structure */ +struct yyParser { + yyStackEntry *yytos; /* Pointer to top element of the stack */ +#ifdef YYTRACKMAXSTACKDEPTH + int yyhwm; /* High-water mark of the stack */ +#endif +#ifndef YYNOERRORRECOVERY + int yyerrcnt; /* Shifts left before out of the error */ +#endif + sqlite3ParserARG_SDECL /* A place to hold %extra_argument */ + sqlite3ParserCTX_SDECL /* A place to hold %extra_context */ +#if YYSTACKDEPTH<=0 + int yystksz; /* Current side of the stack */ + yyStackEntry *yystack; /* The parser's stack */ + yyStackEntry yystk0; /* First stack entry */ +#else + yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */ + yyStackEntry *yystackEnd; /* Last entry in the stack */ +#endif +}; +typedef struct yyParser yyParser; + +#ifndef NDEBUG +/* #include */ +/* #include */ +static FILE *yyTraceFILE = 0; +static char *yyTracePrompt = 0; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* +** Turn parser tracing on by giving a stream to which to write the trace +** and a prompt to preface each trace message. Tracing is turned off +** by making either argument NULL +** +** Inputs: +**
      +**
    • A FILE* to which trace output should be written. +** If NULL, then tracing is turned off. +**
    • A prefix string written at the beginning of every +** line of trace output. If NULL, then tracing is +** turned off. +**
    +** +** Outputs: +** None. +*/ +SQLITE_PRIVATE void sqlite3ParserTrace(FILE *TraceFILE, char *zTracePrompt){ + yyTraceFILE = TraceFILE; + yyTracePrompt = zTracePrompt; + if( yyTraceFILE==0 ) yyTracePrompt = 0; + else if( yyTracePrompt==0 ) yyTraceFILE = 0; +} +#endif /* NDEBUG */ + +#if defined(YYCOVERAGE) || !defined(NDEBUG) +/* For tracing shifts, the names of all terminals and nonterminals +** are required. The following table supplies these names */ +static const char *const yyTokenName[] = { + /* 0 */ "$", + /* 1 */ "SEMI", + /* 2 */ "EXPLAIN", + /* 3 */ "QUERY", + /* 4 */ "PLAN", + /* 5 */ "BEGIN", + /* 6 */ "TRANSACTION", + /* 7 */ "DEFERRED", + /* 8 */ "IMMEDIATE", + /* 9 */ "EXCLUSIVE", + /* 10 */ "COMMIT", + /* 11 */ "END", + /* 12 */ "ROLLBACK", + /* 13 */ "SAVEPOINT", + /* 14 */ "RELEASE", + /* 15 */ "TO", + /* 16 */ "TABLE", + /* 17 */ "CREATE", + /* 18 */ "IF", + /* 19 */ "NOT", + /* 20 */ "EXISTS", + /* 21 */ "TEMP", + /* 22 */ "LP", + /* 23 */ "RP", + /* 24 */ "AS", + /* 25 */ "WITHOUT", + /* 26 */ "COMMA", + /* 27 */ "ABORT", + /* 28 */ "ACTION", + /* 29 */ "AFTER", + /* 30 */ "ANALYZE", + /* 31 */ "ASC", + /* 32 */ "ATTACH", + /* 33 */ "BEFORE", + /* 34 */ "BY", + /* 35 */ "CASCADE", + /* 36 */ "CAST", + /* 37 */ "CONFLICT", + /* 38 */ "DATABASE", + /* 39 */ "DESC", + /* 40 */ "DETACH", + /* 41 */ "EACH", + /* 42 */ "FAIL", + /* 43 */ "OR", + /* 44 */ "AND", + /* 45 */ "IS", + /* 46 */ "MATCH", + /* 47 */ "LIKE_KW", + /* 48 */ "BETWEEN", + /* 49 */ "IN", + /* 50 */ "ISNULL", + /* 51 */ "NOTNULL", + /* 52 */ "NE", + /* 53 */ "EQ", + /* 54 */ "GT", + /* 55 */ "LE", + /* 56 */ "LT", + /* 57 */ "GE", + /* 58 */ "ESCAPE", + /* 59 */ "ID", + /* 60 */ "COLUMNKW", + /* 61 */ "DO", + /* 62 */ "FOR", + /* 63 */ "IGNORE", + /* 64 */ "INITIALLY", + /* 65 */ "INSTEAD", + /* 66 */ "NO", + /* 67 */ "KEY", + /* 68 */ "OF", + /* 69 */ "OFFSET", + /* 70 */ "PRAGMA", + /* 71 */ "RAISE", + /* 72 */ "RECURSIVE", + /* 73 */ "REPLACE", + /* 74 */ "RESTRICT", + /* 75 */ "ROW", + /* 76 */ "ROWS", + /* 77 */ "TRIGGER", + /* 78 */ "VACUUM", + /* 79 */ "VIEW", + /* 80 */ "VIRTUAL", + /* 81 */ "WITH", + /* 82 */ "NULLS", + /* 83 */ "FIRST", + /* 84 */ "LAST", + /* 85 */ "CURRENT", + /* 86 */ "FOLLOWING", + /* 87 */ "PARTITION", + /* 88 */ "PRECEDING", + /* 89 */ "RANGE", + /* 90 */ "UNBOUNDED", + /* 91 */ "EXCLUDE", + /* 92 */ "GROUPS", + /* 93 */ "OTHERS", + /* 94 */ "TIES", + /* 95 */ "GENERATED", + /* 96 */ "ALWAYS", + /* 97 */ "REINDEX", + /* 98 */ "RENAME", + /* 99 */ "CTIME_KW", + /* 100 */ "ANY", + /* 101 */ "BITAND", + /* 102 */ "BITOR", + /* 103 */ "LSHIFT", + /* 104 */ "RSHIFT", + /* 105 */ "PLUS", + /* 106 */ "MINUS", + /* 107 */ "STAR", + /* 108 */ "SLASH", + /* 109 */ "REM", + /* 110 */ "CONCAT", + /* 111 */ "COLLATE", + /* 112 */ "BITNOT", + /* 113 */ "ON", + /* 114 */ "INDEXED", + /* 115 */ "STRING", + /* 116 */ "JOIN_KW", + /* 117 */ "CONSTRAINT", + /* 118 */ "DEFAULT", + /* 119 */ "NULL", + /* 120 */ "PRIMARY", + /* 121 */ "UNIQUE", + /* 122 */ "CHECK", + /* 123 */ "REFERENCES", + /* 124 */ "AUTOINCR", + /* 125 */ "INSERT", + /* 126 */ "DELETE", + /* 127 */ "UPDATE", + /* 128 */ "SET", + /* 129 */ "DEFERRABLE", + /* 130 */ "FOREIGN", + /* 131 */ "DROP", + /* 132 */ "UNION", + /* 133 */ "ALL", + /* 134 */ "EXCEPT", + /* 135 */ "INTERSECT", + /* 136 */ "SELECT", + /* 137 */ "VALUES", + /* 138 */ "DISTINCT", + /* 139 */ "DOT", + /* 140 */ "FROM", + /* 141 */ "JOIN", + /* 142 */ "USING", + /* 143 */ "ORDER", + /* 144 */ "GROUP", + /* 145 */ "HAVING", + /* 146 */ "LIMIT", + /* 147 */ "WHERE", + /* 148 */ "INTO", + /* 149 */ "NOTHING", + /* 150 */ "FLOAT", + /* 151 */ "BLOB", + /* 152 */ "INTEGER", + /* 153 */ "VARIABLE", + /* 154 */ "CASE", + /* 155 */ "WHEN", + /* 156 */ "THEN", + /* 157 */ "ELSE", + /* 158 */ "INDEX", + /* 159 */ "ALTER", + /* 160 */ "ADD", + /* 161 */ "WINDOW", + /* 162 */ "OVER", + /* 163 */ "FILTER", + /* 164 */ "COLUMN", + /* 165 */ "AGG_FUNCTION", + /* 166 */ "AGG_COLUMN", + /* 167 */ "TRUEFALSE", + /* 168 */ "ISNOT", + /* 169 */ "FUNCTION", + /* 170 */ "UMINUS", + /* 171 */ "UPLUS", + /* 172 */ "TRUTH", + /* 173 */ "REGISTER", + /* 174 */ "VECTOR", + /* 175 */ "SELECT_COLUMN", + /* 176 */ "IF_NULL_ROW", + /* 177 */ "ASTERISK", + /* 178 */ "SPAN", + /* 179 */ "SPACE", + /* 180 */ "ILLEGAL", + /* 181 */ "input", + /* 182 */ "cmdlist", + /* 183 */ "ecmd", + /* 184 */ "cmdx", + /* 185 */ "explain", + /* 186 */ "cmd", + /* 187 */ "transtype", + /* 188 */ "trans_opt", + /* 189 */ "nm", + /* 190 */ "savepoint_opt", + /* 191 */ "create_table", + /* 192 */ "create_table_args", + /* 193 */ "createkw", + /* 194 */ "temp", + /* 195 */ "ifnotexists", + /* 196 */ "dbnm", + /* 197 */ "columnlist", + /* 198 */ "conslist_opt", + /* 199 */ "table_options", + /* 200 */ "select", + /* 201 */ "columnname", + /* 202 */ "carglist", + /* 203 */ "typetoken", + /* 204 */ "typename", + /* 205 */ "signed", + /* 206 */ "plus_num", + /* 207 */ "minus_num", + /* 208 */ "scanpt", + /* 209 */ "scantok", + /* 210 */ "ccons", + /* 211 */ "term", + /* 212 */ "expr", + /* 213 */ "onconf", + /* 214 */ "sortorder", + /* 215 */ "autoinc", + /* 216 */ "eidlist_opt", + /* 217 */ "refargs", + /* 218 */ "defer_subclause", + /* 219 */ "generated", + /* 220 */ "refarg", + /* 221 */ "refact", + /* 222 */ "init_deferred_pred_opt", + /* 223 */ "conslist", + /* 224 */ "tconscomma", + /* 225 */ "tcons", + /* 226 */ "sortlist", + /* 227 */ "eidlist", + /* 228 */ "defer_subclause_opt", + /* 229 */ "orconf", + /* 230 */ "resolvetype", + /* 231 */ "raisetype", + /* 232 */ "ifexists", + /* 233 */ "fullname", + /* 234 */ "selectnowith", + /* 235 */ "oneselect", + /* 236 */ "wqlist", + /* 237 */ "multiselect_op", + /* 238 */ "distinct", + /* 239 */ "selcollist", + /* 240 */ "from", + /* 241 */ "where_opt", + /* 242 */ "groupby_opt", + /* 243 */ "having_opt", + /* 244 */ "orderby_opt", + /* 245 */ "limit_opt", + /* 246 */ "window_clause", + /* 247 */ "values", + /* 248 */ "nexprlist", + /* 249 */ "sclp", + /* 250 */ "as", + /* 251 */ "seltablist", + /* 252 */ "stl_prefix", + /* 253 */ "joinop", + /* 254 */ "indexed_opt", + /* 255 */ "on_opt", + /* 256 */ "using_opt", + /* 257 */ "exprlist", + /* 258 */ "xfullname", + /* 259 */ "idlist", + /* 260 */ "nulls", + /* 261 */ "with", + /* 262 */ "setlist", + /* 263 */ "insert_cmd", + /* 264 */ "idlist_opt", + /* 265 */ "upsert", + /* 266 */ "filter_over", + /* 267 */ "likeop", + /* 268 */ "between_op", + /* 269 */ "in_op", + /* 270 */ "paren_exprlist", + /* 271 */ "case_operand", + /* 272 */ "case_exprlist", + /* 273 */ "case_else", + /* 274 */ "uniqueflag", + /* 275 */ "collate", + /* 276 */ "vinto", + /* 277 */ "nmnum", + /* 278 */ "trigger_decl", + /* 279 */ "trigger_cmd_list", + /* 280 */ "trigger_time", + /* 281 */ "trigger_event", + /* 282 */ "foreach_clause", + /* 283 */ "when_clause", + /* 284 */ "trigger_cmd", + /* 285 */ "trnm", + /* 286 */ "tridxby", + /* 287 */ "database_kw_opt", + /* 288 */ "key_opt", + /* 289 */ "add_column_fullname", + /* 290 */ "kwcolumn_opt", + /* 291 */ "create_vtab", + /* 292 */ "vtabarglist", + /* 293 */ "vtabarg", + /* 294 */ "vtabargtoken", + /* 295 */ "lp", + /* 296 */ "anylist", + /* 297 */ "windowdefn_list", + /* 298 */ "windowdefn", + /* 299 */ "window", + /* 300 */ "frame_opt", + /* 301 */ "part_opt", + /* 302 */ "filter_clause", + /* 303 */ "over_clause", + /* 304 */ "range_or_rows", + /* 305 */ "frame_bound", + /* 306 */ "frame_bound_s", + /* 307 */ "frame_bound_e", + /* 308 */ "frame_exclude_opt", + /* 309 */ "frame_exclude", +}; +#endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ + +#ifndef NDEBUG +/* For tracing reduce actions, the names of all rules are required. +*/ +static const char *const yyRuleName[] = { + /* 0 */ "explain ::= EXPLAIN", + /* 1 */ "explain ::= EXPLAIN QUERY PLAN", + /* 2 */ "cmdx ::= cmd", + /* 3 */ "cmd ::= BEGIN transtype trans_opt", + /* 4 */ "transtype ::=", + /* 5 */ "transtype ::= DEFERRED", + /* 6 */ "transtype ::= IMMEDIATE", + /* 7 */ "transtype ::= EXCLUSIVE", + /* 8 */ "cmd ::= COMMIT|END trans_opt", + /* 9 */ "cmd ::= ROLLBACK trans_opt", + /* 10 */ "cmd ::= SAVEPOINT nm", + /* 11 */ "cmd ::= RELEASE savepoint_opt nm", + /* 12 */ "cmd ::= ROLLBACK trans_opt TO savepoint_opt nm", + /* 13 */ "create_table ::= createkw temp TABLE ifnotexists nm dbnm", + /* 14 */ "createkw ::= CREATE", + /* 15 */ "ifnotexists ::=", + /* 16 */ "ifnotexists ::= IF NOT EXISTS", + /* 17 */ "temp ::= TEMP", + /* 18 */ "temp ::=", + /* 19 */ "create_table_args ::= LP columnlist conslist_opt RP table_options", + /* 20 */ "create_table_args ::= AS select", + /* 21 */ "table_options ::=", + /* 22 */ "table_options ::= WITHOUT nm", + /* 23 */ "columnname ::= nm typetoken", + /* 24 */ "typetoken ::=", + /* 25 */ "typetoken ::= typename LP signed RP", + /* 26 */ "typetoken ::= typename LP signed COMMA signed RP", + /* 27 */ "typename ::= typename ID|STRING", + /* 28 */ "scanpt ::=", + /* 29 */ "scantok ::=", + /* 30 */ "ccons ::= CONSTRAINT nm", + /* 31 */ "ccons ::= DEFAULT scantok term", + /* 32 */ "ccons ::= DEFAULT LP expr RP", + /* 33 */ "ccons ::= DEFAULT PLUS scantok term", + /* 34 */ "ccons ::= DEFAULT MINUS scantok term", + /* 35 */ "ccons ::= DEFAULT scantok ID|INDEXED", + /* 36 */ "ccons ::= NOT NULL onconf", + /* 37 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc", + /* 38 */ "ccons ::= UNIQUE onconf", + /* 39 */ "ccons ::= CHECK LP expr RP", + /* 40 */ "ccons ::= REFERENCES nm eidlist_opt refargs", + /* 41 */ "ccons ::= defer_subclause", + /* 42 */ "ccons ::= COLLATE ID|STRING", + /* 43 */ "generated ::= LP expr RP", + /* 44 */ "generated ::= LP expr RP ID", + /* 45 */ "autoinc ::=", + /* 46 */ "autoinc ::= AUTOINCR", + /* 47 */ "refargs ::=", + /* 48 */ "refargs ::= refargs refarg", + /* 49 */ "refarg ::= MATCH nm", + /* 50 */ "refarg ::= ON INSERT refact", + /* 51 */ "refarg ::= ON DELETE refact", + /* 52 */ "refarg ::= ON UPDATE refact", + /* 53 */ "refact ::= SET NULL", + /* 54 */ "refact ::= SET DEFAULT", + /* 55 */ "refact ::= CASCADE", + /* 56 */ "refact ::= RESTRICT", + /* 57 */ "refact ::= NO ACTION", + /* 58 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt", + /* 59 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt", + /* 60 */ "init_deferred_pred_opt ::=", + /* 61 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED", + /* 62 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE", + /* 63 */ "conslist_opt ::=", + /* 64 */ "tconscomma ::= COMMA", + /* 65 */ "tcons ::= CONSTRAINT nm", + /* 66 */ "tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf", + /* 67 */ "tcons ::= UNIQUE LP sortlist RP onconf", + /* 68 */ "tcons ::= CHECK LP expr RP onconf", + /* 69 */ "tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt", + /* 70 */ "defer_subclause_opt ::=", + /* 71 */ "onconf ::=", + /* 72 */ "onconf ::= ON CONFLICT resolvetype", + /* 73 */ "orconf ::=", + /* 74 */ "orconf ::= OR resolvetype", + /* 75 */ "resolvetype ::= IGNORE", + /* 76 */ "resolvetype ::= REPLACE", + /* 77 */ "cmd ::= DROP TABLE ifexists fullname", + /* 78 */ "ifexists ::= IF EXISTS", + /* 79 */ "ifexists ::=", + /* 80 */ "cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select", + /* 81 */ "cmd ::= DROP VIEW ifexists fullname", + /* 82 */ "cmd ::= select", + /* 83 */ "select ::= WITH wqlist selectnowith", + /* 84 */ "select ::= WITH RECURSIVE wqlist selectnowith", + /* 85 */ "select ::= selectnowith", + /* 86 */ "selectnowith ::= selectnowith multiselect_op oneselect", + /* 87 */ "multiselect_op ::= UNION", + /* 88 */ "multiselect_op ::= UNION ALL", + /* 89 */ "multiselect_op ::= EXCEPT|INTERSECT", + /* 90 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt", + /* 91 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt", + /* 92 */ "values ::= VALUES LP nexprlist RP", + /* 93 */ "values ::= values COMMA LP nexprlist RP", + /* 94 */ "distinct ::= DISTINCT", + /* 95 */ "distinct ::= ALL", + /* 96 */ "distinct ::=", + /* 97 */ "sclp ::=", + /* 98 */ "selcollist ::= sclp scanpt expr scanpt as", + /* 99 */ "selcollist ::= sclp scanpt STAR", + /* 100 */ "selcollist ::= sclp scanpt nm DOT STAR", + /* 101 */ "as ::= AS nm", + /* 102 */ "as ::=", + /* 103 */ "from ::=", + /* 104 */ "from ::= FROM seltablist", + /* 105 */ "stl_prefix ::= seltablist joinop", + /* 106 */ "stl_prefix ::=", + /* 107 */ "seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt", + /* 108 */ "seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt", + /* 109 */ "seltablist ::= stl_prefix LP select RP as on_opt using_opt", + /* 110 */ "seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt", + /* 111 */ "dbnm ::=", + /* 112 */ "dbnm ::= DOT nm", + /* 113 */ "fullname ::= nm", + /* 114 */ "fullname ::= nm DOT nm", + /* 115 */ "xfullname ::= nm", + /* 116 */ "xfullname ::= nm DOT nm", + /* 117 */ "xfullname ::= nm DOT nm AS nm", + /* 118 */ "xfullname ::= nm AS nm", + /* 119 */ "joinop ::= COMMA|JOIN", + /* 120 */ "joinop ::= JOIN_KW JOIN", + /* 121 */ "joinop ::= JOIN_KW nm JOIN", + /* 122 */ "joinop ::= JOIN_KW nm nm JOIN", + /* 123 */ "on_opt ::= ON expr", + /* 124 */ "on_opt ::=", + /* 125 */ "indexed_opt ::=", + /* 126 */ "indexed_opt ::= INDEXED BY nm", + /* 127 */ "indexed_opt ::= NOT INDEXED", + /* 128 */ "using_opt ::= USING LP idlist RP", + /* 129 */ "using_opt ::=", + /* 130 */ "orderby_opt ::=", + /* 131 */ "orderby_opt ::= ORDER BY sortlist", + /* 132 */ "sortlist ::= sortlist COMMA expr sortorder nulls", + /* 133 */ "sortlist ::= expr sortorder nulls", + /* 134 */ "sortorder ::= ASC", + /* 135 */ "sortorder ::= DESC", + /* 136 */ "sortorder ::=", + /* 137 */ "nulls ::= NULLS FIRST", + /* 138 */ "nulls ::= NULLS LAST", + /* 139 */ "nulls ::=", + /* 140 */ "groupby_opt ::=", + /* 141 */ "groupby_opt ::= GROUP BY nexprlist", + /* 142 */ "having_opt ::=", + /* 143 */ "having_opt ::= HAVING expr", + /* 144 */ "limit_opt ::=", + /* 145 */ "limit_opt ::= LIMIT expr", + /* 146 */ "limit_opt ::= LIMIT expr OFFSET expr", + /* 147 */ "limit_opt ::= LIMIT expr COMMA expr", + /* 148 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt", + /* 149 */ "where_opt ::=", + /* 150 */ "where_opt ::= WHERE expr", + /* 151 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt", + /* 152 */ "setlist ::= setlist COMMA nm EQ expr", + /* 153 */ "setlist ::= setlist COMMA LP idlist RP EQ expr", + /* 154 */ "setlist ::= nm EQ expr", + /* 155 */ "setlist ::= LP idlist RP EQ expr", + /* 156 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert", + /* 157 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES", + /* 158 */ "upsert ::=", + /* 159 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt", + /* 160 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING", + /* 161 */ "upsert ::= ON CONFLICT DO NOTHING", + /* 162 */ "insert_cmd ::= INSERT orconf", + /* 163 */ "insert_cmd ::= REPLACE", + /* 164 */ "idlist_opt ::=", + /* 165 */ "idlist_opt ::= LP idlist RP", + /* 166 */ "idlist ::= idlist COMMA nm", + /* 167 */ "idlist ::= nm", + /* 168 */ "expr ::= LP expr RP", + /* 169 */ "expr ::= ID|INDEXED", + /* 170 */ "expr ::= JOIN_KW", + /* 171 */ "expr ::= nm DOT nm", + /* 172 */ "expr ::= nm DOT nm DOT nm", + /* 173 */ "term ::= NULL|FLOAT|BLOB", + /* 174 */ "term ::= STRING", + /* 175 */ "term ::= INTEGER", + /* 176 */ "expr ::= VARIABLE", + /* 177 */ "expr ::= expr COLLATE ID|STRING", + /* 178 */ "expr ::= CAST LP expr AS typetoken RP", + /* 179 */ "expr ::= ID|INDEXED LP distinct exprlist RP", + /* 180 */ "expr ::= ID|INDEXED LP STAR RP", + /* 181 */ "expr ::= ID|INDEXED LP distinct exprlist RP filter_over", + /* 182 */ "expr ::= ID|INDEXED LP STAR RP filter_over", + /* 183 */ "term ::= CTIME_KW", + /* 184 */ "expr ::= LP nexprlist COMMA expr RP", + /* 185 */ "expr ::= expr AND expr", + /* 186 */ "expr ::= expr OR expr", + /* 187 */ "expr ::= expr LT|GT|GE|LE expr", + /* 188 */ "expr ::= expr EQ|NE expr", + /* 189 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr", + /* 190 */ "expr ::= expr PLUS|MINUS expr", + /* 191 */ "expr ::= expr STAR|SLASH|REM expr", + /* 192 */ "expr ::= expr CONCAT expr", + /* 193 */ "likeop ::= NOT LIKE_KW|MATCH", + /* 194 */ "expr ::= expr likeop expr", + /* 195 */ "expr ::= expr likeop expr ESCAPE expr", + /* 196 */ "expr ::= expr ISNULL|NOTNULL", + /* 197 */ "expr ::= expr NOT NULL", + /* 198 */ "expr ::= expr IS expr", + /* 199 */ "expr ::= expr IS NOT expr", + /* 200 */ "expr ::= NOT expr", + /* 201 */ "expr ::= BITNOT expr", + /* 202 */ "expr ::= PLUS|MINUS expr", + /* 203 */ "between_op ::= BETWEEN", + /* 204 */ "between_op ::= NOT BETWEEN", + /* 205 */ "expr ::= expr between_op expr AND expr", + /* 206 */ "in_op ::= IN", + /* 207 */ "in_op ::= NOT IN", + /* 208 */ "expr ::= expr in_op LP exprlist RP", + /* 209 */ "expr ::= LP select RP", + /* 210 */ "expr ::= expr in_op LP select RP", + /* 211 */ "expr ::= expr in_op nm dbnm paren_exprlist", + /* 212 */ "expr ::= EXISTS LP select RP", + /* 213 */ "expr ::= CASE case_operand case_exprlist case_else END", + /* 214 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr", + /* 215 */ "case_exprlist ::= WHEN expr THEN expr", + /* 216 */ "case_else ::= ELSE expr", + /* 217 */ "case_else ::=", + /* 218 */ "case_operand ::= expr", + /* 219 */ "case_operand ::=", + /* 220 */ "exprlist ::=", + /* 221 */ "nexprlist ::= nexprlist COMMA expr", + /* 222 */ "nexprlist ::= expr", + /* 223 */ "paren_exprlist ::=", + /* 224 */ "paren_exprlist ::= LP exprlist RP", + /* 225 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt", + /* 226 */ "uniqueflag ::= UNIQUE", + /* 227 */ "uniqueflag ::=", + /* 228 */ "eidlist_opt ::=", + /* 229 */ "eidlist_opt ::= LP eidlist RP", + /* 230 */ "eidlist ::= eidlist COMMA nm collate sortorder", + /* 231 */ "eidlist ::= nm collate sortorder", + /* 232 */ "collate ::=", + /* 233 */ "collate ::= COLLATE ID|STRING", + /* 234 */ "cmd ::= DROP INDEX ifexists fullname", + /* 235 */ "cmd ::= VACUUM vinto", + /* 236 */ "cmd ::= VACUUM nm vinto", + /* 237 */ "vinto ::= INTO expr", + /* 238 */ "vinto ::=", + /* 239 */ "cmd ::= PRAGMA nm dbnm", + /* 240 */ "cmd ::= PRAGMA nm dbnm EQ nmnum", + /* 241 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP", + /* 242 */ "cmd ::= PRAGMA nm dbnm EQ minus_num", + /* 243 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP", + /* 244 */ "plus_num ::= PLUS INTEGER|FLOAT", + /* 245 */ "minus_num ::= MINUS INTEGER|FLOAT", + /* 246 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END", + /* 247 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause", + /* 248 */ "trigger_time ::= BEFORE|AFTER", + /* 249 */ "trigger_time ::= INSTEAD OF", + /* 250 */ "trigger_time ::=", + /* 251 */ "trigger_event ::= DELETE|INSERT", + /* 252 */ "trigger_event ::= UPDATE", + /* 253 */ "trigger_event ::= UPDATE OF idlist", + /* 254 */ "when_clause ::=", + /* 255 */ "when_clause ::= WHEN expr", + /* 256 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI", + /* 257 */ "trigger_cmd_list ::= trigger_cmd SEMI", + /* 258 */ "trnm ::= nm DOT nm", + /* 259 */ "tridxby ::= INDEXED BY nm", + /* 260 */ "tridxby ::= NOT INDEXED", + /* 261 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt", + /* 262 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt", + /* 263 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt", + /* 264 */ "trigger_cmd ::= scanpt select scanpt", + /* 265 */ "expr ::= RAISE LP IGNORE RP", + /* 266 */ "expr ::= RAISE LP raisetype COMMA nm RP", + /* 267 */ "raisetype ::= ROLLBACK", + /* 268 */ "raisetype ::= ABORT", + /* 269 */ "raisetype ::= FAIL", + /* 270 */ "cmd ::= DROP TRIGGER ifexists fullname", + /* 271 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt", + /* 272 */ "cmd ::= DETACH database_kw_opt expr", + /* 273 */ "key_opt ::=", + /* 274 */ "key_opt ::= KEY expr", + /* 275 */ "cmd ::= REINDEX", + /* 276 */ "cmd ::= REINDEX nm dbnm", + /* 277 */ "cmd ::= ANALYZE", + /* 278 */ "cmd ::= ANALYZE nm dbnm", + /* 279 */ "cmd ::= ALTER TABLE fullname RENAME TO nm", + /* 280 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist", + /* 281 */ "add_column_fullname ::= fullname", + /* 282 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm", + /* 283 */ "cmd ::= create_vtab", + /* 284 */ "cmd ::= create_vtab LP vtabarglist RP", + /* 285 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm", + /* 286 */ "vtabarg ::=", + /* 287 */ "vtabargtoken ::= ANY", + /* 288 */ "vtabargtoken ::= lp anylist RP", + /* 289 */ "lp ::= LP", + /* 290 */ "with ::= WITH wqlist", + /* 291 */ "with ::= WITH RECURSIVE wqlist", + /* 292 */ "wqlist ::= nm eidlist_opt AS LP select RP", + /* 293 */ "wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP", + /* 294 */ "windowdefn_list ::= windowdefn", + /* 295 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn", + /* 296 */ "windowdefn ::= nm AS LP window RP", + /* 297 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt", + /* 298 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt", + /* 299 */ "window ::= ORDER BY sortlist frame_opt", + /* 300 */ "window ::= nm ORDER BY sortlist frame_opt", + /* 301 */ "window ::= frame_opt", + /* 302 */ "window ::= nm frame_opt", + /* 303 */ "frame_opt ::=", + /* 304 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt", + /* 305 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt", + /* 306 */ "range_or_rows ::= RANGE|ROWS|GROUPS", + /* 307 */ "frame_bound_s ::= frame_bound", + /* 308 */ "frame_bound_s ::= UNBOUNDED PRECEDING", + /* 309 */ "frame_bound_e ::= frame_bound", + /* 310 */ "frame_bound_e ::= UNBOUNDED FOLLOWING", + /* 311 */ "frame_bound ::= expr PRECEDING|FOLLOWING", + /* 312 */ "frame_bound ::= CURRENT ROW", + /* 313 */ "frame_exclude_opt ::=", + /* 314 */ "frame_exclude_opt ::= EXCLUDE frame_exclude", + /* 315 */ "frame_exclude ::= NO OTHERS", + /* 316 */ "frame_exclude ::= CURRENT ROW", + /* 317 */ "frame_exclude ::= GROUP|TIES", + /* 318 */ "window_clause ::= WINDOW windowdefn_list", + /* 319 */ "filter_over ::= filter_clause over_clause", + /* 320 */ "filter_over ::= over_clause", + /* 321 */ "filter_over ::= filter_clause", + /* 322 */ "over_clause ::= OVER LP window RP", + /* 323 */ "over_clause ::= OVER nm", + /* 324 */ "filter_clause ::= FILTER LP WHERE expr RP", + /* 325 */ "input ::= cmdlist", + /* 326 */ "cmdlist ::= cmdlist ecmd", + /* 327 */ "cmdlist ::= ecmd", + /* 328 */ "ecmd ::= SEMI", + /* 329 */ "ecmd ::= cmdx SEMI", + /* 330 */ "ecmd ::= explain cmdx SEMI", + /* 331 */ "trans_opt ::=", + /* 332 */ "trans_opt ::= TRANSACTION", + /* 333 */ "trans_opt ::= TRANSACTION nm", + /* 334 */ "savepoint_opt ::= SAVEPOINT", + /* 335 */ "savepoint_opt ::=", + /* 336 */ "cmd ::= create_table create_table_args", + /* 337 */ "columnlist ::= columnlist COMMA columnname carglist", + /* 338 */ "columnlist ::= columnname carglist", + /* 339 */ "nm ::= ID|INDEXED", + /* 340 */ "nm ::= STRING", + /* 341 */ "nm ::= JOIN_KW", + /* 342 */ "typetoken ::= typename", + /* 343 */ "typename ::= ID|STRING", + /* 344 */ "signed ::= plus_num", + /* 345 */ "signed ::= minus_num", + /* 346 */ "carglist ::= carglist ccons", + /* 347 */ "carglist ::=", + /* 348 */ "ccons ::= NULL onconf", + /* 349 */ "ccons ::= GENERATED ALWAYS AS generated", + /* 350 */ "ccons ::= AS generated", + /* 351 */ "conslist_opt ::= COMMA conslist", + /* 352 */ "conslist ::= conslist tconscomma tcons", + /* 353 */ "conslist ::= tcons", + /* 354 */ "tconscomma ::=", + /* 355 */ "defer_subclause_opt ::= defer_subclause", + /* 356 */ "resolvetype ::= raisetype", + /* 357 */ "selectnowith ::= oneselect", + /* 358 */ "oneselect ::= values", + /* 359 */ "sclp ::= selcollist COMMA", + /* 360 */ "as ::= ID|STRING", + /* 361 */ "expr ::= term", + /* 362 */ "likeop ::= LIKE_KW|MATCH", + /* 363 */ "exprlist ::= nexprlist", + /* 364 */ "nmnum ::= plus_num", + /* 365 */ "nmnum ::= nm", + /* 366 */ "nmnum ::= ON", + /* 367 */ "nmnum ::= DELETE", + /* 368 */ "nmnum ::= DEFAULT", + /* 369 */ "plus_num ::= INTEGER|FLOAT", + /* 370 */ "foreach_clause ::=", + /* 371 */ "foreach_clause ::= FOR EACH ROW", + /* 372 */ "trnm ::= nm", + /* 373 */ "tridxby ::=", + /* 374 */ "database_kw_opt ::= DATABASE", + /* 375 */ "database_kw_opt ::=", + /* 376 */ "kwcolumn_opt ::=", + /* 377 */ "kwcolumn_opt ::= COLUMNKW", + /* 378 */ "vtabarglist ::= vtabarg", + /* 379 */ "vtabarglist ::= vtabarglist COMMA vtabarg", + /* 380 */ "vtabarg ::= vtabarg vtabargtoken", + /* 381 */ "anylist ::=", + /* 382 */ "anylist ::= anylist LP anylist RP", + /* 383 */ "anylist ::= anylist ANY", + /* 384 */ "with ::=", +}; +#endif /* NDEBUG */ + + +#if YYSTACKDEPTH<=0 +/* +** Try to increase the size of the parser stack. Return the number +** of errors. Return 0 on success. +*/ +static int yyGrowStack(yyParser *p){ + int newSize; + int idx; + yyStackEntry *pNew; + + newSize = p->yystksz*2 + 100; + idx = p->yytos ? (int)(p->yytos - p->yystack) : 0; + if( p->yystack==&p->yystk0 ){ + pNew = malloc(newSize*sizeof(pNew[0])); + if( pNew ) pNew[0] = p->yystk0; + }else{ + pNew = realloc(p->yystack, newSize*sizeof(pNew[0])); + } + if( pNew ){ + p->yystack = pNew; + p->yytos = &p->yystack[idx]; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n", + yyTracePrompt, p->yystksz, newSize); + } +#endif + p->yystksz = newSize; + } + return pNew==0; +} +#endif + +/* Datatype of the argument to the memory allocated passed as the +** second argument to sqlite3ParserAlloc() below. This can be changed by +** putting an appropriate #define in the %include section of the input +** grammar. +*/ +#ifndef YYMALLOCARGTYPE +# define YYMALLOCARGTYPE size_t +#endif + +/* Initialize a new parser that has already been allocated. +*/ +SQLITE_PRIVATE void sqlite3ParserInit(void *yypRawParser sqlite3ParserCTX_PDECL){ + yyParser *yypParser = (yyParser*)yypRawParser; + sqlite3ParserCTX_STORE +#ifdef YYTRACKMAXSTACKDEPTH + yypParser->yyhwm = 0; +#endif +#if YYSTACKDEPTH<=0 + yypParser->yytos = NULL; + yypParser->yystack = NULL; + yypParser->yystksz = 0; + if( yyGrowStack(yypParser) ){ + yypParser->yystack = &yypParser->yystk0; + yypParser->yystksz = 1; + } +#endif +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt = -1; +#endif + yypParser->yytos = yypParser->yystack; + yypParser->yystack[0].stateno = 0; + yypParser->yystack[0].major = 0; +#if YYSTACKDEPTH>0 + yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1]; +#endif +} + +#ifndef sqlite3Parser_ENGINEALWAYSONSTACK +/* +** This function allocates a new parser. +** The only argument is a pointer to a function which works like +** malloc. +** +** Inputs: +** A pointer to the function used to allocate memory. +** +** Outputs: +** A pointer to a parser. This pointer is used in subsequent calls +** to sqlite3Parser and sqlite3ParserFree. +*/ +SQLITE_PRIVATE void *sqlite3ParserAlloc(void *(*mallocProc)(YYMALLOCARGTYPE) sqlite3ParserCTX_PDECL){ + yyParser *yypParser; + yypParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) ); + if( yypParser ){ + sqlite3ParserCTX_STORE + sqlite3ParserInit(yypParser sqlite3ParserCTX_PARAM); + } + return (void*)yypParser; +} +#endif /* sqlite3Parser_ENGINEALWAYSONSTACK */ + + +/* The following function deletes the "minor type" or semantic value +** associated with a symbol. The symbol can be either a terminal +** or nonterminal. "yymajor" is the symbol code, and "yypminor" is +** a pointer to the value to be deleted. The code used to do the +** deletions is derived from the %destructor and/or %token_destructor +** directives of the input grammar. +*/ +static void yy_destructor( + yyParser *yypParser, /* The parser */ + YYCODETYPE yymajor, /* Type code for object to destroy */ + YYMINORTYPE *yypminor /* The object to be destroyed */ +){ + sqlite3ParserARG_FETCH + sqlite3ParserCTX_FETCH + switch( yymajor ){ + /* Here is inserted the actions which take place when a + ** terminal or non-terminal is destroyed. This can happen + ** when the symbol is popped from the stack during a + ** reduce or during error processing or when a parser is + ** being destroyed before it is finished parsing. + ** + ** Note: during a reduce, the only symbols destroyed are those + ** which appear on the RHS of the rule, but which are *not* used + ** inside the C code. + */ +/********* Begin destructor definitions ***************************************/ + case 200: /* select */ + case 234: /* selectnowith */ + case 235: /* oneselect */ + case 247: /* values */ +{ +sqlite3SelectDelete(pParse->db, (yypminor->yy539)); +} + break; + case 211: /* term */ + case 212: /* expr */ + case 241: /* where_opt */ + case 243: /* having_opt */ + case 255: /* on_opt */ + case 271: /* case_operand */ + case 273: /* case_else */ + case 276: /* vinto */ + case 283: /* when_clause */ + case 288: /* key_opt */ + case 302: /* filter_clause */ +{ +sqlite3ExprDelete(pParse->db, (yypminor->yy202)); +} + break; + case 216: /* eidlist_opt */ + case 226: /* sortlist */ + case 227: /* eidlist */ + case 239: /* selcollist */ + case 242: /* groupby_opt */ + case 244: /* orderby_opt */ + case 248: /* nexprlist */ + case 249: /* sclp */ + case 257: /* exprlist */ + case 262: /* setlist */ + case 270: /* paren_exprlist */ + case 272: /* case_exprlist */ + case 301: /* part_opt */ +{ +sqlite3ExprListDelete(pParse->db, (yypminor->yy242)); +} + break; + case 233: /* fullname */ + case 240: /* from */ + case 251: /* seltablist */ + case 252: /* stl_prefix */ + case 258: /* xfullname */ +{ +sqlite3SrcListDelete(pParse->db, (yypminor->yy47)); +} + break; + case 236: /* wqlist */ +{ +sqlite3WithDelete(pParse->db, (yypminor->yy131)); +} + break; + case 246: /* window_clause */ + case 297: /* windowdefn_list */ +{ +sqlite3WindowListDelete(pParse->db, (yypminor->yy303)); +} + break; + case 256: /* using_opt */ + case 259: /* idlist */ + case 264: /* idlist_opt */ +{ +sqlite3IdListDelete(pParse->db, (yypminor->yy600)); +} + break; + case 266: /* filter_over */ + case 298: /* windowdefn */ + case 299: /* window */ + case 300: /* frame_opt */ + case 303: /* over_clause */ +{ +sqlite3WindowDelete(pParse->db, (yypminor->yy303)); +} + break; + case 279: /* trigger_cmd_list */ + case 284: /* trigger_cmd */ +{ +sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy447)); +} + break; + case 281: /* trigger_event */ +{ +sqlite3IdListDelete(pParse->db, (yypminor->yy230).b); +} + break; + case 305: /* frame_bound */ + case 306: /* frame_bound_s */ + case 307: /* frame_bound_e */ +{ +sqlite3ExprDelete(pParse->db, (yypminor->yy77).pExpr); +} + break; +/********* End destructor definitions *****************************************/ + default: break; /* If no destructor action specified: do nothing */ + } +} + +/* +** Pop the parser's stack once. +** +** If there is a destructor routine associated with the token which +** is popped from the stack, then call it. +*/ +static void yy_pop_parser_stack(yyParser *pParser){ + yyStackEntry *yytos; + assert( pParser->yytos!=0 ); + assert( pParser->yytos > pParser->yystack ); + yytos = pParser->yytos--; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sPopping %s\n", + yyTracePrompt, + yyTokenName[yytos->major]); + } +#endif + yy_destructor(pParser, yytos->major, &yytos->minor); +} + +/* +** Clear all secondary memory allocations from the parser +*/ +SQLITE_PRIVATE void sqlite3ParserFinalize(void *p){ + yyParser *pParser = (yyParser*)p; + while( pParser->yytos>pParser->yystack ) yy_pop_parser_stack(pParser); +#if YYSTACKDEPTH<=0 + if( pParser->yystack!=&pParser->yystk0 ) free(pParser->yystack); +#endif +} + +#ifndef sqlite3Parser_ENGINEALWAYSONSTACK +/* +** Deallocate and destroy a parser. Destructors are called for +** all stack elements before shutting the parser down. +** +** If the YYPARSEFREENEVERNULL macro exists (for example because it +** is defined in a %include section of the input grammar) then it is +** assumed that the input pointer is never NULL. +*/ +SQLITE_PRIVATE void sqlite3ParserFree( + void *p, /* The parser to be deleted */ + void (*freeProc)(void*) /* Function used to reclaim memory */ +){ +#ifndef YYPARSEFREENEVERNULL + if( p==0 ) return; +#endif + sqlite3ParserFinalize(p); + (*freeProc)(p); +} +#endif /* sqlite3Parser_ENGINEALWAYSONSTACK */ + +/* +** Return the peak depth of the stack for a parser. +*/ +#ifdef YYTRACKMAXSTACKDEPTH +SQLITE_PRIVATE int sqlite3ParserStackPeak(void *p){ + yyParser *pParser = (yyParser*)p; + return pParser->yyhwm; +} +#endif + +/* This array of booleans keeps track of the parser statement +** coverage. The element yycoverage[X][Y] is set when the parser +** is in state X and has a lookahead token Y. In a well-tested +** systems, every element of this matrix should end up being set. +*/ +#if defined(YYCOVERAGE) +static unsigned char yycoverage[YYNSTATE][YYNTOKEN]; +#endif + +/* +** Write into out a description of every state/lookahead combination that +** +** (1) has not been used by the parser, and +** (2) is not a syntax error. +** +** Return the number of missed state/lookahead combinations. +*/ +#if defined(YYCOVERAGE) +SQLITE_PRIVATE int sqlite3ParserCoverage(FILE *out){ + int stateno, iLookAhead, i; + int nMissed = 0; + for(stateno=0; statenoYY_MAX_SHIFT ) return stateno; + assert( stateno <= YY_SHIFT_COUNT ); +#if defined(YYCOVERAGE) + yycoverage[stateno][iLookAhead] = 1; +#endif + do{ + i = yy_shift_ofst[stateno]; + assert( i>=0 ); + assert( i<=YY_ACTTAB_COUNT ); + assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD ); + assert( iLookAhead!=YYNOCODE ); + assert( iLookAhead < YYNTOKEN ); + i += iLookAhead; + assert( i<(int)YY_NLOOKAHEAD ); + if( yy_lookahead[i]!=iLookAhead ){ +#ifdef YYFALLBACK + YYCODETYPE iFallback; /* Fallback token */ + assert( iLookAhead %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]); + } +#endif + assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */ + iLookAhead = iFallback; + continue; + } +#endif +#ifdef YYWILDCARD + { + int j = i - iLookAhead + YYWILDCARD; + assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) ); + if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n", + yyTracePrompt, yyTokenName[iLookAhead], + yyTokenName[YYWILDCARD]); + } +#endif /* NDEBUG */ + return yy_action[j]; + } + } +#endif /* YYWILDCARD */ + return yy_default[stateno]; + }else{ + assert( i>=0 && i<(int)(sizeof(yy_action)/sizeof(yy_action[0])) ); + return yy_action[i]; + } + }while(1); +} + +/* +** Find the appropriate action for a parser given the non-terminal +** look-ahead token iLookAhead. +*/ +static YYACTIONTYPE yy_find_reduce_action( + YYACTIONTYPE stateno, /* Current state number */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; +#ifdef YYERRORSYMBOL + if( stateno>YY_REDUCE_COUNT ){ + return yy_default[stateno]; + } +#else + assert( stateno<=YY_REDUCE_COUNT ); +#endif + i = yy_reduce_ofst[stateno]; + assert( iLookAhead!=YYNOCODE ); + i += iLookAhead; +#ifdef YYERRORSYMBOL + if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){ + return yy_default[stateno]; + } +#else + assert( i>=0 && iyytos>yypParser->yystack ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will execute if the parser + ** stack every overflows */ +/******** Begin %stack_overflow code ******************************************/ + + sqlite3ErrorMsg(pParse, "parser stack overflow"); +/******** End %stack_overflow code ********************************************/ + sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument var */ + sqlite3ParserCTX_STORE +} + +/* +** Print tracing information for a SHIFT action +*/ +#ifndef NDEBUG +static void yyTraceShift(yyParser *yypParser, int yyNewState, const char *zTag){ + if( yyTraceFILE ){ + if( yyNewStateyytos->major], + yyNewState); + }else{ + fprintf(yyTraceFILE,"%s%s '%s', pending reduce %d\n", + yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major], + yyNewState - YY_MIN_REDUCE); + } + } +} +#else +# define yyTraceShift(X,Y,Z) +#endif + +/* +** Perform a shift action. +*/ +static void yy_shift( + yyParser *yypParser, /* The parser to be shifted */ + YYACTIONTYPE yyNewState, /* The new state to shift in */ + YYCODETYPE yyMajor, /* The major token to shift in */ + sqlite3ParserTOKENTYPE yyMinor /* The minor token to shift in */ +){ + yyStackEntry *yytos; + yypParser->yytos++; +#ifdef YYTRACKMAXSTACKDEPTH + if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){ + yypParser->yyhwm++; + assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) ); + } +#endif +#if YYSTACKDEPTH>0 + if( yypParser->yytos>yypParser->yystackEnd ){ + yypParser->yytos--; + yyStackOverflow(yypParser); + return; + } +#else + if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz] ){ + if( yyGrowStack(yypParser) ){ + yypParser->yytos--; + yyStackOverflow(yypParser); + return; + } + } +#endif + if( yyNewState > YY_MAX_SHIFT ){ + yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE; + } + yytos = yypParser->yytos; + yytos->stateno = yyNewState; + yytos->major = yyMajor; + yytos->minor.yy0 = yyMinor; + yyTraceShift(yypParser, yyNewState, "Shift"); +} + +/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side +** of that rule */ +static const YYCODETYPE yyRuleInfoLhs[] = { + 185, /* (0) explain ::= EXPLAIN */ + 185, /* (1) explain ::= EXPLAIN QUERY PLAN */ + 184, /* (2) cmdx ::= cmd */ + 186, /* (3) cmd ::= BEGIN transtype trans_opt */ + 187, /* (4) transtype ::= */ + 187, /* (5) transtype ::= DEFERRED */ + 187, /* (6) transtype ::= IMMEDIATE */ + 187, /* (7) transtype ::= EXCLUSIVE */ + 186, /* (8) cmd ::= COMMIT|END trans_opt */ + 186, /* (9) cmd ::= ROLLBACK trans_opt */ + 186, /* (10) cmd ::= SAVEPOINT nm */ + 186, /* (11) cmd ::= RELEASE savepoint_opt nm */ + 186, /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */ + 191, /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */ + 193, /* (14) createkw ::= CREATE */ + 195, /* (15) ifnotexists ::= */ + 195, /* (16) ifnotexists ::= IF NOT EXISTS */ + 194, /* (17) temp ::= TEMP */ + 194, /* (18) temp ::= */ + 192, /* (19) create_table_args ::= LP columnlist conslist_opt RP table_options */ + 192, /* (20) create_table_args ::= AS select */ + 199, /* (21) table_options ::= */ + 199, /* (22) table_options ::= WITHOUT nm */ + 201, /* (23) columnname ::= nm typetoken */ + 203, /* (24) typetoken ::= */ + 203, /* (25) typetoken ::= typename LP signed RP */ + 203, /* (26) typetoken ::= typename LP signed COMMA signed RP */ + 204, /* (27) typename ::= typename ID|STRING */ + 208, /* (28) scanpt ::= */ + 209, /* (29) scantok ::= */ + 210, /* (30) ccons ::= CONSTRAINT nm */ + 210, /* (31) ccons ::= DEFAULT scantok term */ + 210, /* (32) ccons ::= DEFAULT LP expr RP */ + 210, /* (33) ccons ::= DEFAULT PLUS scantok term */ + 210, /* (34) ccons ::= DEFAULT MINUS scantok term */ + 210, /* (35) ccons ::= DEFAULT scantok ID|INDEXED */ + 210, /* (36) ccons ::= NOT NULL onconf */ + 210, /* (37) ccons ::= PRIMARY KEY sortorder onconf autoinc */ + 210, /* (38) ccons ::= UNIQUE onconf */ + 210, /* (39) ccons ::= CHECK LP expr RP */ + 210, /* (40) ccons ::= REFERENCES nm eidlist_opt refargs */ + 210, /* (41) ccons ::= defer_subclause */ + 210, /* (42) ccons ::= COLLATE ID|STRING */ + 219, /* (43) generated ::= LP expr RP */ + 219, /* (44) generated ::= LP expr RP ID */ + 215, /* (45) autoinc ::= */ + 215, /* (46) autoinc ::= AUTOINCR */ + 217, /* (47) refargs ::= */ + 217, /* (48) refargs ::= refargs refarg */ + 220, /* (49) refarg ::= MATCH nm */ + 220, /* (50) refarg ::= ON INSERT refact */ + 220, /* (51) refarg ::= ON DELETE refact */ + 220, /* (52) refarg ::= ON UPDATE refact */ + 221, /* (53) refact ::= SET NULL */ + 221, /* (54) refact ::= SET DEFAULT */ + 221, /* (55) refact ::= CASCADE */ + 221, /* (56) refact ::= RESTRICT */ + 221, /* (57) refact ::= NO ACTION */ + 218, /* (58) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ + 218, /* (59) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ + 222, /* (60) init_deferred_pred_opt ::= */ + 222, /* (61) init_deferred_pred_opt ::= INITIALLY DEFERRED */ + 222, /* (62) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ + 198, /* (63) conslist_opt ::= */ + 224, /* (64) tconscomma ::= COMMA */ + 225, /* (65) tcons ::= CONSTRAINT nm */ + 225, /* (66) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ + 225, /* (67) tcons ::= UNIQUE LP sortlist RP onconf */ + 225, /* (68) tcons ::= CHECK LP expr RP onconf */ + 225, /* (69) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ + 228, /* (70) defer_subclause_opt ::= */ + 213, /* (71) onconf ::= */ + 213, /* (72) onconf ::= ON CONFLICT resolvetype */ + 229, /* (73) orconf ::= */ + 229, /* (74) orconf ::= OR resolvetype */ + 230, /* (75) resolvetype ::= IGNORE */ + 230, /* (76) resolvetype ::= REPLACE */ + 186, /* (77) cmd ::= DROP TABLE ifexists fullname */ + 232, /* (78) ifexists ::= IF EXISTS */ + 232, /* (79) ifexists ::= */ + 186, /* (80) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ + 186, /* (81) cmd ::= DROP VIEW ifexists fullname */ + 186, /* (82) cmd ::= select */ + 200, /* (83) select ::= WITH wqlist selectnowith */ + 200, /* (84) select ::= WITH RECURSIVE wqlist selectnowith */ + 200, /* (85) select ::= selectnowith */ + 234, /* (86) selectnowith ::= selectnowith multiselect_op oneselect */ + 237, /* (87) multiselect_op ::= UNION */ + 237, /* (88) multiselect_op ::= UNION ALL */ + 237, /* (89) multiselect_op ::= EXCEPT|INTERSECT */ + 235, /* (90) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ + 235, /* (91) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ + 247, /* (92) values ::= VALUES LP nexprlist RP */ + 247, /* (93) values ::= values COMMA LP nexprlist RP */ + 238, /* (94) distinct ::= DISTINCT */ + 238, /* (95) distinct ::= ALL */ + 238, /* (96) distinct ::= */ + 249, /* (97) sclp ::= */ + 239, /* (98) selcollist ::= sclp scanpt expr scanpt as */ + 239, /* (99) selcollist ::= sclp scanpt STAR */ + 239, /* (100) selcollist ::= sclp scanpt nm DOT STAR */ + 250, /* (101) as ::= AS nm */ + 250, /* (102) as ::= */ + 240, /* (103) from ::= */ + 240, /* (104) from ::= FROM seltablist */ + 252, /* (105) stl_prefix ::= seltablist joinop */ + 252, /* (106) stl_prefix ::= */ + 251, /* (107) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */ + 251, /* (108) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */ + 251, /* (109) seltablist ::= stl_prefix LP select RP as on_opt using_opt */ + 251, /* (110) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */ + 196, /* (111) dbnm ::= */ + 196, /* (112) dbnm ::= DOT nm */ + 233, /* (113) fullname ::= nm */ + 233, /* (114) fullname ::= nm DOT nm */ + 258, /* (115) xfullname ::= nm */ + 258, /* (116) xfullname ::= nm DOT nm */ + 258, /* (117) xfullname ::= nm DOT nm AS nm */ + 258, /* (118) xfullname ::= nm AS nm */ + 253, /* (119) joinop ::= COMMA|JOIN */ + 253, /* (120) joinop ::= JOIN_KW JOIN */ + 253, /* (121) joinop ::= JOIN_KW nm JOIN */ + 253, /* (122) joinop ::= JOIN_KW nm nm JOIN */ + 255, /* (123) on_opt ::= ON expr */ + 255, /* (124) on_opt ::= */ + 254, /* (125) indexed_opt ::= */ + 254, /* (126) indexed_opt ::= INDEXED BY nm */ + 254, /* (127) indexed_opt ::= NOT INDEXED */ + 256, /* (128) using_opt ::= USING LP idlist RP */ + 256, /* (129) using_opt ::= */ + 244, /* (130) orderby_opt ::= */ + 244, /* (131) orderby_opt ::= ORDER BY sortlist */ + 226, /* (132) sortlist ::= sortlist COMMA expr sortorder nulls */ + 226, /* (133) sortlist ::= expr sortorder nulls */ + 214, /* (134) sortorder ::= ASC */ + 214, /* (135) sortorder ::= DESC */ + 214, /* (136) sortorder ::= */ + 260, /* (137) nulls ::= NULLS FIRST */ + 260, /* (138) nulls ::= NULLS LAST */ + 260, /* (139) nulls ::= */ + 242, /* (140) groupby_opt ::= */ + 242, /* (141) groupby_opt ::= GROUP BY nexprlist */ + 243, /* (142) having_opt ::= */ + 243, /* (143) having_opt ::= HAVING expr */ + 245, /* (144) limit_opt ::= */ + 245, /* (145) limit_opt ::= LIMIT expr */ + 245, /* (146) limit_opt ::= LIMIT expr OFFSET expr */ + 245, /* (147) limit_opt ::= LIMIT expr COMMA expr */ + 186, /* (148) cmd ::= with DELETE FROM xfullname indexed_opt where_opt */ + 241, /* (149) where_opt ::= */ + 241, /* (150) where_opt ::= WHERE expr */ + 186, /* (151) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt */ + 262, /* (152) setlist ::= setlist COMMA nm EQ expr */ + 262, /* (153) setlist ::= setlist COMMA LP idlist RP EQ expr */ + 262, /* (154) setlist ::= nm EQ expr */ + 262, /* (155) setlist ::= LP idlist RP EQ expr */ + 186, /* (156) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ + 186, /* (157) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES */ + 265, /* (158) upsert ::= */ + 265, /* (159) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt */ + 265, /* (160) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING */ + 265, /* (161) upsert ::= ON CONFLICT DO NOTHING */ + 263, /* (162) insert_cmd ::= INSERT orconf */ + 263, /* (163) insert_cmd ::= REPLACE */ + 264, /* (164) idlist_opt ::= */ + 264, /* (165) idlist_opt ::= LP idlist RP */ + 259, /* (166) idlist ::= idlist COMMA nm */ + 259, /* (167) idlist ::= nm */ + 212, /* (168) expr ::= LP expr RP */ + 212, /* (169) expr ::= ID|INDEXED */ + 212, /* (170) expr ::= JOIN_KW */ + 212, /* (171) expr ::= nm DOT nm */ + 212, /* (172) expr ::= nm DOT nm DOT nm */ + 211, /* (173) term ::= NULL|FLOAT|BLOB */ + 211, /* (174) term ::= STRING */ + 211, /* (175) term ::= INTEGER */ + 212, /* (176) expr ::= VARIABLE */ + 212, /* (177) expr ::= expr COLLATE ID|STRING */ + 212, /* (178) expr ::= CAST LP expr AS typetoken RP */ + 212, /* (179) expr ::= ID|INDEXED LP distinct exprlist RP */ + 212, /* (180) expr ::= ID|INDEXED LP STAR RP */ + 212, /* (181) expr ::= ID|INDEXED LP distinct exprlist RP filter_over */ + 212, /* (182) expr ::= ID|INDEXED LP STAR RP filter_over */ + 211, /* (183) term ::= CTIME_KW */ + 212, /* (184) expr ::= LP nexprlist COMMA expr RP */ + 212, /* (185) expr ::= expr AND expr */ + 212, /* (186) expr ::= expr OR expr */ + 212, /* (187) expr ::= expr LT|GT|GE|LE expr */ + 212, /* (188) expr ::= expr EQ|NE expr */ + 212, /* (189) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ + 212, /* (190) expr ::= expr PLUS|MINUS expr */ + 212, /* (191) expr ::= expr STAR|SLASH|REM expr */ + 212, /* (192) expr ::= expr CONCAT expr */ + 267, /* (193) likeop ::= NOT LIKE_KW|MATCH */ + 212, /* (194) expr ::= expr likeop expr */ + 212, /* (195) expr ::= expr likeop expr ESCAPE expr */ + 212, /* (196) expr ::= expr ISNULL|NOTNULL */ + 212, /* (197) expr ::= expr NOT NULL */ + 212, /* (198) expr ::= expr IS expr */ + 212, /* (199) expr ::= expr IS NOT expr */ + 212, /* (200) expr ::= NOT expr */ + 212, /* (201) expr ::= BITNOT expr */ + 212, /* (202) expr ::= PLUS|MINUS expr */ + 268, /* (203) between_op ::= BETWEEN */ + 268, /* (204) between_op ::= NOT BETWEEN */ + 212, /* (205) expr ::= expr between_op expr AND expr */ + 269, /* (206) in_op ::= IN */ + 269, /* (207) in_op ::= NOT IN */ + 212, /* (208) expr ::= expr in_op LP exprlist RP */ + 212, /* (209) expr ::= LP select RP */ + 212, /* (210) expr ::= expr in_op LP select RP */ + 212, /* (211) expr ::= expr in_op nm dbnm paren_exprlist */ + 212, /* (212) expr ::= EXISTS LP select RP */ + 212, /* (213) expr ::= CASE case_operand case_exprlist case_else END */ + 272, /* (214) case_exprlist ::= case_exprlist WHEN expr THEN expr */ + 272, /* (215) case_exprlist ::= WHEN expr THEN expr */ + 273, /* (216) case_else ::= ELSE expr */ + 273, /* (217) case_else ::= */ + 271, /* (218) case_operand ::= expr */ + 271, /* (219) case_operand ::= */ + 257, /* (220) exprlist ::= */ + 248, /* (221) nexprlist ::= nexprlist COMMA expr */ + 248, /* (222) nexprlist ::= expr */ + 270, /* (223) paren_exprlist ::= */ + 270, /* (224) paren_exprlist ::= LP exprlist RP */ + 186, /* (225) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ + 274, /* (226) uniqueflag ::= UNIQUE */ + 274, /* (227) uniqueflag ::= */ + 216, /* (228) eidlist_opt ::= */ + 216, /* (229) eidlist_opt ::= LP eidlist RP */ + 227, /* (230) eidlist ::= eidlist COMMA nm collate sortorder */ + 227, /* (231) eidlist ::= nm collate sortorder */ + 275, /* (232) collate ::= */ + 275, /* (233) collate ::= COLLATE ID|STRING */ + 186, /* (234) cmd ::= DROP INDEX ifexists fullname */ + 186, /* (235) cmd ::= VACUUM vinto */ + 186, /* (236) cmd ::= VACUUM nm vinto */ + 276, /* (237) vinto ::= INTO expr */ + 276, /* (238) vinto ::= */ + 186, /* (239) cmd ::= PRAGMA nm dbnm */ + 186, /* (240) cmd ::= PRAGMA nm dbnm EQ nmnum */ + 186, /* (241) cmd ::= PRAGMA nm dbnm LP nmnum RP */ + 186, /* (242) cmd ::= PRAGMA nm dbnm EQ minus_num */ + 186, /* (243) cmd ::= PRAGMA nm dbnm LP minus_num RP */ + 206, /* (244) plus_num ::= PLUS INTEGER|FLOAT */ + 207, /* (245) minus_num ::= MINUS INTEGER|FLOAT */ + 186, /* (246) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ + 278, /* (247) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ + 280, /* (248) trigger_time ::= BEFORE|AFTER */ + 280, /* (249) trigger_time ::= INSTEAD OF */ + 280, /* (250) trigger_time ::= */ + 281, /* (251) trigger_event ::= DELETE|INSERT */ + 281, /* (252) trigger_event ::= UPDATE */ + 281, /* (253) trigger_event ::= UPDATE OF idlist */ + 283, /* (254) when_clause ::= */ + 283, /* (255) when_clause ::= WHEN expr */ + 279, /* (256) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ + 279, /* (257) trigger_cmd_list ::= trigger_cmd SEMI */ + 285, /* (258) trnm ::= nm DOT nm */ + 286, /* (259) tridxby ::= INDEXED BY nm */ + 286, /* (260) tridxby ::= NOT INDEXED */ + 284, /* (261) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ + 284, /* (262) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ + 284, /* (263) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ + 284, /* (264) trigger_cmd ::= scanpt select scanpt */ + 212, /* (265) expr ::= RAISE LP IGNORE RP */ + 212, /* (266) expr ::= RAISE LP raisetype COMMA nm RP */ + 231, /* (267) raisetype ::= ROLLBACK */ + 231, /* (268) raisetype ::= ABORT */ + 231, /* (269) raisetype ::= FAIL */ + 186, /* (270) cmd ::= DROP TRIGGER ifexists fullname */ + 186, /* (271) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ + 186, /* (272) cmd ::= DETACH database_kw_opt expr */ + 288, /* (273) key_opt ::= */ + 288, /* (274) key_opt ::= KEY expr */ + 186, /* (275) cmd ::= REINDEX */ + 186, /* (276) cmd ::= REINDEX nm dbnm */ + 186, /* (277) cmd ::= ANALYZE */ + 186, /* (278) cmd ::= ANALYZE nm dbnm */ + 186, /* (279) cmd ::= ALTER TABLE fullname RENAME TO nm */ + 186, /* (280) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ + 289, /* (281) add_column_fullname ::= fullname */ + 186, /* (282) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ + 186, /* (283) cmd ::= create_vtab */ + 186, /* (284) cmd ::= create_vtab LP vtabarglist RP */ + 291, /* (285) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ + 293, /* (286) vtabarg ::= */ + 294, /* (287) vtabargtoken ::= ANY */ + 294, /* (288) vtabargtoken ::= lp anylist RP */ + 295, /* (289) lp ::= LP */ + 261, /* (290) with ::= WITH wqlist */ + 261, /* (291) with ::= WITH RECURSIVE wqlist */ + 236, /* (292) wqlist ::= nm eidlist_opt AS LP select RP */ + 236, /* (293) wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */ + 297, /* (294) windowdefn_list ::= windowdefn */ + 297, /* (295) windowdefn_list ::= windowdefn_list COMMA windowdefn */ + 298, /* (296) windowdefn ::= nm AS LP window RP */ + 299, /* (297) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ + 299, /* (298) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ + 299, /* (299) window ::= ORDER BY sortlist frame_opt */ + 299, /* (300) window ::= nm ORDER BY sortlist frame_opt */ + 299, /* (301) window ::= frame_opt */ + 299, /* (302) window ::= nm frame_opt */ + 300, /* (303) frame_opt ::= */ + 300, /* (304) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ + 300, /* (305) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ + 304, /* (306) range_or_rows ::= RANGE|ROWS|GROUPS */ + 306, /* (307) frame_bound_s ::= frame_bound */ + 306, /* (308) frame_bound_s ::= UNBOUNDED PRECEDING */ + 307, /* (309) frame_bound_e ::= frame_bound */ + 307, /* (310) frame_bound_e ::= UNBOUNDED FOLLOWING */ + 305, /* (311) frame_bound ::= expr PRECEDING|FOLLOWING */ + 305, /* (312) frame_bound ::= CURRENT ROW */ + 308, /* (313) frame_exclude_opt ::= */ + 308, /* (314) frame_exclude_opt ::= EXCLUDE frame_exclude */ + 309, /* (315) frame_exclude ::= NO OTHERS */ + 309, /* (316) frame_exclude ::= CURRENT ROW */ + 309, /* (317) frame_exclude ::= GROUP|TIES */ + 246, /* (318) window_clause ::= WINDOW windowdefn_list */ + 266, /* (319) filter_over ::= filter_clause over_clause */ + 266, /* (320) filter_over ::= over_clause */ + 266, /* (321) filter_over ::= filter_clause */ + 303, /* (322) over_clause ::= OVER LP window RP */ + 303, /* (323) over_clause ::= OVER nm */ + 302, /* (324) filter_clause ::= FILTER LP WHERE expr RP */ + 181, /* (325) input ::= cmdlist */ + 182, /* (326) cmdlist ::= cmdlist ecmd */ + 182, /* (327) cmdlist ::= ecmd */ + 183, /* (328) ecmd ::= SEMI */ + 183, /* (329) ecmd ::= cmdx SEMI */ + 183, /* (330) ecmd ::= explain cmdx SEMI */ + 188, /* (331) trans_opt ::= */ + 188, /* (332) trans_opt ::= TRANSACTION */ + 188, /* (333) trans_opt ::= TRANSACTION nm */ + 190, /* (334) savepoint_opt ::= SAVEPOINT */ + 190, /* (335) savepoint_opt ::= */ + 186, /* (336) cmd ::= create_table create_table_args */ + 197, /* (337) columnlist ::= columnlist COMMA columnname carglist */ + 197, /* (338) columnlist ::= columnname carglist */ + 189, /* (339) nm ::= ID|INDEXED */ + 189, /* (340) nm ::= STRING */ + 189, /* (341) nm ::= JOIN_KW */ + 203, /* (342) typetoken ::= typename */ + 204, /* (343) typename ::= ID|STRING */ + 205, /* (344) signed ::= plus_num */ + 205, /* (345) signed ::= minus_num */ + 202, /* (346) carglist ::= carglist ccons */ + 202, /* (347) carglist ::= */ + 210, /* (348) ccons ::= NULL onconf */ + 210, /* (349) ccons ::= GENERATED ALWAYS AS generated */ + 210, /* (350) ccons ::= AS generated */ + 198, /* (351) conslist_opt ::= COMMA conslist */ + 223, /* (352) conslist ::= conslist tconscomma tcons */ + 223, /* (353) conslist ::= tcons */ + 224, /* (354) tconscomma ::= */ + 228, /* (355) defer_subclause_opt ::= defer_subclause */ + 230, /* (356) resolvetype ::= raisetype */ + 234, /* (357) selectnowith ::= oneselect */ + 235, /* (358) oneselect ::= values */ + 249, /* (359) sclp ::= selcollist COMMA */ + 250, /* (360) as ::= ID|STRING */ + 212, /* (361) expr ::= term */ + 267, /* (362) likeop ::= LIKE_KW|MATCH */ + 257, /* (363) exprlist ::= nexprlist */ + 277, /* (364) nmnum ::= plus_num */ + 277, /* (365) nmnum ::= nm */ + 277, /* (366) nmnum ::= ON */ + 277, /* (367) nmnum ::= DELETE */ + 277, /* (368) nmnum ::= DEFAULT */ + 206, /* (369) plus_num ::= INTEGER|FLOAT */ + 282, /* (370) foreach_clause ::= */ + 282, /* (371) foreach_clause ::= FOR EACH ROW */ + 285, /* (372) trnm ::= nm */ + 286, /* (373) tridxby ::= */ + 287, /* (374) database_kw_opt ::= DATABASE */ + 287, /* (375) database_kw_opt ::= */ + 290, /* (376) kwcolumn_opt ::= */ + 290, /* (377) kwcolumn_opt ::= COLUMNKW */ + 292, /* (378) vtabarglist ::= vtabarg */ + 292, /* (379) vtabarglist ::= vtabarglist COMMA vtabarg */ + 293, /* (380) vtabarg ::= vtabarg vtabargtoken */ + 296, /* (381) anylist ::= */ + 296, /* (382) anylist ::= anylist LP anylist RP */ + 296, /* (383) anylist ::= anylist ANY */ + 261, /* (384) with ::= */ +}; + +/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number +** of symbols on the right-hand side of that rule. */ +static const signed char yyRuleInfoNRhs[] = { + -1, /* (0) explain ::= EXPLAIN */ + -3, /* (1) explain ::= EXPLAIN QUERY PLAN */ + -1, /* (2) cmdx ::= cmd */ + -3, /* (3) cmd ::= BEGIN transtype trans_opt */ + 0, /* (4) transtype ::= */ + -1, /* (5) transtype ::= DEFERRED */ + -1, /* (6) transtype ::= IMMEDIATE */ + -1, /* (7) transtype ::= EXCLUSIVE */ + -2, /* (8) cmd ::= COMMIT|END trans_opt */ + -2, /* (9) cmd ::= ROLLBACK trans_opt */ + -2, /* (10) cmd ::= SAVEPOINT nm */ + -3, /* (11) cmd ::= RELEASE savepoint_opt nm */ + -5, /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */ + -6, /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */ + -1, /* (14) createkw ::= CREATE */ + 0, /* (15) ifnotexists ::= */ + -3, /* (16) ifnotexists ::= IF NOT EXISTS */ + -1, /* (17) temp ::= TEMP */ + 0, /* (18) temp ::= */ + -5, /* (19) create_table_args ::= LP columnlist conslist_opt RP table_options */ + -2, /* (20) create_table_args ::= AS select */ + 0, /* (21) table_options ::= */ + -2, /* (22) table_options ::= WITHOUT nm */ + -2, /* (23) columnname ::= nm typetoken */ + 0, /* (24) typetoken ::= */ + -4, /* (25) typetoken ::= typename LP signed RP */ + -6, /* (26) typetoken ::= typename LP signed COMMA signed RP */ + -2, /* (27) typename ::= typename ID|STRING */ + 0, /* (28) scanpt ::= */ + 0, /* (29) scantok ::= */ + -2, /* (30) ccons ::= CONSTRAINT nm */ + -3, /* (31) ccons ::= DEFAULT scantok term */ + -4, /* (32) ccons ::= DEFAULT LP expr RP */ + -4, /* (33) ccons ::= DEFAULT PLUS scantok term */ + -4, /* (34) ccons ::= DEFAULT MINUS scantok term */ + -3, /* (35) ccons ::= DEFAULT scantok ID|INDEXED */ + -3, /* (36) ccons ::= NOT NULL onconf */ + -5, /* (37) ccons ::= PRIMARY KEY sortorder onconf autoinc */ + -2, /* (38) ccons ::= UNIQUE onconf */ + -4, /* (39) ccons ::= CHECK LP expr RP */ + -4, /* (40) ccons ::= REFERENCES nm eidlist_opt refargs */ + -1, /* (41) ccons ::= defer_subclause */ + -2, /* (42) ccons ::= COLLATE ID|STRING */ + -3, /* (43) generated ::= LP expr RP */ + -4, /* (44) generated ::= LP expr RP ID */ + 0, /* (45) autoinc ::= */ + -1, /* (46) autoinc ::= AUTOINCR */ + 0, /* (47) refargs ::= */ + -2, /* (48) refargs ::= refargs refarg */ + -2, /* (49) refarg ::= MATCH nm */ + -3, /* (50) refarg ::= ON INSERT refact */ + -3, /* (51) refarg ::= ON DELETE refact */ + -3, /* (52) refarg ::= ON UPDATE refact */ + -2, /* (53) refact ::= SET NULL */ + -2, /* (54) refact ::= SET DEFAULT */ + -1, /* (55) refact ::= CASCADE */ + -1, /* (56) refact ::= RESTRICT */ + -2, /* (57) refact ::= NO ACTION */ + -3, /* (58) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ + -2, /* (59) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ + 0, /* (60) init_deferred_pred_opt ::= */ + -2, /* (61) init_deferred_pred_opt ::= INITIALLY DEFERRED */ + -2, /* (62) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ + 0, /* (63) conslist_opt ::= */ + -1, /* (64) tconscomma ::= COMMA */ + -2, /* (65) tcons ::= CONSTRAINT nm */ + -7, /* (66) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ + -5, /* (67) tcons ::= UNIQUE LP sortlist RP onconf */ + -5, /* (68) tcons ::= CHECK LP expr RP onconf */ + -10, /* (69) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ + 0, /* (70) defer_subclause_opt ::= */ + 0, /* (71) onconf ::= */ + -3, /* (72) onconf ::= ON CONFLICT resolvetype */ + 0, /* (73) orconf ::= */ + -2, /* (74) orconf ::= OR resolvetype */ + -1, /* (75) resolvetype ::= IGNORE */ + -1, /* (76) resolvetype ::= REPLACE */ + -4, /* (77) cmd ::= DROP TABLE ifexists fullname */ + -2, /* (78) ifexists ::= IF EXISTS */ + 0, /* (79) ifexists ::= */ + -9, /* (80) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ + -4, /* (81) cmd ::= DROP VIEW ifexists fullname */ + -1, /* (82) cmd ::= select */ + -3, /* (83) select ::= WITH wqlist selectnowith */ + -4, /* (84) select ::= WITH RECURSIVE wqlist selectnowith */ + -1, /* (85) select ::= selectnowith */ + -3, /* (86) selectnowith ::= selectnowith multiselect_op oneselect */ + -1, /* (87) multiselect_op ::= UNION */ + -2, /* (88) multiselect_op ::= UNION ALL */ + -1, /* (89) multiselect_op ::= EXCEPT|INTERSECT */ + -9, /* (90) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ + -10, /* (91) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ + -4, /* (92) values ::= VALUES LP nexprlist RP */ + -5, /* (93) values ::= values COMMA LP nexprlist RP */ + -1, /* (94) distinct ::= DISTINCT */ + -1, /* (95) distinct ::= ALL */ + 0, /* (96) distinct ::= */ + 0, /* (97) sclp ::= */ + -5, /* (98) selcollist ::= sclp scanpt expr scanpt as */ + -3, /* (99) selcollist ::= sclp scanpt STAR */ + -5, /* (100) selcollist ::= sclp scanpt nm DOT STAR */ + -2, /* (101) as ::= AS nm */ + 0, /* (102) as ::= */ + 0, /* (103) from ::= */ + -2, /* (104) from ::= FROM seltablist */ + -2, /* (105) stl_prefix ::= seltablist joinop */ + 0, /* (106) stl_prefix ::= */ + -7, /* (107) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */ + -9, /* (108) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */ + -7, /* (109) seltablist ::= stl_prefix LP select RP as on_opt using_opt */ + -7, /* (110) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */ + 0, /* (111) dbnm ::= */ + -2, /* (112) dbnm ::= DOT nm */ + -1, /* (113) fullname ::= nm */ + -3, /* (114) fullname ::= nm DOT nm */ + -1, /* (115) xfullname ::= nm */ + -3, /* (116) xfullname ::= nm DOT nm */ + -5, /* (117) xfullname ::= nm DOT nm AS nm */ + -3, /* (118) xfullname ::= nm AS nm */ + -1, /* (119) joinop ::= COMMA|JOIN */ + -2, /* (120) joinop ::= JOIN_KW JOIN */ + -3, /* (121) joinop ::= JOIN_KW nm JOIN */ + -4, /* (122) joinop ::= JOIN_KW nm nm JOIN */ + -2, /* (123) on_opt ::= ON expr */ + 0, /* (124) on_opt ::= */ + 0, /* (125) indexed_opt ::= */ + -3, /* (126) indexed_opt ::= INDEXED BY nm */ + -2, /* (127) indexed_opt ::= NOT INDEXED */ + -4, /* (128) using_opt ::= USING LP idlist RP */ + 0, /* (129) using_opt ::= */ + 0, /* (130) orderby_opt ::= */ + -3, /* (131) orderby_opt ::= ORDER BY sortlist */ + -5, /* (132) sortlist ::= sortlist COMMA expr sortorder nulls */ + -3, /* (133) sortlist ::= expr sortorder nulls */ + -1, /* (134) sortorder ::= ASC */ + -1, /* (135) sortorder ::= DESC */ + 0, /* (136) sortorder ::= */ + -2, /* (137) nulls ::= NULLS FIRST */ + -2, /* (138) nulls ::= NULLS LAST */ + 0, /* (139) nulls ::= */ + 0, /* (140) groupby_opt ::= */ + -3, /* (141) groupby_opt ::= GROUP BY nexprlist */ + 0, /* (142) having_opt ::= */ + -2, /* (143) having_opt ::= HAVING expr */ + 0, /* (144) limit_opt ::= */ + -2, /* (145) limit_opt ::= LIMIT expr */ + -4, /* (146) limit_opt ::= LIMIT expr OFFSET expr */ + -4, /* (147) limit_opt ::= LIMIT expr COMMA expr */ + -6, /* (148) cmd ::= with DELETE FROM xfullname indexed_opt where_opt */ + 0, /* (149) where_opt ::= */ + -2, /* (150) where_opt ::= WHERE expr */ + -9, /* (151) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt */ + -5, /* (152) setlist ::= setlist COMMA nm EQ expr */ + -7, /* (153) setlist ::= setlist COMMA LP idlist RP EQ expr */ + -3, /* (154) setlist ::= nm EQ expr */ + -5, /* (155) setlist ::= LP idlist RP EQ expr */ + -7, /* (156) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ + -7, /* (157) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES */ + 0, /* (158) upsert ::= */ + -11, /* (159) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt */ + -8, /* (160) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING */ + -4, /* (161) upsert ::= ON CONFLICT DO NOTHING */ + -2, /* (162) insert_cmd ::= INSERT orconf */ + -1, /* (163) insert_cmd ::= REPLACE */ + 0, /* (164) idlist_opt ::= */ + -3, /* (165) idlist_opt ::= LP idlist RP */ + -3, /* (166) idlist ::= idlist COMMA nm */ + -1, /* (167) idlist ::= nm */ + -3, /* (168) expr ::= LP expr RP */ + -1, /* (169) expr ::= ID|INDEXED */ + -1, /* (170) expr ::= JOIN_KW */ + -3, /* (171) expr ::= nm DOT nm */ + -5, /* (172) expr ::= nm DOT nm DOT nm */ + -1, /* (173) term ::= NULL|FLOAT|BLOB */ + -1, /* (174) term ::= STRING */ + -1, /* (175) term ::= INTEGER */ + -1, /* (176) expr ::= VARIABLE */ + -3, /* (177) expr ::= expr COLLATE ID|STRING */ + -6, /* (178) expr ::= CAST LP expr AS typetoken RP */ + -5, /* (179) expr ::= ID|INDEXED LP distinct exprlist RP */ + -4, /* (180) expr ::= ID|INDEXED LP STAR RP */ + -6, /* (181) expr ::= ID|INDEXED LP distinct exprlist RP filter_over */ + -5, /* (182) expr ::= ID|INDEXED LP STAR RP filter_over */ + -1, /* (183) term ::= CTIME_KW */ + -5, /* (184) expr ::= LP nexprlist COMMA expr RP */ + -3, /* (185) expr ::= expr AND expr */ + -3, /* (186) expr ::= expr OR expr */ + -3, /* (187) expr ::= expr LT|GT|GE|LE expr */ + -3, /* (188) expr ::= expr EQ|NE expr */ + -3, /* (189) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ + -3, /* (190) expr ::= expr PLUS|MINUS expr */ + -3, /* (191) expr ::= expr STAR|SLASH|REM expr */ + -3, /* (192) expr ::= expr CONCAT expr */ + -2, /* (193) likeop ::= NOT LIKE_KW|MATCH */ + -3, /* (194) expr ::= expr likeop expr */ + -5, /* (195) expr ::= expr likeop expr ESCAPE expr */ + -2, /* (196) expr ::= expr ISNULL|NOTNULL */ + -3, /* (197) expr ::= expr NOT NULL */ + -3, /* (198) expr ::= expr IS expr */ + -4, /* (199) expr ::= expr IS NOT expr */ + -2, /* (200) expr ::= NOT expr */ + -2, /* (201) expr ::= BITNOT expr */ + -2, /* (202) expr ::= PLUS|MINUS expr */ + -1, /* (203) between_op ::= BETWEEN */ + -2, /* (204) between_op ::= NOT BETWEEN */ + -5, /* (205) expr ::= expr between_op expr AND expr */ + -1, /* (206) in_op ::= IN */ + -2, /* (207) in_op ::= NOT IN */ + -5, /* (208) expr ::= expr in_op LP exprlist RP */ + -3, /* (209) expr ::= LP select RP */ + -5, /* (210) expr ::= expr in_op LP select RP */ + -5, /* (211) expr ::= expr in_op nm dbnm paren_exprlist */ + -4, /* (212) expr ::= EXISTS LP select RP */ + -5, /* (213) expr ::= CASE case_operand case_exprlist case_else END */ + -5, /* (214) case_exprlist ::= case_exprlist WHEN expr THEN expr */ + -4, /* (215) case_exprlist ::= WHEN expr THEN expr */ + -2, /* (216) case_else ::= ELSE expr */ + 0, /* (217) case_else ::= */ + -1, /* (218) case_operand ::= expr */ + 0, /* (219) case_operand ::= */ + 0, /* (220) exprlist ::= */ + -3, /* (221) nexprlist ::= nexprlist COMMA expr */ + -1, /* (222) nexprlist ::= expr */ + 0, /* (223) paren_exprlist ::= */ + -3, /* (224) paren_exprlist ::= LP exprlist RP */ + -12, /* (225) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ + -1, /* (226) uniqueflag ::= UNIQUE */ + 0, /* (227) uniqueflag ::= */ + 0, /* (228) eidlist_opt ::= */ + -3, /* (229) eidlist_opt ::= LP eidlist RP */ + -5, /* (230) eidlist ::= eidlist COMMA nm collate sortorder */ + -3, /* (231) eidlist ::= nm collate sortorder */ + 0, /* (232) collate ::= */ + -2, /* (233) collate ::= COLLATE ID|STRING */ + -4, /* (234) cmd ::= DROP INDEX ifexists fullname */ + -2, /* (235) cmd ::= VACUUM vinto */ + -3, /* (236) cmd ::= VACUUM nm vinto */ + -2, /* (237) vinto ::= INTO expr */ + 0, /* (238) vinto ::= */ + -3, /* (239) cmd ::= PRAGMA nm dbnm */ + -5, /* (240) cmd ::= PRAGMA nm dbnm EQ nmnum */ + -6, /* (241) cmd ::= PRAGMA nm dbnm LP nmnum RP */ + -5, /* (242) cmd ::= PRAGMA nm dbnm EQ minus_num */ + -6, /* (243) cmd ::= PRAGMA nm dbnm LP minus_num RP */ + -2, /* (244) plus_num ::= PLUS INTEGER|FLOAT */ + -2, /* (245) minus_num ::= MINUS INTEGER|FLOAT */ + -5, /* (246) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ + -11, /* (247) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ + -1, /* (248) trigger_time ::= BEFORE|AFTER */ + -2, /* (249) trigger_time ::= INSTEAD OF */ + 0, /* (250) trigger_time ::= */ + -1, /* (251) trigger_event ::= DELETE|INSERT */ + -1, /* (252) trigger_event ::= UPDATE */ + -3, /* (253) trigger_event ::= UPDATE OF idlist */ + 0, /* (254) when_clause ::= */ + -2, /* (255) when_clause ::= WHEN expr */ + -3, /* (256) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ + -2, /* (257) trigger_cmd_list ::= trigger_cmd SEMI */ + -3, /* (258) trnm ::= nm DOT nm */ + -3, /* (259) tridxby ::= INDEXED BY nm */ + -2, /* (260) tridxby ::= NOT INDEXED */ + -9, /* (261) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ + -8, /* (262) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ + -6, /* (263) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ + -3, /* (264) trigger_cmd ::= scanpt select scanpt */ + -4, /* (265) expr ::= RAISE LP IGNORE RP */ + -6, /* (266) expr ::= RAISE LP raisetype COMMA nm RP */ + -1, /* (267) raisetype ::= ROLLBACK */ + -1, /* (268) raisetype ::= ABORT */ + -1, /* (269) raisetype ::= FAIL */ + -4, /* (270) cmd ::= DROP TRIGGER ifexists fullname */ + -6, /* (271) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ + -3, /* (272) cmd ::= DETACH database_kw_opt expr */ + 0, /* (273) key_opt ::= */ + -2, /* (274) key_opt ::= KEY expr */ + -1, /* (275) cmd ::= REINDEX */ + -3, /* (276) cmd ::= REINDEX nm dbnm */ + -1, /* (277) cmd ::= ANALYZE */ + -3, /* (278) cmd ::= ANALYZE nm dbnm */ + -6, /* (279) cmd ::= ALTER TABLE fullname RENAME TO nm */ + -7, /* (280) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ + -1, /* (281) add_column_fullname ::= fullname */ + -8, /* (282) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ + -1, /* (283) cmd ::= create_vtab */ + -4, /* (284) cmd ::= create_vtab LP vtabarglist RP */ + -8, /* (285) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ + 0, /* (286) vtabarg ::= */ + -1, /* (287) vtabargtoken ::= ANY */ + -3, /* (288) vtabargtoken ::= lp anylist RP */ + -1, /* (289) lp ::= LP */ + -2, /* (290) with ::= WITH wqlist */ + -3, /* (291) with ::= WITH RECURSIVE wqlist */ + -6, /* (292) wqlist ::= nm eidlist_opt AS LP select RP */ + -8, /* (293) wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */ + -1, /* (294) windowdefn_list ::= windowdefn */ + -3, /* (295) windowdefn_list ::= windowdefn_list COMMA windowdefn */ + -5, /* (296) windowdefn ::= nm AS LP window RP */ + -5, /* (297) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ + -6, /* (298) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ + -4, /* (299) window ::= ORDER BY sortlist frame_opt */ + -5, /* (300) window ::= nm ORDER BY sortlist frame_opt */ + -1, /* (301) window ::= frame_opt */ + -2, /* (302) window ::= nm frame_opt */ + 0, /* (303) frame_opt ::= */ + -3, /* (304) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ + -6, /* (305) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ + -1, /* (306) range_or_rows ::= RANGE|ROWS|GROUPS */ + -1, /* (307) frame_bound_s ::= frame_bound */ + -2, /* (308) frame_bound_s ::= UNBOUNDED PRECEDING */ + -1, /* (309) frame_bound_e ::= frame_bound */ + -2, /* (310) frame_bound_e ::= UNBOUNDED FOLLOWING */ + -2, /* (311) frame_bound ::= expr PRECEDING|FOLLOWING */ + -2, /* (312) frame_bound ::= CURRENT ROW */ + 0, /* (313) frame_exclude_opt ::= */ + -2, /* (314) frame_exclude_opt ::= EXCLUDE frame_exclude */ + -2, /* (315) frame_exclude ::= NO OTHERS */ + -2, /* (316) frame_exclude ::= CURRENT ROW */ + -1, /* (317) frame_exclude ::= GROUP|TIES */ + -2, /* (318) window_clause ::= WINDOW windowdefn_list */ + -2, /* (319) filter_over ::= filter_clause over_clause */ + -1, /* (320) filter_over ::= over_clause */ + -1, /* (321) filter_over ::= filter_clause */ + -4, /* (322) over_clause ::= OVER LP window RP */ + -2, /* (323) over_clause ::= OVER nm */ + -5, /* (324) filter_clause ::= FILTER LP WHERE expr RP */ + -1, /* (325) input ::= cmdlist */ + -2, /* (326) cmdlist ::= cmdlist ecmd */ + -1, /* (327) cmdlist ::= ecmd */ + -1, /* (328) ecmd ::= SEMI */ + -2, /* (329) ecmd ::= cmdx SEMI */ + -3, /* (330) ecmd ::= explain cmdx SEMI */ + 0, /* (331) trans_opt ::= */ + -1, /* (332) trans_opt ::= TRANSACTION */ + -2, /* (333) trans_opt ::= TRANSACTION nm */ + -1, /* (334) savepoint_opt ::= SAVEPOINT */ + 0, /* (335) savepoint_opt ::= */ + -2, /* (336) cmd ::= create_table create_table_args */ + -4, /* (337) columnlist ::= columnlist COMMA columnname carglist */ + -2, /* (338) columnlist ::= columnname carglist */ + -1, /* (339) nm ::= ID|INDEXED */ + -1, /* (340) nm ::= STRING */ + -1, /* (341) nm ::= JOIN_KW */ + -1, /* (342) typetoken ::= typename */ + -1, /* (343) typename ::= ID|STRING */ + -1, /* (344) signed ::= plus_num */ + -1, /* (345) signed ::= minus_num */ + -2, /* (346) carglist ::= carglist ccons */ + 0, /* (347) carglist ::= */ + -2, /* (348) ccons ::= NULL onconf */ + -4, /* (349) ccons ::= GENERATED ALWAYS AS generated */ + -2, /* (350) ccons ::= AS generated */ + -2, /* (351) conslist_opt ::= COMMA conslist */ + -3, /* (352) conslist ::= conslist tconscomma tcons */ + -1, /* (353) conslist ::= tcons */ + 0, /* (354) tconscomma ::= */ + -1, /* (355) defer_subclause_opt ::= defer_subclause */ + -1, /* (356) resolvetype ::= raisetype */ + -1, /* (357) selectnowith ::= oneselect */ + -1, /* (358) oneselect ::= values */ + -2, /* (359) sclp ::= selcollist COMMA */ + -1, /* (360) as ::= ID|STRING */ + -1, /* (361) expr ::= term */ + -1, /* (362) likeop ::= LIKE_KW|MATCH */ + -1, /* (363) exprlist ::= nexprlist */ + -1, /* (364) nmnum ::= plus_num */ + -1, /* (365) nmnum ::= nm */ + -1, /* (366) nmnum ::= ON */ + -1, /* (367) nmnum ::= DELETE */ + -1, /* (368) nmnum ::= DEFAULT */ + -1, /* (369) plus_num ::= INTEGER|FLOAT */ + 0, /* (370) foreach_clause ::= */ + -3, /* (371) foreach_clause ::= FOR EACH ROW */ + -1, /* (372) trnm ::= nm */ + 0, /* (373) tridxby ::= */ + -1, /* (374) database_kw_opt ::= DATABASE */ + 0, /* (375) database_kw_opt ::= */ + 0, /* (376) kwcolumn_opt ::= */ + -1, /* (377) kwcolumn_opt ::= COLUMNKW */ + -1, /* (378) vtabarglist ::= vtabarg */ + -3, /* (379) vtabarglist ::= vtabarglist COMMA vtabarg */ + -2, /* (380) vtabarg ::= vtabarg vtabargtoken */ + 0, /* (381) anylist ::= */ + -4, /* (382) anylist ::= anylist LP anylist RP */ + -2, /* (383) anylist ::= anylist ANY */ + 0, /* (384) with ::= */ +}; + +static void yy_accept(yyParser*); /* Forward Declaration */ + +/* +** Perform a reduce action and the shift that must immediately +** follow the reduce. +** +** The yyLookahead and yyLookaheadToken parameters provide reduce actions +** access to the lookahead token (if any). The yyLookahead will be YYNOCODE +** if the lookahead token has already been consumed. As this procedure is +** only called from one place, optimizing compilers will in-line it, which +** means that the extra parameters have no performance impact. +*/ +static YYACTIONTYPE yy_reduce( + yyParser *yypParser, /* The parser */ + unsigned int yyruleno, /* Number of the rule by which to reduce */ + int yyLookahead, /* Lookahead token, or YYNOCODE if none */ + sqlite3ParserTOKENTYPE yyLookaheadToken /* Value of the lookahead token */ + sqlite3ParserCTX_PDECL /* %extra_context */ +){ + int yygoto; /* The next state */ + YYACTIONTYPE yyact; /* The next action */ + yyStackEntry *yymsp; /* The top of the parser's stack */ + int yysize; /* Amount to pop the stack */ + sqlite3ParserARG_FETCH + (void)yyLookahead; + (void)yyLookaheadToken; + yymsp = yypParser->yytos; + assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ); +#ifndef NDEBUG + if( yyTraceFILE ){ + yysize = yyRuleInfoNRhs[yyruleno]; + if( yysize ){ + fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n", + yyTracePrompt, + yyruleno, yyRuleName[yyruleno], + yyrulenoyytos - yypParser->yystack)>yypParser->yyhwm ){ + yypParser->yyhwm++; + assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack)); + } +#endif +#if YYSTACKDEPTH>0 + if( yypParser->yytos>=yypParser->yystackEnd ){ + yyStackOverflow(yypParser); + /* The call to yyStackOverflow() above pops the stack until it is + ** empty, causing the main parser loop to exit. So the return value + ** is never used and does not matter. */ + return 0; + } +#else + if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){ + if( yyGrowStack(yypParser) ){ + yyStackOverflow(yypParser); + /* The call to yyStackOverflow() above pops the stack until it is + ** empty, causing the main parser loop to exit. So the return value + ** is never used and does not matter. */ + return 0; + } + yymsp = yypParser->yytos; + } +#endif + } + + switch( yyruleno ){ + /* Beginning here are the reduction cases. A typical example + ** follows: + ** case 0: + ** #line + ** { ... } // User supplied code + ** #line + ** break; + */ +/********** Begin reduce actions **********************************************/ + YYMINORTYPE yylhsminor; + case 0: /* explain ::= EXPLAIN */ +{ pParse->explain = 1; } + break; + case 1: /* explain ::= EXPLAIN QUERY PLAN */ +{ pParse->explain = 2; } + break; + case 2: /* cmdx ::= cmd */ +{ sqlite3FinishCoding(pParse); } + break; + case 3: /* cmd ::= BEGIN transtype trans_opt */ +{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy192);} + break; + case 4: /* transtype ::= */ +{yymsp[1].minor.yy192 = TK_DEFERRED;} + break; + case 5: /* transtype ::= DEFERRED */ + case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6); + case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7); + case 306: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==306); +{yymsp[0].minor.yy192 = yymsp[0].major; /*A-overwrites-X*/} + break; + case 8: /* cmd ::= COMMIT|END trans_opt */ + case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9); +{sqlite3EndTransaction(pParse,yymsp[-1].major);} + break; + case 10: /* cmd ::= SAVEPOINT nm */ +{ + sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &yymsp[0].minor.yy0); +} + break; + case 11: /* cmd ::= RELEASE savepoint_opt nm */ +{ + sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &yymsp[0].minor.yy0); +} + break; + case 12: /* cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */ +{ + sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0); +} + break; + case 13: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */ +{ + sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy192,0,0,yymsp[-2].minor.yy192); +} + break; + case 14: /* createkw ::= CREATE */ +{disableLookaside(pParse);} + break; + case 15: /* ifnotexists ::= */ + case 18: /* temp ::= */ yytestcase(yyruleno==18); + case 21: /* table_options ::= */ yytestcase(yyruleno==21); + case 45: /* autoinc ::= */ yytestcase(yyruleno==45); + case 60: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==60); + case 70: /* defer_subclause_opt ::= */ yytestcase(yyruleno==70); + case 79: /* ifexists ::= */ yytestcase(yyruleno==79); + case 96: /* distinct ::= */ yytestcase(yyruleno==96); + case 232: /* collate ::= */ yytestcase(yyruleno==232); +{yymsp[1].minor.yy192 = 0;} + break; + case 16: /* ifnotexists ::= IF NOT EXISTS */ +{yymsp[-2].minor.yy192 = 1;} + break; + case 17: /* temp ::= TEMP */ + case 46: /* autoinc ::= AUTOINCR */ yytestcase(yyruleno==46); +{yymsp[0].minor.yy192 = 1;} + break; + case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_options */ +{ + sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy192,0); +} + break; + case 20: /* create_table_args ::= AS select */ +{ + sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy539); + sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy539); +} + break; + case 22: /* table_options ::= WITHOUT nm */ +{ + if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){ + yymsp[-1].minor.yy192 = TF_WithoutRowid | TF_NoVisibleRowid; + }else{ + yymsp[-1].minor.yy192 = 0; + sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z); + } +} + break; + case 23: /* columnname ::= nm typetoken */ +{sqlite3AddColumn(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);} + break; + case 24: /* typetoken ::= */ + case 63: /* conslist_opt ::= */ yytestcase(yyruleno==63); + case 102: /* as ::= */ yytestcase(yyruleno==102); +{yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = 0;} + break; + case 25: /* typetoken ::= typename LP signed RP */ +{ + yymsp[-3].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy0.z); +} + break; + case 26: /* typetoken ::= typename LP signed COMMA signed RP */ +{ + yymsp[-5].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-5].minor.yy0.z); +} + break; + case 27: /* typename ::= typename ID|STRING */ +{yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);} + break; + case 28: /* scanpt ::= */ +{ + assert( yyLookahead!=YYNOCODE ); + yymsp[1].minor.yy436 = yyLookaheadToken.z; +} + break; + case 29: /* scantok ::= */ +{ + assert( yyLookahead!=YYNOCODE ); + yymsp[1].minor.yy0 = yyLookaheadToken; +} + break; + case 30: /* ccons ::= CONSTRAINT nm */ + case 65: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==65); +{pParse->constraintName = yymsp[0].minor.yy0;} + break; + case 31: /* ccons ::= DEFAULT scantok term */ +{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy202,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} + break; + case 32: /* ccons ::= DEFAULT LP expr RP */ +{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy202,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);} + break; + case 33: /* ccons ::= DEFAULT PLUS scantok term */ +{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy202,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} + break; + case 34: /* ccons ::= DEFAULT MINUS scantok term */ +{ + Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy202, 0); + sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]); +} + break; + case 35: /* ccons ::= DEFAULT scantok ID|INDEXED */ +{ + Expr *p = tokenExpr(pParse, TK_STRING, yymsp[0].minor.yy0); + if( p ){ + sqlite3ExprIdToTrueFalse(p); + testcase( p->op==TK_TRUEFALSE && sqlite3ExprTruthValue(p) ); + } + sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n); +} + break; + case 36: /* ccons ::= NOT NULL onconf */ +{sqlite3AddNotNull(pParse, yymsp[0].minor.yy192);} + break; + case 37: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */ +{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy192,yymsp[0].minor.yy192,yymsp[-2].minor.yy192);} + break; + case 38: /* ccons ::= UNIQUE onconf */ +{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy192,0,0,0,0, + SQLITE_IDXTYPE_UNIQUE);} + break; + case 39: /* ccons ::= CHECK LP expr RP */ +{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy202,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);} + break; + case 40: /* ccons ::= REFERENCES nm eidlist_opt refargs */ +{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy242,yymsp[0].minor.yy192);} + break; + case 41: /* ccons ::= defer_subclause */ +{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy192);} + break; + case 42: /* ccons ::= COLLATE ID|STRING */ +{sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);} + break; + case 43: /* generated ::= LP expr RP */ +{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy202,0);} + break; + case 44: /* generated ::= LP expr RP ID */ +{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy202,&yymsp[0].minor.yy0);} + break; + case 47: /* refargs ::= */ +{ yymsp[1].minor.yy192 = OE_None*0x0101; /* EV: R-19803-45884 */} + break; + case 48: /* refargs ::= refargs refarg */ +{ yymsp[-1].minor.yy192 = (yymsp[-1].minor.yy192 & ~yymsp[0].minor.yy207.mask) | yymsp[0].minor.yy207.value; } + break; + case 49: /* refarg ::= MATCH nm */ +{ yymsp[-1].minor.yy207.value = 0; yymsp[-1].minor.yy207.mask = 0x000000; } + break; + case 50: /* refarg ::= ON INSERT refact */ +{ yymsp[-2].minor.yy207.value = 0; yymsp[-2].minor.yy207.mask = 0x000000; } + break; + case 51: /* refarg ::= ON DELETE refact */ +{ yymsp[-2].minor.yy207.value = yymsp[0].minor.yy192; yymsp[-2].minor.yy207.mask = 0x0000ff; } + break; + case 52: /* refarg ::= ON UPDATE refact */ +{ yymsp[-2].minor.yy207.value = yymsp[0].minor.yy192<<8; yymsp[-2].minor.yy207.mask = 0x00ff00; } + break; + case 53: /* refact ::= SET NULL */ +{ yymsp[-1].minor.yy192 = OE_SetNull; /* EV: R-33326-45252 */} + break; + case 54: /* refact ::= SET DEFAULT */ +{ yymsp[-1].minor.yy192 = OE_SetDflt; /* EV: R-33326-45252 */} + break; + case 55: /* refact ::= CASCADE */ +{ yymsp[0].minor.yy192 = OE_Cascade; /* EV: R-33326-45252 */} + break; + case 56: /* refact ::= RESTRICT */ +{ yymsp[0].minor.yy192 = OE_Restrict; /* EV: R-33326-45252 */} + break; + case 57: /* refact ::= NO ACTION */ +{ yymsp[-1].minor.yy192 = OE_None; /* EV: R-33326-45252 */} + break; + case 58: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ +{yymsp[-2].minor.yy192 = 0;} + break; + case 59: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ + case 74: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==74); + case 162: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==162); +{yymsp[-1].minor.yy192 = yymsp[0].minor.yy192;} + break; + case 61: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */ + case 78: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==78); + case 204: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==204); + case 207: /* in_op ::= NOT IN */ yytestcase(yyruleno==207); + case 233: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==233); +{yymsp[-1].minor.yy192 = 1;} + break; + case 62: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ +{yymsp[-1].minor.yy192 = 0;} + break; + case 64: /* tconscomma ::= COMMA */ +{pParse->constraintName.n = 0;} + break; + case 66: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ +{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy242,yymsp[0].minor.yy192,yymsp[-2].minor.yy192,0);} + break; + case 67: /* tcons ::= UNIQUE LP sortlist RP onconf */ +{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy242,yymsp[0].minor.yy192,0,0,0,0, + SQLITE_IDXTYPE_UNIQUE);} + break; + case 68: /* tcons ::= CHECK LP expr RP onconf */ +{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy202,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);} + break; + case 69: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ +{ + sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy242, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy242, yymsp[-1].minor.yy192); + sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy192); +} + break; + case 71: /* onconf ::= */ + case 73: /* orconf ::= */ yytestcase(yyruleno==73); +{yymsp[1].minor.yy192 = OE_Default;} + break; + case 72: /* onconf ::= ON CONFLICT resolvetype */ +{yymsp[-2].minor.yy192 = yymsp[0].minor.yy192;} + break; + case 75: /* resolvetype ::= IGNORE */ +{yymsp[0].minor.yy192 = OE_Ignore;} + break; + case 76: /* resolvetype ::= REPLACE */ + case 163: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==163); +{yymsp[0].minor.yy192 = OE_Replace;} + break; + case 77: /* cmd ::= DROP TABLE ifexists fullname */ +{ + sqlite3DropTable(pParse, yymsp[0].minor.yy47, 0, yymsp[-1].minor.yy192); +} + break; + case 80: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ +{ + sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy242, yymsp[0].minor.yy539, yymsp[-7].minor.yy192, yymsp[-5].minor.yy192); +} + break; + case 81: /* cmd ::= DROP VIEW ifexists fullname */ +{ + sqlite3DropTable(pParse, yymsp[0].minor.yy47, 1, yymsp[-1].minor.yy192); +} + break; + case 82: /* cmd ::= select */ +{ + SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0}; + sqlite3Select(pParse, yymsp[0].minor.yy539, &dest); + sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy539); +} + break; + case 83: /* select ::= WITH wqlist selectnowith */ +{ + Select *p = yymsp[0].minor.yy539; + if( p ){ + p->pWith = yymsp[-1].minor.yy131; + parserDoubleLinkSelect(pParse, p); + }else{ + sqlite3WithDelete(pParse->db, yymsp[-1].minor.yy131); + } + yymsp[-2].minor.yy539 = p; +} + break; + case 84: /* select ::= WITH RECURSIVE wqlist selectnowith */ +{ + Select *p = yymsp[0].minor.yy539; + if( p ){ + p->pWith = yymsp[-1].minor.yy131; + parserDoubleLinkSelect(pParse, p); + }else{ + sqlite3WithDelete(pParse->db, yymsp[-1].minor.yy131); + } + yymsp[-3].minor.yy539 = p; +} + break; + case 85: /* select ::= selectnowith */ +{ + Select *p = yymsp[0].minor.yy539; + if( p ){ + parserDoubleLinkSelect(pParse, p); + } + yymsp[0].minor.yy539 = p; /*A-overwrites-X*/ +} + break; + case 86: /* selectnowith ::= selectnowith multiselect_op oneselect */ +{ + Select *pRhs = yymsp[0].minor.yy539; + Select *pLhs = yymsp[-2].minor.yy539; + if( pRhs && pRhs->pPrior ){ + SrcList *pFrom; + Token x; + x.n = 0; + parserDoubleLinkSelect(pParse, pRhs); + pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0,0); + pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0); + } + if( pRhs ){ + pRhs->op = (u8)yymsp[-1].minor.yy192; + pRhs->pPrior = pLhs; + if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue; + pRhs->selFlags &= ~SF_MultiValue; + if( yymsp[-1].minor.yy192!=TK_ALL ) pParse->hasCompound = 1; + }else{ + sqlite3SelectDelete(pParse->db, pLhs); + } + yymsp[-2].minor.yy539 = pRhs; +} + break; + case 87: /* multiselect_op ::= UNION */ + case 89: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==89); +{yymsp[0].minor.yy192 = yymsp[0].major; /*A-overwrites-OP*/} + break; + case 88: /* multiselect_op ::= UNION ALL */ +{yymsp[-1].minor.yy192 = TK_ALL;} + break; + case 90: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ +{ + yymsp[-8].minor.yy539 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy242,yymsp[-5].minor.yy47,yymsp[-4].minor.yy202,yymsp[-3].minor.yy242,yymsp[-2].minor.yy202,yymsp[-1].minor.yy242,yymsp[-7].minor.yy192,yymsp[0].minor.yy202); +} + break; + case 91: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ +{ + yymsp[-9].minor.yy539 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy242,yymsp[-6].minor.yy47,yymsp[-5].minor.yy202,yymsp[-4].minor.yy242,yymsp[-3].minor.yy202,yymsp[-1].minor.yy242,yymsp[-8].minor.yy192,yymsp[0].minor.yy202); + if( yymsp[-9].minor.yy539 ){ + yymsp[-9].minor.yy539->pWinDefn = yymsp[-2].minor.yy303; + }else{ + sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy303); + } +} + break; + case 92: /* values ::= VALUES LP nexprlist RP */ +{ + yymsp[-3].minor.yy539 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy242,0,0,0,0,0,SF_Values,0); +} + break; + case 93: /* values ::= values COMMA LP nexprlist RP */ +{ + Select *pRight, *pLeft = yymsp[-4].minor.yy539; + pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy242,0,0,0,0,0,SF_Values|SF_MultiValue,0); + if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue; + if( pRight ){ + pRight->op = TK_ALL; + pRight->pPrior = pLeft; + yymsp[-4].minor.yy539 = pRight; + }else{ + yymsp[-4].minor.yy539 = pLeft; + } +} + break; + case 94: /* distinct ::= DISTINCT */ +{yymsp[0].minor.yy192 = SF_Distinct;} + break; + case 95: /* distinct ::= ALL */ +{yymsp[0].minor.yy192 = SF_All;} + break; + case 97: /* sclp ::= */ + case 130: /* orderby_opt ::= */ yytestcase(yyruleno==130); + case 140: /* groupby_opt ::= */ yytestcase(yyruleno==140); + case 220: /* exprlist ::= */ yytestcase(yyruleno==220); + case 223: /* paren_exprlist ::= */ yytestcase(yyruleno==223); + case 228: /* eidlist_opt ::= */ yytestcase(yyruleno==228); +{yymsp[1].minor.yy242 = 0;} + break; + case 98: /* selcollist ::= sclp scanpt expr scanpt as */ +{ + yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy242, yymsp[-2].minor.yy202); + if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy242, &yymsp[0].minor.yy0, 1); + sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy242,yymsp[-3].minor.yy436,yymsp[-1].minor.yy436); +} + break; + case 99: /* selcollist ::= sclp scanpt STAR */ +{ + Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0); + yymsp[-2].minor.yy242 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy242, p); +} + break; + case 100: /* selcollist ::= sclp scanpt nm DOT STAR */ +{ + Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0); + Expr *pLeft = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1); + Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight); + yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242, pDot); +} + break; + case 101: /* as ::= AS nm */ + case 112: /* dbnm ::= DOT nm */ yytestcase(yyruleno==112); + case 244: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==244); + case 245: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==245); +{yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;} + break; + case 103: /* from ::= */ + case 106: /* stl_prefix ::= */ yytestcase(yyruleno==106); +{yymsp[1].minor.yy47 = 0;} + break; + case 104: /* from ::= FROM seltablist */ +{ + yymsp[-1].minor.yy47 = yymsp[0].minor.yy47; + sqlite3SrcListShiftJoinType(yymsp[-1].minor.yy47); +} + break; + case 105: /* stl_prefix ::= seltablist joinop */ +{ + if( ALWAYS(yymsp[-1].minor.yy47 && yymsp[-1].minor.yy47->nSrc>0) ) yymsp[-1].minor.yy47->a[yymsp[-1].minor.yy47->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy192; +} + break; + case 107: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */ +{ + yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy202,yymsp[0].minor.yy600); + sqlite3SrcListIndexedBy(pParse, yymsp[-6].minor.yy47, &yymsp[-2].minor.yy0); +} + break; + case 108: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */ +{ + yymsp[-8].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-8].minor.yy47,&yymsp[-7].minor.yy0,&yymsp[-6].minor.yy0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy202,yymsp[0].minor.yy600); + sqlite3SrcListFuncArgs(pParse, yymsp[-8].minor.yy47, yymsp[-4].minor.yy242); +} + break; + case 109: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */ +{ + yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy539,yymsp[-1].minor.yy202,yymsp[0].minor.yy600); + } + break; + case 110: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */ +{ + if( yymsp[-6].minor.yy47==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy202==0 && yymsp[0].minor.yy600==0 ){ + yymsp[-6].minor.yy47 = yymsp[-4].minor.yy47; + }else if( yymsp[-4].minor.yy47->nSrc==1 ){ + yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy202,yymsp[0].minor.yy600); + if( yymsp[-6].minor.yy47 ){ + struct SrcList_item *pNew = &yymsp[-6].minor.yy47->a[yymsp[-6].minor.yy47->nSrc-1]; + struct SrcList_item *pOld = yymsp[-4].minor.yy47->a; + pNew->zName = pOld->zName; + pNew->zDatabase = pOld->zDatabase; + pNew->pSelect = pOld->pSelect; + if( pOld->fg.isTabFunc ){ + pNew->u1.pFuncArg = pOld->u1.pFuncArg; + pOld->u1.pFuncArg = 0; + pOld->fg.isTabFunc = 0; + pNew->fg.isTabFunc = 1; + } + pOld->zName = pOld->zDatabase = 0; + pOld->pSelect = 0; + } + sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy47); + }else{ + Select *pSubquery; + sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy47); + pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy47,0,0,0,0,SF_NestedFrom,0); + yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy202,yymsp[0].minor.yy600); + } + } + break; + case 111: /* dbnm ::= */ + case 125: /* indexed_opt ::= */ yytestcase(yyruleno==125); +{yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;} + break; + case 113: /* fullname ::= nm */ +{ + yylhsminor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); + if( IN_RENAME_OBJECT && yylhsminor.yy47 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy47->a[0].zName, &yymsp[0].minor.yy0); +} + yymsp[0].minor.yy47 = yylhsminor.yy47; + break; + case 114: /* fullname ::= nm DOT nm */ +{ + yylhsminor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); + if( IN_RENAME_OBJECT && yylhsminor.yy47 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy47->a[0].zName, &yymsp[0].minor.yy0); +} + yymsp[-2].minor.yy47 = yylhsminor.yy47; + break; + case 115: /* xfullname ::= nm */ +{yymsp[0].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/} + break; + case 116: /* xfullname ::= nm DOT nm */ +{yymsp[-2].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/} + break; + case 117: /* xfullname ::= nm DOT nm AS nm */ +{ + yymsp[-4].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/ + if( yymsp[-4].minor.yy47 ) yymsp[-4].minor.yy47->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); +} + break; + case 118: /* xfullname ::= nm AS nm */ +{ + yymsp[-2].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/ + if( yymsp[-2].minor.yy47 ) yymsp[-2].minor.yy47->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); +} + break; + case 119: /* joinop ::= COMMA|JOIN */ +{ yymsp[0].minor.yy192 = JT_INNER; } + break; + case 120: /* joinop ::= JOIN_KW JOIN */ +{yymsp[-1].minor.yy192 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /*X-overwrites-A*/} + break; + case 121: /* joinop ::= JOIN_KW nm JOIN */ +{yymsp[-2].minor.yy192 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/} + break; + case 122: /* joinop ::= JOIN_KW nm nm JOIN */ +{yymsp[-3].minor.yy192 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/} + break; + case 123: /* on_opt ::= ON expr */ + case 143: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==143); + case 150: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==150); + case 216: /* case_else ::= ELSE expr */ yytestcase(yyruleno==216); + case 237: /* vinto ::= INTO expr */ yytestcase(yyruleno==237); +{yymsp[-1].minor.yy202 = yymsp[0].minor.yy202;} + break; + case 124: /* on_opt ::= */ + case 142: /* having_opt ::= */ yytestcase(yyruleno==142); + case 144: /* limit_opt ::= */ yytestcase(yyruleno==144); + case 149: /* where_opt ::= */ yytestcase(yyruleno==149); + case 217: /* case_else ::= */ yytestcase(yyruleno==217); + case 219: /* case_operand ::= */ yytestcase(yyruleno==219); + case 238: /* vinto ::= */ yytestcase(yyruleno==238); +{yymsp[1].minor.yy202 = 0;} + break; + case 126: /* indexed_opt ::= INDEXED BY nm */ +{yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;} + break; + case 127: /* indexed_opt ::= NOT INDEXED */ +{yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;} + break; + case 128: /* using_opt ::= USING LP idlist RP */ +{yymsp[-3].minor.yy600 = yymsp[-1].minor.yy600;} + break; + case 129: /* using_opt ::= */ + case 164: /* idlist_opt ::= */ yytestcase(yyruleno==164); +{yymsp[1].minor.yy600 = 0;} + break; + case 131: /* orderby_opt ::= ORDER BY sortlist */ + case 141: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==141); +{yymsp[-2].minor.yy242 = yymsp[0].minor.yy242;} + break; + case 132: /* sortlist ::= sortlist COMMA expr sortorder nulls */ +{ + yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242,yymsp[-2].minor.yy202); + sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy242,yymsp[-1].minor.yy192,yymsp[0].minor.yy192); +} + break; + case 133: /* sortlist ::= expr sortorder nulls */ +{ + yymsp[-2].minor.yy242 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy202); /*A-overwrites-Y*/ + sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy242,yymsp[-1].minor.yy192,yymsp[0].minor.yy192); +} + break; + case 134: /* sortorder ::= ASC */ +{yymsp[0].minor.yy192 = SQLITE_SO_ASC;} + break; + case 135: /* sortorder ::= DESC */ +{yymsp[0].minor.yy192 = SQLITE_SO_DESC;} + break; + case 136: /* sortorder ::= */ + case 139: /* nulls ::= */ yytestcase(yyruleno==139); +{yymsp[1].minor.yy192 = SQLITE_SO_UNDEFINED;} + break; + case 137: /* nulls ::= NULLS FIRST */ +{yymsp[-1].minor.yy192 = SQLITE_SO_ASC;} + break; + case 138: /* nulls ::= NULLS LAST */ +{yymsp[-1].minor.yy192 = SQLITE_SO_DESC;} + break; + case 145: /* limit_opt ::= LIMIT expr */ +{yymsp[-1].minor.yy202 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy202,0);} + break; + case 146: /* limit_opt ::= LIMIT expr OFFSET expr */ +{yymsp[-3].minor.yy202 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy202,yymsp[0].minor.yy202);} + break; + case 147: /* limit_opt ::= LIMIT expr COMMA expr */ +{yymsp[-3].minor.yy202 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy202,yymsp[-2].minor.yy202);} + break; + case 148: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt */ +{ + sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy47, &yymsp[-1].minor.yy0); + sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy47,yymsp[0].minor.yy202,0,0); +} + break; + case 151: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt */ +{ + sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy47, &yymsp[-4].minor.yy0); + sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy242,"set list"); + yymsp[-5].minor.yy47 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy47, yymsp[-1].minor.yy47); + sqlite3Update(pParse,yymsp[-5].minor.yy47,yymsp[-2].minor.yy242,yymsp[0].minor.yy202,yymsp[-6].minor.yy192,0,0,0); +} + break; + case 152: /* setlist ::= setlist COMMA nm EQ expr */ +{ + yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy242, yymsp[0].minor.yy202); + sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy242, &yymsp[-2].minor.yy0, 1); +} + break; + case 153: /* setlist ::= setlist COMMA LP idlist RP EQ expr */ +{ + yymsp[-6].minor.yy242 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy242, yymsp[-3].minor.yy600, yymsp[0].minor.yy202); +} + break; + case 154: /* setlist ::= nm EQ expr */ +{ + yylhsminor.yy242 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy202); + sqlite3ExprListSetName(pParse, yylhsminor.yy242, &yymsp[-2].minor.yy0, 1); +} + yymsp[-2].minor.yy242 = yylhsminor.yy242; + break; + case 155: /* setlist ::= LP idlist RP EQ expr */ +{ + yymsp[-4].minor.yy242 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy600, yymsp[0].minor.yy202); +} + break; + case 156: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ +{ + sqlite3Insert(pParse, yymsp[-3].minor.yy47, yymsp[-1].minor.yy539, yymsp[-2].minor.yy600, yymsp[-5].minor.yy192, yymsp[0].minor.yy318); +} + break; + case 157: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES */ +{ + sqlite3Insert(pParse, yymsp[-3].minor.yy47, 0, yymsp[-2].minor.yy600, yymsp[-5].minor.yy192, 0); +} + break; + case 158: /* upsert ::= */ +{ yymsp[1].minor.yy318 = 0; } + break; + case 159: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt */ +{ yymsp[-10].minor.yy318 = sqlite3UpsertNew(pParse->db,yymsp[-7].minor.yy242,yymsp[-5].minor.yy202,yymsp[-1].minor.yy242,yymsp[0].minor.yy202);} + break; + case 160: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING */ +{ yymsp[-7].minor.yy318 = sqlite3UpsertNew(pParse->db,yymsp[-4].minor.yy242,yymsp[-2].minor.yy202,0,0); } + break; + case 161: /* upsert ::= ON CONFLICT DO NOTHING */ +{ yymsp[-3].minor.yy318 = sqlite3UpsertNew(pParse->db,0,0,0,0); } + break; + case 165: /* idlist_opt ::= LP idlist RP */ +{yymsp[-2].minor.yy600 = yymsp[-1].minor.yy600;} + break; + case 166: /* idlist ::= idlist COMMA nm */ +{yymsp[-2].minor.yy600 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy600,&yymsp[0].minor.yy0);} + break; + case 167: /* idlist ::= nm */ +{yymsp[0].minor.yy600 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/} + break; + case 168: /* expr ::= LP expr RP */ +{yymsp[-2].minor.yy202 = yymsp[-1].minor.yy202;} + break; + case 169: /* expr ::= ID|INDEXED */ + case 170: /* expr ::= JOIN_KW */ yytestcase(yyruleno==170); +{yymsp[0].minor.yy202=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/} + break; + case 171: /* expr ::= nm DOT nm */ +{ + Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1); + Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[0].minor.yy0, 1); + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[0].minor.yy0); + sqlite3RenameTokenMap(pParse, (void*)temp1, &yymsp[-2].minor.yy0); + } + yylhsminor.yy202 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2); +} + yymsp[-2].minor.yy202 = yylhsminor.yy202; + break; + case 172: /* expr ::= nm DOT nm DOT nm */ +{ + Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-4].minor.yy0, 1); + Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1); + Expr *temp3 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[0].minor.yy0, 1); + Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3); + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenMap(pParse, (void*)temp3, &yymsp[0].minor.yy0); + sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[-2].minor.yy0); + } + yylhsminor.yy202 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4); +} + yymsp[-4].minor.yy202 = yylhsminor.yy202; + break; + case 173: /* term ::= NULL|FLOAT|BLOB */ + case 174: /* term ::= STRING */ yytestcase(yyruleno==174); +{yymsp[0].minor.yy202=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/} + break; + case 175: /* term ::= INTEGER */ +{ + yylhsminor.yy202 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1); +} + yymsp[0].minor.yy202 = yylhsminor.yy202; + break; + case 176: /* expr ::= VARIABLE */ +{ + if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){ + u32 n = yymsp[0].minor.yy0.n; + yymsp[0].minor.yy202 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0); + sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy202, n); + }else{ + /* When doing a nested parse, one can include terms in an expression + ** that look like this: #1 #2 ... These terms refer to registers + ** in the virtual machine. #N is the N-th register. */ + Token t = yymsp[0].minor.yy0; /*A-overwrites-X*/ + assert( t.n>=2 ); + if( pParse->nested==0 ){ + sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t); + yymsp[0].minor.yy202 = 0; + }else{ + yymsp[0].minor.yy202 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0); + if( yymsp[0].minor.yy202 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy202->iTable); + } + } +} + break; + case 177: /* expr ::= expr COLLATE ID|STRING */ +{ + yymsp[-2].minor.yy202 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy202, &yymsp[0].minor.yy0, 1); +} + break; + case 178: /* expr ::= CAST LP expr AS typetoken RP */ +{ + yymsp[-5].minor.yy202 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1); + sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy202, yymsp[-3].minor.yy202, 0); +} + break; + case 179: /* expr ::= ID|INDEXED LP distinct exprlist RP */ +{ + yylhsminor.yy202 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy242, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy192); +} + yymsp[-4].minor.yy202 = yylhsminor.yy202; + break; + case 180: /* expr ::= ID|INDEXED LP STAR RP */ +{ + yylhsminor.yy202 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0); +} + yymsp[-3].minor.yy202 = yylhsminor.yy202; + break; + case 181: /* expr ::= ID|INDEXED LP distinct exprlist RP filter_over */ +{ + yylhsminor.yy202 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy242, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy192); + sqlite3WindowAttach(pParse, yylhsminor.yy202, yymsp[0].minor.yy303); +} + yymsp[-5].minor.yy202 = yylhsminor.yy202; + break; + case 182: /* expr ::= ID|INDEXED LP STAR RP filter_over */ +{ + yylhsminor.yy202 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0); + sqlite3WindowAttach(pParse, yylhsminor.yy202, yymsp[0].minor.yy303); +} + yymsp[-4].minor.yy202 = yylhsminor.yy202; + break; + case 183: /* term ::= CTIME_KW */ +{ + yylhsminor.yy202 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0); +} + yymsp[0].minor.yy202 = yylhsminor.yy202; + break; + case 184: /* expr ::= LP nexprlist COMMA expr RP */ +{ + ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy242, yymsp[-1].minor.yy202); + yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0); + if( yymsp[-4].minor.yy202 ){ + yymsp[-4].minor.yy202->x.pList = pList; + if( ALWAYS(pList->nExpr) ){ + yymsp[-4].minor.yy202->flags |= pList->a[0].pExpr->flags & EP_Propagate; + } + }else{ + sqlite3ExprListDelete(pParse->db, pList); + } +} + break; + case 185: /* expr ::= expr AND expr */ +{yymsp[-2].minor.yy202=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy202,yymsp[0].minor.yy202);} + break; + case 186: /* expr ::= expr OR expr */ + case 187: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==187); + case 188: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==188); + case 189: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==189); + case 190: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==190); + case 191: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==191); + case 192: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==192); +{yymsp[-2].minor.yy202=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy202,yymsp[0].minor.yy202);} + break; + case 193: /* likeop ::= NOT LIKE_KW|MATCH */ +{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n|=0x80000000; /*yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0*/} + break; + case 194: /* expr ::= expr likeop expr */ +{ + ExprList *pList; + int bNot = yymsp[-1].minor.yy0.n & 0x80000000; + yymsp[-1].minor.yy0.n &= 0x7fffffff; + pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy202); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy202); + yymsp[-2].minor.yy202 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0); + if( bNot ) yymsp[-2].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy202, 0); + if( yymsp[-2].minor.yy202 ) yymsp[-2].minor.yy202->flags |= EP_InfixFunc; +} + break; + case 195: /* expr ::= expr likeop expr ESCAPE expr */ +{ + ExprList *pList; + int bNot = yymsp[-3].minor.yy0.n & 0x80000000; + yymsp[-3].minor.yy0.n &= 0x7fffffff; + pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy202); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy202); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy202); + yymsp[-4].minor.yy202 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0); + if( bNot ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0); + if( yymsp[-4].minor.yy202 ) yymsp[-4].minor.yy202->flags |= EP_InfixFunc; +} + break; + case 196: /* expr ::= expr ISNULL|NOTNULL */ +{yymsp[-1].minor.yy202 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy202,0);} + break; + case 197: /* expr ::= expr NOT NULL */ +{yymsp[-2].minor.yy202 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy202,0);} + break; + case 198: /* expr ::= expr IS expr */ +{ + yymsp[-2].minor.yy202 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy202,yymsp[0].minor.yy202); + binaryToUnaryIfNull(pParse, yymsp[0].minor.yy202, yymsp[-2].minor.yy202, TK_ISNULL); +} + break; + case 199: /* expr ::= expr IS NOT expr */ +{ + yymsp[-3].minor.yy202 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy202,yymsp[0].minor.yy202); + binaryToUnaryIfNull(pParse, yymsp[0].minor.yy202, yymsp[-3].minor.yy202, TK_NOTNULL); +} + break; + case 200: /* expr ::= NOT expr */ + case 201: /* expr ::= BITNOT expr */ yytestcase(yyruleno==201); +{yymsp[-1].minor.yy202 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy202, 0);/*A-overwrites-B*/} + break; + case 202: /* expr ::= PLUS|MINUS expr */ +{ + yymsp[-1].minor.yy202 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy202, 0); + /*A-overwrites-B*/ +} + break; + case 203: /* between_op ::= BETWEEN */ + case 206: /* in_op ::= IN */ yytestcase(yyruleno==206); +{yymsp[0].minor.yy192 = 0;} + break; + case 205: /* expr ::= expr between_op expr AND expr */ +{ + ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy202); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy202); + yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy202, 0); + if( yymsp[-4].minor.yy202 ){ + yymsp[-4].minor.yy202->x.pList = pList; + }else{ + sqlite3ExprListDelete(pParse->db, pList); + } + if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0); +} + break; + case 208: /* expr ::= expr in_op LP exprlist RP */ +{ + if( yymsp[-1].minor.yy242==0 ){ + /* Expressions of the form + ** + ** expr1 IN () + ** expr1 NOT IN () + ** + ** simplify to constants 0 (false) and 1 (true), respectively, + ** regardless of the value of expr1. + */ + sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy202); + yymsp[-4].minor.yy202 = sqlite3Expr(pParse->db, TK_INTEGER, yymsp[-3].minor.yy192 ? "1" : "0"); + }else if( yymsp[-1].minor.yy242->nExpr==1 && sqlite3ExprIsConstant(yymsp[-1].minor.yy242->a[0].pExpr) ){ + Expr *pRHS = yymsp[-1].minor.yy242->a[0].pExpr; + yymsp[-1].minor.yy242->a[0].pExpr = 0; + sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy242); + pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0); + yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy202, pRHS); + if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0); + }else{ + yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy202, 0); + if( yymsp[-4].minor.yy202 ){ + yymsp[-4].minor.yy202->x.pList = yymsp[-1].minor.yy242; + sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy202); + }else{ + sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy242); + } + if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0); + } + } + break; + case 209: /* expr ::= LP select RP */ +{ + yymsp[-2].minor.yy202 = sqlite3PExpr(pParse, TK_SELECT, 0, 0); + sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy202, yymsp[-1].minor.yy539); + } + break; + case 210: /* expr ::= expr in_op LP select RP */ +{ + yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy202, 0); + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy202, yymsp[-1].minor.yy539); + if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0); + } + break; + case 211: /* expr ::= expr in_op nm dbnm paren_exprlist */ +{ + SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); + Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0); + if( yymsp[0].minor.yy242 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy242); + yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy202, 0); + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy202, pSelect); + if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0); + } + break; + case 212: /* expr ::= EXISTS LP select RP */ +{ + Expr *p; + p = yymsp[-3].minor.yy202 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0); + sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy539); + } + break; + case 213: /* expr ::= CASE case_operand case_exprlist case_else END */ +{ + yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy202, 0); + if( yymsp[-4].minor.yy202 ){ + yymsp[-4].minor.yy202->x.pList = yymsp[-1].minor.yy202 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy242,yymsp[-1].minor.yy202) : yymsp[-2].minor.yy242; + sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy202); + }else{ + sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy242); + sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy202); + } +} + break; + case 214: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */ +{ + yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242, yymsp[-2].minor.yy202); + yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242, yymsp[0].minor.yy202); +} + break; + case 215: /* case_exprlist ::= WHEN expr THEN expr */ +{ + yymsp[-3].minor.yy242 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy202); + yymsp[-3].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy242, yymsp[0].minor.yy202); +} + break; + case 218: /* case_operand ::= expr */ +{yymsp[0].minor.yy202 = yymsp[0].minor.yy202; /*A-overwrites-X*/} + break; + case 221: /* nexprlist ::= nexprlist COMMA expr */ +{yymsp[-2].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy242,yymsp[0].minor.yy202);} + break; + case 222: /* nexprlist ::= expr */ +{yymsp[0].minor.yy242 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy202); /*A-overwrites-Y*/} + break; + case 224: /* paren_exprlist ::= LP exprlist RP */ + case 229: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==229); +{yymsp[-2].minor.yy242 = yymsp[-1].minor.yy242;} + break; + case 225: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ +{ + sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, + sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy242, yymsp[-10].minor.yy192, + &yymsp[-11].minor.yy0, yymsp[0].minor.yy202, SQLITE_SO_ASC, yymsp[-8].minor.yy192, SQLITE_IDXTYPE_APPDEF); + if( IN_RENAME_OBJECT && pParse->pNewIndex ){ + sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0); + } +} + break; + case 226: /* uniqueflag ::= UNIQUE */ + case 268: /* raisetype ::= ABORT */ yytestcase(yyruleno==268); +{yymsp[0].minor.yy192 = OE_Abort;} + break; + case 227: /* uniqueflag ::= */ +{yymsp[1].minor.yy192 = OE_None;} + break; + case 230: /* eidlist ::= eidlist COMMA nm collate sortorder */ +{ + yymsp[-4].minor.yy242 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy242, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy192, yymsp[0].minor.yy192); +} + break; + case 231: /* eidlist ::= nm collate sortorder */ +{ + yymsp[-2].minor.yy242 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy192, yymsp[0].minor.yy192); /*A-overwrites-Y*/ +} + break; + case 234: /* cmd ::= DROP INDEX ifexists fullname */ +{sqlite3DropIndex(pParse, yymsp[0].minor.yy47, yymsp[-1].minor.yy192);} + break; + case 235: /* cmd ::= VACUUM vinto */ +{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy202);} + break; + case 236: /* cmd ::= VACUUM nm vinto */ +{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy202);} + break; + case 239: /* cmd ::= PRAGMA nm dbnm */ +{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);} + break; + case 240: /* cmd ::= PRAGMA nm dbnm EQ nmnum */ +{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);} + break; + case 241: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */ +{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);} + break; + case 242: /* cmd ::= PRAGMA nm dbnm EQ minus_num */ +{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);} + break; + case 243: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */ +{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);} + break; + case 246: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ +{ + Token all; + all.z = yymsp[-3].minor.yy0.z; + all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n; + sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy447, &all); +} + break; + case 247: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ +{ + sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy192, yymsp[-4].minor.yy230.a, yymsp[-4].minor.yy230.b, yymsp[-2].minor.yy47, yymsp[0].minor.yy202, yymsp[-10].minor.yy192, yymsp[-8].minor.yy192); + yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /*A-overwrites-T*/ +} + break; + case 248: /* trigger_time ::= BEFORE|AFTER */ +{ yymsp[0].minor.yy192 = yymsp[0].major; /*A-overwrites-X*/ } + break; + case 249: /* trigger_time ::= INSTEAD OF */ +{ yymsp[-1].minor.yy192 = TK_INSTEAD;} + break; + case 250: /* trigger_time ::= */ +{ yymsp[1].minor.yy192 = TK_BEFORE; } + break; + case 251: /* trigger_event ::= DELETE|INSERT */ + case 252: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==252); +{yymsp[0].minor.yy230.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy230.b = 0;} + break; + case 253: /* trigger_event ::= UPDATE OF idlist */ +{yymsp[-2].minor.yy230.a = TK_UPDATE; yymsp[-2].minor.yy230.b = yymsp[0].minor.yy600;} + break; + case 254: /* when_clause ::= */ + case 273: /* key_opt ::= */ yytestcase(yyruleno==273); +{ yymsp[1].minor.yy202 = 0; } + break; + case 255: /* when_clause ::= WHEN expr */ + case 274: /* key_opt ::= KEY expr */ yytestcase(yyruleno==274); +{ yymsp[-1].minor.yy202 = yymsp[0].minor.yy202; } + break; + case 256: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ +{ + assert( yymsp[-2].minor.yy447!=0 ); + yymsp[-2].minor.yy447->pLast->pNext = yymsp[-1].minor.yy447; + yymsp[-2].minor.yy447->pLast = yymsp[-1].minor.yy447; +} + break; + case 257: /* trigger_cmd_list ::= trigger_cmd SEMI */ +{ + assert( yymsp[-1].minor.yy447!=0 ); + yymsp[-1].minor.yy447->pLast = yymsp[-1].minor.yy447; +} + break; + case 258: /* trnm ::= nm DOT nm */ +{ + yymsp[-2].minor.yy0 = yymsp[0].minor.yy0; + sqlite3ErrorMsg(pParse, + "qualified table names are not allowed on INSERT, UPDATE, and DELETE " + "statements within triggers"); +} + break; + case 259: /* tridxby ::= INDEXED BY nm */ +{ + sqlite3ErrorMsg(pParse, + "the INDEXED BY clause is not allowed on UPDATE or DELETE statements " + "within triggers"); +} + break; + case 260: /* tridxby ::= NOT INDEXED */ +{ + sqlite3ErrorMsg(pParse, + "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements " + "within triggers"); +} + break; + case 261: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ +{yylhsminor.yy447 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy47, yymsp[-3].minor.yy242, yymsp[-1].minor.yy202, yymsp[-7].minor.yy192, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy436);} + yymsp[-8].minor.yy447 = yylhsminor.yy447; + break; + case 262: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ +{ + yylhsminor.yy447 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy600,yymsp[-2].minor.yy539,yymsp[-6].minor.yy192,yymsp[-1].minor.yy318,yymsp[-7].minor.yy436,yymsp[0].minor.yy436);/*yylhsminor.yy447-overwrites-yymsp[-6].minor.yy192*/ +} + yymsp[-7].minor.yy447 = yylhsminor.yy447; + break; + case 263: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ +{yylhsminor.yy447 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy202, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy436);} + yymsp[-5].minor.yy447 = yylhsminor.yy447; + break; + case 264: /* trigger_cmd ::= scanpt select scanpt */ +{yylhsminor.yy447 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy539, yymsp[-2].minor.yy436, yymsp[0].minor.yy436); /*yylhsminor.yy447-overwrites-yymsp[-1].minor.yy539*/} + yymsp[-2].minor.yy447 = yylhsminor.yy447; + break; + case 265: /* expr ::= RAISE LP IGNORE RP */ +{ + yymsp[-3].minor.yy202 = sqlite3PExpr(pParse, TK_RAISE, 0, 0); + if( yymsp[-3].minor.yy202 ){ + yymsp[-3].minor.yy202->affExpr = OE_Ignore; + } +} + break; + case 266: /* expr ::= RAISE LP raisetype COMMA nm RP */ +{ + yymsp[-5].minor.yy202 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1); + if( yymsp[-5].minor.yy202 ) { + yymsp[-5].minor.yy202->affExpr = (char)yymsp[-3].minor.yy192; + } +} + break; + case 267: /* raisetype ::= ROLLBACK */ +{yymsp[0].minor.yy192 = OE_Rollback;} + break; + case 269: /* raisetype ::= FAIL */ +{yymsp[0].minor.yy192 = OE_Fail;} + break; + case 270: /* cmd ::= DROP TRIGGER ifexists fullname */ +{ + sqlite3DropTrigger(pParse,yymsp[0].minor.yy47,yymsp[-1].minor.yy192); +} + break; + case 271: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ +{ + sqlite3Attach(pParse, yymsp[-3].minor.yy202, yymsp[-1].minor.yy202, yymsp[0].minor.yy202); +} + break; + case 272: /* cmd ::= DETACH database_kw_opt expr */ +{ + sqlite3Detach(pParse, yymsp[0].minor.yy202); +} + break; + case 275: /* cmd ::= REINDEX */ +{sqlite3Reindex(pParse, 0, 0);} + break; + case 276: /* cmd ::= REINDEX nm dbnm */ +{sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);} + break; + case 277: /* cmd ::= ANALYZE */ +{sqlite3Analyze(pParse, 0, 0);} + break; + case 278: /* cmd ::= ANALYZE nm dbnm */ +{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);} + break; + case 279: /* cmd ::= ALTER TABLE fullname RENAME TO nm */ +{ + sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy47,&yymsp[0].minor.yy0); +} + break; + case 280: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ +{ + yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n; + sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0); +} + break; + case 281: /* add_column_fullname ::= fullname */ +{ + disableLookaside(pParse); + sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy47); +} + break; + case 282: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ +{ + sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy47, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); +} + break; + case 283: /* cmd ::= create_vtab */ +{sqlite3VtabFinishParse(pParse,0);} + break; + case 284: /* cmd ::= create_vtab LP vtabarglist RP */ +{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);} + break; + case 285: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ +{ + sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy192); +} + break; + case 286: /* vtabarg ::= */ +{sqlite3VtabArgInit(pParse);} + break; + case 287: /* vtabargtoken ::= ANY */ + case 288: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==288); + case 289: /* lp ::= LP */ yytestcase(yyruleno==289); +{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);} + break; + case 290: /* with ::= WITH wqlist */ + case 291: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==291); +{ sqlite3WithPush(pParse, yymsp[0].minor.yy131, 1); } + break; + case 292: /* wqlist ::= nm eidlist_opt AS LP select RP */ +{ + yymsp[-5].minor.yy131 = sqlite3WithAdd(pParse, 0, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy242, yymsp[-1].minor.yy539); /*A-overwrites-X*/ +} + break; + case 293: /* wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */ +{ + yymsp[-7].minor.yy131 = sqlite3WithAdd(pParse, yymsp[-7].minor.yy131, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy242, yymsp[-1].minor.yy539); +} + break; + case 294: /* windowdefn_list ::= windowdefn */ +{ yylhsminor.yy303 = yymsp[0].minor.yy303; } + yymsp[0].minor.yy303 = yylhsminor.yy303; + break; + case 295: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */ +{ + assert( yymsp[0].minor.yy303!=0 ); + sqlite3WindowChain(pParse, yymsp[0].minor.yy303, yymsp[-2].minor.yy303); + yymsp[0].minor.yy303->pNextWin = yymsp[-2].minor.yy303; + yylhsminor.yy303 = yymsp[0].minor.yy303; +} + yymsp[-2].minor.yy303 = yylhsminor.yy303; + break; + case 296: /* windowdefn ::= nm AS LP window RP */ +{ + if( ALWAYS(yymsp[-1].minor.yy303) ){ + yymsp[-1].minor.yy303->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n); + } + yylhsminor.yy303 = yymsp[-1].minor.yy303; +} + yymsp[-4].minor.yy303 = yylhsminor.yy303; + break; + case 297: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */ +{ + yymsp[-4].minor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, yymsp[-2].minor.yy242, yymsp[-1].minor.yy242, 0); +} + break; + case 298: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ +{ + yylhsminor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, yymsp[-2].minor.yy242, yymsp[-1].minor.yy242, &yymsp[-5].minor.yy0); +} + yymsp[-5].minor.yy303 = yylhsminor.yy303; + break; + case 299: /* window ::= ORDER BY sortlist frame_opt */ +{ + yymsp[-3].minor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, 0, yymsp[-1].minor.yy242, 0); +} + break; + case 300: /* window ::= nm ORDER BY sortlist frame_opt */ +{ + yylhsminor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, 0, yymsp[-1].minor.yy242, &yymsp[-4].minor.yy0); +} + yymsp[-4].minor.yy303 = yylhsminor.yy303; + break; + case 301: /* window ::= frame_opt */ + case 320: /* filter_over ::= over_clause */ yytestcase(yyruleno==320); +{ + yylhsminor.yy303 = yymsp[0].minor.yy303; +} + yymsp[0].minor.yy303 = yylhsminor.yy303; + break; + case 302: /* window ::= nm frame_opt */ +{ + yylhsminor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, 0, 0, &yymsp[-1].minor.yy0); +} + yymsp[-1].minor.yy303 = yylhsminor.yy303; + break; + case 303: /* frame_opt ::= */ +{ + yymsp[1].minor.yy303 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0); +} + break; + case 304: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ +{ + yylhsminor.yy303 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy192, yymsp[-1].minor.yy77.eType, yymsp[-1].minor.yy77.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy58); +} + yymsp[-2].minor.yy303 = yylhsminor.yy303; + break; + case 305: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ +{ + yylhsminor.yy303 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy192, yymsp[-3].minor.yy77.eType, yymsp[-3].minor.yy77.pExpr, yymsp[-1].minor.yy77.eType, yymsp[-1].minor.yy77.pExpr, yymsp[0].minor.yy58); +} + yymsp[-5].minor.yy303 = yylhsminor.yy303; + break; + case 307: /* frame_bound_s ::= frame_bound */ + case 309: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==309); +{yylhsminor.yy77 = yymsp[0].minor.yy77;} + yymsp[0].minor.yy77 = yylhsminor.yy77; + break; + case 308: /* frame_bound_s ::= UNBOUNDED PRECEDING */ + case 310: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==310); + case 312: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==312); +{yylhsminor.yy77.eType = yymsp[-1].major; yylhsminor.yy77.pExpr = 0;} + yymsp[-1].minor.yy77 = yylhsminor.yy77; + break; + case 311: /* frame_bound ::= expr PRECEDING|FOLLOWING */ +{yylhsminor.yy77.eType = yymsp[0].major; yylhsminor.yy77.pExpr = yymsp[-1].minor.yy202;} + yymsp[-1].minor.yy77 = yylhsminor.yy77; + break; + case 313: /* frame_exclude_opt ::= */ +{yymsp[1].minor.yy58 = 0;} + break; + case 314: /* frame_exclude_opt ::= EXCLUDE frame_exclude */ +{yymsp[-1].minor.yy58 = yymsp[0].minor.yy58;} + break; + case 315: /* frame_exclude ::= NO OTHERS */ + case 316: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==316); +{yymsp[-1].minor.yy58 = yymsp[-1].major; /*A-overwrites-X*/} + break; + case 317: /* frame_exclude ::= GROUP|TIES */ +{yymsp[0].minor.yy58 = yymsp[0].major; /*A-overwrites-X*/} + break; + case 318: /* window_clause ::= WINDOW windowdefn_list */ +{ yymsp[-1].minor.yy303 = yymsp[0].minor.yy303; } + break; + case 319: /* filter_over ::= filter_clause over_clause */ +{ + yymsp[0].minor.yy303->pFilter = yymsp[-1].minor.yy202; + yylhsminor.yy303 = yymsp[0].minor.yy303; +} + yymsp[-1].minor.yy303 = yylhsminor.yy303; + break; + case 321: /* filter_over ::= filter_clause */ +{ + yylhsminor.yy303 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); + if( yylhsminor.yy303 ){ + yylhsminor.yy303->eFrmType = TK_FILTER; + yylhsminor.yy303->pFilter = yymsp[0].minor.yy202; + }else{ + sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy202); + } +} + yymsp[0].minor.yy303 = yylhsminor.yy303; + break; + case 322: /* over_clause ::= OVER LP window RP */ +{ + yymsp[-3].minor.yy303 = yymsp[-1].minor.yy303; + assert( yymsp[-3].minor.yy303!=0 ); +} + break; + case 323: /* over_clause ::= OVER nm */ +{ + yymsp[-1].minor.yy303 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); + if( yymsp[-1].minor.yy303 ){ + yymsp[-1].minor.yy303->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n); + } +} + break; + case 324: /* filter_clause ::= FILTER LP WHERE expr RP */ +{ yymsp[-4].minor.yy202 = yymsp[-1].minor.yy202; } + break; + default: + /* (325) input ::= cmdlist */ yytestcase(yyruleno==325); + /* (326) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==326); + /* (327) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=327); + /* (328) ecmd ::= SEMI */ yytestcase(yyruleno==328); + /* (329) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==329); + /* (330) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=330); + /* (331) trans_opt ::= */ yytestcase(yyruleno==331); + /* (332) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==332); + /* (333) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==333); + /* (334) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==334); + /* (335) savepoint_opt ::= */ yytestcase(yyruleno==335); + /* (336) cmd ::= create_table create_table_args */ yytestcase(yyruleno==336); + /* (337) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==337); + /* (338) columnlist ::= columnname carglist */ yytestcase(yyruleno==338); + /* (339) nm ::= ID|INDEXED */ yytestcase(yyruleno==339); + /* (340) nm ::= STRING */ yytestcase(yyruleno==340); + /* (341) nm ::= JOIN_KW */ yytestcase(yyruleno==341); + /* (342) typetoken ::= typename */ yytestcase(yyruleno==342); + /* (343) typename ::= ID|STRING */ yytestcase(yyruleno==343); + /* (344) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=344); + /* (345) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=345); + /* (346) carglist ::= carglist ccons */ yytestcase(yyruleno==346); + /* (347) carglist ::= */ yytestcase(yyruleno==347); + /* (348) ccons ::= NULL onconf */ yytestcase(yyruleno==348); + /* (349) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==349); + /* (350) ccons ::= AS generated */ yytestcase(yyruleno==350); + /* (351) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==351); + /* (352) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==352); + /* (353) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=353); + /* (354) tconscomma ::= */ yytestcase(yyruleno==354); + /* (355) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=355); + /* (356) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=356); + /* (357) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=357); + /* (358) oneselect ::= values */ yytestcase(yyruleno==358); + /* (359) sclp ::= selcollist COMMA */ yytestcase(yyruleno==359); + /* (360) as ::= ID|STRING */ yytestcase(yyruleno==360); + /* (361) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=361); + /* (362) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==362); + /* (363) exprlist ::= nexprlist */ yytestcase(yyruleno==363); + /* (364) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=364); + /* (365) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=365); + /* (366) nmnum ::= ON */ yytestcase(yyruleno==366); + /* (367) nmnum ::= DELETE */ yytestcase(yyruleno==367); + /* (368) nmnum ::= DEFAULT */ yytestcase(yyruleno==368); + /* (369) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==369); + /* (370) foreach_clause ::= */ yytestcase(yyruleno==370); + /* (371) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==371); + /* (372) trnm ::= nm */ yytestcase(yyruleno==372); + /* (373) tridxby ::= */ yytestcase(yyruleno==373); + /* (374) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==374); + /* (375) database_kw_opt ::= */ yytestcase(yyruleno==375); + /* (376) kwcolumn_opt ::= */ yytestcase(yyruleno==376); + /* (377) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==377); + /* (378) vtabarglist ::= vtabarg */ yytestcase(yyruleno==378); + /* (379) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==379); + /* (380) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==380); + /* (381) anylist ::= */ yytestcase(yyruleno==381); + /* (382) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==382); + /* (383) anylist ::= anylist ANY */ yytestcase(yyruleno==383); + /* (384) with ::= */ yytestcase(yyruleno==384); + break; +/********** End reduce actions ************************************************/ + }; + assert( yyrulenoYY_MAX_SHIFT && yyact<=YY_MAX_SHIFTREDUCE) ); + + /* It is not possible for a REDUCE to be followed by an error */ + assert( yyact!=YY_ERROR_ACTION ); + + yymsp += yysize+1; + yypParser->yytos = yymsp; + yymsp->stateno = (YYACTIONTYPE)yyact; + yymsp->major = (YYCODETYPE)yygoto; + yyTraceShift(yypParser, yyact, "... then shift"); + return yyact; +} + +/* +** The following code executes when the parse fails +*/ +#ifndef YYNOERRORRECOVERY +static void yy_parse_failed( + yyParser *yypParser /* The parser */ +){ + sqlite3ParserARG_FETCH + sqlite3ParserCTX_FETCH +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); + } +#endif + while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser fails */ +/************ Begin %parse_failure code ***************************************/ +/************ End %parse_failure code *****************************************/ + sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument variable */ + sqlite3ParserCTX_STORE +} +#endif /* YYNOERRORRECOVERY */ + +/* +** The following code executes when a syntax error first occurs. +*/ +static void yy_syntax_error( + yyParser *yypParser, /* The parser */ + int yymajor, /* The major type of the error token */ + sqlite3ParserTOKENTYPE yyminor /* The minor type of the error token */ +){ + sqlite3ParserARG_FETCH + sqlite3ParserCTX_FETCH +#define TOKEN yyminor +/************ Begin %syntax_error code ****************************************/ + + UNUSED_PARAMETER(yymajor); /* Silence some compiler warnings */ + if( TOKEN.z[0] ){ + sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN); + }else{ + sqlite3ErrorMsg(pParse, "incomplete input"); + } +/************ End %syntax_error code ******************************************/ + sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument variable */ + sqlite3ParserCTX_STORE +} + +/* +** The following is executed when the parser accepts +*/ +static void yy_accept( + yyParser *yypParser /* The parser */ +){ + sqlite3ParserARG_FETCH + sqlite3ParserCTX_FETCH +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); + } +#endif +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt = -1; +#endif + assert( yypParser->yytos==yypParser->yystack ); + /* Here code is inserted which will be executed whenever the + ** parser accepts */ +/*********** Begin %parse_accept code *****************************************/ +/*********** End %parse_accept code *******************************************/ + sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument variable */ + sqlite3ParserCTX_STORE +} + +/* The main parser program. +** The first argument is a pointer to a structure obtained from +** "sqlite3ParserAlloc" which describes the current state of the parser. +** The second argument is the major token number. The third is +** the minor token. The fourth optional argument is whatever the +** user wants (and specified in the grammar) and is available for +** use by the action routines. +** +** Inputs: +**
      +**
    • A pointer to the parser (an opaque structure.) +**
    • The major token number. +**
    • The minor token number. +**
    • An option argument of a grammar-specified type. +**
    +** +** Outputs: +** None. +*/ +SQLITE_PRIVATE void sqlite3Parser( + void *yyp, /* The parser */ + int yymajor, /* The major token code number */ + sqlite3ParserTOKENTYPE yyminor /* The value for the token */ + sqlite3ParserARG_PDECL /* Optional %extra_argument parameter */ +){ + YYMINORTYPE yyminorunion; + YYACTIONTYPE yyact; /* The parser action. */ +#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY) + int yyendofinput; /* True if we are at the end of input */ +#endif +#ifdef YYERRORSYMBOL + int yyerrorhit = 0; /* True if yymajor has invoked an error */ +#endif + yyParser *yypParser = (yyParser*)yyp; /* The parser */ + sqlite3ParserCTX_FETCH + sqlite3ParserARG_STORE + + assert( yypParser->yytos!=0 ); +#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY) + yyendofinput = (yymajor==0); +#endif + + yyact = yypParser->yytos->stateno; +#ifndef NDEBUG + if( yyTraceFILE ){ + if( yyact < YY_MIN_REDUCE ){ + fprintf(yyTraceFILE,"%sInput '%s' in state %d\n", + yyTracePrompt,yyTokenName[yymajor],yyact); + }else{ + fprintf(yyTraceFILE,"%sInput '%s' with pending reduce %d\n", + yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE); + } + } +#endif + + do{ + assert( yyact==yypParser->yytos->stateno ); + yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact); + if( yyact >= YY_MIN_REDUCE ){ + yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor, + yyminor sqlite3ParserCTX_PARAM); + }else if( yyact <= YY_MAX_SHIFTREDUCE ){ + yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor); +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt--; +#endif + break; + }else if( yyact==YY_ACCEPT_ACTION ){ + yypParser->yytos--; + yy_accept(yypParser); + return; + }else{ + assert( yyact == YY_ERROR_ACTION ); + yyminorunion.yy0 = yyminor; +#ifdef YYERRORSYMBOL + int yymx; +#endif +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt); + } +#endif +#ifdef YYERRORSYMBOL + /* A syntax error has occurred. + ** The response to an error depends upon whether or not the + ** grammar defines an error token "ERROR". + ** + ** This is what we do if the grammar does define ERROR: + ** + ** * Call the %syntax_error function. + ** + ** * Begin popping the stack until we enter a state where + ** it is legal to shift the error symbol, then shift + ** the error symbol. + ** + ** * Set the error count to three. + ** + ** * Begin accepting and shifting new tokens. No new error + ** processing will occur until three tokens have been + ** shifted successfully. + ** + */ + if( yypParser->yyerrcnt<0 ){ + yy_syntax_error(yypParser,yymajor,yyminor); + } + yymx = yypParser->yytos->major; + if( yymx==YYERRORSYMBOL || yyerrorhit ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sDiscard input token %s\n", + yyTracePrompt,yyTokenName[yymajor]); + } +#endif + yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion); + yymajor = YYNOCODE; + }else{ + while( yypParser->yytos >= yypParser->yystack + && (yyact = yy_find_reduce_action( + yypParser->yytos->stateno, + YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE + ){ + yy_pop_parser_stack(yypParser); + } + if( yypParser->yytos < yypParser->yystack || yymajor==0 ){ + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + yy_parse_failed(yypParser); +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt = -1; +#endif + yymajor = YYNOCODE; + }else if( yymx!=YYERRORSYMBOL ){ + yy_shift(yypParser,yyact,YYERRORSYMBOL,yyminor); + } + } + yypParser->yyerrcnt = 3; + yyerrorhit = 1; + if( yymajor==YYNOCODE ) break; + yyact = yypParser->yytos->stateno; +#elif defined(YYNOERRORRECOVERY) + /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to + ** do any kind of error recovery. Instead, simply invoke the syntax + ** error routine and continue going as if nothing had happened. + ** + ** Applications can set this macro (for example inside %include) if + ** they intend to abandon the parse upon the first syntax error seen. + */ + yy_syntax_error(yypParser,yymajor, yyminor); + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + break; +#else /* YYERRORSYMBOL is not defined */ + /* This is what we do if the grammar does not define ERROR: + ** + ** * Report an error message, and throw away the input token. + ** + ** * If the input token is $, then fail the parse. + ** + ** As before, subsequent error messages are suppressed until + ** three input tokens have been successfully shifted. + */ + if( yypParser->yyerrcnt<=0 ){ + yy_syntax_error(yypParser,yymajor, yyminor); + } + yypParser->yyerrcnt = 3; + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + if( yyendofinput ){ + yy_parse_failed(yypParser); +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt = -1; +#endif + } + break; +#endif + } + }while( yypParser->yytos>yypParser->yystack ); +#ifndef NDEBUG + if( yyTraceFILE ){ + yyStackEntry *i; + char cDiv = '['; + fprintf(yyTraceFILE,"%sReturn. Stack=",yyTracePrompt); + for(i=&yypParser->yystack[1]; i<=yypParser->yytos; i++){ + fprintf(yyTraceFILE,"%c%s", cDiv, yyTokenName[i->major]); + cDiv = ' '; + } + fprintf(yyTraceFILE,"]\n"); + } +#endif + return; +} + +/* +** Return the fallback token corresponding to canonical token iToken, or +** 0 if iToken has no fallback. +*/ +SQLITE_PRIVATE int sqlite3ParserFallback(int iToken){ +#ifdef YYFALLBACK + assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) ); + return yyFallback[iToken]; +#else + (void)iToken; + return 0; +#endif +} + +/************** End of parse.c ***********************************************/ +/************** Begin file tokenize.c ****************************************/ +/* +** 2001 September 15 +** +** 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. +** +************************************************************************* +** An tokenizer for SQL +** +** This file contains C code that splits an SQL input string up into +** individual tokens and sends those tokens one-by-one over to the +** parser for analysis. +*/ +/* #include "sqliteInt.h" */ +/* #include */ + +/* Character classes for tokenizing +** +** In the sqlite3GetToken() function, a switch() on aiClass[c] is implemented +** using a lookup table, whereas a switch() directly on c uses a binary search. +** The lookup table is much faster. To maximize speed, and to ensure that +** a lookup table is used, all of the classes need to be small integers and +** all of them need to be used within the switch. +*/ +#define CC_X 0 /* The letter 'x', or start of BLOB literal */ +#define CC_KYWD 1 /* Alphabetics or '_'. Usable in a keyword */ +#define CC_ID 2 /* unicode characters usable in IDs */ +#define CC_DIGIT 3 /* Digits */ +#define CC_DOLLAR 4 /* '$' */ +#define CC_VARALPHA 5 /* '@', '#', ':'. Alphabetic SQL variables */ +#define CC_VARNUM 6 /* '?'. Numeric SQL variables */ +#define CC_SPACE 7 /* Space characters */ +#define CC_QUOTE 8 /* '"', '\'', or '`'. String literals, quoted ids */ +#define CC_QUOTE2 9 /* '['. [...] style quoted ids */ +#define CC_PIPE 10 /* '|'. Bitwise OR or concatenate */ +#define CC_MINUS 11 /* '-'. Minus or SQL-style comment */ +#define CC_LT 12 /* '<'. Part of < or <= or <> */ +#define CC_GT 13 /* '>'. Part of > or >= */ +#define CC_EQ 14 /* '='. Part of = or == */ +#define CC_BANG 15 /* '!'. Part of != */ +#define CC_SLASH 16 /* '/'. / or c-style comment */ +#define CC_LP 17 /* '(' */ +#define CC_RP 18 /* ')' */ +#define CC_SEMI 19 /* ';' */ +#define CC_PLUS 20 /* '+' */ +#define CC_STAR 21 /* '*' */ +#define CC_PERCENT 22 /* '%' */ +#define CC_COMMA 23 /* ',' */ +#define CC_AND 24 /* '&' */ +#define CC_TILDA 25 /* '~' */ +#define CC_DOT 26 /* '.' */ +#define CC_ILLEGAL 27 /* Illegal character */ +#define CC_NUL 28 /* 0x00 */ + +static const unsigned char aiClass[] = { +#ifdef SQLITE_ASCII +/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xa xb xc xd xe xf */ +/* 0x */ 28, 27, 27, 27, 27, 27, 27, 27, 27, 7, 7, 27, 7, 7, 27, 27, +/* 1x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* 2x */ 7, 15, 8, 5, 4, 22, 24, 8, 17, 18, 21, 20, 23, 11, 26, 16, +/* 3x */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 19, 12, 14, 13, 6, +/* 4x */ 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +/* 5x */ 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 9, 27, 27, 27, 1, +/* 6x */ 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +/* 7x */ 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 27, 10, 27, 25, 27, +/* 8x */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +/* 9x */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +/* Ax */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +/* Bx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +/* Cx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +/* Dx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +/* Ex */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +/* Fx */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 +#endif +#ifdef SQLITE_EBCDIC +/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xa xb xc xd xe xf */ +/* 0x */ 27, 27, 27, 27, 27, 7, 27, 27, 27, 27, 27, 27, 7, 7, 27, 27, +/* 1x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* 2x */ 27, 27, 27, 27, 27, 7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* 3x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* 4x */ 7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 26, 12, 17, 20, 10, +/* 5x */ 24, 27, 27, 27, 27, 27, 27, 27, 27, 27, 15, 4, 21, 18, 19, 27, +/* 6x */ 11, 16, 27, 27, 27, 27, 27, 27, 27, 27, 27, 23, 22, 1, 13, 6, +/* 7x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 8, 5, 5, 5, 8, 14, 8, +/* 8x */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27, +/* 9x */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27, +/* Ax */ 27, 25, 1, 1, 1, 1, 1, 0, 1, 1, 27, 27, 27, 27, 27, 27, +/* Bx */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 9, 27, 27, 27, 27, 27, +/* Cx */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27, +/* Dx */ 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 27, 27, 27, 27, 27, 27, +/* Ex */ 27, 27, 1, 1, 1, 1, 1, 0, 1, 1, 27, 27, 27, 27, 27, 27, +/* Fx */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 27, 27, 27, 27, 27, 27, +#endif +}; + +/* +** The charMap() macro maps alphabetic characters (only) into their +** lower-case ASCII equivalent. On ASCII machines, this is just +** an upper-to-lower case map. On EBCDIC machines we also need +** to adjust the encoding. The mapping is only valid for alphabetics +** which are the only characters for which this feature is used. +** +** Used by keywordhash.h +*/ +#ifdef SQLITE_ASCII +# define charMap(X) sqlite3UpperToLower[(unsigned char)X] +#endif +#ifdef SQLITE_EBCDIC +# define charMap(X) ebcdicToAscii[(unsigned char)X] +const unsigned char ebcdicToAscii[] = { +/* 0 1 2 3 4 5 6 7 8 9 A B C D E F */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 3x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 4x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 5x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 0, /* 6x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 7x */ + 0, 97, 98, 99,100,101,102,103,104,105, 0, 0, 0, 0, 0, 0, /* 8x */ + 0,106,107,108,109,110,111,112,113,114, 0, 0, 0, 0, 0, 0, /* 9x */ + 0, 0,115,116,117,118,119,120,121,122, 0, 0, 0, 0, 0, 0, /* Ax */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */ + 0, 97, 98, 99,100,101,102,103,104,105, 0, 0, 0, 0, 0, 0, /* Cx */ + 0,106,107,108,109,110,111,112,113,114, 0, 0, 0, 0, 0, 0, /* Dx */ + 0, 0,115,116,117,118,119,120,121,122, 0, 0, 0, 0, 0, 0, /* Ex */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Fx */ +}; +#endif + +/* +** The sqlite3KeywordCode function looks up an identifier to determine if +** it is a keyword. If it is a keyword, the token code of that keyword is +** returned. If the input is not a keyword, TK_ID is returned. +** +** The implementation of this routine was generated by a program, +** mkkeywordhash.c, located in the tool subdirectory of the distribution. +** The output of the mkkeywordhash.c program is written into a file +** named keywordhash.h and then included into this source file by +** the #include below. +*/ +/************** Include keywordhash.h in the middle of tokenize.c ************/ +/************** Begin file keywordhash.h *************************************/ +/***** This file contains automatically generated code ****** +** +** The code in this file has been automatically generated by +** +** sqlite/tool/mkkeywordhash.c +** +** The code in this file implements a function that determines whether +** or not a given identifier is really an SQL keyword. The same thing +** might be implemented more directly using a hand-written hash table. +** But by using this automatically generated code, the size of the code +** is substantially reduced. This is important for embedded applications +** on platforms with limited memory. +*/ +/* Hash score: 227 */ +/* zKWText[] encodes 984 bytes of keyword text in 648 bytes */ +/* REINDEXEDESCAPEACHECKEYBEFOREIGNOREGEXPLAINSTEADDATABASELECT */ +/* ABLEFTHENDEFERRABLELSEXCLUDELETEMPORARYISNULLSAVEPOINTERSECT */ +/* IESNOTNULLIKEXCEPTRANSACTIONATURALTERAISEXCLUSIVEXISTS */ +/* CONSTRAINTOFFSETRIGGERANGENERATEDETACHAVINGLOBEGINNEREFERENCES */ +/* UNIQUERYWITHOUTERELEASEATTACHBETWEENOTHINGROUPSCASCADEFAULT */ +/* CASECOLLATECREATECURRENT_DATEIMMEDIATEJOINSERTMATCHPLANALYZE */ +/* PRAGMABORTUPDATEVALUESVIRTUALWAYSWHENWHERECURSIVEAFTERENAMEAND */ +/* EFERREDISTINCTAUTOINCREMENTCASTCOLUMNCOMMITCONFLICTCROSS */ +/* CURRENT_TIMESTAMPARTITIONDROPRECEDINGFAILASTFILTEREPLACEFIRST */ +/* FOLLOWINGFROMFULLIMITIFORDERESTRICTOTHERSOVERIGHTROLLBACKROWS */ +/* UNBOUNDEDUNIONUSINGVACUUMVIEWINDOWBYINITIALLYPRIMARY */ +static const char zKWText[647] = { + 'R','E','I','N','D','E','X','E','D','E','S','C','A','P','E','A','C','H', + 'E','C','K','E','Y','B','E','F','O','R','E','I','G','N','O','R','E','G', + 'E','X','P','L','A','I','N','S','T','E','A','D','D','A','T','A','B','A', + 'S','E','L','E','C','T','A','B','L','E','F','T','H','E','N','D','E','F', + 'E','R','R','A','B','L','E','L','S','E','X','C','L','U','D','E','L','E', + 'T','E','M','P','O','R','A','R','Y','I','S','N','U','L','L','S','A','V', + 'E','P','O','I','N','T','E','R','S','E','C','T','I','E','S','N','O','T', + 'N','U','L','L','I','K','E','X','C','E','P','T','R','A','N','S','A','C', + 'T','I','O','N','A','T','U','R','A','L','T','E','R','A','I','S','E','X', + 'C','L','U','S','I','V','E','X','I','S','T','S','C','O','N','S','T','R', + 'A','I','N','T','O','F','F','S','E','T','R','I','G','G','E','R','A','N', + 'G','E','N','E','R','A','T','E','D','E','T','A','C','H','A','V','I','N', + 'G','L','O','B','E','G','I','N','N','E','R','E','F','E','R','E','N','C', + 'E','S','U','N','I','Q','U','E','R','Y','W','I','T','H','O','U','T','E', + 'R','E','L','E','A','S','E','A','T','T','A','C','H','B','E','T','W','E', + 'E','N','O','T','H','I','N','G','R','O','U','P','S','C','A','S','C','A', + 'D','E','F','A','U','L','T','C','A','S','E','C','O','L','L','A','T','E', + 'C','R','E','A','T','E','C','U','R','R','E','N','T','_','D','A','T','E', + 'I','M','M','E','D','I','A','T','E','J','O','I','N','S','E','R','T','M', + 'A','T','C','H','P','L','A','N','A','L','Y','Z','E','P','R','A','G','M', + 'A','B','O','R','T','U','P','D','A','T','E','V','A','L','U','E','S','V', + 'I','R','T','U','A','L','W','A','Y','S','W','H','E','N','W','H','E','R', + 'E','C','U','R','S','I','V','E','A','F','T','E','R','E','N','A','M','E', + 'A','N','D','E','F','E','R','R','E','D','I','S','T','I','N','C','T','A', + 'U','T','O','I','N','C','R','E','M','E','N','T','C','A','S','T','C','O', + 'L','U','M','N','C','O','M','M','I','T','C','O','N','F','L','I','C','T', + 'C','R','O','S','S','C','U','R','R','E','N','T','_','T','I','M','E','S', + 'T','A','M','P','A','R','T','I','T','I','O','N','D','R','O','P','R','E', + 'C','E','D','I','N','G','F','A','I','L','A','S','T','F','I','L','T','E', + 'R','E','P','L','A','C','E','F','I','R','S','T','F','O','L','L','O','W', + 'I','N','G','F','R','O','M','F','U','L','L','I','M','I','T','I','F','O', + 'R','D','E','R','E','S','T','R','I','C','T','O','T','H','E','R','S','O', + 'V','E','R','I','G','H','T','R','O','L','L','B','A','C','K','R','O','W', + 'S','U','N','B','O','U','N','D','E','D','U','N','I','O','N','U','S','I', + 'N','G','V','A','C','U','U','M','V','I','E','W','I','N','D','O','W','B', + 'Y','I','N','I','T','I','A','L','L','Y','P','R','I','M','A','R','Y', +}; +/* aKWHash[i] is the hash value for the i-th keyword */ +static const unsigned char aKWHash[127] = { + 84, 102, 132, 82, 114, 29, 0, 0, 91, 0, 85, 72, 0, + 53, 35, 86, 15, 0, 42, 94, 54, 126, 133, 19, 0, 0, + 138, 0, 40, 128, 0, 22, 104, 0, 9, 0, 0, 122, 80, + 0, 78, 6, 0, 65, 99, 145, 0, 134, 112, 0, 0, 48, + 0, 100, 24, 0, 17, 0, 27, 70, 23, 26, 5, 60, 140, + 107, 121, 0, 73, 101, 71, 143, 61, 119, 74, 0, 49, 0, + 11, 41, 0, 110, 0, 0, 0, 106, 10, 108, 113, 124, 14, + 50, 123, 0, 89, 0, 18, 120, 142, 56, 129, 137, 88, 83, + 37, 30, 125, 0, 0, 105, 51, 130, 127, 0, 34, 0, 0, + 44, 0, 95, 38, 39, 0, 20, 45, 116, 90, +}; +/* aKWNext[] forms the hash collision chain. If aKWHash[i]==0 +** then the i-th keyword has no more hash collisions. Otherwise, +** the next keyword with the same hash is aKWHash[i]-1. */ +static const unsigned char aKWNext[145] = { + 0, 0, 0, 0, 4, 0, 43, 0, 0, 103, 111, 0, 0, + 0, 2, 0, 0, 141, 0, 0, 0, 13, 0, 0, 0, 0, + 139, 0, 0, 118, 52, 0, 0, 135, 12, 0, 0, 62, 0, + 136, 0, 131, 0, 0, 36, 0, 0, 28, 77, 0, 0, 0, + 0, 59, 0, 47, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 69, 0, 0, 0, 0, 0, 144, 3, 0, 58, 0, 1, + 75, 0, 0, 0, 31, 0, 0, 0, 0, 0, 0, 64, 66, + 63, 0, 0, 0, 0, 46, 0, 16, 0, 115, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 81, 97, 0, 8, 0, 109, + 21, 7, 67, 0, 79, 93, 117, 0, 0, 68, 0, 0, 96, + 0, 55, 0, 76, 0, 92, 32, 33, 57, 25, 0, 98, 0, + 0, 87, +}; +/* aKWLen[i] is the length (in bytes) of the i-th keyword */ +static const unsigned char aKWLen[145] = { + 7, 7, 5, 4, 6, 4, 5, 3, 6, 7, 3, 6, 6, + 7, 7, 3, 8, 2, 6, 5, 4, 4, 3, 10, 4, 7, + 6, 9, 4, 2, 6, 5, 9, 9, 4, 7, 3, 2, 4, + 4, 6, 11, 6, 2, 7, 5, 5, 9, 6, 10, 4, 6, + 2, 3, 7, 5, 9, 6, 6, 4, 5, 5, 10, 6, 5, + 7, 4, 5, 7, 6, 7, 7, 6, 5, 7, 3, 7, 4, + 7, 6, 12, 9, 4, 6, 5, 4, 7, 6, 5, 6, 6, + 7, 6, 4, 5, 9, 5, 6, 3, 8, 8, 2, 13, 2, + 2, 4, 6, 6, 8, 5, 17, 12, 7, 9, 4, 9, 4, + 4, 6, 7, 5, 9, 4, 4, 5, 2, 5, 8, 6, 4, + 5, 8, 4, 3, 9, 5, 5, 6, 4, 6, 2, 2, 9, + 3, 7, +}; +/* aKWOffset[i] is the index into zKWText[] of the start of +** the text for the i-th keyword. */ +static const unsigned short int aKWOffset[145] = { + 0, 2, 2, 8, 9, 14, 16, 20, 23, 25, 25, 29, 33, + 36, 41, 46, 48, 53, 54, 59, 62, 65, 67, 69, 78, 81, + 86, 90, 90, 94, 99, 101, 105, 111, 119, 123, 123, 123, 126, + 129, 132, 137, 142, 146, 147, 152, 156, 160, 168, 174, 181, 184, + 184, 187, 189, 195, 198, 206, 211, 216, 219, 222, 226, 236, 239, + 244, 244, 248, 252, 259, 265, 271, 277, 277, 283, 284, 288, 295, + 299, 306, 312, 324, 333, 335, 341, 346, 348, 355, 360, 365, 371, + 377, 382, 388, 392, 395, 404, 408, 414, 416, 423, 424, 431, 433, + 435, 444, 448, 454, 460, 468, 473, 473, 473, 489, 498, 501, 510, + 513, 517, 522, 529, 534, 543, 547, 550, 555, 557, 561, 569, 575, + 578, 583, 591, 591, 595, 604, 609, 614, 620, 623, 626, 629, 631, + 636, 640, +}; +/* aKWCode[i] is the parser symbol code for the i-th keyword */ +static const unsigned char aKWCode[145] = { + TK_REINDEX, TK_INDEXED, TK_INDEX, TK_DESC, TK_ESCAPE, + TK_EACH, TK_CHECK, TK_KEY, TK_BEFORE, TK_FOREIGN, + TK_FOR, TK_IGNORE, TK_LIKE_KW, TK_EXPLAIN, TK_INSTEAD, + TK_ADD, TK_DATABASE, TK_AS, TK_SELECT, TK_TABLE, + TK_JOIN_KW, TK_THEN, TK_END, TK_DEFERRABLE, TK_ELSE, + TK_EXCLUDE, TK_DELETE, TK_TEMP, TK_TEMP, TK_OR, + TK_ISNULL, TK_NULLS, TK_SAVEPOINT, TK_INTERSECT, TK_TIES, + TK_NOTNULL, TK_NOT, TK_NO, TK_NULL, TK_LIKE_KW, + TK_EXCEPT, TK_TRANSACTION,TK_ACTION, TK_ON, TK_JOIN_KW, + TK_ALTER, TK_RAISE, TK_EXCLUSIVE, TK_EXISTS, TK_CONSTRAINT, + TK_INTO, TK_OFFSET, TK_OF, TK_SET, TK_TRIGGER, + TK_RANGE, TK_GENERATED, TK_DETACH, TK_HAVING, TK_LIKE_KW, + TK_BEGIN, TK_JOIN_KW, TK_REFERENCES, TK_UNIQUE, TK_QUERY, + TK_WITHOUT, TK_WITH, TK_JOIN_KW, TK_RELEASE, TK_ATTACH, + TK_BETWEEN, TK_NOTHING, TK_GROUPS, TK_GROUP, TK_CASCADE, + TK_ASC, TK_DEFAULT, TK_CASE, TK_COLLATE, TK_CREATE, + TK_CTIME_KW, TK_IMMEDIATE, TK_JOIN, TK_INSERT, TK_MATCH, + TK_PLAN, TK_ANALYZE, TK_PRAGMA, TK_ABORT, TK_UPDATE, + TK_VALUES, TK_VIRTUAL, TK_ALWAYS, TK_WHEN, TK_WHERE, + TK_RECURSIVE, TK_AFTER, TK_RENAME, TK_AND, TK_DEFERRED, + TK_DISTINCT, TK_IS, TK_AUTOINCR, TK_TO, TK_IN, + TK_CAST, TK_COLUMNKW, TK_COMMIT, TK_CONFLICT, TK_JOIN_KW, + TK_CTIME_KW, TK_CTIME_KW, TK_CURRENT, TK_PARTITION, TK_DROP, + TK_PRECEDING, TK_FAIL, TK_LAST, TK_FILTER, TK_REPLACE, + TK_FIRST, TK_FOLLOWING, TK_FROM, TK_JOIN_KW, TK_LIMIT, + TK_IF, TK_ORDER, TK_RESTRICT, TK_OTHERS, TK_OVER, + TK_JOIN_KW, TK_ROLLBACK, TK_ROWS, TK_ROW, TK_UNBOUNDED, + TK_UNION, TK_USING, TK_VACUUM, TK_VIEW, TK_WINDOW, + TK_DO, TK_BY, TK_INITIALLY, TK_ALL, TK_PRIMARY, +}; +/* Hash table decoded: +** 0: INSERT +** 1: IS +** 2: ROLLBACK TRIGGER +** 3: IMMEDIATE +** 4: PARTITION +** 5: TEMP +** 6: +** 7: +** 8: VALUES WITHOUT +** 9: +** 10: MATCH +** 11: NOTHING +** 12: +** 13: OF +** 14: TIES IGNORE +** 15: PLAN +** 16: INSTEAD INDEXED +** 17: +** 18: TRANSACTION RIGHT +** 19: WHEN +** 20: SET HAVING +** 21: IF +** 22: ROWS +** 23: SELECT +** 24: +** 25: +** 26: VACUUM SAVEPOINT +** 27: +** 28: LIKE UNION VIRTUAL REFERENCES +** 29: RESTRICT +** 30: +** 31: THEN REGEXP +** 32: TO +** 33: +** 34: BEFORE +** 35: +** 36: +** 37: FOLLOWING COLLATE CASCADE +** 38: CREATE +** 39: +** 40: CASE REINDEX +** 41: EACH +** 42: +** 43: QUERY +** 44: AND ADD +** 45: PRIMARY ANALYZE +** 46: +** 47: ROW ASC DETACH +** 48: CURRENT_TIME CURRENT_DATE +** 49: +** 50: +** 51: EXCLUSIVE TEMPORARY +** 52: +** 53: DEFERRED +** 54: DEFERRABLE +** 55: +** 56: DATABASE +** 57: +** 58: DELETE VIEW GENERATED +** 59: ATTACH +** 60: END +** 61: EXCLUDE +** 62: ESCAPE DESC +** 63: GLOB +** 64: WINDOW ELSE +** 65: COLUMN +** 66: FIRST +** 67: +** 68: GROUPS ALL +** 69: DISTINCT DROP KEY +** 70: BETWEEN +** 71: INITIALLY +** 72: BEGIN +** 73: FILTER CHECK ACTION +** 74: GROUP INDEX +** 75: +** 76: EXISTS DEFAULT +** 77: +** 78: FOR CURRENT_TIMESTAMP +** 79: EXCEPT +** 80: +** 81: CROSS +** 82: +** 83: +** 84: +** 85: CAST +** 86: FOREIGN AUTOINCREMENT +** 87: COMMIT +** 88: CURRENT AFTER ALTER +** 89: FULL FAIL CONFLICT +** 90: EXPLAIN +** 91: CONSTRAINT +** 92: FROM ALWAYS +** 93: +** 94: ABORT +** 95: +** 96: AS DO +** 97: REPLACE WITH RELEASE +** 98: BY RENAME +** 99: RANGE RAISE +** 100: OTHERS +** 101: USING NULLS +** 102: PRAGMA +** 103: JOIN ISNULL OFFSET +** 104: NOT +** 105: OR LAST LEFT +** 106: LIMIT +** 107: +** 108: +** 109: IN +** 110: INTO +** 111: OVER RECURSIVE +** 112: ORDER OUTER +** 113: +** 114: INTERSECT UNBOUNDED +** 115: +** 116: +** 117: ON +** 118: +** 119: WHERE +** 120: NO INNER +** 121: NULL +** 122: +** 123: TABLE +** 124: NATURAL NOTNULL +** 125: PRECEDING +** 126: UPDATE UNIQUE +*/ +/* Check to see if z[0..n-1] is a keyword. If it is, write the +** parser symbol code for that keyword into *pType. Always +** return the integer n (the length of the token). */ +static int keywordCode(const char *z, int n, int *pType){ + int i, j; + const char *zKW; + if( n>=2 ){ + i = ((charMap(z[0])*4) ^ (charMap(z[n-1])*3) ^ n) % 127; + for(i=((int)aKWHash[i])-1; i>=0; i=((int)aKWNext[i])-1){ + if( aKWLen[i]!=n ) continue; + zKW = &zKWText[aKWOffset[i]]; +#ifdef SQLITE_ASCII + if( (z[0]&~0x20)!=zKW[0] ) continue; + if( (z[1]&~0x20)!=zKW[1] ) continue; + j = 2; + while( j=SQLITE_N_KEYWORD ) return SQLITE_ERROR; + *pzName = zKWText + aKWOffset[i]; + *pnName = aKWLen[i]; + return SQLITE_OK; +} +SQLITE_API int sqlite3_keyword_count(void){ return SQLITE_N_KEYWORD; } +SQLITE_API int sqlite3_keyword_check(const char *zName, int nName){ + return TK_ID!=sqlite3KeywordCode((const u8*)zName, nName); +} + +/************** End of keywordhash.h *****************************************/ +/************** Continuing where we left off in tokenize.c *******************/ + + +/* +** If X is a character that can be used in an identifier then +** IdChar(X) will be true. Otherwise it is false. +** +** For ASCII, any character with the high-order bit set is +** allowed in an identifier. For 7-bit characters, +** sqlite3IsIdChar[X] must be 1. +** +** For EBCDIC, the rules are more complex but have the same +** end result. +** +** Ticket #1066. the SQL standard does not allow '$' in the +** middle of identifiers. But many SQL implementations do. +** SQLite will allow '$' in identifiers for compatibility. +** But the feature is undocumented. +*/ +#ifdef SQLITE_ASCII +#define IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0) +#endif +#ifdef SQLITE_EBCDIC +SQLITE_PRIVATE const char sqlite3IsEbcdicIdChar[] = { +/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */ + 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 4x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, /* 5x */ + 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, /* 6x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, /* 7x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, /* 8x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, /* 9x */ + 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, /* Ax */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Cx */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Dx */ + 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Ex */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, /* Fx */ +}; +#define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40])) +#endif + +/* Make the IdChar function accessible from ctime.c and alter.c */ +SQLITE_PRIVATE int sqlite3IsIdChar(u8 c){ return IdChar(c); } + +#ifndef SQLITE_OMIT_WINDOWFUNC +/* +** Return the id of the next token in string (*pz). Before returning, set +** (*pz) to point to the byte following the parsed token. +*/ +static int getToken(const unsigned char **pz){ + const unsigned char *z = *pz; + int t; /* Token type to return */ + do { + z += sqlite3GetToken(z, &t); + }while( t==TK_SPACE ); + if( t==TK_ID + || t==TK_STRING + || t==TK_JOIN_KW + || t==TK_WINDOW + || t==TK_OVER + || sqlite3ParserFallback(t)==TK_ID + ){ + t = TK_ID; + } + *pz = z; + return t; +} + +/* +** The following three functions are called immediately after the tokenizer +** reads the keywords WINDOW, OVER and FILTER, respectively, to determine +** whether the token should be treated as a keyword or an SQL identifier. +** This cannot be handled by the usual lemon %fallback method, due to +** the ambiguity in some constructions. e.g. +** +** SELECT sum(x) OVER ... +** +** In the above, "OVER" might be a keyword, or it might be an alias for the +** sum(x) expression. If a "%fallback ID OVER" directive were added to +** grammar, then SQLite would always treat "OVER" as an alias, making it +** impossible to call a window-function without a FILTER clause. +** +** WINDOW is treated as a keyword if: +** +** * the following token is an identifier, or a keyword that can fallback +** to being an identifier, and +** * the token after than one is TK_AS. +** +** OVER is a keyword if: +** +** * the previous token was TK_RP, and +** * the next token is either TK_LP or an identifier. +** +** FILTER is a keyword if: +** +** * the previous token was TK_RP, and +** * the next token is TK_LP. +*/ +static int analyzeWindowKeyword(const unsigned char *z){ + int t; + t = getToken(&z); + if( t!=TK_ID ) return TK_ID; + t = getToken(&z); + if( t!=TK_AS ) return TK_ID; + return TK_WINDOW; +} +static int analyzeOverKeyword(const unsigned char *z, int lastToken){ + if( lastToken==TK_RP ){ + int t = getToken(&z); + if( t==TK_LP || t==TK_ID ) return TK_OVER; + } + return TK_ID; +} +static int analyzeFilterKeyword(const unsigned char *z, int lastToken){ + if( lastToken==TK_RP && getToken(&z)==TK_LP ){ + return TK_FILTER; + } + return TK_ID; +} +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +/* +** Return the length (in bytes) of the token that begins at z[0]. +** Store the token type in *tokenType before returning. +*/ +SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){ + int i, c; + switch( aiClass[*z] ){ /* Switch on the character-class of the first byte + ** of the token. See the comment on the CC_ defines + ** above. */ + case CC_SPACE: { + testcase( z[0]==' ' ); + testcase( z[0]=='\t' ); + testcase( z[0]=='\n' ); + testcase( z[0]=='\f' ); + testcase( z[0]=='\r' ); + for(i=1; sqlite3Isspace(z[i]); i++){} + *tokenType = TK_SPACE; + return i; + } + case CC_MINUS: { + if( z[1]=='-' ){ + for(i=2; (c=z[i])!=0 && c!='\n'; i++){} + *tokenType = TK_SPACE; /* IMP: R-22934-25134 */ + return i; + } + *tokenType = TK_MINUS; + return 1; + } + case CC_LP: { + *tokenType = TK_LP; + return 1; + } + case CC_RP: { + *tokenType = TK_RP; + return 1; + } + case CC_SEMI: { + *tokenType = TK_SEMI; + return 1; + } + case CC_PLUS: { + *tokenType = TK_PLUS; + return 1; + } + case CC_STAR: { + *tokenType = TK_STAR; + return 1; + } + case CC_SLASH: { + if( z[1]!='*' || z[2]==0 ){ + *tokenType = TK_SLASH; + return 1; + } + for(i=3, c=z[2]; (c!='*' || z[i]!='/') && (c=z[i])!=0; i++){} + if( c ) i++; + *tokenType = TK_SPACE; /* IMP: R-22934-25134 */ + return i; + } + case CC_PERCENT: { + *tokenType = TK_REM; + return 1; + } + case CC_EQ: { + *tokenType = TK_EQ; + return 1 + (z[1]=='='); + } + case CC_LT: { + if( (c=z[1])=='=' ){ + *tokenType = TK_LE; + return 2; + }else if( c=='>' ){ + *tokenType = TK_NE; + return 2; + }else if( c=='<' ){ + *tokenType = TK_LSHIFT; + return 2; + }else{ + *tokenType = TK_LT; + return 1; + } + } + case CC_GT: { + if( (c=z[1])=='=' ){ + *tokenType = TK_GE; + return 2; + }else if( c=='>' ){ + *tokenType = TK_RSHIFT; + return 2; + }else{ + *tokenType = TK_GT; + return 1; + } + } + case CC_BANG: { + if( z[1]!='=' ){ + *tokenType = TK_ILLEGAL; + return 1; + }else{ + *tokenType = TK_NE; + return 2; + } + } + case CC_PIPE: { + if( z[1]!='|' ){ + *tokenType = TK_BITOR; + return 1; + }else{ + *tokenType = TK_CONCAT; + return 2; + } + } + case CC_COMMA: { + *tokenType = TK_COMMA; + return 1; + } + case CC_AND: { + *tokenType = TK_BITAND; + return 1; + } + case CC_TILDA: { + *tokenType = TK_BITNOT; + return 1; + } + case CC_QUOTE: { + int delim = z[0]; + testcase( delim=='`' ); + testcase( delim=='\'' ); + testcase( delim=='"' ); + for(i=1; (c=z[i])!=0; i++){ + if( c==delim ){ + if( z[i+1]==delim ){ + i++; + }else{ + break; + } + } + } + if( c=='\'' ){ + *tokenType = TK_STRING; + return i+1; + }else if( c!=0 ){ + *tokenType = TK_ID; + return i+1; + }else{ + *tokenType = TK_ILLEGAL; + return i; + } + } + case CC_DOT: { +#ifndef SQLITE_OMIT_FLOATING_POINT + if( !sqlite3Isdigit(z[1]) ) +#endif + { + *tokenType = TK_DOT; + return 1; + } + /* If the next character is a digit, this is a floating point + ** number that begins with ".". Fall thru into the next case */ + /* no break */ deliberate_fall_through + } + case CC_DIGIT: { + testcase( z[0]=='0' ); testcase( z[0]=='1' ); testcase( z[0]=='2' ); + testcase( z[0]=='3' ); testcase( z[0]=='4' ); testcase( z[0]=='5' ); + testcase( z[0]=='6' ); testcase( z[0]=='7' ); testcase( z[0]=='8' ); + testcase( z[0]=='9' ); + *tokenType = TK_INTEGER; +#ifndef SQLITE_OMIT_HEX_INTEGER + if( z[0]=='0' && (z[1]=='x' || z[1]=='X') && sqlite3Isxdigit(z[2]) ){ + for(i=3; sqlite3Isxdigit(z[i]); i++){} + return i; + } +#endif + for(i=0; sqlite3Isdigit(z[i]); i++){} +#ifndef SQLITE_OMIT_FLOATING_POINT + if( z[i]=='.' ){ + i++; + while( sqlite3Isdigit(z[i]) ){ i++; } + *tokenType = TK_FLOAT; + } + if( (z[i]=='e' || z[i]=='E') && + ( sqlite3Isdigit(z[i+1]) + || ((z[i+1]=='+' || z[i+1]=='-') && sqlite3Isdigit(z[i+2])) + ) + ){ + i += 2; + while( sqlite3Isdigit(z[i]) ){ i++; } + *tokenType = TK_FLOAT; + } +#endif + while( IdChar(z[i]) ){ + *tokenType = TK_ILLEGAL; + i++; + } + return i; + } + case CC_QUOTE2: { + for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){} + *tokenType = c==']' ? TK_ID : TK_ILLEGAL; + return i; + } + case CC_VARNUM: { + *tokenType = TK_VARIABLE; + for(i=1; sqlite3Isdigit(z[i]); i++){} + return i; + } + case CC_DOLLAR: + case CC_VARALPHA: { + int n = 0; + testcase( z[0]=='$' ); testcase( z[0]=='@' ); + testcase( z[0]==':' ); testcase( z[0]=='#' ); + *tokenType = TK_VARIABLE; + for(i=1; (c=z[i])!=0; i++){ + if( IdChar(c) ){ + n++; +#ifndef SQLITE_OMIT_TCL_VARIABLE + }else if( c=='(' && n>0 ){ + do{ + i++; + }while( (c=z[i])!=0 && !sqlite3Isspace(c) && c!=')' ); + if( c==')' ){ + i++; + }else{ + *tokenType = TK_ILLEGAL; + } + break; + }else if( c==':' && z[i+1]==':' ){ + i++; +#endif + }else{ + break; + } + } + if( n==0 ) *tokenType = TK_ILLEGAL; + return i; + } + case CC_KYWD: { + for(i=1; aiClass[z[i]]<=CC_KYWD; i++){} + if( IdChar(z[i]) ){ + /* This token started out using characters that can appear in keywords, + ** but z[i] is a character not allowed within keywords, so this must + ** be an identifier instead */ + i++; + break; + } + *tokenType = TK_ID; + return keywordCode((char*)z, i, tokenType); + } + case CC_X: { +#ifndef SQLITE_OMIT_BLOB_LITERAL + testcase( z[0]=='x' ); testcase( z[0]=='X' ); + if( z[1]=='\'' ){ + *tokenType = TK_BLOB; + for(i=2; sqlite3Isxdigit(z[i]); i++){} + if( z[i]!='\'' || i%2 ){ + *tokenType = TK_ILLEGAL; + while( z[i] && z[i]!='\'' ){ i++; } + } + if( z[i] ) i++; + return i; + } +#endif + /* If it is not a BLOB literal, then it must be an ID, since no + ** SQL keywords start with the letter 'x'. Fall through */ + /* no break */ deliberate_fall_through + } + case CC_ID: { + i = 1; + break; + } + case CC_NUL: { + *tokenType = TK_ILLEGAL; + return 0; + } + default: { + *tokenType = TK_ILLEGAL; + return 1; + } + } + while( IdChar(z[i]) ){ i++; } + *tokenType = TK_ID; + return i; +} + +/* +** Run the parser on the given SQL string. The parser structure is +** passed in. An SQLITE_ status code is returned. If an error occurs +** then an and attempt is made to write an error message into +** memory obtained from sqlite3_malloc() and to make *pzErrMsg point to that +** error message. +*/ +SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){ + int nErr = 0; /* Number of errors encountered */ + void *pEngine; /* The LEMON-generated LALR(1) parser */ + int n = 0; /* Length of the next token token */ + int tokenType; /* type of the next token */ + int lastTokenParsed = -1; /* type of the previous token */ + sqlite3 *db = pParse->db; /* The database connection */ + int mxSqlLen; /* Max length of an SQL string */ +#ifdef sqlite3Parser_ENGINEALWAYSONSTACK + yyParser sEngine; /* Space to hold the Lemon-generated Parser object */ +#endif + VVA_ONLY( u8 startedWithOom = db->mallocFailed ); + + assert( zSql!=0 ); + mxSqlLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH]; + if( db->nVdbeActive==0 ){ + AtomicStore(&db->u1.isInterrupted, 0); + } + pParse->rc = SQLITE_OK; + pParse->zTail = zSql; + assert( pzErrMsg!=0 ); +#ifdef SQLITE_DEBUG + if( db->flags & SQLITE_ParserTrace ){ + printf("parser: [[[%s]]]\n", zSql); + sqlite3ParserTrace(stdout, "parser: "); + }else{ + sqlite3ParserTrace(0, 0); + } +#endif +#ifdef sqlite3Parser_ENGINEALWAYSONSTACK + pEngine = &sEngine; + sqlite3ParserInit(pEngine, pParse); +#else + pEngine = sqlite3ParserAlloc(sqlite3Malloc, pParse); + if( pEngine==0 ){ + sqlite3OomFault(db); + return SQLITE_NOMEM_BKPT; + } +#endif + assert( pParse->pNewTable==0 ); + assert( pParse->pNewTrigger==0 ); + assert( pParse->nVar==0 ); + assert( pParse->pVList==0 ); + pParse->pParentParse = db->pParse; + db->pParse = pParse; + while( 1 ){ + n = sqlite3GetToken((u8*)zSql, &tokenType); + mxSqlLen -= n; + if( mxSqlLen<0 ){ + pParse->rc = SQLITE_TOOBIG; + break; + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( tokenType>=TK_WINDOW ){ + assert( tokenType==TK_SPACE || tokenType==TK_OVER || tokenType==TK_FILTER + || tokenType==TK_ILLEGAL || tokenType==TK_WINDOW + ); +#else + if( tokenType>=TK_SPACE ){ + assert( tokenType==TK_SPACE || tokenType==TK_ILLEGAL ); +#endif /* SQLITE_OMIT_WINDOWFUNC */ + if( AtomicLoad(&db->u1.isInterrupted) ){ + pParse->rc = SQLITE_INTERRUPT; + break; + } + if( tokenType==TK_SPACE ){ + zSql += n; + continue; + } + if( zSql[0]==0 ){ + /* Upon reaching the end of input, call the parser two more times + ** with tokens TK_SEMI and 0, in that order. */ + if( lastTokenParsed==TK_SEMI ){ + tokenType = 0; + }else if( lastTokenParsed==0 ){ + break; + }else{ + tokenType = TK_SEMI; + } + n = 0; +#ifndef SQLITE_OMIT_WINDOWFUNC + }else if( tokenType==TK_WINDOW ){ + assert( n==6 ); + tokenType = analyzeWindowKeyword((const u8*)&zSql[6]); + }else if( tokenType==TK_OVER ){ + assert( n==4 ); + tokenType = analyzeOverKeyword((const u8*)&zSql[4], lastTokenParsed); + }else if( tokenType==TK_FILTER ){ + assert( n==6 ); + tokenType = analyzeFilterKeyword((const u8*)&zSql[6], lastTokenParsed); +#endif /* SQLITE_OMIT_WINDOWFUNC */ + }else{ + sqlite3ErrorMsg(pParse, "unrecognized token: \"%.*s\"", n, zSql); + break; + } + } + pParse->sLastToken.z = zSql; + pParse->sLastToken.n = n; + sqlite3Parser(pEngine, tokenType, pParse->sLastToken); + lastTokenParsed = tokenType; + zSql += n; + assert( db->mallocFailed==0 || pParse->rc!=SQLITE_OK || startedWithOom ); + if( pParse->rc!=SQLITE_OK ) break; + } + assert( nErr==0 ); +#ifdef YYTRACKMAXSTACKDEPTH + sqlite3_mutex_enter(sqlite3MallocMutex()); + sqlite3StatusHighwater(SQLITE_STATUS_PARSER_STACK, + sqlite3ParserStackPeak(pEngine) + ); + sqlite3_mutex_leave(sqlite3MallocMutex()); +#endif /* YYDEBUG */ +#ifdef sqlite3Parser_ENGINEALWAYSONSTACK + sqlite3ParserFinalize(pEngine); +#else + sqlite3ParserFree(pEngine, sqlite3_free); +#endif + if( db->mallocFailed ){ + pParse->rc = SQLITE_NOMEM_BKPT; + } + if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){ + pParse->zErrMsg = sqlite3MPrintf(db, "%s", sqlite3ErrStr(pParse->rc)); + } + assert( pzErrMsg!=0 ); + if( pParse->zErrMsg ){ + *pzErrMsg = pParse->zErrMsg; + sqlite3_log(pParse->rc, "%s in \"%s\"", + *pzErrMsg, pParse->zTail); + pParse->zErrMsg = 0; + nErr++; + } + pParse->zTail = zSql; + if( pParse->pVdbe && pParse->nErr>0 && pParse->nested==0 ){ + sqlite3VdbeDelete(pParse->pVdbe); + pParse->pVdbe = 0; + } +#ifndef SQLITE_OMIT_SHARED_CACHE + if( pParse->nested==0 ){ + sqlite3DbFree(db, pParse->aTableLock); + pParse->aTableLock = 0; + pParse->nTableLock = 0; + } +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + sqlite3_free(pParse->apVtabLock); +#endif + + if( !IN_SPECIAL_PARSE ){ + /* If the pParse->declareVtab flag is set, do not delete any table + ** structure built up in pParse->pNewTable. The calling code (see vtab.c) + ** will take responsibility for freeing the Table structure. + */ + sqlite3DeleteTable(db, pParse->pNewTable); + } + if( !IN_RENAME_OBJECT ){ + sqlite3DeleteTrigger(db, pParse->pNewTrigger); + } + + if( pParse->pWithToFree ) sqlite3WithDelete(db, pParse->pWithToFree); + sqlite3DbFree(db, pParse->pVList); + while( pParse->pAinc ){ + AutoincInfo *p = pParse->pAinc; + pParse->pAinc = p->pNext; + sqlite3DbFreeNN(db, p); + } + while( pParse->pZombieTab ){ + Table *p = pParse->pZombieTab; + pParse->pZombieTab = p->pNextZombie; + sqlite3DeleteTable(db, p); + } + db->pParse = pParse->pParentParse; + pParse->pParentParse = 0; + assert( nErr==0 || pParse->rc!=SQLITE_OK ); + return nErr; +} + + +#ifdef SQLITE_ENABLE_NORMALIZE +/* +** Insert a single space character into pStr if the current string +** ends with an identifier +*/ +static void addSpaceSeparator(sqlite3_str *pStr){ + if( pStr->nChar && sqlite3IsIdChar(pStr->zText[pStr->nChar-1]) ){ + sqlite3_str_append(pStr, " ", 1); + } +} + +/* +** Compute a normalization of the SQL given by zSql[0..nSql-1]. Return +** the normalization in space obtained from sqlite3DbMalloc(). Or return +** NULL if anything goes wrong or if zSql is NULL. +*/ +SQLITE_PRIVATE char *sqlite3Normalize( + Vdbe *pVdbe, /* VM being reprepared */ + const char *zSql /* The original SQL string */ +){ + sqlite3 *db; /* The database connection */ + int i; /* Next unread byte of zSql[] */ + int n; /* length of current token */ + int tokenType; /* type of current token */ + int prevType = 0; /* Previous non-whitespace token */ + int nParen; /* Number of nested levels of parentheses */ + int iStartIN; /* Start of RHS of IN operator in z[] */ + int nParenAtIN; /* Value of nParent at start of RHS of IN operator */ + u32 j; /* Bytes of normalized SQL generated so far */ + sqlite3_str *pStr; /* The normalized SQL string under construction */ + + db = sqlite3VdbeDb(pVdbe); + tokenType = -1; + nParen = iStartIN = nParenAtIN = 0; + pStr = sqlite3_str_new(db); + assert( pStr!=0 ); /* sqlite3_str_new() never returns NULL */ + for(i=0; zSql[i] && pStr->accError==0; i+=n){ + if( tokenType!=TK_SPACE ){ + prevType = tokenType; + } + n = sqlite3GetToken((unsigned char*)zSql+i, &tokenType); + if( NEVER(n<=0) ) break; + switch( tokenType ){ + case TK_SPACE: { + break; + } + case TK_NULL: { + if( prevType==TK_IS || prevType==TK_NOT ){ + sqlite3_str_append(pStr, " NULL", 5); + break; + } + /* Fall through */ + } + case TK_STRING: + case TK_INTEGER: + case TK_FLOAT: + case TK_VARIABLE: + case TK_BLOB: { + sqlite3_str_append(pStr, "?", 1); + break; + } + case TK_LP: { + nParen++; + if( prevType==TK_IN ){ + iStartIN = pStr->nChar; + nParenAtIN = nParen; + } + sqlite3_str_append(pStr, "(", 1); + break; + } + case TK_RP: { + if( iStartIN>0 && nParen==nParenAtIN ){ + assert( pStr->nChar>=(u32)iStartIN ); + pStr->nChar = iStartIN+1; + sqlite3_str_append(pStr, "?,?,?", 5); + iStartIN = 0; + } + nParen--; + sqlite3_str_append(pStr, ")", 1); + break; + } + case TK_ID: { + iStartIN = 0; + j = pStr->nChar; + if( sqlite3Isquote(zSql[i]) ){ + char *zId = sqlite3DbStrNDup(db, zSql+i, n); + int nId; + int eType = 0; + if( zId==0 ) break; + sqlite3Dequote(zId); + if( zSql[i]=='"' && sqlite3VdbeUsesDoubleQuotedString(pVdbe, zId) ){ + sqlite3_str_append(pStr, "?", 1); + sqlite3DbFree(db, zId); + break; + } + nId = sqlite3Strlen30(zId); + if( sqlite3GetToken((u8*)zId, &eType)==nId && eType==TK_ID ){ + addSpaceSeparator(pStr); + sqlite3_str_append(pStr, zId, nId); + }else{ + sqlite3_str_appendf(pStr, "\"%w\"", zId); + } + sqlite3DbFree(db, zId); + }else{ + addSpaceSeparator(pStr); + sqlite3_str_append(pStr, zSql+i, n); + } + while( jnChar ){ + pStr->zText[j] = sqlite3Tolower(pStr->zText[j]); + j++; + } + break; + } + case TK_SELECT: { + iStartIN = 0; + /* fall through */ + } + default: { + if( sqlite3IsIdChar(zSql[i]) ) addSpaceSeparator(pStr); + j = pStr->nChar; + sqlite3_str_append(pStr, zSql+i, n); + while( jnChar ){ + pStr->zText[j] = sqlite3Toupper(pStr->zText[j]); + j++; + } + break; + } + } + } + if( tokenType!=TK_SEMI ) sqlite3_str_append(pStr, ";", 1); + return sqlite3_str_finish(pStr); +} +#endif /* SQLITE_ENABLE_NORMALIZE */ + +/************** End of tokenize.c ********************************************/ +/************** Begin file complete.c ****************************************/ +/* +** 2001 September 15 +** +** 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. +** +************************************************************************* +** An tokenizer for SQL +** +** This file contains C code that implements the sqlite3_complete() API. +** This code used to be part of the tokenizer.c source file. But by +** separating it out, the code will be automatically omitted from +** static links that do not use it. +*/ +/* #include "sqliteInt.h" */ +#ifndef SQLITE_OMIT_COMPLETE + +/* +** This is defined in tokenize.c. We just have to import the definition. +*/ +#ifndef SQLITE_AMALGAMATION +#ifdef SQLITE_ASCII +#define IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0) +#endif +#ifdef SQLITE_EBCDIC +SQLITE_PRIVATE const char sqlite3IsEbcdicIdChar[]; +#define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40])) +#endif +#endif /* SQLITE_AMALGAMATION */ + + +/* +** Token types used by the sqlite3_complete() routine. See the header +** comments on that procedure for additional information. +*/ +#define tkSEMI 0 +#define tkWS 1 +#define tkOTHER 2 +#ifndef SQLITE_OMIT_TRIGGER +#define tkEXPLAIN 3 +#define tkCREATE 4 +#define tkTEMP 5 +#define tkTRIGGER 6 +#define tkEND 7 +#endif + +/* +** Return TRUE if the given SQL string ends in a semicolon. +** +** Special handling is require for CREATE TRIGGER statements. +** Whenever the CREATE TRIGGER keywords are seen, the statement +** must end with ";END;". +** +** This implementation uses a state machine with 8 states: +** +** (0) INVALID We have not yet seen a non-whitespace character. +** +** (1) START At the beginning or end of an SQL statement. This routine +** returns 1 if it ends in the START state and 0 if it ends +** in any other state. +** +** (2) NORMAL We are in the middle of statement which ends with a single +** semicolon. +** +** (3) EXPLAIN The keyword EXPLAIN has been seen at the beginning of +** a statement. +** +** (4) CREATE The keyword CREATE has been seen at the beginning of a +** statement, possibly preceded by EXPLAIN and/or followed by +** TEMP or TEMPORARY +** +** (5) TRIGGER We are in the middle of a trigger definition that must be +** ended by a semicolon, the keyword END, and another semicolon. +** +** (6) SEMI We've seen the first semicolon in the ";END;" that occurs at +** the end of a trigger definition. +** +** (7) END We've seen the ";END" of the ";END;" that occurs at the end +** of a trigger definition. +** +** Transitions between states above are determined by tokens extracted +** from the input. The following tokens are significant: +** +** (0) tkSEMI A semicolon. +** (1) tkWS Whitespace. +** (2) tkOTHER Any other SQL token. +** (3) tkEXPLAIN The "explain" keyword. +** (4) tkCREATE The "create" keyword. +** (5) tkTEMP The "temp" or "temporary" keyword. +** (6) tkTRIGGER The "trigger" keyword. +** (7) tkEND The "end" keyword. +** +** Whitespace never causes a state transition and is always ignored. +** This means that a SQL string of all whitespace is invalid. +** +** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed +** to recognize the end of a trigger can be omitted. All we have to do +** is look for a semicolon that is not part of an string or comment. +*/ +SQLITE_API int sqlite3_complete(const char *zSql){ + u8 state = 0; /* Current state, using numbers defined in header comment */ + u8 token; /* Value of the next token */ + +#ifndef SQLITE_OMIT_TRIGGER + /* A complex statement machine used to detect the end of a CREATE TRIGGER + ** statement. This is the normal case. + */ + static const u8 trans[8][8] = { + /* Token: */ + /* State: ** SEMI WS OTHER EXPLAIN CREATE TEMP TRIGGER END */ + /* 0 INVALID: */ { 1, 0, 2, 3, 4, 2, 2, 2, }, + /* 1 START: */ { 1, 1, 2, 3, 4, 2, 2, 2, }, + /* 2 NORMAL: */ { 1, 2, 2, 2, 2, 2, 2, 2, }, + /* 3 EXPLAIN: */ { 1, 3, 3, 2, 4, 2, 2, 2, }, + /* 4 CREATE: */ { 1, 4, 2, 2, 2, 4, 5, 2, }, + /* 5 TRIGGER: */ { 6, 5, 5, 5, 5, 5, 5, 5, }, + /* 6 SEMI: */ { 6, 6, 5, 5, 5, 5, 5, 7, }, + /* 7 END: */ { 1, 7, 5, 5, 5, 5, 5, 5, }, + }; +#else + /* If triggers are not supported by this compile then the statement machine + ** used to detect the end of a statement is much simpler + */ + static const u8 trans[3][3] = { + /* Token: */ + /* State: ** SEMI WS OTHER */ + /* 0 INVALID: */ { 1, 0, 2, }, + /* 1 START: */ { 1, 1, 2, }, + /* 2 NORMAL: */ { 1, 2, 2, }, + }; +#endif /* SQLITE_OMIT_TRIGGER */ + +#ifdef SQLITE_ENABLE_API_ARMOR + if( zSql==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + + while( *zSql ){ + switch( *zSql ){ + case ';': { /* A semicolon */ + token = tkSEMI; + break; + } + case ' ': + case '\r': + case '\t': + case '\n': + case '\f': { /* White space is ignored */ + token = tkWS; + break; + } + case '/': { /* C-style comments */ + if( zSql[1]!='*' ){ + token = tkOTHER; + break; + } + zSql += 2; + while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; } + if( zSql[0]==0 ) return 0; + zSql++; + token = tkWS; + break; + } + case '-': { /* SQL-style comments from "--" to end of line */ + if( zSql[1]!='-' ){ + token = tkOTHER; + break; + } + while( *zSql && *zSql!='\n' ){ zSql++; } + if( *zSql==0 ) return state==1; + token = tkWS; + break; + } + case '[': { /* Microsoft-style identifiers in [...] */ + zSql++; + while( *zSql && *zSql!=']' ){ zSql++; } + if( *zSql==0 ) return 0; + token = tkOTHER; + break; + } + case '`': /* Grave-accent quoted symbols used by MySQL */ + case '"': /* single- and double-quoted strings */ + case '\'': { + int c = *zSql; + zSql++; + while( *zSql && *zSql!=c ){ zSql++; } + if( *zSql==0 ) return 0; + token = tkOTHER; + break; + } + default: { +#ifdef SQLITE_EBCDIC + unsigned char c; +#endif + if( IdChar((u8)*zSql) ){ + /* Keywords and unquoted identifiers */ + int nId; + for(nId=1; IdChar(zSql[nId]); nId++){} +#ifdef SQLITE_OMIT_TRIGGER + token = tkOTHER; +#else + switch( *zSql ){ + case 'c': case 'C': { + if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){ + token = tkCREATE; + }else{ + token = tkOTHER; + } + break; + } + case 't': case 'T': { + if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){ + token = tkTRIGGER; + }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){ + token = tkTEMP; + }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){ + token = tkTEMP; + }else{ + token = tkOTHER; + } + break; + } + case 'e': case 'E': { + if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){ + token = tkEND; + }else +#ifndef SQLITE_OMIT_EXPLAIN + if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){ + token = tkEXPLAIN; + }else +#endif + { + token = tkOTHER; + } + break; + } + default: { + token = tkOTHER; + break; + } + } +#endif /* SQLITE_OMIT_TRIGGER */ + zSql += nId-1; + }else{ + /* Operators and special symbols */ + token = tkOTHER; + } + break; + } + } + state = trans[state][token]; + zSql++; + } + return state==1; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** This routine is the same as the sqlite3_complete() routine described +** above, except that the parameter is required to be UTF-16 encoded, not +** UTF-8. +*/ +SQLITE_API int sqlite3_complete16(const void *zSql){ + sqlite3_value *pVal; + char const *zSql8; + int rc; + +#ifndef SQLITE_OMIT_AUTOINIT + rc = sqlite3_initialize(); + if( rc ) return rc; +#endif + pVal = sqlite3ValueNew(0); + sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC); + zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8); + if( zSql8 ){ + rc = sqlite3_complete(zSql8); + }else{ + rc = SQLITE_NOMEM_BKPT; + } + sqlite3ValueFree(pVal); + return rc & 0xff; +} +#endif /* SQLITE_OMIT_UTF16 */ +#endif /* SQLITE_OMIT_COMPLETE */ + +/************** End of complete.c ********************************************/ +/************** Begin file main.c ********************************************/ +/* +** 2001 September 15 +** +** 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. +** +************************************************************************* +** Main file for the SQLite library. The routines in this file +** implement the programmer interface to the library. Routines in +** other files are for internal use by SQLite and should not be +** accessed by users of the library. +*/ +/* #include "sqliteInt.h" */ + +#ifdef SQLITE_ENABLE_FTS3 +/************** Include fts3.h in the middle of main.c ***********************/ +/************** Begin file fts3.h ********************************************/ +/* +** 2006 Oct 10 +** +** 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 header file is used by programs that want to link against the +** FTS3 library. All it does is declare the sqlite3Fts3Init() interface. +*/ +/* #include "sqlite3.h" */ + +#if 0 +extern "C" { +#endif /* __cplusplus */ + +SQLITE_PRIVATE int sqlite3Fts3Init(sqlite3 *db); + +#if 0 +} /* extern "C" */ +#endif /* __cplusplus */ + +/************** End of fts3.h ************************************************/ +/************** Continuing where we left off in main.c ***********************/ +#endif +#ifdef SQLITE_ENABLE_RTREE +/************** Include rtree.h in the middle of main.c **********************/ +/************** Begin file rtree.h *******************************************/ +/* +** 2008 May 26 +** +** 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 header file is used by programs that want to link against the +** RTREE library. All it does is declare the sqlite3RtreeInit() interface. +*/ +/* #include "sqlite3.h" */ + +#ifdef SQLITE_OMIT_VIRTUALTABLE +# undef SQLITE_ENABLE_RTREE +#endif + +#if 0 +extern "C" { +#endif /* __cplusplus */ + +SQLITE_PRIVATE int sqlite3RtreeInit(sqlite3 *db); + +#if 0 +} /* extern "C" */ +#endif /* __cplusplus */ + +/************** End of rtree.h ***********************************************/ +/************** Continuing where we left off in main.c ***********************/ +#endif +#if defined(SQLITE_ENABLE_ICU) || defined(SQLITE_ENABLE_ICU_COLLATIONS) +/************** Include sqliteicu.h in the middle of main.c ******************/ +/************** Begin file sqliteicu.h ***************************************/ +/* +** 2008 May 26 +** +** 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 header file is used by programs that want to link against the +** ICU extension. All it does is declare the sqlite3IcuInit() interface. +*/ +/* #include "sqlite3.h" */ + +#if 0 +extern "C" { +#endif /* __cplusplus */ + +SQLITE_PRIVATE int sqlite3IcuInit(sqlite3 *db); + +#if 0 +} /* extern "C" */ +#endif /* __cplusplus */ + +/************** End of sqliteicu.h *******************************************/ +/************** Continuing where we left off in main.c ***********************/ +#endif + +/* +** This is an extension initializer that is a no-op and always +** succeeds, except that it fails if the fault-simulation is set +** to 500. +*/ +static int sqlite3TestExtInit(sqlite3 *db){ + (void)db; + return sqlite3FaultSim(500); +} + + +/* +** Forward declarations of external module initializer functions +** for modules that need them. +*/ +#ifdef SQLITE_ENABLE_FTS1 +SQLITE_PRIVATE int sqlite3Fts1Init(sqlite3*); +#endif +#ifdef SQLITE_ENABLE_FTS2 +SQLITE_PRIVATE int sqlite3Fts2Init(sqlite3*); +#endif +#ifdef SQLITE_ENABLE_FTS5 +SQLITE_PRIVATE int sqlite3Fts5Init(sqlite3*); +#endif +#ifdef SQLITE_ENABLE_JSON1 +SQLITE_PRIVATE int sqlite3Json1Init(sqlite3*); +#endif +#ifdef SQLITE_ENABLE_STMTVTAB +SQLITE_PRIVATE int sqlite3StmtVtabInit(sqlite3*); +#endif + +/* +** An array of pointers to extension initializer functions for +** built-in extensions. +*/ +static int (*const sqlite3BuiltinExtensions[])(sqlite3*) = { +#ifdef SQLITE_ENABLE_FTS1 + sqlite3Fts1Init, +#endif +#ifdef SQLITE_ENABLE_FTS2 + sqlite3Fts2Init, +#endif +#ifdef SQLITE_ENABLE_FTS3 + sqlite3Fts3Init, +#endif +#ifdef SQLITE_ENABLE_FTS5 + sqlite3Fts5Init, +#endif +#if defined(SQLITE_ENABLE_ICU) || defined(SQLITE_ENABLE_ICU_COLLATIONS) + sqlite3IcuInit, +#endif +#ifdef SQLITE_ENABLE_RTREE + sqlite3RtreeInit, +#endif +#ifdef SQLITE_ENABLE_DBPAGE_VTAB + sqlite3DbpageRegister, +#endif +#ifdef SQLITE_ENABLE_DBSTAT_VTAB + sqlite3DbstatRegister, +#endif + sqlite3TestExtInit, +#ifdef SQLITE_ENABLE_JSON1 + sqlite3Json1Init, +#endif +#ifdef SQLITE_ENABLE_STMTVTAB + sqlite3StmtVtabInit, +#endif +#ifdef SQLITE_ENABLE_BYTECODE_VTAB + sqlite3VdbeBytecodeVtabInit, +#endif +}; + +#ifndef SQLITE_AMALGAMATION +/* IMPLEMENTATION-OF: R-46656-45156 The sqlite3_version[] string constant +** contains the text of SQLITE_VERSION macro. +*/ +SQLITE_API const char sqlite3_version[] = SQLITE_VERSION; +#endif + +/* IMPLEMENTATION-OF: R-53536-42575 The sqlite3_libversion() function returns +** a pointer to the to the sqlite3_version[] string constant. +*/ +SQLITE_API const char *sqlite3_libversion(void){ return sqlite3_version; } + +/* IMPLEMENTATION-OF: R-25063-23286 The sqlite3_sourceid() function returns a +** pointer to a string constant whose value is the same as the +** SQLITE_SOURCE_ID C preprocessor macro. Except if SQLite is built using +** an edited copy of the amalgamation, then the last four characters of +** the hash might be different from SQLITE_SOURCE_ID. +*/ +/* SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; } */ + +/* IMPLEMENTATION-OF: R-35210-63508 The sqlite3_libversion_number() function +** returns an integer equal to SQLITE_VERSION_NUMBER. +*/ +SQLITE_API int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; } + +/* IMPLEMENTATION-OF: R-20790-14025 The sqlite3_threadsafe() function returns +** zero if and only if SQLite was compiled with mutexing code omitted due to +** the SQLITE_THREADSAFE compile-time option being set to 0. +*/ +SQLITE_API int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; } + +/* +** When compiling the test fixture or with debugging enabled (on Win32), +** this variable being set to non-zero will cause OSTRACE macros to emit +** extra diagnostic information. +*/ +#ifdef SQLITE_HAVE_OS_TRACE +# ifndef SQLITE_DEBUG_OS_TRACE +# define SQLITE_DEBUG_OS_TRACE 0 +# endif + int sqlite3OSTrace = SQLITE_DEBUG_OS_TRACE; +#endif + +#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE) +/* +** If the following function pointer is not NULL and if +** SQLITE_ENABLE_IOTRACE is enabled, then messages describing +** I/O active are written using this function. These messages +** are intended for debugging activity only. +*/ +SQLITE_API void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...) = 0; +#endif + +/* +** If the following global variable points to a string which is the +** name of a directory, then that directory will be used to store +** temporary files. +** +** See also the "PRAGMA temp_store_directory" SQL command. +*/ +SQLITE_API char *sqlite3_temp_directory = 0; + +/* +** If the following global variable points to a string which is the +** name of a directory, then that directory will be used to store +** all database files specified with a relative pathname. +** +** See also the "PRAGMA data_store_directory" SQL command. +*/ +SQLITE_API char *sqlite3_data_directory = 0; + +/* +** Initialize SQLite. +** +** This routine must be called to initialize the memory allocation, +** VFS, and mutex subsystems prior to doing any serious work with +** SQLite. But as long as you do not compile with SQLITE_OMIT_AUTOINIT +** this routine will be called automatically by key routines such as +** sqlite3_open(). +** +** This routine is a no-op except on its very first call for the process, +** or for the first call after a call to sqlite3_shutdown. +** +** The first thread to call this routine runs the initialization to +** completion. If subsequent threads call this routine before the first +** thread has finished the initialization process, then the subsequent +** threads must block until the first thread finishes with the initialization. +** +** The first thread might call this routine recursively. Recursive +** calls to this routine should not block, of course. Otherwise the +** initialization process would never complete. +** +** Let X be the first thread to enter this routine. Let Y be some other +** thread. Then while the initial invocation of this routine by X is +** incomplete, it is required that: +** +** * Calls to this routine from Y must block until the outer-most +** call by X completes. +** +** * Recursive calls to this routine from thread X return immediately +** without blocking. +*/ +SQLITE_API int sqlite3_initialize(void){ + MUTEX_LOGIC( sqlite3_mutex *pMainMtx; ) /* The main static mutex */ + int rc; /* Result code */ +#ifdef SQLITE_EXTRA_INIT + int bRunExtraInit = 0; /* Extra initialization needed */ +#endif + +#ifdef SQLITE_OMIT_WSD + rc = sqlite3_wsd_init(4096, 24); + if( rc!=SQLITE_OK ){ + return rc; + } +#endif + + /* If the following assert() fails on some obscure processor/compiler + ** combination, the work-around is to set the correct pointer + ** size at compile-time using -DSQLITE_PTRSIZE=n compile-time option */ + assert( SQLITE_PTRSIZE==sizeof(char*) ); + + /* If SQLite is already completely initialized, then this call + ** to sqlite3_initialize() should be a no-op. But the initialization + ** must be complete. So isInit must not be set until the very end + ** of this routine. + */ + if( sqlite3GlobalConfig.isInit ){ + sqlite3MemoryBarrier(); + return SQLITE_OK; + } + + /* Make sure the mutex subsystem is initialized. If unable to + ** initialize the mutex subsystem, return early with the error. + ** If the system is so sick that we are unable to allocate a mutex, + ** there is not much SQLite is going to be able to do. + ** + ** The mutex subsystem must take care of serializing its own + ** initialization. + */ + rc = sqlite3MutexInit(); + if( rc ) return rc; + + /* Initialize the malloc() system and the recursive pInitMutex mutex. + ** This operation is protected by the STATIC_MAIN mutex. Note that + ** MutexAlloc() is called for a static mutex prior to initializing the + ** malloc subsystem - this implies that the allocation of a static + ** mutex must not require support from the malloc subsystem. + */ + MUTEX_LOGIC( pMainMtx = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); ) + sqlite3_mutex_enter(pMainMtx); + sqlite3GlobalConfig.isMutexInit = 1; + if( !sqlite3GlobalConfig.isMallocInit ){ + rc = sqlite3MallocInit(); + } + if( rc==SQLITE_OK ){ + sqlite3GlobalConfig.isMallocInit = 1; + if( !sqlite3GlobalConfig.pInitMutex ){ + sqlite3GlobalConfig.pInitMutex = + sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE); + if( sqlite3GlobalConfig.bCoreMutex && !sqlite3GlobalConfig.pInitMutex ){ + rc = SQLITE_NOMEM_BKPT; + } + } + } + if( rc==SQLITE_OK ){ + sqlite3GlobalConfig.nRefInitMutex++; + } + sqlite3_mutex_leave(pMainMtx); + + /* If rc is not SQLITE_OK at this point, then either the malloc + ** subsystem could not be initialized or the system failed to allocate + ** the pInitMutex mutex. Return an error in either case. */ + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Do the rest of the initialization under the recursive mutex so + ** that we will be able to handle recursive calls into + ** sqlite3_initialize(). The recursive calls normally come through + ** sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other + ** recursive calls might also be possible. + ** + ** IMPLEMENTATION-OF: R-00140-37445 SQLite automatically serializes calls + ** to the xInit method, so the xInit method need not be threadsafe. + ** + ** The following mutex is what serializes access to the appdef pcache xInit + ** methods. The sqlite3_pcache_methods.xInit() all is embedded in the + ** call to sqlite3PcacheInitialize(). + */ + sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex); + if( sqlite3GlobalConfig.isInit==0 && sqlite3GlobalConfig.inProgress==0 ){ + sqlite3GlobalConfig.inProgress = 1; +#ifdef SQLITE_ENABLE_SQLLOG + { + extern void sqlite3_init_sqllog(void); + sqlite3_init_sqllog(); + } +#endif + memset(&sqlite3BuiltinFunctions, 0, sizeof(sqlite3BuiltinFunctions)); + sqlite3RegisterBuiltinFunctions(); + if( sqlite3GlobalConfig.isPCacheInit==0 ){ + rc = sqlite3PcacheInitialize(); + } + if( rc==SQLITE_OK ){ + sqlite3GlobalConfig.isPCacheInit = 1; + rc = sqlite3OsInit(); + } +#ifdef SQLITE_ENABLE_DESERIALIZE + if( rc==SQLITE_OK ){ + rc = sqlite3MemdbInit(); + } +#endif + if( rc==SQLITE_OK ){ + sqlite3PCacheBufferSetup( sqlite3GlobalConfig.pPage, + sqlite3GlobalConfig.szPage, sqlite3GlobalConfig.nPage); + sqlite3MemoryBarrier(); + sqlite3GlobalConfig.isInit = 1; +#ifdef SQLITE_EXTRA_INIT + bRunExtraInit = 1; +#endif + } + sqlite3GlobalConfig.inProgress = 0; + } + sqlite3_mutex_leave(sqlite3GlobalConfig.pInitMutex); + + /* Go back under the static mutex and clean up the recursive + ** mutex to prevent a resource leak. + */ + sqlite3_mutex_enter(pMainMtx); + sqlite3GlobalConfig.nRefInitMutex--; + if( sqlite3GlobalConfig.nRefInitMutex<=0 ){ + assert( sqlite3GlobalConfig.nRefInitMutex==0 ); + sqlite3_mutex_free(sqlite3GlobalConfig.pInitMutex); + sqlite3GlobalConfig.pInitMutex = 0; + } + sqlite3_mutex_leave(pMainMtx); + + /* The following is just a sanity check to make sure SQLite has + ** been compiled correctly. It is important to run this code, but + ** we don't want to run it too often and soak up CPU cycles for no + ** reason. So we run it once during initialization. + */ +#ifndef NDEBUG +#ifndef SQLITE_OMIT_FLOATING_POINT + /* This section of code's only "output" is via assert() statements. */ + if( rc==SQLITE_OK ){ + u64 x = (((u64)1)<<63)-1; + double y; + assert(sizeof(x)==8); + assert(sizeof(x)==sizeof(y)); + memcpy(&y, &x, 8); + assert( sqlite3IsNaN(y) ); + } +#endif +#endif + + /* Do extra initialization steps requested by the SQLITE_EXTRA_INIT + ** compile-time option. + */ +#ifdef SQLITE_EXTRA_INIT + if( bRunExtraInit ){ + int SQLITE_EXTRA_INIT(const char*); + rc = SQLITE_EXTRA_INIT(0); + } +#endif + + return rc; +} + +/* +** Undo the effects of sqlite3_initialize(). Must not be called while +** there are outstanding database connections or memory allocations or +** while any part of SQLite is otherwise in use in any thread. This +** routine is not threadsafe. But it is safe to invoke this routine +** on when SQLite is already shut down. If SQLite is already shut down +** when this routine is invoked, then this routine is a harmless no-op. +*/ +SQLITE_API int sqlite3_shutdown(void){ +#ifdef SQLITE_OMIT_WSD + int rc = sqlite3_wsd_init(4096, 24); + if( rc!=SQLITE_OK ){ + return rc; + } +#endif + + if( sqlite3GlobalConfig.isInit ){ +#ifdef SQLITE_EXTRA_SHUTDOWN + void SQLITE_EXTRA_SHUTDOWN(void); + SQLITE_EXTRA_SHUTDOWN(); +#endif + sqlite3_os_end(); + sqlite3_reset_auto_extension(); + sqlite3GlobalConfig.isInit = 0; + } + if( sqlite3GlobalConfig.isPCacheInit ){ + sqlite3PcacheShutdown(); + sqlite3GlobalConfig.isPCacheInit = 0; + } + if( sqlite3GlobalConfig.isMallocInit ){ + sqlite3MallocEnd(); + sqlite3GlobalConfig.isMallocInit = 0; + +#ifndef SQLITE_OMIT_SHUTDOWN_DIRECTORIES + /* The heap subsystem has now been shutdown and these values are supposed + ** to be NULL or point to memory that was obtained from sqlite3_malloc(), + ** which would rely on that heap subsystem; therefore, make sure these + ** values cannot refer to heap memory that was just invalidated when the + ** heap subsystem was shutdown. This is only done if the current call to + ** this function resulted in the heap subsystem actually being shutdown. + */ + sqlite3_data_directory = 0; + sqlite3_temp_directory = 0; +#endif + } + if( sqlite3GlobalConfig.isMutexInit ){ + sqlite3MutexEnd(); + sqlite3GlobalConfig.isMutexInit = 0; + } + + return SQLITE_OK; +} + +/* +** This API allows applications to modify the global configuration of +** the SQLite library at run-time. +** +** This routine should only be called when there are no outstanding +** database connections or memory allocations. This routine is not +** threadsafe. Failure to heed these warnings can lead to unpredictable +** behavior. +*/ +SQLITE_API int sqlite3_config(int op, ...){ + va_list ap; + int rc = SQLITE_OK; + + /* sqlite3_config() shall return SQLITE_MISUSE if it is invoked while + ** the SQLite library is in use. */ + if( sqlite3GlobalConfig.isInit ) return SQLITE_MISUSE_BKPT; + + va_start(ap, op); + switch( op ){ + + /* Mutex configuration options are only available in a threadsafe + ** compile. + */ +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-54466-46756 */ + case SQLITE_CONFIG_SINGLETHREAD: { + /* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to + ** Single-thread. */ + sqlite3GlobalConfig.bCoreMutex = 0; /* Disable mutex on core */ + sqlite3GlobalConfig.bFullMutex = 0; /* Disable mutex on connections */ + break; + } +#endif +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-20520-54086 */ + case SQLITE_CONFIG_MULTITHREAD: { + /* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to + ** Multi-thread. */ + sqlite3GlobalConfig.bCoreMutex = 1; /* Enable mutex on core */ + sqlite3GlobalConfig.bFullMutex = 0; /* Disable mutex on connections */ + break; + } +#endif +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-59593-21810 */ + case SQLITE_CONFIG_SERIALIZED: { + /* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to + ** Serialized. */ + sqlite3GlobalConfig.bCoreMutex = 1; /* Enable mutex on core */ + sqlite3GlobalConfig.bFullMutex = 1; /* Enable mutex on connections */ + break; + } +#endif +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-63666-48755 */ + case SQLITE_CONFIG_MUTEX: { + /* Specify an alternative mutex implementation */ + sqlite3GlobalConfig.mutex = *va_arg(ap, sqlite3_mutex_methods*); + break; + } +#endif +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-14450-37597 */ + case SQLITE_CONFIG_GETMUTEX: { + /* Retrieve the current mutex implementation */ + *va_arg(ap, sqlite3_mutex_methods*) = sqlite3GlobalConfig.mutex; + break; + } +#endif + + case SQLITE_CONFIG_MALLOC: { + /* EVIDENCE-OF: R-55594-21030 The SQLITE_CONFIG_MALLOC option takes a + ** single argument which is a pointer to an instance of the + ** sqlite3_mem_methods structure. The argument specifies alternative + ** low-level memory allocation routines to be used in place of the memory + ** allocation routines built into SQLite. */ + sqlite3GlobalConfig.m = *va_arg(ap, sqlite3_mem_methods*); + break; + } + case SQLITE_CONFIG_GETMALLOC: { + /* EVIDENCE-OF: R-51213-46414 The SQLITE_CONFIG_GETMALLOC option takes a + ** single argument which is a pointer to an instance of the + ** sqlite3_mem_methods structure. The sqlite3_mem_methods structure is + ** filled with the currently defined memory allocation routines. */ + if( sqlite3GlobalConfig.m.xMalloc==0 ) sqlite3MemSetDefault(); + *va_arg(ap, sqlite3_mem_methods*) = sqlite3GlobalConfig.m; + break; + } + case SQLITE_CONFIG_MEMSTATUS: { + /* EVIDENCE-OF: R-61275-35157 The SQLITE_CONFIG_MEMSTATUS option takes + ** single argument of type int, interpreted as a boolean, which enables + ** or disables the collection of memory allocation statistics. */ + sqlite3GlobalConfig.bMemstat = va_arg(ap, int); + break; + } + case SQLITE_CONFIG_SMALL_MALLOC: { + sqlite3GlobalConfig.bSmallMalloc = va_arg(ap, int); + break; + } + case SQLITE_CONFIG_PAGECACHE: { + /* EVIDENCE-OF: R-18761-36601 There are three arguments to + ** SQLITE_CONFIG_PAGECACHE: A pointer to 8-byte aligned memory (pMem), + ** the size of each page cache line (sz), and the number of cache lines + ** (N). */ + sqlite3GlobalConfig.pPage = va_arg(ap, void*); + sqlite3GlobalConfig.szPage = va_arg(ap, int); + sqlite3GlobalConfig.nPage = va_arg(ap, int); + break; + } + case SQLITE_CONFIG_PCACHE_HDRSZ: { + /* EVIDENCE-OF: R-39100-27317 The SQLITE_CONFIG_PCACHE_HDRSZ option takes + ** a single parameter which is a pointer to an integer and writes into + ** that integer the number of extra bytes per page required for each page + ** in SQLITE_CONFIG_PAGECACHE. */ + *va_arg(ap, int*) = + sqlite3HeaderSizeBtree() + + sqlite3HeaderSizePcache() + + sqlite3HeaderSizePcache1(); + break; + } + + case SQLITE_CONFIG_PCACHE: { + /* no-op */ + break; + } + case SQLITE_CONFIG_GETPCACHE: { + /* now an error */ + rc = SQLITE_ERROR; + break; + } + + case SQLITE_CONFIG_PCACHE2: { + /* EVIDENCE-OF: R-63325-48378 The SQLITE_CONFIG_PCACHE2 option takes a + ** single argument which is a pointer to an sqlite3_pcache_methods2 + ** object. This object specifies the interface to a custom page cache + ** implementation. */ + sqlite3GlobalConfig.pcache2 = *va_arg(ap, sqlite3_pcache_methods2*); + break; + } + case SQLITE_CONFIG_GETPCACHE2: { + /* EVIDENCE-OF: R-22035-46182 The SQLITE_CONFIG_GETPCACHE2 option takes a + ** single argument which is a pointer to an sqlite3_pcache_methods2 + ** object. SQLite copies of the current page cache implementation into + ** that object. */ + if( sqlite3GlobalConfig.pcache2.xInit==0 ){ + sqlite3PCacheSetDefault(); + } + *va_arg(ap, sqlite3_pcache_methods2*) = sqlite3GlobalConfig.pcache2; + break; + } + +/* EVIDENCE-OF: R-06626-12911 The SQLITE_CONFIG_HEAP option is only +** available if SQLite is compiled with either SQLITE_ENABLE_MEMSYS3 or +** SQLITE_ENABLE_MEMSYS5 and returns SQLITE_ERROR if invoked otherwise. */ +#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) + case SQLITE_CONFIG_HEAP: { + /* EVIDENCE-OF: R-19854-42126 There are three arguments to + ** SQLITE_CONFIG_HEAP: An 8-byte aligned pointer to the memory, the + ** number of bytes in the memory buffer, and the minimum allocation size. + */ + sqlite3GlobalConfig.pHeap = va_arg(ap, void*); + sqlite3GlobalConfig.nHeap = va_arg(ap, int); + sqlite3GlobalConfig.mnReq = va_arg(ap, int); + + if( sqlite3GlobalConfig.mnReq<1 ){ + sqlite3GlobalConfig.mnReq = 1; + }else if( sqlite3GlobalConfig.mnReq>(1<<12) ){ + /* cap min request size at 2^12 */ + sqlite3GlobalConfig.mnReq = (1<<12); + } + + if( sqlite3GlobalConfig.pHeap==0 ){ + /* EVIDENCE-OF: R-49920-60189 If the first pointer (the memory pointer) + ** is NULL, then SQLite reverts to using its default memory allocator + ** (the system malloc() implementation), undoing any prior invocation of + ** SQLITE_CONFIG_MALLOC. + ** + ** Setting sqlite3GlobalConfig.m to all zeros will cause malloc to + ** revert to its default implementation when sqlite3_initialize() is run + */ + memset(&sqlite3GlobalConfig.m, 0, sizeof(sqlite3GlobalConfig.m)); + }else{ + /* EVIDENCE-OF: R-61006-08918 If the memory pointer is not NULL then the + ** alternative memory allocator is engaged to handle all of SQLites + ** memory allocation needs. */ +#ifdef SQLITE_ENABLE_MEMSYS3 + sqlite3GlobalConfig.m = *sqlite3MemGetMemsys3(); +#endif +#ifdef SQLITE_ENABLE_MEMSYS5 + sqlite3GlobalConfig.m = *sqlite3MemGetMemsys5(); +#endif + } + break; + } +#endif + + case SQLITE_CONFIG_LOOKASIDE: { + sqlite3GlobalConfig.szLookaside = va_arg(ap, int); + sqlite3GlobalConfig.nLookaside = va_arg(ap, int); + break; + } + + /* Record a pointer to the logger function and its first argument. + ** The default is NULL. Logging is disabled if the function pointer is + ** NULL. + */ + case SQLITE_CONFIG_LOG: { + /* MSVC is picky about pulling func ptrs from va lists. + ** http://support.microsoft.com/kb/47961 + ** sqlite3GlobalConfig.xLog = va_arg(ap, void(*)(void*,int,const char*)); + */ + typedef void(*LOGFUNC_t)(void*,int,const char*); + sqlite3GlobalConfig.xLog = va_arg(ap, LOGFUNC_t); + sqlite3GlobalConfig.pLogArg = va_arg(ap, void*); + break; + } + + /* EVIDENCE-OF: R-55548-33817 The compile-time setting for URI filenames + ** can be changed at start-time using the + ** sqlite3_config(SQLITE_CONFIG_URI,1) or + ** sqlite3_config(SQLITE_CONFIG_URI,0) configuration calls. + */ + case SQLITE_CONFIG_URI: { + /* EVIDENCE-OF: R-25451-61125 The SQLITE_CONFIG_URI option takes a single + ** argument of type int. If non-zero, then URI handling is globally + ** enabled. If the parameter is zero, then URI handling is globally + ** disabled. */ + sqlite3GlobalConfig.bOpenUri = va_arg(ap, int); + break; + } + + case SQLITE_CONFIG_COVERING_INDEX_SCAN: { + /* EVIDENCE-OF: R-36592-02772 The SQLITE_CONFIG_COVERING_INDEX_SCAN + ** option takes a single integer argument which is interpreted as a + ** boolean in order to enable or disable the use of covering indices for + ** full table scans in the query optimizer. */ + sqlite3GlobalConfig.bUseCis = va_arg(ap, int); + break; + } + +#ifdef SQLITE_ENABLE_SQLLOG + case SQLITE_CONFIG_SQLLOG: { + typedef void(*SQLLOGFUNC_t)(void*, sqlite3*, const char*, int); + sqlite3GlobalConfig.xSqllog = va_arg(ap, SQLLOGFUNC_t); + sqlite3GlobalConfig.pSqllogArg = va_arg(ap, void *); + break; + } +#endif + + case SQLITE_CONFIG_MMAP_SIZE: { + /* EVIDENCE-OF: R-58063-38258 SQLITE_CONFIG_MMAP_SIZE takes two 64-bit + ** integer (sqlite3_int64) values that are the default mmap size limit + ** (the default setting for PRAGMA mmap_size) and the maximum allowed + ** mmap size limit. */ + sqlite3_int64 szMmap = va_arg(ap, sqlite3_int64); + sqlite3_int64 mxMmap = va_arg(ap, sqlite3_int64); + /* EVIDENCE-OF: R-53367-43190 If either argument to this option is + ** negative, then that argument is changed to its compile-time default. + ** + ** EVIDENCE-OF: R-34993-45031 The maximum allowed mmap size will be + ** silently truncated if necessary so that it does not exceed the + ** compile-time maximum mmap size set by the SQLITE_MAX_MMAP_SIZE + ** compile-time option. + */ + if( mxMmap<0 || mxMmap>SQLITE_MAX_MMAP_SIZE ){ + mxMmap = SQLITE_MAX_MMAP_SIZE; + } + if( szMmap<0 ) szMmap = SQLITE_DEFAULT_MMAP_SIZE; + if( szMmap>mxMmap) szMmap = mxMmap; + sqlite3GlobalConfig.mxMmap = mxMmap; + sqlite3GlobalConfig.szMmap = szMmap; + break; + } + +#if SQLITE_OS_WIN && defined(SQLITE_WIN32_MALLOC) /* IMP: R-04780-55815 */ + case SQLITE_CONFIG_WIN32_HEAPSIZE: { + /* EVIDENCE-OF: R-34926-03360 SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit + ** unsigned integer value that specifies the maximum size of the created + ** heap. */ + sqlite3GlobalConfig.nHeap = va_arg(ap, int); + break; + } +#endif + + case SQLITE_CONFIG_PMASZ: { + sqlite3GlobalConfig.szPma = va_arg(ap, unsigned int); + break; + } + + case SQLITE_CONFIG_STMTJRNL_SPILL: { + sqlite3GlobalConfig.nStmtSpill = va_arg(ap, int); + break; + } + +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + case SQLITE_CONFIG_SORTERREF_SIZE: { + int iVal = va_arg(ap, int); + if( iVal<0 ){ + iVal = SQLITE_DEFAULT_SORTERREF_SIZE; + } + sqlite3GlobalConfig.szSorterRef = (u32)iVal; + break; + } +#endif /* SQLITE_ENABLE_SORTER_REFERENCES */ + +#ifdef SQLITE_ENABLE_DESERIALIZE + case SQLITE_CONFIG_MEMDB_MAXSIZE: { + sqlite3GlobalConfig.mxMemdbSize = va_arg(ap, sqlite3_int64); + break; + } +#endif /* SQLITE_ENABLE_DESERIALIZE */ + + default: { + rc = SQLITE_ERROR; + break; + } + } + va_end(ap); + return rc; +} + +/* +** Set up the lookaside buffers for a database connection. +** Return SQLITE_OK on success. +** If lookaside is already active, return SQLITE_BUSY. +** +** The sz parameter is the number of bytes in each lookaside slot. +** The cnt parameter is the number of slots. If pStart is NULL the +** space for the lookaside memory is obtained from sqlite3_malloc(). +** If pStart is not NULL then it is sz*cnt bytes of memory to use for +** the lookaside memory. +*/ +static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){ +#ifndef SQLITE_OMIT_LOOKASIDE + void *pStart; + sqlite3_int64 szAlloc = sz*(sqlite3_int64)cnt; + int nBig; /* Number of full-size slots */ + int nSm; /* Number smaller LOOKASIDE_SMALL-byte slots */ + + if( sqlite3LookasideUsed(db,0)>0 ){ + return SQLITE_BUSY; + } + /* Free any existing lookaside buffer for this handle before + ** allocating a new one so we don't have to have space for + ** both at the same time. + */ + if( db->lookaside.bMalloced ){ + sqlite3_free(db->lookaside.pStart); + } + /* The size of a lookaside slot after ROUNDDOWN8 needs to be larger + ** than a pointer to be useful. + */ + sz = ROUNDDOWN8(sz); /* IMP: R-33038-09382 */ + if( sz<=(int)sizeof(LookasideSlot*) ) sz = 0; + if( cnt<0 ) cnt = 0; + if( sz==0 || cnt==0 ){ + sz = 0; + pStart = 0; + }else if( pBuf==0 ){ + sqlite3BeginBenignMalloc(); + pStart = sqlite3Malloc( szAlloc ); /* IMP: R-61949-35727 */ + sqlite3EndBenignMalloc(); + if( pStart ) szAlloc = sqlite3MallocSize(pStart); + }else{ + pStart = pBuf; + } +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + if( sz>=LOOKASIDE_SMALL*3 ){ + nBig = szAlloc/(3*LOOKASIDE_SMALL+sz); + nSm = (szAlloc - sz*nBig)/LOOKASIDE_SMALL; + }else if( sz>=LOOKASIDE_SMALL*2 ){ + nBig = szAlloc/(LOOKASIDE_SMALL+sz); + nSm = (szAlloc - sz*nBig)/LOOKASIDE_SMALL; + }else +#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */ + if( sz>0 ){ + nBig = szAlloc/sz; + nSm = 0; + }else{ + nBig = nSm = 0; + } + db->lookaside.pStart = pStart; + db->lookaside.pInit = 0; + db->lookaside.pFree = 0; + db->lookaside.sz = (u16)sz; + db->lookaside.szTrue = (u16)sz; + if( pStart ){ + int i; + LookasideSlot *p; + assert( sz > (int)sizeof(LookasideSlot*) ); + p = (LookasideSlot*)pStart; + for(i=0; ipNext = db->lookaside.pInit; + db->lookaside.pInit = p; + p = (LookasideSlot*)&((u8*)p)[sz]; + } +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + db->lookaside.pSmallInit = 0; + db->lookaside.pSmallFree = 0; + db->lookaside.pMiddle = p; + for(i=0; ipNext = db->lookaside.pSmallInit; + db->lookaside.pSmallInit = p; + p = (LookasideSlot*)&((u8*)p)[LOOKASIDE_SMALL]; + } +#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */ + assert( ((uptr)p)<=szAlloc + (uptr)pStart ); + db->lookaside.pEnd = p; + db->lookaside.bDisable = 0; + db->lookaside.bMalloced = pBuf==0 ?1:0; + db->lookaside.nSlot = nBig+nSm; + }else{ + db->lookaside.pStart = db; +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + db->lookaside.pSmallInit = 0; + db->lookaside.pSmallFree = 0; + db->lookaside.pMiddle = db; +#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */ + db->lookaside.pEnd = db; + db->lookaside.bDisable = 1; + db->lookaside.sz = 0; + db->lookaside.bMalloced = 0; + db->lookaside.nSlot = 0; + } + assert( sqlite3LookasideUsed(db,0)==0 ); +#endif /* SQLITE_OMIT_LOOKASIDE */ + return SQLITE_OK; +} + +/* +** Return the mutex associated with a database connection. +*/ +SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return db->mutex; +} + +/* +** Free up as much memory as we can from the given database +** connection. +*/ +SQLITE_API int sqlite3_db_release_memory(sqlite3 *db){ + int i; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + sqlite3BtreeEnterAll(db); + for(i=0; inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + Pager *pPager = sqlite3BtreePager(pBt); + sqlite3PagerShrink(pPager); + } + } + sqlite3BtreeLeaveAll(db); + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +/* +** Flush any dirty pages in the pager-cache for any attached database +** to disk. +*/ +SQLITE_API int sqlite3_db_cacheflush(sqlite3 *db){ + int i; + int rc = SQLITE_OK; + int bSeenBusy = 0; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + sqlite3BtreeEnterAll(db); + for(i=0; rc==SQLITE_OK && inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt && sqlite3BtreeTxnState(pBt)==SQLITE_TXN_WRITE ){ + Pager *pPager = sqlite3BtreePager(pBt); + rc = sqlite3PagerFlush(pPager); + if( rc==SQLITE_BUSY ){ + bSeenBusy = 1; + rc = SQLITE_OK; + } + } + } + sqlite3BtreeLeaveAll(db); + sqlite3_mutex_leave(db->mutex); + return ((rc==SQLITE_OK && bSeenBusy) ? SQLITE_BUSY : rc); +} + +/* +** Configuration settings for an individual database connection +*/ +SQLITE_API int sqlite3_db_config(sqlite3 *db, int op, ...){ + va_list ap; + int rc; + va_start(ap, op); + switch( op ){ + case SQLITE_DBCONFIG_MAINDBNAME: { + /* IMP: R-06824-28531 */ + /* IMP: R-36257-52125 */ + db->aDb[0].zDbSName = va_arg(ap,char*); + rc = SQLITE_OK; + break; + } + case SQLITE_DBCONFIG_LOOKASIDE: { + void *pBuf = va_arg(ap, void*); /* IMP: R-26835-10964 */ + int sz = va_arg(ap, int); /* IMP: R-47871-25994 */ + int cnt = va_arg(ap, int); /* IMP: R-04460-53386 */ + rc = setupLookaside(db, pBuf, sz, cnt); + break; + } + default: { + static const struct { + int op; /* The opcode */ + u32 mask; /* Mask of the bit in sqlite3.flags to set/clear */ + } aFlagOp[] = { + { SQLITE_DBCONFIG_ENABLE_FKEY, SQLITE_ForeignKeys }, + { SQLITE_DBCONFIG_ENABLE_TRIGGER, SQLITE_EnableTrigger }, + { SQLITE_DBCONFIG_ENABLE_VIEW, SQLITE_EnableView }, + { SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, SQLITE_Fts3Tokenizer }, + { SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, SQLITE_LoadExtension }, + { SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE, SQLITE_NoCkptOnClose }, + { SQLITE_DBCONFIG_ENABLE_QPSG, SQLITE_EnableQPSG }, + { SQLITE_DBCONFIG_TRIGGER_EQP, SQLITE_TriggerEQP }, + { SQLITE_DBCONFIG_RESET_DATABASE, SQLITE_ResetDatabase }, + { SQLITE_DBCONFIG_DEFENSIVE, SQLITE_Defensive }, + { SQLITE_DBCONFIG_WRITABLE_SCHEMA, SQLITE_WriteSchema| + SQLITE_NoSchemaError }, + { SQLITE_DBCONFIG_LEGACY_ALTER_TABLE, SQLITE_LegacyAlter }, + { SQLITE_DBCONFIG_DQS_DDL, SQLITE_DqsDDL }, + { SQLITE_DBCONFIG_DQS_DML, SQLITE_DqsDML }, + { SQLITE_DBCONFIG_LEGACY_FILE_FORMAT, SQLITE_LegacyFileFmt }, + { SQLITE_DBCONFIG_TRUSTED_SCHEMA, SQLITE_TrustedSchema }, + }; + unsigned int i; + rc = SQLITE_ERROR; /* IMP: R-42790-23372 */ + for(i=0; iflags; + if( onoff>0 ){ + db->flags |= aFlagOp[i].mask; + }else if( onoff==0 ){ + db->flags &= ~(u64)aFlagOp[i].mask; + } + if( oldFlags!=db->flags ){ + sqlite3ExpirePreparedStatements(db, 0); + } + if( pRes ){ + *pRes = (db->flags & aFlagOp[i].mask)!=0; + } + rc = SQLITE_OK; + break; + } + } + break; + } + } + va_end(ap); + return rc; +} + +/* +** This is the default collating function named "BINARY" which is always +** available. +*/ +static int binCollFunc( + void *NotUsed, + int nKey1, const void *pKey1, + int nKey2, const void *pKey2 +){ + int rc, n; + UNUSED_PARAMETER(NotUsed); + n = nKey1xCmp!=binCollFunc || strcmp(p->zName,"BINARY")==0 ); + return p==0 || p->xCmp==binCollFunc; +} + +/* +** Another built-in collating sequence: NOCASE. +** +** This collating sequence is intended to be used for "case independent +** comparison". SQLite's knowledge of upper and lower case equivalents +** extends only to the 26 characters used in the English language. +** +** At the moment there is only a UTF-8 implementation. +*/ +static int nocaseCollatingFunc( + void *NotUsed, + int nKey1, const void *pKey1, + int nKey2, const void *pKey2 +){ + int r = sqlite3StrNICmp( + (const char *)pKey1, (const char *)pKey2, (nKey1lastRowid; +} + +/* +** Set the value returned by the sqlite3_last_insert_rowid() API function. +*/ +SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3 *db, sqlite3_int64 iRowid){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return; + } +#endif + sqlite3_mutex_enter(db->mutex); + db->lastRowid = iRowid; + sqlite3_mutex_leave(db->mutex); +} + +/* +** Return the number of changes in the most recent call to sqlite3_exec(). +*/ +SQLITE_API int sqlite3_changes(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return db->nChange; +} + +/* +** Return the number of changes since the database handle was opened. +*/ +SQLITE_API int sqlite3_total_changes(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return db->nTotalChange; +} + +/* +** Close all open savepoints. This function only manipulates fields of the +** database handle object, it does not close any savepoints that may be open +** at the b-tree/pager level. +*/ +SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *db){ + while( db->pSavepoint ){ + Savepoint *pTmp = db->pSavepoint; + db->pSavepoint = pTmp->pNext; + sqlite3DbFree(db, pTmp); + } + db->nSavepoint = 0; + db->nStatement = 0; + db->isTransactionSavepoint = 0; +} + +/* +** Invoke the destructor function associated with FuncDef p, if any. Except, +** if this is not the last copy of the function, do not invoke it. Multiple +** copies of a single function are created when create_function() is called +** with SQLITE_ANY as the encoding. +*/ +static void functionDestroy(sqlite3 *db, FuncDef *p){ + FuncDestructor *pDestructor = p->u.pDestructor; + if( pDestructor ){ + pDestructor->nRef--; + if( pDestructor->nRef==0 ){ + pDestructor->xDestroy(pDestructor->pUserData); + sqlite3DbFree(db, pDestructor); + } + } +} + +/* +** Disconnect all sqlite3_vtab objects that belong to database connection +** db. This is called when db is being closed. +*/ +static void disconnectAllVtab(sqlite3 *db){ +#ifndef SQLITE_OMIT_VIRTUALTABLE + int i; + HashElem *p; + sqlite3BtreeEnterAll(db); + for(i=0; inDb; i++){ + Schema *pSchema = db->aDb[i].pSchema; + if( pSchema ){ + for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){ + Table *pTab = (Table *)sqliteHashData(p); + if( IsVirtual(pTab) ) sqlite3VtabDisconnect(db, pTab); + } + } + } + for(p=sqliteHashFirst(&db->aModule); p; p=sqliteHashNext(p)){ + Module *pMod = (Module *)sqliteHashData(p); + if( pMod->pEpoTab ){ + sqlite3VtabDisconnect(db, pMod->pEpoTab); + } + } + sqlite3VtabUnlockList(db); + sqlite3BtreeLeaveAll(db); +#else + UNUSED_PARAMETER(db); +#endif +} + +/* +** Return TRUE if database connection db has unfinalized prepared +** statements or unfinished sqlite3_backup objects. +*/ +static int connectionIsBusy(sqlite3 *db){ + int j; + assert( sqlite3_mutex_held(db->mutex) ); + if( db->pVdbe ) return 1; + for(j=0; jnDb; j++){ + Btree *pBt = db->aDb[j].pBt; + if( pBt && sqlite3BtreeIsInBackup(pBt) ) return 1; + } + return 0; +} + +/* +** Close an existing SQLite database +*/ +static int sqlite3Close(sqlite3 *db, int forceZombie){ + if( !db ){ + /* EVIDENCE-OF: R-63257-11740 Calling sqlite3_close() or + ** sqlite3_close_v2() with a NULL pointer argument is a harmless no-op. */ + return SQLITE_OK; + } + if( !sqlite3SafetyCheckSickOrOk(db) ){ + return SQLITE_MISUSE_BKPT; + } + sqlite3_mutex_enter(db->mutex); + if( db->mTrace & SQLITE_TRACE_CLOSE ){ + db->trace.xV2(SQLITE_TRACE_CLOSE, db->pTraceArg, db, 0); + } + + /* Force xDisconnect calls on all virtual tables */ + disconnectAllVtab(db); + + /* If a transaction is open, the disconnectAllVtab() call above + ** will not have called the xDisconnect() method on any virtual + ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback() + ** call will do so. We need to do this before the check for active + ** SQL statements below, as the v-table implementation may be storing + ** some prepared statements internally. + */ + sqlite3VtabRollback(db); + + /* Legacy behavior (sqlite3_close() behavior) is to return + ** SQLITE_BUSY if the connection can not be closed immediately. + */ + if( !forceZombie && connectionIsBusy(db) ){ + sqlite3ErrorWithMsg(db, SQLITE_BUSY, "unable to close due to unfinalized " + "statements or unfinished backups"); + sqlite3_mutex_leave(db->mutex); + return SQLITE_BUSY; + } + +#ifdef SQLITE_ENABLE_SQLLOG + if( sqlite3GlobalConfig.xSqllog ){ + /* Closing the handle. Fourth parameter is passed the value 2. */ + sqlite3GlobalConfig.xSqllog(sqlite3GlobalConfig.pSqllogArg, db, 0, 2); + } +#endif + + /* Convert the connection into a zombie and then close it. + */ + db->magic = SQLITE_MAGIC_ZOMBIE; + sqlite3LeaveMutexAndCloseZombie(db); + return SQLITE_OK; +} + +/* +** Return the transaction state for a single databse, or the maximum +** transaction state over all attached databases if zSchema is null. +*/ +SQLITE_API int sqlite3_txn_state(sqlite3 *db, const char *zSchema){ + int iDb, nDb; + int iTxn = -1; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return -1; + } +#endif + sqlite3_mutex_enter(db->mutex); + if( zSchema ){ + nDb = iDb = sqlite3FindDbName(db, zSchema); + if( iDb<0 ) nDb--; + }else{ + iDb = 0; + nDb = db->nDb-1; + } + for(; iDb<=nDb; iDb++){ + Btree *pBt = db->aDb[iDb].pBt; + int x = pBt!=0 ? sqlite3BtreeTxnState(pBt) : SQLITE_TXN_NONE; + if( x>iTxn ) iTxn = x; + } + sqlite3_mutex_leave(db->mutex); + return iTxn; +} + +/* +** Two variations on the public interface for closing a database +** connection. The sqlite3_close() version returns SQLITE_BUSY and +** leaves the connection option if there are unfinalized prepared +** statements or unfinished sqlite3_backups. The sqlite3_close_v2() +** version forces the connection to become a zombie if there are +** unclosed resources, and arranges for deallocation when the last +** prepare statement or sqlite3_backup closes. +*/ +SQLITE_API int sqlite3_close(sqlite3 *db){ return sqlite3Close(db,0); } +SQLITE_API int sqlite3_close_v2(sqlite3 *db){ return sqlite3Close(db,1); } + + +/* +** Close the mutex on database connection db. +** +** Furthermore, if database connection db is a zombie (meaning that there +** has been a prior call to sqlite3_close(db) or sqlite3_close_v2(db)) and +** every sqlite3_stmt has now been finalized and every sqlite3_backup has +** finished, then free all resources. +*/ +SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3 *db){ + HashElem *i; /* Hash table iterator */ + int j; + + /* If there are outstanding sqlite3_stmt or sqlite3_backup objects + ** or if the connection has not yet been closed by sqlite3_close_v2(), + ** then just leave the mutex and return. + */ + if( db->magic!=SQLITE_MAGIC_ZOMBIE || connectionIsBusy(db) ){ + sqlite3_mutex_leave(db->mutex); + return; + } + + /* If we reach this point, it means that the database connection has + ** closed all sqlite3_stmt and sqlite3_backup objects and has been + ** passed to sqlite3_close (meaning that it is a zombie). Therefore, + ** go ahead and free all resources. + */ + + /* If a transaction is open, roll it back. This also ensures that if + ** any database schemas have been modified by an uncommitted transaction + ** they are reset. And that the required b-tree mutex is held to make + ** the pager rollback and schema reset an atomic operation. */ + sqlite3RollbackAll(db, SQLITE_OK); + + /* Free any outstanding Savepoint structures. */ + sqlite3CloseSavepoints(db); + + /* Close all database connections */ + for(j=0; jnDb; j++){ + struct Db *pDb = &db->aDb[j]; + if( pDb->pBt ){ + sqlite3BtreeClose(pDb->pBt); + pDb->pBt = 0; + if( j!=1 ){ + pDb->pSchema = 0; + } + } + } + /* Clear the TEMP schema separately and last */ + if( db->aDb[1].pSchema ){ + sqlite3SchemaClear(db->aDb[1].pSchema); + } + sqlite3VtabUnlockList(db); + + /* Free up the array of auxiliary databases */ + sqlite3CollapseDatabaseArray(db); + assert( db->nDb<=2 ); + assert( db->aDb==db->aDbStatic ); + + /* Tell the code in notify.c that the connection no longer holds any + ** locks and does not require any further unlock-notify callbacks. + */ + sqlite3ConnectionClosed(db); + + for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){ + FuncDef *pNext, *p; + p = sqliteHashData(i); + do{ + functionDestroy(db, p); + pNext = p->pNext; + sqlite3DbFree(db, p); + p = pNext; + }while( p ); + } + sqlite3HashClear(&db->aFunc); + for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){ + CollSeq *pColl = (CollSeq *)sqliteHashData(i); + /* Invoke any destructors registered for collation sequence user data. */ + for(j=0; j<3; j++){ + if( pColl[j].xDel ){ + pColl[j].xDel(pColl[j].pUser); + } + } + sqlite3DbFree(db, pColl); + } + sqlite3HashClear(&db->aCollSeq); +#ifndef SQLITE_OMIT_VIRTUALTABLE + for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){ + Module *pMod = (Module *)sqliteHashData(i); + sqlite3VtabEponymousTableClear(db, pMod); + sqlite3VtabModuleUnref(db, pMod); + } + sqlite3HashClear(&db->aModule); +#endif + + sqlite3Error(db, SQLITE_OK); /* Deallocates any cached error strings. */ + sqlite3ValueFree(db->pErr); + sqlite3CloseExtensions(db); +#if SQLITE_USER_AUTHENTICATION + sqlite3_free(db->auth.zAuthUser); + sqlite3_free(db->auth.zAuthPW); +#endif + + db->magic = SQLITE_MAGIC_ERROR; + + /* The temp-database schema is allocated differently from the other schema + ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()). + ** So it needs to be freed here. Todo: Why not roll the temp schema into + ** the same sqliteMalloc() as the one that allocates the database + ** structure? + */ + sqlite3DbFree(db, db->aDb[1].pSchema); + sqlite3_mutex_leave(db->mutex); + db->magic = SQLITE_MAGIC_CLOSED; + sqlite3_mutex_free(db->mutex); + assert( sqlite3LookasideUsed(db,0)==0 ); + if( db->lookaside.bMalloced ){ + sqlite3_free(db->lookaside.pStart); + } + sqlite3_free(db); +} + +/* +** Rollback all database files. If tripCode is not SQLITE_OK, then +** any write cursors are invalidated ("tripped" - as in "tripping a circuit +** breaker") and made to return tripCode if there are any further +** attempts to use that cursor. Read cursors remain open and valid +** but are "saved" in case the table pages are moved around. +*/ +SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3 *db, int tripCode){ + int i; + int inTrans = 0; + int schemaChange; + assert( sqlite3_mutex_held(db->mutex) ); + sqlite3BeginBenignMalloc(); + + /* Obtain all b-tree mutexes before making any calls to BtreeRollback(). + ** This is important in case the transaction being rolled back has + ** modified the database schema. If the b-tree mutexes are not taken + ** here, then another shared-cache connection might sneak in between + ** the database rollback and schema reset, which can cause false + ** corruption reports in some cases. */ + sqlite3BtreeEnterAll(db); + schemaChange = (db->mDbFlags & DBFLAG_SchemaChange)!=0 && db->init.busy==0; + + for(i=0; inDb; i++){ + Btree *p = db->aDb[i].pBt; + if( p ){ + if( sqlite3BtreeTxnState(p)==SQLITE_TXN_WRITE ){ + inTrans = 1; + } + sqlite3BtreeRollback(p, tripCode, !schemaChange); + } + } + sqlite3VtabRollback(db); + sqlite3EndBenignMalloc(); + + if( schemaChange ){ + sqlite3ExpirePreparedStatements(db, 0); + sqlite3ResetAllSchemasOfConnection(db); + } + sqlite3BtreeLeaveAll(db); + + /* Any deferred constraint violations have now been resolved. */ + db->nDeferredCons = 0; + db->nDeferredImmCons = 0; + db->flags &= ~(u64)SQLITE_DeferFKs; + + /* If one has been configured, invoke the rollback-hook callback */ + if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){ + db->xRollbackCallback(db->pRollbackArg); + } +} + +/* +** Return a static string containing the name corresponding to the error code +** specified in the argument. +*/ +#if defined(SQLITE_NEED_ERR_NAME) +SQLITE_PRIVATE const char *sqlite3ErrName(int rc){ + const char *zName = 0; + int i, origRc = rc; + for(i=0; i<2 && zName==0; i++, rc &= 0xff){ + switch( rc ){ + case SQLITE_OK: zName = "SQLITE_OK"; break; + case SQLITE_ERROR: zName = "SQLITE_ERROR"; break; + case SQLITE_ERROR_SNAPSHOT: zName = "SQLITE_ERROR_SNAPSHOT"; break; + case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break; + case SQLITE_PERM: zName = "SQLITE_PERM"; break; + case SQLITE_ABORT: zName = "SQLITE_ABORT"; break; + case SQLITE_ABORT_ROLLBACK: zName = "SQLITE_ABORT_ROLLBACK"; break; + case SQLITE_BUSY: zName = "SQLITE_BUSY"; break; + case SQLITE_BUSY_RECOVERY: zName = "SQLITE_BUSY_RECOVERY"; break; + case SQLITE_BUSY_SNAPSHOT: zName = "SQLITE_BUSY_SNAPSHOT"; break; + case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break; + case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break; + case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break; + case SQLITE_READONLY: zName = "SQLITE_READONLY"; break; + case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break; + case SQLITE_READONLY_CANTINIT: zName = "SQLITE_READONLY_CANTINIT"; break; + case SQLITE_READONLY_ROLLBACK: zName = "SQLITE_READONLY_ROLLBACK"; break; + case SQLITE_READONLY_DBMOVED: zName = "SQLITE_READONLY_DBMOVED"; break; + case SQLITE_READONLY_DIRECTORY: zName = "SQLITE_READONLY_DIRECTORY";break; + case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break; + case SQLITE_IOERR: zName = "SQLITE_IOERR"; break; + case SQLITE_IOERR_READ: zName = "SQLITE_IOERR_READ"; break; + case SQLITE_IOERR_SHORT_READ: zName = "SQLITE_IOERR_SHORT_READ"; break; + case SQLITE_IOERR_WRITE: zName = "SQLITE_IOERR_WRITE"; break; + case SQLITE_IOERR_FSYNC: zName = "SQLITE_IOERR_FSYNC"; break; + case SQLITE_IOERR_DIR_FSYNC: zName = "SQLITE_IOERR_DIR_FSYNC"; break; + case SQLITE_IOERR_TRUNCATE: zName = "SQLITE_IOERR_TRUNCATE"; break; + case SQLITE_IOERR_FSTAT: zName = "SQLITE_IOERR_FSTAT"; break; + case SQLITE_IOERR_UNLOCK: zName = "SQLITE_IOERR_UNLOCK"; break; + case SQLITE_IOERR_RDLOCK: zName = "SQLITE_IOERR_RDLOCK"; break; + case SQLITE_IOERR_DELETE: zName = "SQLITE_IOERR_DELETE"; break; + case SQLITE_IOERR_NOMEM: zName = "SQLITE_IOERR_NOMEM"; break; + case SQLITE_IOERR_ACCESS: zName = "SQLITE_IOERR_ACCESS"; break; + case SQLITE_IOERR_CHECKRESERVEDLOCK: + zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break; + case SQLITE_IOERR_LOCK: zName = "SQLITE_IOERR_LOCK"; break; + case SQLITE_IOERR_CLOSE: zName = "SQLITE_IOERR_CLOSE"; break; + case SQLITE_IOERR_DIR_CLOSE: zName = "SQLITE_IOERR_DIR_CLOSE"; break; + case SQLITE_IOERR_SHMOPEN: zName = "SQLITE_IOERR_SHMOPEN"; break; + case SQLITE_IOERR_SHMSIZE: zName = "SQLITE_IOERR_SHMSIZE"; break; + case SQLITE_IOERR_SHMLOCK: zName = "SQLITE_IOERR_SHMLOCK"; break; + case SQLITE_IOERR_SHMMAP: zName = "SQLITE_IOERR_SHMMAP"; break; + case SQLITE_IOERR_SEEK: zName = "SQLITE_IOERR_SEEK"; break; + case SQLITE_IOERR_DELETE_NOENT: zName = "SQLITE_IOERR_DELETE_NOENT";break; + case SQLITE_IOERR_MMAP: zName = "SQLITE_IOERR_MMAP"; break; + case SQLITE_IOERR_GETTEMPPATH: zName = "SQLITE_IOERR_GETTEMPPATH"; break; + case SQLITE_IOERR_CONVPATH: zName = "SQLITE_IOERR_CONVPATH"; break; + case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break; + case SQLITE_CORRUPT_VTAB: zName = "SQLITE_CORRUPT_VTAB"; break; + case SQLITE_NOTFOUND: zName = "SQLITE_NOTFOUND"; break; + case SQLITE_FULL: zName = "SQLITE_FULL"; break; + case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break; + case SQLITE_CANTOPEN_NOTEMPDIR: zName = "SQLITE_CANTOPEN_NOTEMPDIR";break; + case SQLITE_CANTOPEN_ISDIR: zName = "SQLITE_CANTOPEN_ISDIR"; break; + case SQLITE_CANTOPEN_FULLPATH: zName = "SQLITE_CANTOPEN_FULLPATH"; break; + case SQLITE_CANTOPEN_CONVPATH: zName = "SQLITE_CANTOPEN_CONVPATH"; break; + case SQLITE_CANTOPEN_SYMLINK: zName = "SQLITE_CANTOPEN_SYMLINK"; break; + case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break; + case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break; + case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break; + case SQLITE_TOOBIG: zName = "SQLITE_TOOBIG"; break; + case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break; + case SQLITE_CONSTRAINT_UNIQUE: zName = "SQLITE_CONSTRAINT_UNIQUE"; break; + case SQLITE_CONSTRAINT_TRIGGER: zName = "SQLITE_CONSTRAINT_TRIGGER";break; + case SQLITE_CONSTRAINT_FOREIGNKEY: + zName = "SQLITE_CONSTRAINT_FOREIGNKEY"; break; + case SQLITE_CONSTRAINT_CHECK: zName = "SQLITE_CONSTRAINT_CHECK"; break; + case SQLITE_CONSTRAINT_PRIMARYKEY: + zName = "SQLITE_CONSTRAINT_PRIMARYKEY"; break; + case SQLITE_CONSTRAINT_NOTNULL: zName = "SQLITE_CONSTRAINT_NOTNULL";break; + case SQLITE_CONSTRAINT_COMMITHOOK: + zName = "SQLITE_CONSTRAINT_COMMITHOOK"; break; + case SQLITE_CONSTRAINT_VTAB: zName = "SQLITE_CONSTRAINT_VTAB"; break; + case SQLITE_CONSTRAINT_FUNCTION: + zName = "SQLITE_CONSTRAINT_FUNCTION"; break; + case SQLITE_CONSTRAINT_ROWID: zName = "SQLITE_CONSTRAINT_ROWID"; break; + case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break; + case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break; + case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break; + case SQLITE_AUTH: zName = "SQLITE_AUTH"; break; + case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break; + case SQLITE_RANGE: zName = "SQLITE_RANGE"; break; + case SQLITE_NOTADB: zName = "SQLITE_NOTADB"; break; + case SQLITE_ROW: zName = "SQLITE_ROW"; break; + case SQLITE_NOTICE: zName = "SQLITE_NOTICE"; break; + case SQLITE_NOTICE_RECOVER_WAL: zName = "SQLITE_NOTICE_RECOVER_WAL";break; + case SQLITE_NOTICE_RECOVER_ROLLBACK: + zName = "SQLITE_NOTICE_RECOVER_ROLLBACK"; break; + case SQLITE_WARNING: zName = "SQLITE_WARNING"; break; + case SQLITE_WARNING_AUTOINDEX: zName = "SQLITE_WARNING_AUTOINDEX"; break; + case SQLITE_DONE: zName = "SQLITE_DONE"; break; + } + } + if( zName==0 ){ + static char zBuf[50]; + sqlite3_snprintf(sizeof(zBuf), zBuf, "SQLITE_UNKNOWN(%d)", origRc); + zName = zBuf; + } + return zName; +} +#endif + +/* +** Return a static string that describes the kind of error specified in the +** argument. +*/ +SQLITE_PRIVATE const char *sqlite3ErrStr(int rc){ + static const char* const aMsg[] = { + /* SQLITE_OK */ "not an error", + /* SQLITE_ERROR */ "SQL logic error", + /* SQLITE_INTERNAL */ 0, + /* SQLITE_PERM */ "access permission denied", + /* SQLITE_ABORT */ "query aborted", + /* SQLITE_BUSY */ "database is locked", + /* SQLITE_LOCKED */ "database table is locked", + /* SQLITE_NOMEM */ "out of memory", + /* SQLITE_READONLY */ "attempt to write a readonly database", + /* SQLITE_INTERRUPT */ "interrupted", + /* SQLITE_IOERR */ "disk I/O error", + /* SQLITE_CORRUPT */ "database disk image is malformed", + /* SQLITE_NOTFOUND */ "unknown operation", + /* SQLITE_FULL */ "database or disk is full", + /* SQLITE_CANTOPEN */ "unable to open database file", + /* SQLITE_PROTOCOL */ "locking protocol", + /* SQLITE_EMPTY */ 0, + /* SQLITE_SCHEMA */ "database schema has changed", + /* SQLITE_TOOBIG */ "string or blob too big", + /* SQLITE_CONSTRAINT */ "constraint failed", + /* SQLITE_MISMATCH */ "datatype mismatch", + /* SQLITE_MISUSE */ "bad parameter or other API misuse", +#ifdef SQLITE_DISABLE_LFS + /* SQLITE_NOLFS */ "large file support is disabled", +#else + /* SQLITE_NOLFS */ 0, +#endif + /* SQLITE_AUTH */ "authorization denied", + /* SQLITE_FORMAT */ 0, + /* SQLITE_RANGE */ "column index out of range", + /* SQLITE_NOTADB */ "file is not a database", + /* SQLITE_NOTICE */ "notification message", + /* SQLITE_WARNING */ "warning message", + }; + const char *zErr = "unknown error"; + switch( rc ){ + case SQLITE_ABORT_ROLLBACK: { + zErr = "abort due to ROLLBACK"; + break; + } + case SQLITE_ROW: { + zErr = "another row available"; + break; + } + case SQLITE_DONE: { + zErr = "no more rows available"; + break; + } + default: { + rc &= 0xff; + if( ALWAYS(rc>=0) && rcbusyTimeout; + int delay, prior; + + assert( count>=0 ); + if( count < NDELAY ){ + delay = delays[count]; + prior = totals[count]; + }else{ + delay = delays[NDELAY-1]; + prior = totals[NDELAY-1] + delay*(count-(NDELAY-1)); + } + if( prior + delay > tmout ){ + delay = tmout - prior; + if( delay<=0 ) return 0; + } + sqlite3OsSleep(db->pVfs, delay*1000); + return 1; +#else + /* This case for unix systems that lack usleep() support. Sleeping + ** must be done in increments of whole seconds */ + sqlite3 *db = (sqlite3 *)ptr; + int tmout = ((sqlite3 *)ptr)->busyTimeout; + if( (count+1)*1000 > tmout ){ + return 0; + } + sqlite3OsSleep(db->pVfs, 1000000); + return 1; +#endif +} + +/* +** Invoke the given busy handler. +** +** This routine is called when an operation failed to acquire a +** lock on VFS file pFile. +** +** If this routine returns non-zero, the lock is retried. If it +** returns 0, the operation aborts with an SQLITE_BUSY error. +*/ +SQLITE_PRIVATE int sqlite3InvokeBusyHandler(BusyHandler *p){ + int rc; + if( p->xBusyHandler==0 || p->nBusy<0 ) return 0; + rc = p->xBusyHandler(p->pBusyArg, p->nBusy); + if( rc==0 ){ + p->nBusy = -1; + }else{ + p->nBusy++; + } + return rc; +} + +/* +** This routine sets the busy callback for an Sqlite database to the +** given callback function with the given argument. +*/ +SQLITE_API int sqlite3_busy_handler( + sqlite3 *db, + int (*xBusy)(void*,int), + void *pArg +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + db->busyHandler.xBusyHandler = xBusy; + db->busyHandler.pBusyArg = pArg; + db->busyHandler.nBusy = 0; + db->busyTimeout = 0; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK +/* +** This routine sets the progress callback for an Sqlite database to the +** given callback function with the given argument. The progress callback will +** be invoked every nOps opcodes. +*/ +SQLITE_API void sqlite3_progress_handler( + sqlite3 *db, + int nOps, + int (*xProgress)(void*), + void *pArg +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return; + } +#endif + sqlite3_mutex_enter(db->mutex); + if( nOps>0 ){ + db->xProgress = xProgress; + db->nProgressOps = (unsigned)nOps; + db->pProgressArg = pArg; + }else{ + db->xProgress = 0; + db->nProgressOps = 0; + db->pProgressArg = 0; + } + sqlite3_mutex_leave(db->mutex); +} +#endif + + +/* +** This routine installs a default busy handler that waits for the +** specified number of milliseconds before returning 0. +*/ +SQLITE_API int sqlite3_busy_timeout(sqlite3 *db, int ms){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + if( ms>0 ){ + sqlite3_busy_handler(db, (int(*)(void*,int))sqliteDefaultBusyCallback, + (void*)db); + db->busyTimeout = ms; + }else{ + sqlite3_busy_handler(db, 0, 0); + } + return SQLITE_OK; +} + +/* +** Cause any pending operation to stop at its earliest opportunity. +*/ +SQLITE_API void sqlite3_interrupt(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) && (db==0 || db->magic!=SQLITE_MAGIC_ZOMBIE) ){ + (void)SQLITE_MISUSE_BKPT; + return; + } +#endif + AtomicStore(&db->u1.isInterrupted, 1); +} + + +/* +** This function is exactly the same as sqlite3_create_function(), except +** that it is designed to be called by internal code. The difference is +** that if a malloc() fails in sqlite3_create_function(), an error code +** is returned and the mallocFailed flag cleared. +*/ +SQLITE_PRIVATE int sqlite3CreateFunc( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int enc, + void *pUserData, + void (*xSFunc)(sqlite3_context*,int,sqlite3_value **), + void (*xStep)(sqlite3_context*,int,sqlite3_value **), + void (*xFinal)(sqlite3_context*), + void (*xValue)(sqlite3_context*), + void (*xInverse)(sqlite3_context*,int,sqlite3_value **), + FuncDestructor *pDestructor +){ + FuncDef *p; + int nName; + int extraFlags; + + assert( sqlite3_mutex_held(db->mutex) ); + assert( xValue==0 || xSFunc==0 ); + if( zFunctionName==0 /* Must have a valid name */ + || (xSFunc!=0 && xFinal!=0) /* Not both xSFunc and xFinal */ + || ((xFinal==0)!=(xStep==0)) /* Both or neither of xFinal and xStep */ + || ((xValue==0)!=(xInverse==0)) /* Both or neither of xValue, xInverse */ + || (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG) + || (255<(nName = sqlite3Strlen30( zFunctionName))) + ){ + return SQLITE_MISUSE_BKPT; + } + + assert( SQLITE_FUNC_CONSTANT==SQLITE_DETERMINISTIC ); + assert( SQLITE_FUNC_DIRECT==SQLITE_DIRECTONLY ); + extraFlags = enc & (SQLITE_DETERMINISTIC|SQLITE_DIRECTONLY| + SQLITE_SUBTYPE|SQLITE_INNOCUOUS); + enc &= (SQLITE_FUNC_ENCMASK|SQLITE_ANY); + + /* The SQLITE_INNOCUOUS flag is the same bit as SQLITE_FUNC_UNSAFE. But + ** the meaning is inverted. So flip the bit. */ + assert( SQLITE_FUNC_UNSAFE==SQLITE_INNOCUOUS ); + extraFlags ^= SQLITE_FUNC_UNSAFE; + + +#ifndef SQLITE_OMIT_UTF16 + /* If SQLITE_UTF16 is specified as the encoding type, transform this + ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the + ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally. + ** + ** If SQLITE_ANY is specified, add three versions of the function + ** to the hash table. + */ + if( enc==SQLITE_UTF16 ){ + enc = SQLITE_UTF16NATIVE; + }else if( enc==SQLITE_ANY ){ + int rc; + rc = sqlite3CreateFunc(db, zFunctionName, nArg, + (SQLITE_UTF8|extraFlags)^SQLITE_FUNC_UNSAFE, + pUserData, xSFunc, xStep, xFinal, xValue, xInverse, pDestructor); + if( rc==SQLITE_OK ){ + rc = sqlite3CreateFunc(db, zFunctionName, nArg, + (SQLITE_UTF16LE|extraFlags)^SQLITE_FUNC_UNSAFE, + pUserData, xSFunc, xStep, xFinal, xValue, xInverse, pDestructor); + } + if( rc!=SQLITE_OK ){ + return rc; + } + enc = SQLITE_UTF16BE; + } +#else + enc = SQLITE_UTF8; +#endif + + /* Check if an existing function is being overridden or deleted. If so, + ** and there are active VMs, then return SQLITE_BUSY. If a function + ** is being overridden/deleted but there are no active VMs, allow the + ** operation to continue but invalidate all precompiled statements. + */ + p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 0); + if( p && (p->funcFlags & SQLITE_FUNC_ENCMASK)==(u32)enc && p->nArg==nArg ){ + if( db->nVdbeActive ){ + sqlite3ErrorWithMsg(db, SQLITE_BUSY, + "unable to delete/modify user-function due to active statements"); + assert( !db->mallocFailed ); + return SQLITE_BUSY; + }else{ + sqlite3ExpirePreparedStatements(db, 0); + } + } + + p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 1); + assert(p || db->mallocFailed); + if( !p ){ + return SQLITE_NOMEM_BKPT; + } + + /* If an older version of the function with a configured destructor is + ** being replaced invoke the destructor function here. */ + functionDestroy(db, p); + + if( pDestructor ){ + pDestructor->nRef++; + } + p->u.pDestructor = pDestructor; + p->funcFlags = (p->funcFlags & SQLITE_FUNC_ENCMASK) | extraFlags; + testcase( p->funcFlags & SQLITE_DETERMINISTIC ); + testcase( p->funcFlags & SQLITE_DIRECTONLY ); + p->xSFunc = xSFunc ? xSFunc : xStep; + p->xFinalize = xFinal; + p->xValue = xValue; + p->xInverse = xInverse; + p->pUserData = pUserData; + p->nArg = (u16)nArg; + return SQLITE_OK; +} + +/* +** Worker function used by utf-8 APIs that create new functions: +** +** sqlite3_create_function() +** sqlite3_create_function_v2() +** sqlite3_create_window_function() +*/ +static int createFunctionApi( + sqlite3 *db, + const char *zFunc, + int nArg, + int enc, + void *p, + void (*xSFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void (*xValue)(sqlite3_context*), + void (*xInverse)(sqlite3_context*,int,sqlite3_value**), + void(*xDestroy)(void*) +){ + int rc = SQLITE_ERROR; + FuncDestructor *pArg = 0; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + if( xDestroy ){ + pArg = (FuncDestructor *)sqlite3Malloc(sizeof(FuncDestructor)); + if( !pArg ){ + sqlite3OomFault(db); + xDestroy(p); + goto out; + } + pArg->nRef = 0; + pArg->xDestroy = xDestroy; + pArg->pUserData = p; + } + rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p, + xSFunc, xStep, xFinal, xValue, xInverse, pArg + ); + if( pArg && pArg->nRef==0 ){ + assert( rc!=SQLITE_OK ); + xDestroy(p); + sqlite3_free(pArg); + } + + out: + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Create new user functions. +*/ +SQLITE_API int sqlite3_create_function( + sqlite3 *db, + const char *zFunc, + int nArg, + int enc, + void *p, + void (*xSFunc)(sqlite3_context*,int,sqlite3_value **), + void (*xStep)(sqlite3_context*,int,sqlite3_value **), + void (*xFinal)(sqlite3_context*) +){ + return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep, + xFinal, 0, 0, 0); +} +SQLITE_API int sqlite3_create_function_v2( + sqlite3 *db, + const char *zFunc, + int nArg, + int enc, + void *p, + void (*xSFunc)(sqlite3_context*,int,sqlite3_value **), + void (*xStep)(sqlite3_context*,int,sqlite3_value **), + void (*xFinal)(sqlite3_context*), + void (*xDestroy)(void *) +){ + return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep, + xFinal, 0, 0, xDestroy); +} +SQLITE_API int sqlite3_create_window_function( + sqlite3 *db, + const char *zFunc, + int nArg, + int enc, + void *p, + void (*xStep)(sqlite3_context*,int,sqlite3_value **), + void (*xFinal)(sqlite3_context*), + void (*xValue)(sqlite3_context*), + void (*xInverse)(sqlite3_context*,int,sqlite3_value **), + void (*xDestroy)(void *) +){ + return createFunctionApi(db, zFunc, nArg, enc, p, 0, xStep, + xFinal, xValue, xInverse, xDestroy); +} + +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API int sqlite3_create_function16( + sqlite3 *db, + const void *zFunctionName, + int nArg, + int eTextRep, + void *p, + void (*xSFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +){ + int rc; + char *zFunc8; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zFunctionName==0 ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1, SQLITE_UTF16NATIVE); + rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xSFunc,xStep,xFinal,0,0,0); + sqlite3DbFree(db, zFunc8); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} +#endif + + +/* +** The following is the implementation of an SQL function that always +** fails with an error message stating that the function is used in the +** wrong context. The sqlite3_overload_function() API might construct +** SQL function that use this routine so that the functions will exist +** for name resolution but are actually overloaded by the xFindFunction +** method of virtual tables. +*/ +static void sqlite3InvalidFunction( + sqlite3_context *context, /* The function calling context */ + int NotUsed, /* Number of arguments to the function */ + sqlite3_value **NotUsed2 /* Value of each argument */ +){ + const char *zName = (const char*)sqlite3_user_data(context); + char *zErr; + UNUSED_PARAMETER2(NotUsed, NotUsed2); + zErr = sqlite3_mprintf( + "unable to use function %s in the requested context", zName); + sqlite3_result_error(context, zErr, -1); + sqlite3_free(zErr); +} + +/* +** Declare that a function has been overloaded by a virtual table. +** +** If the function already exists as a regular global function, then +** this routine is a no-op. If the function does not exist, then create +** a new one that always throws a run-time error. +** +** When virtual tables intend to provide an overloaded function, they +** should call this routine to make sure the global function exists. +** A global function must exist in order for name resolution to work +** properly. +*/ +SQLITE_API int sqlite3_overload_function( + sqlite3 *db, + const char *zName, + int nArg +){ + int rc; + char *zCopy; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + rc = sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)!=0; + sqlite3_mutex_leave(db->mutex); + if( rc ) return SQLITE_OK; + zCopy = sqlite3_mprintf(zName); + if( zCopy==0 ) return SQLITE_NOMEM; + return sqlite3_create_function_v2(db, zName, nArg, SQLITE_UTF8, + zCopy, sqlite3InvalidFunction, 0, 0, sqlite3_free); +} + +#ifndef SQLITE_OMIT_TRACE +/* +** Register a trace function. The pArg from the previously registered trace +** is returned. +** +** A NULL trace function means that no tracing is executes. A non-NULL +** trace is a pointer to a function that is invoked at the start of each +** SQL statement. +*/ +#ifndef SQLITE_OMIT_DEPRECATED +SQLITE_API void *sqlite3_trace(sqlite3 *db, void(*xTrace)(void*,const char*), void *pArg){ + void *pOld; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pOld = db->pTraceArg; + db->mTrace = xTrace ? SQLITE_TRACE_LEGACY : 0; + db->trace.xLegacy = xTrace; + db->pTraceArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pOld; +} +#endif /* SQLITE_OMIT_DEPRECATED */ + +/* Register a trace callback using the version-2 interface. +*/ +SQLITE_API int sqlite3_trace_v2( + sqlite3 *db, /* Trace this connection */ + unsigned mTrace, /* Mask of events to be traced */ + int(*xTrace)(unsigned,void*,void*,void*), /* Callback to invoke */ + void *pArg /* Context */ +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + if( mTrace==0 ) xTrace = 0; + if( xTrace==0 ) mTrace = 0; + db->mTrace = mTrace; + db->trace.xV2 = xTrace; + db->pTraceArg = pArg; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Register a profile function. The pArg from the previously registered +** profile function is returned. +** +** A NULL profile function means that no profiling is executes. A non-NULL +** profile is a pointer to a function that is invoked at the conclusion of +** each SQL statement that is run. +*/ +SQLITE_API void *sqlite3_profile( + sqlite3 *db, + void (*xProfile)(void*,const char*,sqlite_uint64), + void *pArg +){ + void *pOld; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pOld = db->pProfileArg; + db->xProfile = xProfile; + db->pProfileArg = pArg; + db->mTrace &= SQLITE_TRACE_NONLEGACY_MASK; + if( db->xProfile ) db->mTrace |= SQLITE_TRACE_XPROFILE; + sqlite3_mutex_leave(db->mutex); + return pOld; +} +#endif /* SQLITE_OMIT_DEPRECATED */ +#endif /* SQLITE_OMIT_TRACE */ + +/* +** Register a function to be invoked when a transaction commits. +** If the invoked function returns non-zero, then the commit becomes a +** rollback. +*/ +SQLITE_API void *sqlite3_commit_hook( + sqlite3 *db, /* Attach the hook to this database */ + int (*xCallback)(void*), /* Function to invoke on each commit */ + void *pArg /* Argument to the function */ +){ + void *pOld; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pOld = db->pCommitArg; + db->xCommitCallback = xCallback; + db->pCommitArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pOld; +} + +/* +** Register a callback to be invoked each time a row is updated, +** inserted or deleted using this database connection. +*/ +SQLITE_API void *sqlite3_update_hook( + sqlite3 *db, /* Attach the hook to this database */ + void (*xCallback)(void*,int,char const *,char const *,sqlite_int64), + void *pArg /* Argument to the function */ +){ + void *pRet; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pRet = db->pUpdateArg; + db->xUpdateCallback = xCallback; + db->pUpdateArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pRet; +} + +/* +** Register a callback to be invoked each time a transaction is rolled +** back by this database connection. +*/ +SQLITE_API void *sqlite3_rollback_hook( + sqlite3 *db, /* Attach the hook to this database */ + void (*xCallback)(void*), /* Callback function */ + void *pArg /* Argument to the function */ +){ + void *pRet; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pRet = db->pRollbackArg; + db->xRollbackCallback = xCallback; + db->pRollbackArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pRet; +} + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +/* +** Register a callback to be invoked each time a row is updated, +** inserted or deleted using this database connection. +*/ +SQLITE_API void *sqlite3_preupdate_hook( + sqlite3 *db, /* Attach the hook to this database */ + void(*xCallback)( /* Callback function */ + void*,sqlite3*,int,char const*,char const*,sqlite3_int64,sqlite3_int64), + void *pArg /* First callback argument */ +){ + void *pRet; + sqlite3_mutex_enter(db->mutex); + pRet = db->pPreUpdateArg; + db->xPreUpdateCallback = xCallback; + db->pPreUpdateArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pRet; +} +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + +#ifndef SQLITE_OMIT_WAL +/* +** The sqlite3_wal_hook() callback registered by sqlite3_wal_autocheckpoint(). +** Invoke sqlite3_wal_checkpoint if the number of frames in the log file +** is greater than sqlite3.pWalArg cast to an integer (the value configured by +** wal_autocheckpoint()). +*/ +SQLITE_PRIVATE int sqlite3WalDefaultHook( + void *pClientData, /* Argument */ + sqlite3 *db, /* Connection */ + const char *zDb, /* Database */ + int nFrame /* Size of WAL */ +){ + if( nFrame>=SQLITE_PTR_TO_INT(pClientData) ){ + sqlite3BeginBenignMalloc(); + sqlite3_wal_checkpoint(db, zDb); + sqlite3EndBenignMalloc(); + } + return SQLITE_OK; +} +#endif /* SQLITE_OMIT_WAL */ + +/* +** Configure an sqlite3_wal_hook() callback to automatically checkpoint +** a database after committing a transaction if there are nFrame or +** more frames in the log file. Passing zero or a negative value as the +** nFrame parameter disables automatic checkpoints entirely. +** +** The callback registered by this function replaces any existing callback +** registered using sqlite3_wal_hook(). Likewise, registering a callback +** using sqlite3_wal_hook() disables the automatic checkpoint mechanism +** configured by this function. +*/ +SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int nFrame){ +#ifdef SQLITE_OMIT_WAL + UNUSED_PARAMETER(db); + UNUSED_PARAMETER(nFrame); +#else +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + if( nFrame>0 ){ + sqlite3_wal_hook(db, sqlite3WalDefaultHook, SQLITE_INT_TO_PTR(nFrame)); + }else{ + sqlite3_wal_hook(db, 0, 0); + } +#endif + return SQLITE_OK; +} + +/* +** Register a callback to be invoked each time a transaction is written +** into the write-ahead-log by this database connection. +*/ +SQLITE_API void *sqlite3_wal_hook( + sqlite3 *db, /* Attach the hook to this db handle */ + int(*xCallback)(void *, sqlite3*, const char*, int), + void *pArg /* First argument passed to xCallback() */ +){ +#ifndef SQLITE_OMIT_WAL + void *pRet; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pRet = db->pWalArg; + db->xWalCallback = xCallback; + db->pWalArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pRet; +#else + return 0; +#endif +} + +/* +** Checkpoint database zDb. +*/ +SQLITE_API int sqlite3_wal_checkpoint_v2( + sqlite3 *db, /* Database handle */ + const char *zDb, /* Name of attached database (or NULL) */ + int eMode, /* SQLITE_CHECKPOINT_* value */ + int *pnLog, /* OUT: Size of WAL log in frames */ + int *pnCkpt /* OUT: Total number of frames checkpointed */ +){ +#ifdef SQLITE_OMIT_WAL + return SQLITE_OK; +#else + int rc; /* Return code */ + int iDb = SQLITE_MAX_ATTACHED; /* sqlite3.aDb[] index of db to checkpoint */ + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + + /* Initialize the output variables to -1 in case an error occurs. */ + if( pnLog ) *pnLog = -1; + if( pnCkpt ) *pnCkpt = -1; + + assert( SQLITE_CHECKPOINT_PASSIVE==0 ); + assert( SQLITE_CHECKPOINT_FULL==1 ); + assert( SQLITE_CHECKPOINT_RESTART==2 ); + assert( SQLITE_CHECKPOINT_TRUNCATE==3 ); + if( eModeSQLITE_CHECKPOINT_TRUNCATE ){ + /* EVIDENCE-OF: R-03996-12088 The M parameter must be a valid checkpoint + ** mode: */ + return SQLITE_MISUSE; + } + + sqlite3_mutex_enter(db->mutex); + if( zDb && zDb[0] ){ + iDb = sqlite3FindDbName(db, zDb); + } + if( iDb<0 ){ + rc = SQLITE_ERROR; + sqlite3ErrorWithMsg(db, SQLITE_ERROR, "unknown database: %s", zDb); + }else{ + db->busyHandler.nBusy = 0; + rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt); + sqlite3Error(db, rc); + } + rc = sqlite3ApiExit(db, rc); + + /* If there are no active statements, clear the interrupt flag at this + ** point. */ + if( db->nVdbeActive==0 ){ + AtomicStore(&db->u1.isInterrupted, 0); + } + + sqlite3_mutex_leave(db->mutex); + return rc; +#endif +} + + +/* +** Checkpoint database zDb. If zDb is NULL, or if the buffer zDb points +** to contains a zero-length string, all attached databases are +** checkpointed. +*/ +SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){ + /* EVIDENCE-OF: R-41613-20553 The sqlite3_wal_checkpoint(D,X) is equivalent to + ** sqlite3_wal_checkpoint_v2(D,X,SQLITE_CHECKPOINT_PASSIVE,0,0). */ + return sqlite3_wal_checkpoint_v2(db,zDb,SQLITE_CHECKPOINT_PASSIVE,0,0); +} + +#ifndef SQLITE_OMIT_WAL +/* +** Run a checkpoint on database iDb. This is a no-op if database iDb is +** not currently open in WAL mode. +** +** If a transaction is open on the database being checkpointed, this +** function returns SQLITE_LOCKED and a checkpoint is not attempted. If +** an error occurs while running the checkpoint, an SQLite error code is +** returned (i.e. SQLITE_IOERR). Otherwise, SQLITE_OK. +** +** The mutex on database handle db should be held by the caller. The mutex +** associated with the specific b-tree being checkpointed is taken by +** this function while the checkpoint is running. +** +** If iDb is passed SQLITE_MAX_ATTACHED, then all attached databases are +** checkpointed. If an error is encountered it is returned immediately - +** no attempt is made to checkpoint any remaining databases. +** +** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL, RESTART +** or TRUNCATE. +*/ +SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){ + int rc = SQLITE_OK; /* Return code */ + int i; /* Used to iterate through attached dbs */ + int bBusy = 0; /* True if SQLITE_BUSY has been encountered */ + + assert( sqlite3_mutex_held(db->mutex) ); + assert( !pnLog || *pnLog==-1 ); + assert( !pnCkpt || *pnCkpt==-1 ); + + for(i=0; inDb && rc==SQLITE_OK; i++){ + if( i==iDb || iDb==SQLITE_MAX_ATTACHED ){ + rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt); + pnLog = 0; + pnCkpt = 0; + if( rc==SQLITE_BUSY ){ + bBusy = 1; + rc = SQLITE_OK; + } + } + } + + return (rc==SQLITE_OK && bBusy) ? SQLITE_BUSY : rc; +} +#endif /* SQLITE_OMIT_WAL */ + +/* +** This function returns true if main-memory should be used instead of +** a temporary file for transient pager files and statement journals. +** The value returned depends on the value of db->temp_store (runtime +** parameter) and the compile time value of SQLITE_TEMP_STORE. The +** following table describes the relationship between these two values +** and this functions return value. +** +** SQLITE_TEMP_STORE db->temp_store Location of temporary database +** ----------------- -------------- ------------------------------ +** 0 any file (return 0) +** 1 1 file (return 0) +** 1 2 memory (return 1) +** 1 0 file (return 0) +** 2 1 file (return 0) +** 2 2 memory (return 1) +** 2 0 memory (return 1) +** 3 any memory (return 1) +*/ +SQLITE_PRIVATE int sqlite3TempInMemory(const sqlite3 *db){ +#if SQLITE_TEMP_STORE==1 + return ( db->temp_store==2 ); +#endif +#if SQLITE_TEMP_STORE==2 + return ( db->temp_store!=1 ); +#endif +#if SQLITE_TEMP_STORE==3 + UNUSED_PARAMETER(db); + return 1; +#endif +#if SQLITE_TEMP_STORE<1 || SQLITE_TEMP_STORE>3 + UNUSED_PARAMETER(db); + return 0; +#endif +} + +/* +** Return UTF-8 encoded English language explanation of the most recent +** error. +*/ +SQLITE_API const char *sqlite3_errmsg(sqlite3 *db){ + const char *z; + if( !db ){ + return sqlite3ErrStr(SQLITE_NOMEM_BKPT); + } + if( !sqlite3SafetyCheckSickOrOk(db) ){ + return sqlite3ErrStr(SQLITE_MISUSE_BKPT); + } + sqlite3_mutex_enter(db->mutex); + if( db->mallocFailed ){ + z = sqlite3ErrStr(SQLITE_NOMEM_BKPT); + }else{ + testcase( db->pErr==0 ); + z = db->errCode ? (char*)sqlite3_value_text(db->pErr) : 0; + assert( !db->mallocFailed ); + if( z==0 ){ + z = sqlite3ErrStr(db->errCode); + } + } + sqlite3_mutex_leave(db->mutex); + return z; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Return UTF-16 encoded English language explanation of the most recent +** error. +*/ +SQLITE_API const void *sqlite3_errmsg16(sqlite3 *db){ + static const u16 outOfMem[] = { + 'o', 'u', 't', ' ', 'o', 'f', ' ', 'm', 'e', 'm', 'o', 'r', 'y', 0 + }; + static const u16 misuse[] = { + 'b', 'a', 'd', ' ', 'p', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', ' ', + 'o', 'r', ' ', 'o', 't', 'h', 'e', 'r', ' ', 'A', 'P', 'I', ' ', + 'm', 'i', 's', 'u', 's', 'e', 0 + }; + + const void *z; + if( !db ){ + return (void *)outOfMem; + } + if( !sqlite3SafetyCheckSickOrOk(db) ){ + return (void *)misuse; + } + sqlite3_mutex_enter(db->mutex); + if( db->mallocFailed ){ + z = (void *)outOfMem; + }else{ + z = sqlite3_value_text16(db->pErr); + if( z==0 ){ + sqlite3ErrorWithMsg(db, db->errCode, sqlite3ErrStr(db->errCode)); + z = sqlite3_value_text16(db->pErr); + } + /* A malloc() may have failed within the call to sqlite3_value_text16() + ** above. If this is the case, then the db->mallocFailed flag needs to + ** be cleared before returning. Do this directly, instead of via + ** sqlite3ApiExit(), to avoid setting the database handle error message. + */ + sqlite3OomClear(db); + } + sqlite3_mutex_leave(db->mutex); + return z; +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Return the most recent error code generated by an SQLite routine. If NULL is +** passed to this function, we assume a malloc() failed during sqlite3_open(). +*/ +SQLITE_API int sqlite3_errcode(sqlite3 *db){ + if( db && !sqlite3SafetyCheckSickOrOk(db) ){ + return SQLITE_MISUSE_BKPT; + } + if( !db || db->mallocFailed ){ + return SQLITE_NOMEM_BKPT; + } + return db->errCode & db->errMask; +} +SQLITE_API int sqlite3_extended_errcode(sqlite3 *db){ + if( db && !sqlite3SafetyCheckSickOrOk(db) ){ + return SQLITE_MISUSE_BKPT; + } + if( !db || db->mallocFailed ){ + return SQLITE_NOMEM_BKPT; + } + return db->errCode; +} +SQLITE_API int sqlite3_system_errno(sqlite3 *db){ + return db ? db->iSysErrno : 0; +} + +/* +** Return a string that describes the kind of error specified in the +** argument. For now, this simply calls the internal sqlite3ErrStr() +** function. +*/ +SQLITE_API const char *sqlite3_errstr(int rc){ + return sqlite3ErrStr(rc); +} + +/* +** Create a new collating function for database "db". The name is zName +** and the encoding is enc. +*/ +static int createCollation( + sqlite3* db, + const char *zName, + u8 enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDel)(void*) +){ + CollSeq *pColl; + int enc2; + + assert( sqlite3_mutex_held(db->mutex) ); + + /* If SQLITE_UTF16 is specified as the encoding type, transform this + ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the + ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally. + */ + enc2 = enc; + testcase( enc2==SQLITE_UTF16 ); + testcase( enc2==SQLITE_UTF16_ALIGNED ); + if( enc2==SQLITE_UTF16 || enc2==SQLITE_UTF16_ALIGNED ){ + enc2 = SQLITE_UTF16NATIVE; + } + if( enc2SQLITE_UTF16BE ){ + return SQLITE_MISUSE_BKPT; + } + + /* Check if this call is removing or replacing an existing collation + ** sequence. If so, and there are active VMs, return busy. If there + ** are no active VMs, invalidate any pre-compiled statements. + */ + pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0); + if( pColl && pColl->xCmp ){ + if( db->nVdbeActive ){ + sqlite3ErrorWithMsg(db, SQLITE_BUSY, + "unable to delete/modify collation sequence due to active statements"); + return SQLITE_BUSY; + } + sqlite3ExpirePreparedStatements(db, 0); + + /* If collation sequence pColl was created directly by a call to + ** sqlite3_create_collation, and not generated by synthCollSeq(), + ** then any copies made by synthCollSeq() need to be invalidated. + ** Also, collation destructor - CollSeq.xDel() - function may need + ** to be called. + */ + if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){ + CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName); + int j; + for(j=0; j<3; j++){ + CollSeq *p = &aColl[j]; + if( p->enc==pColl->enc ){ + if( p->xDel ){ + p->xDel(p->pUser); + } + p->xCmp = 0; + } + } + } + } + + pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1); + if( pColl==0 ) return SQLITE_NOMEM_BKPT; + pColl->xCmp = xCompare; + pColl->pUser = pCtx; + pColl->xDel = xDel; + pColl->enc = (u8)(enc2 | (enc & SQLITE_UTF16_ALIGNED)); + sqlite3Error(db, SQLITE_OK); + return SQLITE_OK; +} + + +/* +** This array defines hard upper bounds on limit values. The +** initializer must be kept in sync with the SQLITE_LIMIT_* +** #defines in sqlite3.h. +*/ +static const int aHardLimit[] = { + SQLITE_MAX_LENGTH, + SQLITE_MAX_SQL_LENGTH, + SQLITE_MAX_COLUMN, + SQLITE_MAX_EXPR_DEPTH, + SQLITE_MAX_COMPOUND_SELECT, + SQLITE_MAX_VDBE_OP, + SQLITE_MAX_FUNCTION_ARG, + SQLITE_MAX_ATTACHED, + SQLITE_MAX_LIKE_PATTERN_LENGTH, + SQLITE_MAX_VARIABLE_NUMBER, /* IMP: R-38091-32352 */ + SQLITE_MAX_TRIGGER_DEPTH, + SQLITE_MAX_WORKER_THREADS, +}; + +/* +** Make sure the hard limits are set to reasonable values +*/ +#if SQLITE_MAX_LENGTH<100 +# error SQLITE_MAX_LENGTH must be at least 100 +#endif +#if SQLITE_MAX_SQL_LENGTH<100 +# error SQLITE_MAX_SQL_LENGTH must be at least 100 +#endif +#if SQLITE_MAX_SQL_LENGTH>SQLITE_MAX_LENGTH +# error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH +#endif +#if SQLITE_MAX_COMPOUND_SELECT<2 +# error SQLITE_MAX_COMPOUND_SELECT must be at least 2 +#endif +#if SQLITE_MAX_VDBE_OP<40 +# error SQLITE_MAX_VDBE_OP must be at least 40 +#endif +#if SQLITE_MAX_FUNCTION_ARG<0 || SQLITE_MAX_FUNCTION_ARG>127 +# error SQLITE_MAX_FUNCTION_ARG must be between 0 and 127 +#endif +#if SQLITE_MAX_ATTACHED<0 || SQLITE_MAX_ATTACHED>125 +# error SQLITE_MAX_ATTACHED must be between 0 and 125 +#endif +#if SQLITE_MAX_LIKE_PATTERN_LENGTH<1 +# error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1 +#endif +#if SQLITE_MAX_COLUMN>32767 +# error SQLITE_MAX_COLUMN must not exceed 32767 +#endif +#if SQLITE_MAX_TRIGGER_DEPTH<1 +# error SQLITE_MAX_TRIGGER_DEPTH must be at least 1 +#endif +#if SQLITE_MAX_WORKER_THREADS<0 || SQLITE_MAX_WORKER_THREADS>50 +# error SQLITE_MAX_WORKER_THREADS must be between 0 and 50 +#endif + + +/* +** Change the value of a limit. Report the old value. +** If an invalid limit index is supplied, report -1. +** Make no changes but still report the old value if the +** new limit is negative. +** +** A new lower limit does not shrink existing constructs. +** It merely prevents new constructs that exceed the limit +** from forming. +*/ +SQLITE_API int sqlite3_limit(sqlite3 *db, int limitId, int newLimit){ + int oldLimit; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return -1; + } +#endif + + /* EVIDENCE-OF: R-30189-54097 For each limit category SQLITE_LIMIT_NAME + ** there is a hard upper bound set at compile-time by a C preprocessor + ** macro called SQLITE_MAX_NAME. (The "_LIMIT_" in the name is changed to + ** "_MAX_".) + */ + assert( aHardLimit[SQLITE_LIMIT_LENGTH]==SQLITE_MAX_LENGTH ); + assert( aHardLimit[SQLITE_LIMIT_SQL_LENGTH]==SQLITE_MAX_SQL_LENGTH ); + assert( aHardLimit[SQLITE_LIMIT_COLUMN]==SQLITE_MAX_COLUMN ); + assert( aHardLimit[SQLITE_LIMIT_EXPR_DEPTH]==SQLITE_MAX_EXPR_DEPTH ); + assert( aHardLimit[SQLITE_LIMIT_COMPOUND_SELECT]==SQLITE_MAX_COMPOUND_SELECT); + assert( aHardLimit[SQLITE_LIMIT_VDBE_OP]==SQLITE_MAX_VDBE_OP ); + assert( aHardLimit[SQLITE_LIMIT_FUNCTION_ARG]==SQLITE_MAX_FUNCTION_ARG ); + assert( aHardLimit[SQLITE_LIMIT_ATTACHED]==SQLITE_MAX_ATTACHED ); + assert( aHardLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]== + SQLITE_MAX_LIKE_PATTERN_LENGTH ); + assert( aHardLimit[SQLITE_LIMIT_VARIABLE_NUMBER]==SQLITE_MAX_VARIABLE_NUMBER); + assert( aHardLimit[SQLITE_LIMIT_TRIGGER_DEPTH]==SQLITE_MAX_TRIGGER_DEPTH ); + assert( aHardLimit[SQLITE_LIMIT_WORKER_THREADS]==SQLITE_MAX_WORKER_THREADS ); + assert( SQLITE_LIMIT_WORKER_THREADS==(SQLITE_N_LIMIT-1) ); + + + if( limitId<0 || limitId>=SQLITE_N_LIMIT ){ + return -1; + } + oldLimit = db->aLimit[limitId]; + if( newLimit>=0 ){ /* IMP: R-52476-28732 */ + if( newLimit>aHardLimit[limitId] ){ + newLimit = aHardLimit[limitId]; /* IMP: R-51463-25634 */ + } + db->aLimit[limitId] = newLimit; + } + return oldLimit; /* IMP: R-53341-35419 */ +} + +/* +** This function is used to parse both URIs and non-URI filenames passed by the +** user to API functions sqlite3_open() or sqlite3_open_v2(), and for database +** URIs specified as part of ATTACH statements. +** +** The first argument to this function is the name of the VFS to use (or +** a NULL to signify the default VFS) if the URI does not contain a "vfs=xxx" +** query parameter. The second argument contains the URI (or non-URI filename) +** itself. When this function is called the *pFlags variable should contain +** the default flags to open the database handle with. The value stored in +** *pFlags may be updated before returning if the URI filename contains +** "cache=xxx" or "mode=xxx" query parameters. +** +** If successful, SQLITE_OK is returned. In this case *ppVfs is set to point to +** the VFS that should be used to open the database file. *pzFile is set to +** point to a buffer containing the name of the file to open. The value +** stored in *pzFile is a database name acceptable to sqlite3_uri_parameter() +** and is in the same format as names created using sqlite3_create_filename(). +** The caller must invoke sqlite3_free_filename() (not sqlite3_free()!) on +** the value returned in *pzFile to avoid a memory leak. +** +** If an error occurs, then an SQLite error code is returned and *pzErrMsg +** may be set to point to a buffer containing an English language error +** message. It is the responsibility of the caller to eventually release +** this buffer by calling sqlite3_free(). +*/ +SQLITE_PRIVATE int sqlite3ParseUri( + const char *zDefaultVfs, /* VFS to use if no "vfs=xxx" query option */ + const char *zUri, /* Nul-terminated URI to parse */ + unsigned int *pFlags, /* IN/OUT: SQLITE_OPEN_XXX flags */ + sqlite3_vfs **ppVfs, /* OUT: VFS to use */ + char **pzFile, /* OUT: Filename component of URI */ + char **pzErrMsg /* OUT: Error message (if rc!=SQLITE_OK) */ +){ + int rc = SQLITE_OK; + unsigned int flags = *pFlags; + const char *zVfs = zDefaultVfs; + char *zFile; + char c; + int nUri = sqlite3Strlen30(zUri); + + assert( *pzErrMsg==0 ); + + if( ((flags & SQLITE_OPEN_URI) /* IMP: R-48725-32206 */ + || sqlite3GlobalConfig.bOpenUri) /* IMP: R-51689-46548 */ + && nUri>=5 && memcmp(zUri, "file:", 5)==0 /* IMP: R-57884-37496 */ + ){ + char *zOpt; + int eState; /* Parser state when parsing URI */ + int iIn; /* Input character index */ + int iOut = 0; /* Output character index */ + u64 nByte = nUri+8; /* Bytes of space to allocate */ + + /* Make sure the SQLITE_OPEN_URI flag is set to indicate to the VFS xOpen + ** method that there may be extra parameters following the file-name. */ + flags |= SQLITE_OPEN_URI; + + for(iIn=0; iIn=0 && octet<256 ); + if( octet==0 ){ +#ifndef SQLITE_ENABLE_URI_00_ERROR + /* This branch is taken when "%00" appears within the URI. In this + ** case we ignore all text in the remainder of the path, name or + ** value currently being parsed. So ignore the current character + ** and skip to the next "?", "=" or "&", as appropriate. */ + while( (c = zUri[iIn])!=0 && c!='#' + && (eState!=0 || c!='?') + && (eState!=1 || (c!='=' && c!='&')) + && (eState!=2 || c!='&') + ){ + iIn++; + } + continue; +#else + /* If ENABLE_URI_00_ERROR is defined, "%00" in a URI is an error. */ + *pzErrMsg = sqlite3_mprintf("unexpected %%00 in uri"); + rc = SQLITE_ERROR; + goto parse_uri_out; +#endif + } + c = octet; + }else if( eState==1 && (c=='&' || c=='=') ){ + if( zFile[iOut-1]==0 ){ + /* An empty option name. Ignore this option altogether. */ + while( zUri[iIn] && zUri[iIn]!='#' && zUri[iIn-1]!='&' ) iIn++; + continue; + } + if( c=='&' ){ + zFile[iOut++] = '\0'; + }else{ + eState = 2; + } + c = 0; + }else if( (eState==0 && c=='?') || (eState==2 && c=='&') ){ + c = 0; + eState = 1; + } + zFile[iOut++] = c; + } + if( eState==1 ) zFile[iOut++] = '\0'; + memset(zFile+iOut, 0, 4); /* end-of-options + empty journal filenames */ + + /* Check if there were any options specified that should be interpreted + ** here. Options that are interpreted here include "vfs" and those that + ** correspond to flags that may be passed to the sqlite3_open_v2() + ** method. */ + zOpt = &zFile[sqlite3Strlen30(zFile)+1]; + while( zOpt[0] ){ + int nOpt = sqlite3Strlen30(zOpt); + char *zVal = &zOpt[nOpt+1]; + int nVal = sqlite3Strlen30(zVal); + + if( nOpt==3 && memcmp("vfs", zOpt, 3)==0 ){ + zVfs = zVal; + }else{ + struct OpenMode { + const char *z; + int mode; + } *aMode = 0; + char *zModeType = 0; + int mask = 0; + int limit = 0; + + if( nOpt==5 && memcmp("cache", zOpt, 5)==0 ){ + static struct OpenMode aCacheMode[] = { + { "shared", SQLITE_OPEN_SHAREDCACHE }, + { "private", SQLITE_OPEN_PRIVATECACHE }, + { 0, 0 } + }; + + mask = SQLITE_OPEN_SHAREDCACHE|SQLITE_OPEN_PRIVATECACHE; + aMode = aCacheMode; + limit = mask; + zModeType = "cache"; + } + if( nOpt==4 && memcmp("mode", zOpt, 4)==0 ){ + static struct OpenMode aOpenMode[] = { + { "ro", SQLITE_OPEN_READONLY }, + { "rw", SQLITE_OPEN_READWRITE }, + { "rwc", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE }, + { "memory", SQLITE_OPEN_MEMORY }, + { 0, 0 } + }; + + mask = SQLITE_OPEN_READONLY | SQLITE_OPEN_READWRITE + | SQLITE_OPEN_CREATE | SQLITE_OPEN_MEMORY; + aMode = aOpenMode; + limit = mask & flags; + zModeType = "access"; + } + + if( aMode ){ + int i; + int mode = 0; + for(i=0; aMode[i].z; i++){ + const char *z = aMode[i].z; + if( nVal==sqlite3Strlen30(z) && 0==memcmp(zVal, z, nVal) ){ + mode = aMode[i].mode; + break; + } + } + if( mode==0 ){ + *pzErrMsg = sqlite3_mprintf("no such %s mode: %s", zModeType, zVal); + rc = SQLITE_ERROR; + goto parse_uri_out; + } + if( (mode & ~SQLITE_OPEN_MEMORY)>limit ){ + *pzErrMsg = sqlite3_mprintf("%s mode not allowed: %s", + zModeType, zVal); + rc = SQLITE_PERM; + goto parse_uri_out; + } + flags = (flags & ~mask) | mode; + } + } + + zOpt = &zVal[nVal+1]; + } + + }else{ + zFile = sqlite3_malloc64(nUri+8); + if( !zFile ) return SQLITE_NOMEM_BKPT; + memset(zFile, 0, 4); + zFile += 4; + if( nUri ){ + memcpy(zFile, zUri, nUri); + } + memset(zFile+nUri, 0, 4); + flags &= ~SQLITE_OPEN_URI; + } + + *ppVfs = sqlite3_vfs_find(zVfs); + if( *ppVfs==0 ){ + *pzErrMsg = sqlite3_mprintf("no such vfs: %s", zVfs); + rc = SQLITE_ERROR; + } + parse_uri_out: + if( rc!=SQLITE_OK ){ + sqlite3_free_filename(zFile); + zFile = 0; + } + *pFlags = flags; + *pzFile = zFile; + return rc; +} + +/* +** This routine does the core work of extracting URI parameters from a +** database filename for the sqlite3_uri_parameter() interface. +*/ +static const char *uriParameter(const char *zFilename, const char *zParam){ + zFilename += sqlite3Strlen30(zFilename) + 1; + while( zFilename[0] ){ + int x = strcmp(zFilename, zParam); + zFilename += sqlite3Strlen30(zFilename) + 1; + if( x==0 ) return zFilename; + zFilename += sqlite3Strlen30(zFilename) + 1; + } + return 0; +} + + + +/* +** This routine does the work of opening a database on behalf of +** sqlite3_open() and sqlite3_open16(). The database filename "zFilename" +** is UTF-8 encoded. +*/ +static int openDatabase( + const char *zFilename, /* Database filename UTF-8 encoded */ + sqlite3 **ppDb, /* OUT: Returned database handle */ + unsigned int flags, /* Operational flags */ + const char *zVfs /* Name of the VFS to use */ +){ + sqlite3 *db; /* Store allocated handle here */ + int rc; /* Return code */ + int isThreadsafe; /* True for threadsafe connections */ + char *zOpen = 0; /* Filename argument to pass to BtreeOpen() */ + char *zErrMsg = 0; /* Error message from sqlite3ParseUri() */ + int i; /* Loop counter */ + +#ifdef SQLITE_ENABLE_API_ARMOR + if( ppDb==0 ) return SQLITE_MISUSE_BKPT; +#endif + *ppDb = 0; +#ifndef SQLITE_OMIT_AUTOINIT + rc = sqlite3_initialize(); + if( rc ) return rc; +#endif + + if( sqlite3GlobalConfig.bCoreMutex==0 ){ + isThreadsafe = 0; + }else if( flags & SQLITE_OPEN_NOMUTEX ){ + isThreadsafe = 0; + }else if( flags & SQLITE_OPEN_FULLMUTEX ){ + isThreadsafe = 1; + }else{ + isThreadsafe = sqlite3GlobalConfig.bFullMutex; + } + + if( flags & SQLITE_OPEN_PRIVATECACHE ){ + flags &= ~SQLITE_OPEN_SHAREDCACHE; + }else if( sqlite3GlobalConfig.sharedCacheEnabled ){ + flags |= SQLITE_OPEN_SHAREDCACHE; + } + + /* Remove harmful bits from the flags parameter + ** + ** The SQLITE_OPEN_NOMUTEX and SQLITE_OPEN_FULLMUTEX flags were + ** dealt with in the previous code block. Besides these, the only + ** valid input flags for sqlite3_open_v2() are SQLITE_OPEN_READONLY, + ** SQLITE_OPEN_READWRITE, SQLITE_OPEN_CREATE, SQLITE_OPEN_SHAREDCACHE, + ** SQLITE_OPEN_PRIVATECACHE, and some reserved bits. Silently mask + ** off all other flags. + */ + flags &= ~( SQLITE_OPEN_DELETEONCLOSE | + SQLITE_OPEN_EXCLUSIVE | + SQLITE_OPEN_MAIN_DB | + SQLITE_OPEN_TEMP_DB | + SQLITE_OPEN_TRANSIENT_DB | + SQLITE_OPEN_MAIN_JOURNAL | + SQLITE_OPEN_TEMP_JOURNAL | + SQLITE_OPEN_SUBJOURNAL | + SQLITE_OPEN_SUPER_JOURNAL | + SQLITE_OPEN_NOMUTEX | + SQLITE_OPEN_FULLMUTEX | + SQLITE_OPEN_WAL + ); + + /* Allocate the sqlite data structure */ + db = sqlite3MallocZero( sizeof(sqlite3) ); + if( db==0 ) goto opendb_out; + if( isThreadsafe +#ifdef SQLITE_ENABLE_MULTITHREADED_CHECKS + || sqlite3GlobalConfig.bCoreMutex +#endif + ){ + db->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE); + if( db->mutex==0 ){ + sqlite3_free(db); + db = 0; + goto opendb_out; + } + if( isThreadsafe==0 ){ + sqlite3MutexWarnOnContention(db->mutex); + } + } + sqlite3_mutex_enter(db->mutex); + db->errMask = 0xff; + db->nDb = 2; + db->magic = SQLITE_MAGIC_BUSY; + db->aDb = db->aDbStatic; + db->lookaside.bDisable = 1; + db->lookaside.sz = 0; + + assert( sizeof(db->aLimit)==sizeof(aHardLimit) ); + memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit)); + db->aLimit[SQLITE_LIMIT_WORKER_THREADS] = SQLITE_DEFAULT_WORKER_THREADS; + db->autoCommit = 1; + db->nextAutovac = -1; + db->szMmap = sqlite3GlobalConfig.szMmap; + db->nextPagesize = 0; + db->nMaxSorterMmap = 0x7FFFFFFF; + db->flags |= SQLITE_ShortColNames + | SQLITE_EnableTrigger + | SQLITE_EnableView + | SQLITE_CacheSpill +#if !defined(SQLITE_TRUSTED_SCHEMA) || SQLITE_TRUSTED_SCHEMA+0!=0 + | SQLITE_TrustedSchema +#endif +/* The SQLITE_DQS compile-time option determines the default settings +** for SQLITE_DBCONFIG_DQS_DDL and SQLITE_DBCONFIG_DQS_DML. +** +** SQLITE_DQS SQLITE_DBCONFIG_DQS_DDL SQLITE_DBCONFIG_DQS_DML +** ---------- ----------------------- ----------------------- +** undefined on on +** 3 on on +** 2 on off +** 1 off on +** 0 off off +** +** Legacy behavior is 3 (double-quoted string literals are allowed anywhere) +** and so that is the default. But developers are encouranged to use +** -DSQLITE_DQS=0 (best) or -DSQLITE_DQS=1 (second choice) if possible. +*/ +#if !defined(SQLITE_DQS) +# define SQLITE_DQS 3 +#endif +#if (SQLITE_DQS&1)==1 + | SQLITE_DqsDML +#endif +#if (SQLITE_DQS&2)==2 + | SQLITE_DqsDDL +#endif + +#if !defined(SQLITE_DEFAULT_AUTOMATIC_INDEX) || SQLITE_DEFAULT_AUTOMATIC_INDEX + | SQLITE_AutoIndex +#endif +#if SQLITE_DEFAULT_CKPTFULLFSYNC + | SQLITE_CkptFullFSync +#endif +#if SQLITE_DEFAULT_FILE_FORMAT<4 + | SQLITE_LegacyFileFmt +#endif +#ifdef SQLITE_ENABLE_LOAD_EXTENSION + | SQLITE_LoadExtension +#endif +#if SQLITE_DEFAULT_RECURSIVE_TRIGGERS + | SQLITE_RecTriggers +#endif +#if defined(SQLITE_DEFAULT_FOREIGN_KEYS) && SQLITE_DEFAULT_FOREIGN_KEYS + | SQLITE_ForeignKeys +#endif +#if defined(SQLITE_REVERSE_UNORDERED_SELECTS) + | SQLITE_ReverseOrder +#endif +#if defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK) + | SQLITE_CellSizeCk +#endif +#if defined(SQLITE_ENABLE_FTS3_TOKENIZER) + | SQLITE_Fts3Tokenizer +#endif +#if defined(SQLITE_ENABLE_QPSG) + | SQLITE_EnableQPSG +#endif +#if defined(SQLITE_DEFAULT_DEFENSIVE) + | SQLITE_Defensive +#endif +#if defined(SQLITE_DEFAULT_LEGACY_ALTER_TABLE) + | SQLITE_LegacyAlter +#endif + ; + sqlite3HashInit(&db->aCollSeq); +#ifndef SQLITE_OMIT_VIRTUALTABLE + sqlite3HashInit(&db->aModule); +#endif + + /* Add the default collation sequence BINARY. BINARY works for both UTF-8 + ** and UTF-16, so add a version for each to avoid any unnecessary + ** conversions. The only error that can occur here is a malloc() failure. + ** + ** EVIDENCE-OF: R-52786-44878 SQLite defines three built-in collating + ** functions: + */ + createCollation(db, sqlite3StrBINARY, SQLITE_UTF8, 0, binCollFunc, 0); + createCollation(db, sqlite3StrBINARY, SQLITE_UTF16BE, 0, binCollFunc, 0); + createCollation(db, sqlite3StrBINARY, SQLITE_UTF16LE, 0, binCollFunc, 0); + createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0); + createCollation(db, "RTRIM", SQLITE_UTF8, 0, rtrimCollFunc, 0); + if( db->mallocFailed ){ + goto opendb_out; + } + + /* Parse the filename/URI argument + ** + ** Only allow sensible combinations of bits in the flags argument. + ** Throw an error if any non-sense combination is used. If we + ** do not block illegal combinations here, it could trigger + ** assert() statements in deeper layers. Sensible combinations + ** are: + ** + ** 1: SQLITE_OPEN_READONLY + ** 2: SQLITE_OPEN_READWRITE + ** 6: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE + */ + db->openFlags = flags; + assert( SQLITE_OPEN_READONLY == 0x01 ); + assert( SQLITE_OPEN_READWRITE == 0x02 ); + assert( SQLITE_OPEN_CREATE == 0x04 ); + testcase( (1<<(flags&7))==0x02 ); /* READONLY */ + testcase( (1<<(flags&7))==0x04 ); /* READWRITE */ + testcase( (1<<(flags&7))==0x40 ); /* READWRITE | CREATE */ + if( ((1<<(flags&7)) & 0x46)==0 ){ + rc = SQLITE_MISUSE_BKPT; /* IMP: R-18321-05872 */ + }else{ + rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg); + } + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_NOMEM ) sqlite3OomFault(db); + sqlite3ErrorWithMsg(db, rc, zErrMsg ? "%s" : 0, zErrMsg); + sqlite3_free(zErrMsg); + goto opendb_out; + } + + /* Open the backend database driver */ + rc = sqlite3BtreeOpen(db->pVfs, zOpen, db, &db->aDb[0].pBt, 0, + flags | SQLITE_OPEN_MAIN_DB); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_IOERR_NOMEM ){ + rc = SQLITE_NOMEM_BKPT; + } + sqlite3Error(db, rc); + goto opendb_out; + } + sqlite3BtreeEnter(db->aDb[0].pBt); + db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt); + if( !db->mallocFailed ){ + sqlite3SetTextEncoding(db, SCHEMA_ENC(db)); + } + sqlite3BtreeLeave(db->aDb[0].pBt); + db->aDb[1].pSchema = sqlite3SchemaGet(db, 0); + + /* The default safety_level for the main database is FULL; for the temp + ** database it is OFF. This matches the pager layer defaults. + */ + db->aDb[0].zDbSName = "main"; + db->aDb[0].safety_level = SQLITE_DEFAULT_SYNCHRONOUS+1; + db->aDb[1].zDbSName = "temp"; + db->aDb[1].safety_level = PAGER_SYNCHRONOUS_OFF; + + db->magic = SQLITE_MAGIC_OPEN; + if( db->mallocFailed ){ + goto opendb_out; + } + + /* Register all built-in functions, but do not attempt to read the + ** database schema yet. This is delayed until the first time the database + ** is accessed. + */ + sqlite3Error(db, SQLITE_OK); + sqlite3RegisterPerConnectionBuiltinFunctions(db); + rc = sqlite3_errcode(db); + + + /* Load compiled-in extensions */ + for(i=0; rc==SQLITE_OK && imDbFlags |= DBFLAG_InternalFunc; +#endif + + /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking + ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking + ** mode. Doing nothing at all also makes NORMAL the default. + */ +#ifdef SQLITE_DEFAULT_LOCKING_MODE + db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE; + sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt), + SQLITE_DEFAULT_LOCKING_MODE); +#endif + + if( rc ) sqlite3Error(db, rc); + + /* Enable the lookaside-malloc subsystem */ + setupLookaside(db, 0, sqlite3GlobalConfig.szLookaside, + sqlite3GlobalConfig.nLookaside); + + sqlite3_wal_autocheckpoint(db, SQLITE_DEFAULT_WAL_AUTOCHECKPOINT); + +opendb_out: + if( db ){ + assert( db->mutex!=0 || isThreadsafe==0 + || sqlite3GlobalConfig.bFullMutex==0 ); + sqlite3_mutex_leave(db->mutex); + } + rc = sqlite3_errcode(db); + assert( db!=0 || rc==SQLITE_NOMEM ); + if( rc==SQLITE_NOMEM ){ + sqlite3_close(db); + db = 0; + }else if( rc!=SQLITE_OK ){ + db->magic = SQLITE_MAGIC_SICK; + } + *ppDb = db; +#ifdef SQLITE_ENABLE_SQLLOG + if( sqlite3GlobalConfig.xSqllog ){ + /* Opening a db handle. Fourth parameter is passed 0. */ + void *pArg = sqlite3GlobalConfig.pSqllogArg; + sqlite3GlobalConfig.xSqllog(pArg, db, zFilename, 0); + } +#endif + sqlite3_free_filename(zOpen); + return rc & 0xff; +} + + +/* +** Open a new database handle. +*/ +SQLITE_API int sqlite3_open( + const char *zFilename, + sqlite3 **ppDb +){ + return openDatabase(zFilename, ppDb, + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0); +} +SQLITE_API int sqlite3_open_v2( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb, /* OUT: SQLite db handle */ + int flags, /* Flags */ + const char *zVfs /* Name of VFS module to use */ +){ + return openDatabase(filename, ppDb, (unsigned int)flags, zVfs); +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Open a new database handle. +*/ +SQLITE_API int sqlite3_open16( + const void *zFilename, + sqlite3 **ppDb +){ + char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */ + sqlite3_value *pVal; + int rc; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( ppDb==0 ) return SQLITE_MISUSE_BKPT; +#endif + *ppDb = 0; +#ifndef SQLITE_OMIT_AUTOINIT + rc = sqlite3_initialize(); + if( rc ) return rc; +#endif + if( zFilename==0 ) zFilename = "\000\000"; + pVal = sqlite3ValueNew(0); + sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC); + zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8); + if( zFilename8 ){ + rc = openDatabase(zFilename8, ppDb, + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0); + assert( *ppDb || rc==SQLITE_NOMEM ); + if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){ + SCHEMA_ENC(*ppDb) = ENC(*ppDb) = SQLITE_UTF16NATIVE; + } + }else{ + rc = SQLITE_NOMEM_BKPT; + } + sqlite3ValueFree(pVal); + + return rc & 0xff; +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Register a new collation sequence with the database handle db. +*/ +SQLITE_API int sqlite3_create_collation( + sqlite3* db, + const char *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*) +){ + return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0); +} + +/* +** Register a new collation sequence with the database handle db. +*/ +SQLITE_API int sqlite3_create_collation_v2( + sqlite3* db, + const char *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDel)(void*) +){ + int rc; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Register a new collation sequence with the database handle db. +*/ +SQLITE_API int sqlite3_create_collation16( + sqlite3* db, + const void *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*) +){ + int rc = SQLITE_OK; + char *zName8; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE); + if( zName8 ){ + rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0); + sqlite3DbFree(db, zName8); + } + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Register a collation sequence factory callback with the database handle +** db. Replace any previously installed collation sequence factory. +*/ +SQLITE_API int sqlite3_collation_needed( + sqlite3 *db, + void *pCollNeededArg, + void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*) +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + db->xCollNeeded = xCollNeeded; + db->xCollNeeded16 = 0; + db->pCollNeededArg = pCollNeededArg; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Register a collation sequence factory callback with the database handle +** db. Replace any previously installed collation sequence factory. +*/ +SQLITE_API int sqlite3_collation_needed16( + sqlite3 *db, + void *pCollNeededArg, + void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*) +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + db->xCollNeeded = 0; + db->xCollNeeded16 = xCollNeeded16; + db->pCollNeededArg = pCollNeededArg; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} +#endif /* SQLITE_OMIT_UTF16 */ + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** This function is now an anachronism. It used to be used to recover from a +** malloc() failure, but SQLite now does this automatically. +*/ +SQLITE_API int sqlite3_global_recover(void){ + return SQLITE_OK; +} +#endif + +/* +** Test to see whether or not the database connection is in autocommit +** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on +** by default. Autocommit is disabled by a BEGIN statement and reenabled +** by the next COMMIT or ROLLBACK. +*/ +SQLITE_API int sqlite3_get_autocommit(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return db->autoCommit; +} + +/* +** The following routines are substitutes for constants SQLITE_CORRUPT, +** SQLITE_MISUSE, SQLITE_CANTOPEN, SQLITE_NOMEM and possibly other error +** constants. They serve two purposes: +** +** 1. Serve as a convenient place to set a breakpoint in a debugger +** to detect when version error conditions occurs. +** +** 2. Invoke sqlite3_log() to provide the source code location where +** a low-level error is first detected. +*/ +SQLITE_PRIVATE int sqlite3ReportError(int iErr, int lineno, const char *zType){ + sqlite3_log(iErr, "%s at line %d of [%.10s]", + zType, lineno, 20+sqlite3_sourceid()); + return iErr; +} +SQLITE_PRIVATE int sqlite3CorruptError(int lineno){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + return sqlite3ReportError(SQLITE_CORRUPT, lineno, "database corruption"); +} +SQLITE_PRIVATE int sqlite3MisuseError(int lineno){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + return sqlite3ReportError(SQLITE_MISUSE, lineno, "misuse"); +} +SQLITE_PRIVATE int sqlite3CantopenError(int lineno){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + return sqlite3ReportError(SQLITE_CANTOPEN, lineno, "cannot open file"); +} +#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_CORRUPT_PGNO) +SQLITE_PRIVATE int sqlite3CorruptPgnoError(int lineno, Pgno pgno){ + char zMsg[100]; + sqlite3_snprintf(sizeof(zMsg), zMsg, "database corruption page %d", pgno); + testcase( sqlite3GlobalConfig.xLog!=0 ); + return sqlite3ReportError(SQLITE_CORRUPT, lineno, zMsg); +} +#endif +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3NomemError(int lineno){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + return sqlite3ReportError(SQLITE_NOMEM, lineno, "OOM"); +} +SQLITE_PRIVATE int sqlite3IoerrnomemError(int lineno){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + return sqlite3ReportError(SQLITE_IOERR_NOMEM, lineno, "I/O OOM error"); +} +#endif + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** This is a convenience routine that makes sure that all thread-specific +** data for this thread has been deallocated. +** +** SQLite no longer uses thread-specific data so this routine is now a +** no-op. It is retained for historical compatibility. +*/ +SQLITE_API void sqlite3_thread_cleanup(void){ +} +#endif + +/* +** Return meta information about a specific column of a database table. +** See comment in sqlite3.h (sqlite.h.in) for details. +*/ +SQLITE_API int sqlite3_table_column_metadata( + sqlite3 *db, /* Connection handle */ + const char *zDbName, /* Database name or NULL */ + const char *zTableName, /* Table name */ + const char *zColumnName, /* Column name */ + char const **pzDataType, /* OUTPUT: Declared data type */ + char const **pzCollSeq, /* OUTPUT: Collation sequence name */ + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ + int *pPrimaryKey, /* OUTPUT: True if column part of PK */ + int *pAutoinc /* OUTPUT: True if column is auto-increment */ +){ + int rc; + char *zErrMsg = 0; + Table *pTab = 0; + Column *pCol = 0; + int iCol = 0; + char const *zDataType = 0; + char const *zCollSeq = 0; + int notnull = 0; + int primarykey = 0; + int autoinc = 0; + + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zTableName==0 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + + /* Ensure the database schema has been loaded */ + sqlite3_mutex_enter(db->mutex); + sqlite3BtreeEnterAll(db); + rc = sqlite3Init(db, &zErrMsg); + if( SQLITE_OK!=rc ){ + goto error_out; + } + + /* Locate the table in question */ + pTab = sqlite3FindTable(db, zTableName, zDbName); + if( !pTab || pTab->pSelect ){ + pTab = 0; + goto error_out; + } + + /* Find the column for which info is requested */ + if( zColumnName==0 ){ + /* Query for existance of table only */ + }else{ + for(iCol=0; iColnCol; iCol++){ + pCol = &pTab->aCol[iCol]; + if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){ + break; + } + } + if( iCol==pTab->nCol ){ + if( HasRowid(pTab) && sqlite3IsRowid(zColumnName) ){ + iCol = pTab->iPKey; + pCol = iCol>=0 ? &pTab->aCol[iCol] : 0; + }else{ + pTab = 0; + goto error_out; + } + } + } + + /* The following block stores the meta information that will be returned + ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey + ** and autoinc. At this point there are two possibilities: + ** + ** 1. The specified column name was rowid", "oid" or "_rowid_" + ** and there is no explicitly declared IPK column. + ** + ** 2. The table is not a view and the column name identified an + ** explicitly declared column. Copy meta information from *pCol. + */ + if( pCol ){ + zDataType = sqlite3ColumnType(pCol,0); + zCollSeq = pCol->zColl; + notnull = pCol->notNull!=0; + primarykey = (pCol->colFlags & COLFLAG_PRIMKEY)!=0; + autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0; + }else{ + zDataType = "INTEGER"; + primarykey = 1; + } + if( !zCollSeq ){ + zCollSeq = sqlite3StrBINARY; + } + +error_out: + sqlite3BtreeLeaveAll(db); + + /* Whether the function call succeeded or failed, set the output parameters + ** to whatever their local counterparts contain. If an error did occur, + ** this has the effect of zeroing all output parameters. + */ + if( pzDataType ) *pzDataType = zDataType; + if( pzCollSeq ) *pzCollSeq = zCollSeq; + if( pNotNull ) *pNotNull = notnull; + if( pPrimaryKey ) *pPrimaryKey = primarykey; + if( pAutoinc ) *pAutoinc = autoinc; + + if( SQLITE_OK==rc && !pTab ){ + sqlite3DbFree(db, zErrMsg); + zErrMsg = sqlite3MPrintf(db, "no such table column: %s.%s", zTableName, + zColumnName); + rc = SQLITE_ERROR; + } + sqlite3ErrorWithMsg(db, rc, (zErrMsg?"%s":0), zErrMsg); + sqlite3DbFree(db, zErrMsg); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Sleep for a little while. Return the amount of time slept. +*/ +SQLITE_API int sqlite3_sleep(int ms){ + sqlite3_vfs *pVfs; + int rc; + pVfs = sqlite3_vfs_find(0); + if( pVfs==0 ) return 0; + + /* This function works in milliseconds, but the underlying OsSleep() + ** API uses microseconds. Hence the 1000's. + */ + rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000); + return rc; +} + +/* +** Enable or disable the extended result codes. +*/ +SQLITE_API int sqlite3_extended_result_codes(sqlite3 *db, int onoff){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + db->errMask = onoff ? 0xffffffff : 0xff; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +/* +** Invoke the xFileControl method on a particular database. +*/ +SQLITE_API int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){ + int rc = SQLITE_ERROR; + Btree *pBtree; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + pBtree = sqlite3DbNameToBtree(db, zDbName); + if( pBtree ){ + Pager *pPager; + sqlite3_file *fd; + sqlite3BtreeEnter(pBtree); + pPager = sqlite3BtreePager(pBtree); + assert( pPager!=0 ); + fd = sqlite3PagerFile(pPager); + assert( fd!=0 ); + if( op==SQLITE_FCNTL_FILE_POINTER ){ + *(sqlite3_file**)pArg = fd; + rc = SQLITE_OK; + }else if( op==SQLITE_FCNTL_VFS_POINTER ){ + *(sqlite3_vfs**)pArg = sqlite3PagerVfs(pPager); + rc = SQLITE_OK; + }else if( op==SQLITE_FCNTL_JOURNAL_POINTER ){ + *(sqlite3_file**)pArg = sqlite3PagerJrnlFile(pPager); + rc = SQLITE_OK; + }else if( op==SQLITE_FCNTL_DATA_VERSION ){ + *(unsigned int*)pArg = sqlite3PagerDataVersion(pPager); + rc = SQLITE_OK; + }else if( op==SQLITE_FCNTL_RESERVE_BYTES ){ + int iNew = *(int*)pArg; + *(int*)pArg = sqlite3BtreeGetRequestedReserve(pBtree); + if( iNew>=0 && iNew<=255 ){ + sqlite3BtreeSetPageSize(pBtree, 0, iNew, 0); + } + rc = SQLITE_OK; + }else{ + int nSave = db->busyHandler.nBusy; + rc = sqlite3OsFileControl(fd, op, pArg); + db->busyHandler.nBusy = nSave; + } + sqlite3BtreeLeave(pBtree); + } + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Interface to the testing logic. +*/ +SQLITE_API int sqlite3_test_control(int op, ...){ + int rc = 0; +#ifdef SQLITE_UNTESTABLE + UNUSED_PARAMETER(op); +#else + va_list ap; + va_start(ap, op); + switch( op ){ + + /* + ** Save the current state of the PRNG. + */ + case SQLITE_TESTCTRL_PRNG_SAVE: { + sqlite3PrngSaveState(); + break; + } + + /* + ** Restore the state of the PRNG to the last state saved using + ** PRNG_SAVE. If PRNG_SAVE has never before been called, then + ** this verb acts like PRNG_RESET. + */ + case SQLITE_TESTCTRL_PRNG_RESTORE: { + sqlite3PrngRestoreState(); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_PRNG_SEED, int x, sqlite3 *db); + ** + ** Control the seed for the pseudo-random number generator (PRNG) that + ** is built into SQLite. Cases: + ** + ** x!=0 && db!=0 Seed the PRNG to the current value of the + ** schema cookie in the main database for db, or + ** x if the schema cookie is zero. This case + ** is convenient to use with database fuzzers + ** as it allows the fuzzer some control over the + ** the PRNG seed. + ** + ** x!=0 && db==0 Seed the PRNG to the value of x. + ** + ** x==0 && db==0 Revert to default behavior of using the + ** xRandomness method on the primary VFS. + ** + ** This test-control also resets the PRNG so that the new seed will + ** be used for the next call to sqlite3_randomness(). + */ +#ifndef SQLITE_OMIT_WSD + case SQLITE_TESTCTRL_PRNG_SEED: { + int x = va_arg(ap, int); + int y; + sqlite3 *db = va_arg(ap, sqlite3*); + assert( db==0 || db->aDb[0].pSchema!=0 ); + if( db && (y = db->aDb[0].pSchema->schema_cookie)!=0 ){ x = y; } + sqlite3Config.iPrngSeed = x; + sqlite3_randomness(0,0); + break; + } +#endif + + /* + ** sqlite3_test_control(BITVEC_TEST, size, program) + ** + ** Run a test against a Bitvec object of size. The program argument + ** is an array of integers that defines the test. Return -1 on a + ** memory allocation error, 0 on success, or non-zero for an error. + ** See the sqlite3BitvecBuiltinTest() for additional information. + */ + case SQLITE_TESTCTRL_BITVEC_TEST: { + int sz = va_arg(ap, int); + int *aProg = va_arg(ap, int*); + rc = sqlite3BitvecBuiltinTest(sz, aProg); + break; + } + + /* + ** sqlite3_test_control(FAULT_INSTALL, xCallback) + ** + ** Arrange to invoke xCallback() whenever sqlite3FaultSim() is called, + ** if xCallback is not NULL. + ** + ** As a test of the fault simulator mechanism itself, sqlite3FaultSim(0) + ** is called immediately after installing the new callback and the return + ** value from sqlite3FaultSim(0) becomes the return from + ** sqlite3_test_control(). + */ + case SQLITE_TESTCTRL_FAULT_INSTALL: { + /* MSVC is picky about pulling func ptrs from va lists. + ** http://support.microsoft.com/kb/47961 + ** sqlite3GlobalConfig.xTestCallback = va_arg(ap, int(*)(int)); + */ + typedef int(*TESTCALLBACKFUNC_t)(int); + sqlite3GlobalConfig.xTestCallback = va_arg(ap, TESTCALLBACKFUNC_t); + rc = sqlite3FaultSim(0); + break; + } + + /* + ** sqlite3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd) + ** + ** Register hooks to call to indicate which malloc() failures + ** are benign. + */ + case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: { + typedef void (*void_function)(void); + void_function xBenignBegin; + void_function xBenignEnd; + xBenignBegin = va_arg(ap, void_function); + xBenignEnd = va_arg(ap, void_function); + sqlite3BenignMallocHooks(xBenignBegin, xBenignEnd); + break; + } + + /* + ** sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, unsigned int X) + ** + ** Set the PENDING byte to the value in the argument, if X>0. + ** Make no changes if X==0. Return the value of the pending byte + ** as it existing before this routine was called. + ** + ** IMPORTANT: Changing the PENDING byte from 0x40000000 results in + ** an incompatible database file format. Changing the PENDING byte + ** while any database connection is open results in undefined and + ** deleterious behavior. + */ + case SQLITE_TESTCTRL_PENDING_BYTE: { + rc = PENDING_BYTE; +#ifndef SQLITE_OMIT_WSD + { + unsigned int newVal = va_arg(ap, unsigned int); + if( newVal ) sqlite3PendingByte = newVal; + } +#endif + break; + } + + /* + ** sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, int X) + ** + ** This action provides a run-time test to see whether or not + ** assert() was enabled at compile-time. If X is true and assert() + ** is enabled, then the return value is true. If X is true and + ** assert() is disabled, then the return value is zero. If X is + ** false and assert() is enabled, then the assertion fires and the + ** process aborts. If X is false and assert() is disabled, then the + ** return value is zero. + */ + case SQLITE_TESTCTRL_ASSERT: { + volatile int x = 0; + assert( /*side-effects-ok*/ (x = va_arg(ap,int))!=0 ); + rc = x; + break; + } + + + /* + ** sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, int X) + ** + ** This action provides a run-time test to see how the ALWAYS and + ** NEVER macros were defined at compile-time. + ** + ** The return value is ALWAYS(X) if X is true, or 0 if X is false. + ** + ** The recommended test is X==2. If the return value is 2, that means + ** ALWAYS() and NEVER() are both no-op pass-through macros, which is the + ** default setting. If the return value is 1, then ALWAYS() is either + ** hard-coded to true or else it asserts if its argument is false. + ** The first behavior (hard-coded to true) is the case if + ** SQLITE_TESTCTRL_ASSERT shows that assert() is disabled and the second + ** behavior (assert if the argument to ALWAYS() is false) is the case if + ** SQLITE_TESTCTRL_ASSERT shows that assert() is enabled. + ** + ** The run-time test procedure might look something like this: + ** + ** if( sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, 2)==2 ){ + ** // ALWAYS() and NEVER() are no-op pass-through macros + ** }else if( sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, 1) ){ + ** // ALWAYS(x) asserts that x is true. NEVER(x) asserts x is false. + ** }else{ + ** // ALWAYS(x) is a constant 1. NEVER(x) is a constant 0. + ** } + */ + case SQLITE_TESTCTRL_ALWAYS: { + int x = va_arg(ap,int); + rc = x ? ALWAYS(x) : 0; + break; + } + + /* + ** sqlite3_test_control(SQLITE_TESTCTRL_BYTEORDER); + ** + ** The integer returned reveals the byte-order of the computer on which + ** SQLite is running: + ** + ** 1 big-endian, determined at run-time + ** 10 little-endian, determined at run-time + ** 432101 big-endian, determined at compile-time + ** 123410 little-endian, determined at compile-time + */ + case SQLITE_TESTCTRL_BYTEORDER: { + rc = SQLITE_BYTEORDER*100 + SQLITE_LITTLEENDIAN*10 + SQLITE_BIGENDIAN; + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, sqlite3 *db, int N) + ** + ** Enable or disable various optimizations for testing purposes. The + ** argument N is a bitmask of optimizations to be disabled. For normal + ** operation N should be 0. The idea is that a test program (like the + ** SQL Logic Test or SLT test module) can run the same SQL multiple times + ** with various optimizations disabled to verify that the same answer + ** is obtained in every case. + */ + case SQLITE_TESTCTRL_OPTIMIZATIONS: { + sqlite3 *db = va_arg(ap, sqlite3*); + db->dbOptFlags = (u16)(va_arg(ap, int) & 0xffff); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff); + ** + ** If parameter onoff is non-zero, subsequent calls to localtime() + ** and its variants fail. If onoff is zero, undo this setting. + */ + case SQLITE_TESTCTRL_LOCALTIME_FAULT: { + sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_INTERNAL_FUNCTIONS, sqlite3*); + ** + ** Toggle the ability to use internal functions on or off for + ** the database connection given in the argument. + */ + case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: { + sqlite3 *db = va_arg(ap, sqlite3*); + db->mDbFlags ^= DBFLAG_InternalFunc; + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, int); + ** + ** Set or clear a flag that indicates that the database file is always well- + ** formed and never corrupt. This flag is clear by default, indicating that + ** database files might have arbitrary corruption. Setting the flag during + ** testing causes certain assert() statements in the code to be activated + ** that demonstrat invariants on well-formed database files. + */ + case SQLITE_TESTCTRL_NEVER_CORRUPT: { + sqlite3GlobalConfig.neverCorrupt = va_arg(ap, int); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS, int); + ** + ** Set or clear a flag that causes SQLite to verify that type, name, + ** and tbl_name fields of the sqlite_schema table. This is normally + ** on, but it is sometimes useful to turn it off for testing. + ** + ** 2020-07-22: Disabling EXTRA_SCHEMA_CHECKS also disables the + ** verification of rootpage numbers when parsing the schema. This + ** is useful to make it easier to reach strange internal error states + ** during testing. The EXTRA_SCHEMA_CHECKS setting is always enabled + ** in production. + */ + case SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS: { + sqlite3GlobalConfig.bExtraSchemaChecks = va_arg(ap, int); + break; + } + + /* Set the threshold at which OP_Once counters reset back to zero. + ** By default this is 0x7ffffffe (over 2 billion), but that value is + ** too big to test in a reasonable amount of time, so this control is + ** provided to set a small and easily reachable reset value. + */ + case SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: { + sqlite3GlobalConfig.iOnceResetThreshold = va_arg(ap, int); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE, xCallback, ptr); + ** + ** Set the VDBE coverage callback function to xCallback with context + ** pointer ptr. + */ + case SQLITE_TESTCTRL_VDBE_COVERAGE: { +#ifdef SQLITE_VDBE_COVERAGE + typedef void (*branch_callback)(void*,unsigned int, + unsigned char,unsigned char); + sqlite3GlobalConfig.xVdbeBranch = va_arg(ap,branch_callback); + sqlite3GlobalConfig.pVdbeBranchArg = va_arg(ap,void*); +#endif + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_SORTER_MMAP, db, nMax); */ + case SQLITE_TESTCTRL_SORTER_MMAP: { + sqlite3 *db = va_arg(ap, sqlite3*); + db->nMaxSorterMmap = va_arg(ap, int); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_ISINIT); + ** + ** Return SQLITE_OK if SQLite has been initialized and SQLITE_ERROR if + ** not. + */ + case SQLITE_TESTCTRL_ISINIT: { + if( sqlite3GlobalConfig.isInit==0 ) rc = SQLITE_ERROR; + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, dbName, onOff, tnum); + ** + ** This test control is used to create imposter tables. "db" is a pointer + ** to the database connection. dbName is the database name (ex: "main" or + ** "temp") which will receive the imposter. "onOff" turns imposter mode on + ** or off. "tnum" is the root page of the b-tree to which the imposter + ** table should connect. + ** + ** Enable imposter mode only when the schema has already been parsed. Then + ** run a single CREATE TABLE statement to construct the imposter table in + ** the parsed schema. Then turn imposter mode back off again. + ** + ** If onOff==0 and tnum>0 then reset the schema for all databases, causing + ** the schema to be reparsed the next time it is needed. This has the + ** effect of erasing all imposter tables. + */ + case SQLITE_TESTCTRL_IMPOSTER: { + sqlite3 *db = va_arg(ap, sqlite3*); + sqlite3_mutex_enter(db->mutex); + db->init.iDb = sqlite3FindDbName(db, va_arg(ap,const char*)); + db->init.busy = db->init.imposterTable = va_arg(ap,int); + db->init.newTnum = va_arg(ap,int); + if( db->init.busy==0 && db->init.newTnum>0 ){ + sqlite3ResetAllSchemasOfConnection(db); + } + sqlite3_mutex_leave(db->mutex); + break; + } + +#if defined(YYCOVERAGE) + /* sqlite3_test_control(SQLITE_TESTCTRL_PARSER_COVERAGE, FILE *out) + ** + ** This test control (only available when SQLite is compiled with + ** -DYYCOVERAGE) writes a report onto "out" that shows all + ** state/lookahead combinations in the parser state machine + ** which are never exercised. If any state is missed, make the + ** return code SQLITE_ERROR. + */ + case SQLITE_TESTCTRL_PARSER_COVERAGE: { + FILE *out = va_arg(ap, FILE*); + if( sqlite3ParserCoverage(out) ) rc = SQLITE_ERROR; + break; + } +#endif /* defined(YYCOVERAGE) */ + + /* sqlite3_test_control(SQLITE_TESTCTRL_RESULT_INTREAL, sqlite3_context*); + ** + ** This test-control causes the most recent sqlite3_result_int64() value + ** to be interpreted as a MEM_IntReal instead of as an MEM_Int. Normally, + ** MEM_IntReal values only arise during an INSERT operation of integer + ** values into a REAL column, so they can be challenging to test. This + ** test-control enables us to write an intreal() SQL function that can + ** inject an intreal() value at arbitrary places in an SQL statement, + ** for testing purposes. + */ + case SQLITE_TESTCTRL_RESULT_INTREAL: { + sqlite3_context *pCtx = va_arg(ap, sqlite3_context*); + sqlite3ResultIntReal(pCtx); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_SEEK_COUNT, + ** sqlite3 *db, // Database connection + ** u64 *pnSeek // Write seek count here + ** ); + ** + ** This test-control queries the seek-counter on the "main" database + ** file. The seek-counter is written into *pnSeek and is then reset. + ** The seek-count is only available if compiled with SQLITE_DEBUG. + */ + case SQLITE_TESTCTRL_SEEK_COUNT: { + sqlite3 *db = va_arg(ap, sqlite3*); + u64 *pn = va_arg(ap, sqlite3_uint64*); + *pn = sqlite3BtreeSeekCount(db->aDb->pBt); + (void)db; /* Silence harmless unused variable warning */ + break; + } + + + } + va_end(ap); +#endif /* SQLITE_UNTESTABLE */ + return rc; +} + +/* +** The Pager stores the Database filename, Journal filename, and WAL filename +** consecutively in memory, in that order. The database filename is prefixed +** by four zero bytes. Locate the start of the database filename by searching +** backwards for the first byte following four consecutive zero bytes. +** +** This only works if the filename passed in was obtained from the Pager. +*/ +static const char *databaseName(const char *zName){ + while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){ + zName--; + } + return zName; +} + +/* +** Append text z[] to the end of p[]. Return a pointer to the first +** character after then zero terminator on the new text in p[]. +*/ +static char *appendText(char *p, const char *z){ + size_t n = strlen(z); + memcpy(p, z, n+1); + return p+n+1; +} + +/* +** Allocate memory to hold names for a database, journal file, WAL file, +** and query parameters. The pointer returned is valid for use by +** sqlite3_filename_database() and sqlite3_uri_parameter() and related +** functions. +** +** Memory layout must be compatible with that generated by the pager +** and expected by sqlite3_uri_parameter() and databaseName(). +*/ +SQLITE_API char *sqlite3_create_filename( + const char *zDatabase, + const char *zJournal, + const char *zWal, + int nParam, + const char **azParam +){ + sqlite3_int64 nByte; + int i; + char *pResult, *p; + nByte = strlen(zDatabase) + strlen(zJournal) + strlen(zWal) + 10; + for(i=0; i0 ){ + zFilename += sqlite3Strlen30(zFilename) + 1; + zFilename += sqlite3Strlen30(zFilename) + 1; + } + return zFilename[0] ? zFilename : 0; +} + +/* +** Return a boolean value for a query parameter. +*/ +SQLITE_API int sqlite3_uri_boolean(const char *zFilename, const char *zParam, int bDflt){ + const char *z = sqlite3_uri_parameter(zFilename, zParam); + bDflt = bDflt!=0; + return z ? sqlite3GetBoolean(z, bDflt) : bDflt; +} + +/* +** Return a 64-bit integer value for a query parameter. +*/ +SQLITE_API sqlite3_int64 sqlite3_uri_int64( + const char *zFilename, /* Filename as passed to xOpen */ + const char *zParam, /* URI parameter sought */ + sqlite3_int64 bDflt /* return if parameter is missing */ +){ + const char *z = sqlite3_uri_parameter(zFilename, zParam); + sqlite3_int64 v; + if( z && sqlite3DecOrHexToI64(z, &v)==0 ){ + bDflt = v; + } + return bDflt; +} + +/* +** Translate a filename that was handed to a VFS routine into the corresponding +** database, journal, or WAL file. +** +** It is an error to pass this routine a filename string that was not +** passed into the VFS from the SQLite core. Doing so is similar to +** passing free() a pointer that was not obtained from malloc() - it is +** an error that we cannot easily detect but that will likely cause memory +** corruption. +*/ +SQLITE_API const char *sqlite3_filename_database(const char *zFilename){ + return databaseName(zFilename); +} +SQLITE_API const char *sqlite3_filename_journal(const char *zFilename){ + zFilename = databaseName(zFilename); + zFilename += sqlite3Strlen30(zFilename) + 1; + while( zFilename[0] ){ + zFilename += sqlite3Strlen30(zFilename) + 1; + zFilename += sqlite3Strlen30(zFilename) + 1; + } + return zFilename + 1; +} +SQLITE_API const char *sqlite3_filename_wal(const char *zFilename){ +#ifdef SQLITE_OMIT_WAL + return 0; +#else + zFilename = sqlite3_filename_journal(zFilename); + zFilename += sqlite3Strlen30(zFilename) + 1; + return zFilename; +#endif +} + +/* +** Return the Btree pointer identified by zDbName. Return NULL if not found. +*/ +SQLITE_PRIVATE Btree *sqlite3DbNameToBtree(sqlite3 *db, const char *zDbName){ + int iDb = zDbName ? sqlite3FindDbName(db, zDbName) : 0; + return iDb<0 ? 0 : db->aDb[iDb].pBt; +} + +/* +** Return the filename of the database associated with a database +** connection. +*/ +SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName){ + Btree *pBt; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + pBt = sqlite3DbNameToBtree(db, zDbName); + return pBt ? sqlite3BtreeGetFilename(pBt) : 0; +} + +/* +** Return 1 if database is read-only or 0 if read/write. Return -1 if +** no such database exists. +*/ +SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName){ + Btree *pBt; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return -1; + } +#endif + pBt = sqlite3DbNameToBtree(db, zDbName); + return pBt ? sqlite3BtreeIsReadonly(pBt) : -1; +} + +#ifdef SQLITE_ENABLE_SNAPSHOT +/* +** Obtain a snapshot handle for the snapshot of database zDb currently +** being read by handle db. +*/ +SQLITE_API int sqlite3_snapshot_get( + sqlite3 *db, + const char *zDb, + sqlite3_snapshot **ppSnapshot +){ + int rc = SQLITE_ERROR; +#ifndef SQLITE_OMIT_WAL + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + + if( db->autoCommit==0 ){ + int iDb = sqlite3FindDbName(db, zDb); + if( iDb==0 || iDb>1 ){ + Btree *pBt = db->aDb[iDb].pBt; + if( SQLITE_TXN_WRITE!=sqlite3BtreeTxnState(pBt) ){ + rc = sqlite3BtreeBeginTrans(pBt, 0, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerSnapshotGet(sqlite3BtreePager(pBt), ppSnapshot); + } + } + } + } + + sqlite3_mutex_leave(db->mutex); +#endif /* SQLITE_OMIT_WAL */ + return rc; +} + +/* +** Open a read-transaction on the snapshot idendified by pSnapshot. +*/ +SQLITE_API int sqlite3_snapshot_open( + sqlite3 *db, + const char *zDb, + sqlite3_snapshot *pSnapshot +){ + int rc = SQLITE_ERROR; +#ifndef SQLITE_OMIT_WAL + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + if( db->autoCommit==0 ){ + int iDb; + iDb = sqlite3FindDbName(db, zDb); + if( iDb==0 || iDb>1 ){ + Btree *pBt = db->aDb[iDb].pBt; + if( sqlite3BtreeTxnState(pBt)!=SQLITE_TXN_WRITE ){ + Pager *pPager = sqlite3BtreePager(pBt); + int bUnlock = 0; + if( sqlite3BtreeTxnState(pBt)!=SQLITE_TXN_NONE ){ + if( db->nVdbeActive==0 ){ + rc = sqlite3PagerSnapshotCheck(pPager, pSnapshot); + if( rc==SQLITE_OK ){ + bUnlock = 1; + rc = sqlite3BtreeCommit(pBt); + } + } + }else{ + rc = SQLITE_OK; + } + if( rc==SQLITE_OK ){ + rc = sqlite3PagerSnapshotOpen(pPager, pSnapshot); + } + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeBeginTrans(pBt, 0, 0); + sqlite3PagerSnapshotOpen(pPager, 0); + } + if( bUnlock ){ + sqlite3PagerSnapshotUnlock(pPager); + } + } + } + } + + sqlite3_mutex_leave(db->mutex); +#endif /* SQLITE_OMIT_WAL */ + return rc; +} + +/* +** Recover as many snapshots as possible from the wal file associated with +** schema zDb of database db. +*/ +SQLITE_API int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb){ + int rc = SQLITE_ERROR; + int iDb; +#ifndef SQLITE_OMIT_WAL + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + return SQLITE_MISUSE_BKPT; + } +#endif + + sqlite3_mutex_enter(db->mutex); + iDb = sqlite3FindDbName(db, zDb); + if( iDb==0 || iDb>1 ){ + Btree *pBt = db->aDb[iDb].pBt; + if( SQLITE_TXN_NONE==sqlite3BtreeTxnState(pBt) ){ + rc = sqlite3BtreeBeginTrans(pBt, 0, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerSnapshotRecover(sqlite3BtreePager(pBt)); + sqlite3BtreeCommit(pBt); + } + } + } + sqlite3_mutex_leave(db->mutex); +#endif /* SQLITE_OMIT_WAL */ + return rc; +} + +/* +** Free a snapshot handle obtained from sqlite3_snapshot_get(). +*/ +SQLITE_API void sqlite3_snapshot_free(sqlite3_snapshot *pSnapshot){ + sqlite3_free(pSnapshot); +} +#endif /* SQLITE_ENABLE_SNAPSHOT */ + +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +/* +** Given the name of a compile-time option, return true if that option +** was used and false if not. +** +** The name can optionally begin with "SQLITE_" but the "SQLITE_" prefix +** is not required for a match. +*/ +SQLITE_API int sqlite3_compileoption_used(const char *zOptName){ + int i, n; + int nOpt; + const char **azCompileOpt; + +#if SQLITE_ENABLE_API_ARMOR + if( zOptName==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + + azCompileOpt = sqlite3CompileOptions(&nOpt); + + if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7; + n = sqlite3Strlen30(zOptName); + + /* Since nOpt is normally in single digits, a linear search is + ** adequate. No need for a binary search. */ + for(i=0; i=0 && NpNextBlocked){ + int seen = 0; + sqlite3 *p2; + + /* Verify property (1) */ + assert( p->pUnlockConnection || p->pBlockingConnection ); + + /* Verify property (2) */ + for(p2=sqlite3BlockedList; p2!=p; p2=p2->pNextBlocked){ + if( p2->xUnlockNotify==p->xUnlockNotify ) seen = 1; + assert( p2->xUnlockNotify==p->xUnlockNotify || !seen ); + assert( db==0 || p->pUnlockConnection!=db ); + assert( db==0 || p->pBlockingConnection!=db ); + } + } +} +#else +# define checkListProperties(x) +#endif + +/* +** Remove connection db from the blocked connections list. If connection +** db is not currently a part of the list, this function is a no-op. +*/ +static void removeFromBlockedList(sqlite3 *db){ + sqlite3 **pp; + assertMutexHeld(); + for(pp=&sqlite3BlockedList; *pp; pp = &(*pp)->pNextBlocked){ + if( *pp==db ){ + *pp = (*pp)->pNextBlocked; + break; + } + } +} + +/* +** Add connection db to the blocked connections list. It is assumed +** that it is not already a part of the list. +*/ +static void addToBlockedList(sqlite3 *db){ + sqlite3 **pp; + assertMutexHeld(); + for( + pp=&sqlite3BlockedList; + *pp && (*pp)->xUnlockNotify!=db->xUnlockNotify; + pp=&(*pp)->pNextBlocked + ); + db->pNextBlocked = *pp; + *pp = db; +} + +/* +** Obtain the STATIC_MAIN mutex. +*/ +static void enterMutex(void){ + sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN)); + checkListProperties(0); +} + +/* +** Release the STATIC_MAIN mutex. +*/ +static void leaveMutex(void){ + assertMutexHeld(); + checkListProperties(0); + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN)); +} + +/* +** Register an unlock-notify callback. +** +** This is called after connection "db" has attempted some operation +** but has received an SQLITE_LOCKED error because another connection +** (call it pOther) in the same process was busy using the same shared +** cache. pOther is found by looking at db->pBlockingConnection. +** +** If there is no blocking connection, the callback is invoked immediately, +** before this routine returns. +** +** If pOther is already blocked on db, then report SQLITE_LOCKED, to indicate +** a deadlock. +** +** Otherwise, make arrangements to invoke xNotify when pOther drops +** its locks. +** +** Each call to this routine overrides any prior callbacks registered +** on the same "db". If xNotify==0 then any prior callbacks are immediately +** cancelled. +*/ +SQLITE_API int sqlite3_unlock_notify( + sqlite3 *db, + void (*xNotify)(void **, int), + void *pArg +){ + int rc = SQLITE_OK; + + sqlite3_mutex_enter(db->mutex); + enterMutex(); + + if( xNotify==0 ){ + removeFromBlockedList(db); + db->pBlockingConnection = 0; + db->pUnlockConnection = 0; + db->xUnlockNotify = 0; + db->pUnlockArg = 0; + }else if( 0==db->pBlockingConnection ){ + /* The blocking transaction has been concluded. Or there never was a + ** blocking transaction. In either case, invoke the notify callback + ** immediately. + */ + xNotify(&pArg, 1); + }else{ + sqlite3 *p; + + for(p=db->pBlockingConnection; p && p!=db; p=p->pUnlockConnection){} + if( p ){ + rc = SQLITE_LOCKED; /* Deadlock detected. */ + }else{ + db->pUnlockConnection = db->pBlockingConnection; + db->xUnlockNotify = xNotify; + db->pUnlockArg = pArg; + removeFromBlockedList(db); + addToBlockedList(db); + } + } + + leaveMutex(); + assert( !db->mallocFailed ); + sqlite3ErrorWithMsg(db, rc, (rc?"database is deadlocked":0)); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** This function is called while stepping or preparing a statement +** associated with connection db. The operation will return SQLITE_LOCKED +** to the user because it requires a lock that will not be available +** until connection pBlocker concludes its current transaction. +*/ +SQLITE_PRIVATE void sqlite3ConnectionBlocked(sqlite3 *db, sqlite3 *pBlocker){ + enterMutex(); + if( db->pBlockingConnection==0 && db->pUnlockConnection==0 ){ + addToBlockedList(db); + } + db->pBlockingConnection = pBlocker; + leaveMutex(); +} + +/* +** This function is called when +** the transaction opened by database db has just finished. Locks held +** by database connection db have been released. +** +** This function loops through each entry in the blocked connections +** list and does the following: +** +** 1) If the sqlite3.pBlockingConnection member of a list entry is +** set to db, then set pBlockingConnection=0. +** +** 2) If the sqlite3.pUnlockConnection member of a list entry is +** set to db, then invoke the configured unlock-notify callback and +** set pUnlockConnection=0. +** +** 3) If the two steps above mean that pBlockingConnection==0 and +** pUnlockConnection==0, remove the entry from the blocked connections +** list. +*/ +SQLITE_PRIVATE void sqlite3ConnectionUnlocked(sqlite3 *db){ + void (*xUnlockNotify)(void **, int) = 0; /* Unlock-notify cb to invoke */ + int nArg = 0; /* Number of entries in aArg[] */ + sqlite3 **pp; /* Iterator variable */ + void **aArg; /* Arguments to the unlock callback */ + void **aDyn = 0; /* Dynamically allocated space for aArg[] */ + void *aStatic[16]; /* Starter space for aArg[]. No malloc required */ + + aArg = aStatic; + enterMutex(); /* Enter STATIC_MAIN mutex */ + + /* This loop runs once for each entry in the blocked-connections list. */ + for(pp=&sqlite3BlockedList; *pp; /* no-op */ ){ + sqlite3 *p = *pp; + + /* Step 1. */ + if( p->pBlockingConnection==db ){ + p->pBlockingConnection = 0; + } + + /* Step 2. */ + if( p->pUnlockConnection==db ){ + assert( p->xUnlockNotify ); + if( p->xUnlockNotify!=xUnlockNotify && nArg!=0 ){ + xUnlockNotify(aArg, nArg); + nArg = 0; + } + + sqlite3BeginBenignMalloc(); + assert( aArg==aDyn || (aDyn==0 && aArg==aStatic) ); + assert( nArg<=(int)ArraySize(aStatic) || aArg==aDyn ); + if( (!aDyn && nArg==(int)ArraySize(aStatic)) + || (aDyn && nArg==(int)(sqlite3MallocSize(aDyn)/sizeof(void*))) + ){ + /* The aArg[] array needs to grow. */ + void **pNew = (void **)sqlite3Malloc(nArg*sizeof(void *)*2); + if( pNew ){ + memcpy(pNew, aArg, nArg*sizeof(void *)); + sqlite3_free(aDyn); + aDyn = aArg = pNew; + }else{ + /* This occurs when the array of context pointers that need to + ** be passed to the unlock-notify callback is larger than the + ** aStatic[] array allocated on the stack and the attempt to + ** allocate a larger array from the heap has failed. + ** + ** This is a difficult situation to handle. Returning an error + ** code to the caller is insufficient, as even if an error code + ** is returned the transaction on connection db will still be + ** closed and the unlock-notify callbacks on blocked connections + ** will go unissued. This might cause the application to wait + ** indefinitely for an unlock-notify callback that will never + ** arrive. + ** + ** Instead, invoke the unlock-notify callback with the context + ** array already accumulated. We can then clear the array and + ** begin accumulating any further context pointers without + ** requiring any dynamic allocation. This is sub-optimal because + ** it means that instead of one callback with a large array of + ** context pointers the application will receive two or more + ** callbacks with smaller arrays of context pointers, which will + ** reduce the applications ability to prioritize multiple + ** connections. But it is the best that can be done under the + ** circumstances. + */ + xUnlockNotify(aArg, nArg); + nArg = 0; + } + } + sqlite3EndBenignMalloc(); + + aArg[nArg++] = p->pUnlockArg; + xUnlockNotify = p->xUnlockNotify; + p->pUnlockConnection = 0; + p->xUnlockNotify = 0; + p->pUnlockArg = 0; + } + + /* Step 3. */ + if( p->pBlockingConnection==0 && p->pUnlockConnection==0 ){ + /* Remove connection p from the blocked connections list. */ + *pp = p->pNextBlocked; + p->pNextBlocked = 0; + }else{ + pp = &p->pNextBlocked; + } + } + + if( nArg!=0 ){ + xUnlockNotify(aArg, nArg); + } + sqlite3_free(aDyn); + leaveMutex(); /* Leave STATIC_MAIN mutex */ +} + +/* +** This is called when the database connection passed as an argument is +** being closed. The connection is removed from the blocked list. +*/ +SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db){ + sqlite3ConnectionUnlocked(db); + enterMutex(); + removeFromBlockedList(db); + checkListProperties(db); + leaveMutex(); +} +#endif + +/************** End of notify.c **********************************************/ +/************** Begin file fts3.c ********************************************/ +/* +** 2006 Oct 10 +** +** 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 is an SQLite module implementing full-text search. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ + +/* The full-text index is stored in a series of b+tree (-like) +** structures called segments which map terms to doclists. The +** structures are like b+trees in layout, but are constructed from the +** bottom up in optimal fashion and are not updatable. Since trees +** are built from the bottom up, things will be described from the +** bottom up. +** +** +**** Varints **** +** The basic unit of encoding is a variable-length integer called a +** varint. We encode variable-length integers in little-endian order +** using seven bits * per byte as follows: +** +** KEY: +** A = 0xxxxxxx 7 bits of data and one flag bit +** B = 1xxxxxxx 7 bits of data and one flag bit +** +** 7 bits - A +** 14 bits - BA +** 21 bits - BBA +** and so on. +** +** This is similar in concept to how sqlite encodes "varints" but +** the encoding is not the same. SQLite varints are big-endian +** are are limited to 9 bytes in length whereas FTS3 varints are +** little-endian and can be up to 10 bytes in length (in theory). +** +** Example encodings: +** +** 1: 0x01 +** 127: 0x7f +** 128: 0x81 0x00 +** +** +**** Document lists **** +** A doclist (document list) holds a docid-sorted list of hits for a +** given term. Doclists hold docids and associated token positions. +** A docid is the unique integer identifier for a single document. +** A position is the index of a word within the document. The first +** word of the document has a position of 0. +** +** FTS3 used to optionally store character offsets using a compile-time +** option. But that functionality is no longer supported. +** +** A doclist is stored like this: +** +** array { +** varint docid; (delta from previous doclist) +** array { (position list for column 0) +** varint position; (2 more than the delta from previous position) +** } +** array { +** varint POS_COLUMN; (marks start of position list for new column) +** varint column; (index of new column) +** array { +** varint position; (2 more than the delta from previous position) +** } +** } +** varint POS_END; (marks end of positions for this document. +** } +** +** Here, array { X } means zero or more occurrences of X, adjacent in +** memory. A "position" is an index of a token in the token stream +** generated by the tokenizer. Note that POS_END and POS_COLUMN occur +** in the same logical place as the position element, and act as sentinals +** ending a position list array. POS_END is 0. POS_COLUMN is 1. +** The positions numbers are not stored literally but rather as two more +** than the difference from the prior position, or the just the position plus +** 2 for the first position. Example: +** +** label: A B C D E F G H I J K +** value: 123 5 9 1 1 14 35 0 234 72 0 +** +** The 123 value is the first docid. For column zero in this document +** there are two matches at positions 3 and 10 (5-2 and 9-2+3). The 1 +** at D signals the start of a new column; the 1 at E indicates that the +** new column is column number 1. There are two positions at 12 and 45 +** (14-2 and 35-2+12). The 0 at H indicate the end-of-document. The +** 234 at I is the delta to next docid (357). It has one position 70 +** (72-2) and then terminates with the 0 at K. +** +** A "position-list" is the list of positions for multiple columns for +** a single docid. A "column-list" is the set of positions for a single +** column. Hence, a position-list consists of one or more column-lists, +** a document record consists of a docid followed by a position-list and +** a doclist consists of one or more document records. +** +** A bare doclist omits the position information, becoming an +** array of varint-encoded docids. +** +**** Segment leaf nodes **** +** Segment leaf nodes store terms and doclists, ordered by term. Leaf +** nodes are written using LeafWriter, and read using LeafReader (to +** iterate through a single leaf node's data) and LeavesReader (to +** iterate through a segment's entire leaf layer). Leaf nodes have +** the format: +** +** varint iHeight; (height from leaf level, always 0) +** varint nTerm; (length of first term) +** char pTerm[nTerm]; (content of first term) +** varint nDoclist; (length of term's associated doclist) +** char pDoclist[nDoclist]; (content of doclist) +** array { +** (further terms are delta-encoded) +** varint nPrefix; (length of prefix shared with previous term) +** varint nSuffix; (length of unshared suffix) +** char pTermSuffix[nSuffix];(unshared suffix of next term) +** varint nDoclist; (length of term's associated doclist) +** char pDoclist[nDoclist]; (content of doclist) +** } +** +** Here, array { X } means zero or more occurrences of X, adjacent in +** memory. +** +** Leaf nodes are broken into blocks which are stored contiguously in +** the %_segments table in sorted order. This means that when the end +** of a node is reached, the next term is in the node with the next +** greater node id. +** +** New data is spilled to a new leaf node when the current node +** exceeds LEAF_MAX bytes (default 2048). New data which itself is +** larger than STANDALONE_MIN (default 1024) is placed in a standalone +** node (a leaf node with a single term and doclist). The goal of +** these settings is to pack together groups of small doclists while +** making it efficient to directly access large doclists. The +** assumption is that large doclists represent terms which are more +** likely to be query targets. +** +** TODO(shess) It may be useful for blocking decisions to be more +** dynamic. For instance, it may make more sense to have a 2.5k leaf +** node rather than splitting into 2k and .5k nodes. My intuition is +** that this might extend through 2x or 4x the pagesize. +** +** +**** Segment interior nodes **** +** Segment interior nodes store blockids for subtree nodes and terms +** to describe what data is stored by the each subtree. Interior +** nodes are written using InteriorWriter, and read using +** InteriorReader. InteriorWriters are created as needed when +** SegmentWriter creates new leaf nodes, or when an interior node +** itself grows too big and must be split. The format of interior +** nodes: +** +** varint iHeight; (height from leaf level, always >0) +** varint iBlockid; (block id of node's leftmost subtree) +** optional { +** varint nTerm; (length of first term) +** char pTerm[nTerm]; (content of first term) +** array { +** (further terms are delta-encoded) +** varint nPrefix; (length of shared prefix with previous term) +** varint nSuffix; (length of unshared suffix) +** char pTermSuffix[nSuffix]; (unshared suffix of next term) +** } +** } +** +** Here, optional { X } means an optional element, while array { X } +** means zero or more occurrences of X, adjacent in memory. +** +** An interior node encodes n terms separating n+1 subtrees. The +** subtree blocks are contiguous, so only the first subtree's blockid +** is encoded. The subtree at iBlockid will contain all terms less +** than the first term encoded (or all terms if no term is encoded). +** Otherwise, for terms greater than or equal to pTerm[i] but less +** than pTerm[i+1], the subtree for that term will be rooted at +** iBlockid+i. Interior nodes only store enough term data to +** distinguish adjacent children (if the rightmost term of the left +** child is "something", and the leftmost term of the right child is +** "wicked", only "w" is stored). +** +** New data is spilled to a new interior node at the same height when +** the current node exceeds INTERIOR_MAX bytes (default 2048). +** INTERIOR_MIN_TERMS (default 7) keeps large terms from monopolizing +** interior nodes and making the tree too skinny. The interior nodes +** at a given height are naturally tracked by interior nodes at +** height+1, and so on. +** +** +**** Segment directory **** +** The segment directory in table %_segdir stores meta-information for +** merging and deleting segments, and also the root node of the +** segment's tree. +** +** The root node is the top node of the segment's tree after encoding +** the entire segment, restricted to ROOT_MAX bytes (default 1024). +** This could be either a leaf node or an interior node. If the top +** node requires more than ROOT_MAX bytes, it is flushed to %_segments +** and a new root interior node is generated (which should always fit +** within ROOT_MAX because it only needs space for 2 varints, the +** height and the blockid of the previous root). +** +** The meta-information in the segment directory is: +** level - segment level (see below) +** idx - index within level +** - (level,idx uniquely identify a segment) +** start_block - first leaf node +** leaves_end_block - last leaf node +** end_block - last block (including interior nodes) +** root - contents of root node +** +** If the root node is a leaf node, then start_block, +** leaves_end_block, and end_block are all 0. +** +** +**** Segment merging **** +** To amortize update costs, segments are grouped into levels and +** merged in batches. Each increase in level represents exponentially +** more documents. +** +** New documents (actually, document updates) are tokenized and +** written individually (using LeafWriter) to a level 0 segment, with +** incrementing idx. When idx reaches MERGE_COUNT (default 16), all +** level 0 segments are merged into a single level 1 segment. Level 1 +** is populated like level 0, and eventually MERGE_COUNT level 1 +** segments are merged to a single level 2 segment (representing +** MERGE_COUNT^2 updates), and so on. +** +** A segment merge traverses all segments at a given level in +** parallel, performing a straightforward sorted merge. Since segment +** leaf nodes are written in to the %_segments table in order, this +** merge traverses the underlying sqlite disk structures efficiently. +** After the merge, all segment blocks from the merged level are +** deleted. +** +** MERGE_COUNT controls how often we merge segments. 16 seems to be +** somewhat of a sweet spot for insertion performance. 32 and 64 show +** very similar performance numbers to 16 on insertion, though they're +** a tiny bit slower (perhaps due to more overhead in merge-time +** sorting). 8 is about 20% slower than 16, 4 about 50% slower than +** 16, 2 about 66% slower than 16. +** +** At query time, high MERGE_COUNT increases the number of segments +** which need to be scanned and merged. For instance, with 100k docs +** inserted: +** +** MERGE_COUNT segments +** 16 25 +** 8 12 +** 4 10 +** 2 6 +** +** This appears to have only a moderate impact on queries for very +** frequent terms (which are somewhat dominated by segment merge +** costs), and infrequent and non-existent terms still seem to be fast +** even with many segments. +** +** TODO(shess) That said, it would be nice to have a better query-side +** argument for MERGE_COUNT of 16. Also, it is possible/likely that +** optimizations to things like doclist merging will swing the sweet +** spot around. +** +** +** +**** Handling of deletions and updates **** +** Since we're using a segmented structure, with no docid-oriented +** index into the term index, we clearly cannot simply update the term +** index when a document is deleted or updated. For deletions, we +** write an empty doclist (varint(docid) varint(POS_END)), for updates +** we simply write the new doclist. Segment merges overwrite older +** data for a particular docid with newer data, so deletes or updates +** will eventually overtake the earlier data and knock it out. The +** query logic likewise merges doclists so that newer data knocks out +** older data. +*/ + +/************** Include fts3Int.h in the middle of fts3.c ********************/ +/************** Begin file fts3Int.h *****************************************/ +/* +** 2009 Nov 12 +** +** 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. +** +****************************************************************************** +** +*/ +#ifndef _FTSINT_H +#define _FTSINT_H + +#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) +# define NDEBUG 1 +#endif + +/* FTS3/FTS4 require virtual tables */ +#ifdef SQLITE_OMIT_VIRTUALTABLE +# undef SQLITE_ENABLE_FTS3 +# undef SQLITE_ENABLE_FTS4 +#endif + +/* +** FTS4 is really an extension for FTS3. It is enabled using the +** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also all +** the SQLITE_ENABLE_FTS4 macro to serve as an alisse for SQLITE_ENABLE_FTS3. +*/ +#if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3) +# define SQLITE_ENABLE_FTS3 +#endif + +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* If not building as part of the core, include sqlite3ext.h. */ +#ifndef SQLITE_CORE +/* # include "sqlite3ext.h" */ +SQLITE_EXTENSION_INIT3 +#endif + +/* #include "sqlite3.h" */ +/************** Include fts3_tokenizer.h in the middle of fts3Int.h **********/ +/************** Begin file fts3_tokenizer.h **********************************/ +/* +** 2006 July 10 +** +** The author disclaims copyright to this source code. +** +************************************************************************* +** Defines the interface to tokenizers used by fulltext-search. There +** are three basic components: +** +** sqlite3_tokenizer_module is a singleton defining the tokenizer +** interface functions. This is essentially the class structure for +** tokenizers. +** +** sqlite3_tokenizer is used to define a particular tokenizer, perhaps +** including customization information defined at creation time. +** +** sqlite3_tokenizer_cursor is generated by a tokenizer to generate +** tokens from a particular input. +*/ +#ifndef _FTS3_TOKENIZER_H_ +#define _FTS3_TOKENIZER_H_ + +/* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time. +** If tokenizers are to be allowed to call sqlite3_*() functions, then +** we will need a way to register the API consistently. +*/ +/* #include "sqlite3.h" */ + +/* +** Structures used by the tokenizer interface. When a new tokenizer +** implementation is registered, the caller provides a pointer to +** an sqlite3_tokenizer_module containing pointers to the callback +** functions that make up an implementation. +** +** When an fts3 table is created, it passes any arguments passed to +** the tokenizer clause of the CREATE VIRTUAL TABLE statement to the +** sqlite3_tokenizer_module.xCreate() function of the requested tokenizer +** implementation. The xCreate() function in turn returns an +** sqlite3_tokenizer structure representing the specific tokenizer to +** be used for the fts3 table (customized by the tokenizer clause arguments). +** +** To tokenize an input buffer, the sqlite3_tokenizer_module.xOpen() +** method is called. It returns an sqlite3_tokenizer_cursor object +** that may be used to tokenize a specific input buffer based on +** the tokenization rules supplied by a specific sqlite3_tokenizer +** object. +*/ +typedef struct sqlite3_tokenizer_module sqlite3_tokenizer_module; +typedef struct sqlite3_tokenizer sqlite3_tokenizer; +typedef struct sqlite3_tokenizer_cursor sqlite3_tokenizer_cursor; + +struct sqlite3_tokenizer_module { + + /* + ** Structure version. Should always be set to 0 or 1. + */ + int iVersion; + + /* + ** Create a new tokenizer. The values in the argv[] array are the + ** arguments passed to the "tokenizer" clause of the CREATE VIRTUAL + ** TABLE statement that created the fts3 table. For example, if + ** the following SQL is executed: + ** + ** CREATE .. USING fts3( ... , tokenizer arg1 arg2) + ** + ** then argc is set to 2, and the argv[] array contains pointers + ** to the strings "arg1" and "arg2". + ** + ** This method should return either SQLITE_OK (0), or an SQLite error + ** code. If SQLITE_OK is returned, then *ppTokenizer should be set + ** to point at the newly created tokenizer structure. The generic + ** sqlite3_tokenizer.pModule variable should not be initialized by + ** this callback. The caller will do so. + */ + int (*xCreate)( + int argc, /* Size of argv array */ + const char *const*argv, /* Tokenizer argument strings */ + sqlite3_tokenizer **ppTokenizer /* OUT: Created tokenizer */ + ); + + /* + ** Destroy an existing tokenizer. The fts3 module calls this method + ** exactly once for each successful call to xCreate(). + */ + int (*xDestroy)(sqlite3_tokenizer *pTokenizer); + + /* + ** Create a tokenizer cursor to tokenize an input buffer. The caller + ** is responsible for ensuring that the input buffer remains valid + ** until the cursor is closed (using the xClose() method). + */ + int (*xOpen)( + sqlite3_tokenizer *pTokenizer, /* Tokenizer object */ + const char *pInput, int nBytes, /* Input buffer */ + sqlite3_tokenizer_cursor **ppCursor /* OUT: Created tokenizer cursor */ + ); + + /* + ** Destroy an existing tokenizer cursor. The fts3 module calls this + ** method exactly once for each successful call to xOpen(). + */ + int (*xClose)(sqlite3_tokenizer_cursor *pCursor); + + /* + ** Retrieve the next token from the tokenizer cursor pCursor. This + ** method should either return SQLITE_OK and set the values of the + ** "OUT" variables identified below, or SQLITE_DONE to indicate that + ** the end of the buffer has been reached, or an SQLite error code. + ** + ** *ppToken should be set to point at a buffer containing the + ** normalized version of the token (i.e. after any case-folding and/or + ** stemming has been performed). *pnBytes should be set to the length + ** of this buffer in bytes. The input text that generated the token is + ** identified by the byte offsets returned in *piStartOffset and + ** *piEndOffset. *piStartOffset should be set to the index of the first + ** byte of the token in the input buffer. *piEndOffset should be set + ** to the index of the first byte just past the end of the token in + ** the input buffer. + ** + ** The buffer *ppToken is set to point at is managed by the tokenizer + ** implementation. It is only required to be valid until the next call + ** to xNext() or xClose(). + */ + /* TODO(shess) current implementation requires pInput to be + ** nul-terminated. This should either be fixed, or pInput/nBytes + ** should be converted to zInput. + */ + int (*xNext)( + sqlite3_tokenizer_cursor *pCursor, /* Tokenizer cursor */ + const char **ppToken, int *pnBytes, /* OUT: Normalized text for token */ + int *piStartOffset, /* OUT: Byte offset of token in input buffer */ + int *piEndOffset, /* OUT: Byte offset of end of token in input buffer */ + int *piPosition /* OUT: Number of tokens returned before this one */ + ); + + /*********************************************************************** + ** Methods below this point are only available if iVersion>=1. + */ + + /* + ** Configure the language id of a tokenizer cursor. + */ + int (*xLanguageid)(sqlite3_tokenizer_cursor *pCsr, int iLangid); +}; + +struct sqlite3_tokenizer { + const sqlite3_tokenizer_module *pModule; /* The module for this tokenizer */ + /* Tokenizer implementations will typically add additional fields */ +}; + +struct sqlite3_tokenizer_cursor { + sqlite3_tokenizer *pTokenizer; /* Tokenizer for this cursor. */ + /* Tokenizer implementations will typically add additional fields */ +}; + +int fts3_global_term_cnt(int iTerm, int iCol); +int fts3_term_cnt(int iTerm, int iCol); + + +#endif /* _FTS3_TOKENIZER_H_ */ + +/************** End of fts3_tokenizer.h **************************************/ +/************** Continuing where we left off in fts3Int.h ********************/ +/************** Include fts3_hash.h in the middle of fts3Int.h ***************/ +/************** Begin file fts3_hash.h ***************************************/ +/* +** 2001 September 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the header file for the generic hash-table implementation +** used in SQLite. We've modified it slightly to serve as a standalone +** hash table implementation for the full-text indexing module. +** +*/ +#ifndef _FTS3_HASH_H_ +#define _FTS3_HASH_H_ + +/* Forward declarations of structures. */ +typedef struct Fts3Hash Fts3Hash; +typedef struct Fts3HashElem Fts3HashElem; + +/* A complete hash table is an instance of the following structure. +** The internals of this structure are intended to be opaque -- client +** code should not attempt to access or modify the fields of this structure +** directly. Change this structure only by using the routines below. +** However, many of the "procedures" and "functions" for modifying and +** accessing this structure are really macros, so we can't really make +** this structure opaque. +*/ +struct Fts3Hash { + char keyClass; /* HASH_INT, _POINTER, _STRING, _BINARY */ + char copyKey; /* True if copy of key made on insert */ + int count; /* Number of entries in this table */ + Fts3HashElem *first; /* The first element of the array */ + int htsize; /* Number of buckets in the hash table */ + struct _fts3ht { /* the hash table */ + int count; /* Number of entries with this hash */ + Fts3HashElem *chain; /* Pointer to first entry with this hash */ + } *ht; +}; + +/* Each element in the hash table is an instance of the following +** structure. All elements are stored on a single doubly-linked list. +** +** Again, this structure is intended to be opaque, but it can't really +** be opaque because it is used by macros. +*/ +struct Fts3HashElem { + Fts3HashElem *next, *prev; /* Next and previous elements in the table */ + void *data; /* Data associated with this element */ + void *pKey; int nKey; /* Key associated with this element */ +}; + +/* +** There are 2 different modes of operation for a hash table: +** +** FTS3_HASH_STRING pKey points to a string that is nKey bytes long +** (including the null-terminator, if any). Case +** is respected in comparisons. +** +** FTS3_HASH_BINARY pKey points to binary data nKey bytes long. +** memcmp() is used to compare keys. +** +** A copy of the key is made if the copyKey parameter to fts3HashInit is 1. +*/ +#define FTS3_HASH_STRING 1 +#define FTS3_HASH_BINARY 2 + +/* +** Access routines. To delete, insert a NULL pointer. +*/ +SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey); +SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData); +SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash*, const void *pKey, int nKey); +SQLITE_PRIVATE void sqlite3Fts3HashClear(Fts3Hash*); +SQLITE_PRIVATE Fts3HashElem *sqlite3Fts3HashFindElem(const Fts3Hash *, const void *, int); + +/* +** Shorthand for the functions above +*/ +#define fts3HashInit sqlite3Fts3HashInit +#define fts3HashInsert sqlite3Fts3HashInsert +#define fts3HashFind sqlite3Fts3HashFind +#define fts3HashClear sqlite3Fts3HashClear +#define fts3HashFindElem sqlite3Fts3HashFindElem + +/* +** Macros for looping over all elements of a hash table. The idiom is +** like this: +** +** Fts3Hash h; +** Fts3HashElem *p; +** ... +** for(p=fts3HashFirst(&h); p; p=fts3HashNext(p)){ +** SomeStructure *pData = fts3HashData(p); +** // do something with pData +** } +*/ +#define fts3HashFirst(H) ((H)->first) +#define fts3HashNext(E) ((E)->next) +#define fts3HashData(E) ((E)->data) +#define fts3HashKey(E) ((E)->pKey) +#define fts3HashKeysize(E) ((E)->nKey) + +/* +** Number of entries in a hash table +*/ +#define fts3HashCount(H) ((H)->count) + +#endif /* _FTS3_HASH_H_ */ + +/************** End of fts3_hash.h *******************************************/ +/************** Continuing where we left off in fts3Int.h ********************/ + +/* +** This constant determines the maximum depth of an FTS expression tree +** that the library will create and use. FTS uses recursion to perform +** various operations on the query tree, so the disadvantage of a large +** limit is that it may allow very large queries to use large amounts +** of stack space (perhaps causing a stack overflow). +*/ +#ifndef SQLITE_FTS3_MAX_EXPR_DEPTH +# define SQLITE_FTS3_MAX_EXPR_DEPTH 12 +#endif + + +/* +** This constant controls how often segments are merged. Once there are +** FTS3_MERGE_COUNT segments of level N, they are merged into a single +** segment of level N+1. +*/ +#define FTS3_MERGE_COUNT 16 + +/* +** This is the maximum amount of data (in bytes) to store in the +** Fts3Table.pendingTerms hash table. Normally, the hash table is +** populated as documents are inserted/updated/deleted in a transaction +** and used to create a new segment when the transaction is committed. +** However if this limit is reached midway through a transaction, a new +** segment is created and the hash table cleared immediately. +*/ +#define FTS3_MAX_PENDING_DATA (1*1024*1024) + +/* +** Macro to return the number of elements in an array. SQLite has a +** similar macro called ArraySize(). Use a different name to avoid +** a collision when building an amalgamation with built-in FTS3. +*/ +#define SizeofArray(X) ((int)(sizeof(X)/sizeof(X[0]))) + + +#ifndef MIN +# define MIN(x,y) ((x)<(y)?(x):(y)) +#endif +#ifndef MAX +# define MAX(x,y) ((x)>(y)?(x):(y)) +#endif + +/* +** Maximum length of a varint encoded integer. The varint format is different +** from that used by SQLite, so the maximum length is 10, not 9. +*/ +#define FTS3_VARINT_MAX 10 + +#define FTS3_BUFFER_PADDING 8 + +/* +** FTS4 virtual tables may maintain multiple indexes - one index of all terms +** in the document set and zero or more prefix indexes. All indexes are stored +** as one or more b+-trees in the %_segments and %_segdir tables. +** +** It is possible to determine which index a b+-tree belongs to based on the +** value stored in the "%_segdir.level" column. Given this value L, the index +** that the b+-tree belongs to is (L<<10). In other words, all b+-trees with +** level values between 0 and 1023 (inclusive) belong to index 0, all levels +** between 1024 and 2047 to index 1, and so on. +** +** It is considered impossible for an index to use more than 1024 levels. In +** theory though this may happen, but only after at least +** (FTS3_MERGE_COUNT^1024) separate flushes of the pending-terms tables. +*/ +#define FTS3_SEGDIR_MAXLEVEL 1024 +#define FTS3_SEGDIR_MAXLEVEL_STR "1024" + +/* +** The testcase() macro is only used by the amalgamation. If undefined, +** make it a no-op. +*/ +#ifndef testcase +# define testcase(X) +#endif + +/* +** Terminator values for position-lists and column-lists. +*/ +#define POS_COLUMN (1) /* Column-list terminator */ +#define POS_END (0) /* Position-list terminator */ + +/* +** The assert_fts3_nc() macro is similar to the assert() macro, except that it +** is used for assert() conditions that are true only if it can be +** guranteed that the database is not corrupt. +*/ +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) +SQLITE_API extern int sqlite3_fts3_may_be_corrupt; +# define assert_fts3_nc(x) assert(sqlite3_fts3_may_be_corrupt || (x)) +#else +# define assert_fts3_nc(x) assert(x) +#endif + +/* +** This section provides definitions to allow the +** FTS3 extension to be compiled outside of the +** amalgamation. +*/ +#ifndef SQLITE_AMALGAMATION +/* +** Macros indicating that conditional expressions are always true or +** false. +*/ +#ifdef SQLITE_COVERAGE_TEST +# define ALWAYS(x) (1) +# define NEVER(X) (0) +#elif defined(SQLITE_DEBUG) +# define ALWAYS(x) sqlite3Fts3Always((x)!=0) +# define NEVER(x) sqlite3Fts3Never((x)!=0) +SQLITE_PRIVATE int sqlite3Fts3Always(int b); +SQLITE_PRIVATE int sqlite3Fts3Never(int b); +#else +# define ALWAYS(x) (x) +# define NEVER(x) (x) +#endif + +/* +** Internal types used by SQLite. +*/ +typedef unsigned char u8; /* 1-byte (or larger) unsigned integer */ +typedef short int i16; /* 2-byte (or larger) signed integer */ +typedef unsigned int u32; /* 4-byte unsigned integer */ +typedef sqlite3_uint64 u64; /* 8-byte unsigned integer */ +typedef sqlite3_int64 i64; /* 8-byte signed integer */ + +/* +** Macro used to suppress compiler warnings for unused parameters. +*/ +#define UNUSED_PARAMETER(x) (void)(x) + +/* +** Activate assert() only if SQLITE_TEST is enabled. +*/ +#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) +# define NDEBUG 1 +#endif + +/* +** The TESTONLY macro is used to enclose variable declarations or +** other bits of code that are needed to support the arguments +** within testcase() and assert() macros. +*/ +#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST) +# define TESTONLY(X) X +#else +# define TESTONLY(X) +#endif + +#define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32)) +#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64) + +#define deliberate_fall_through + +#endif /* SQLITE_AMALGAMATION */ + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3Fts3Corrupt(void); +# define FTS_CORRUPT_VTAB sqlite3Fts3Corrupt() +#else +# define FTS_CORRUPT_VTAB SQLITE_CORRUPT_VTAB +#endif + +typedef struct Fts3Table Fts3Table; +typedef struct Fts3Cursor Fts3Cursor; +typedef struct Fts3Expr Fts3Expr; +typedef struct Fts3Phrase Fts3Phrase; +typedef struct Fts3PhraseToken Fts3PhraseToken; + +typedef struct Fts3Doclist Fts3Doclist; +typedef struct Fts3SegFilter Fts3SegFilter; +typedef struct Fts3DeferredToken Fts3DeferredToken; +typedef struct Fts3SegReader Fts3SegReader; +typedef struct Fts3MultiSegReader Fts3MultiSegReader; + +typedef struct MatchinfoBuffer MatchinfoBuffer; + +/* +** A connection to a fulltext index is an instance of the following +** structure. The xCreate and xConnect methods create an instance +** of this structure and xDestroy and xDisconnect free that instance. +** All other methods receive a pointer to the structure as one of their +** arguments. +*/ +struct Fts3Table { + sqlite3_vtab base; /* Base class used by SQLite core */ + sqlite3 *db; /* The database connection */ + const char *zDb; /* logical database name */ + const char *zName; /* virtual table name */ + int nColumn; /* number of named columns in virtual table */ + char **azColumn; /* column names. malloced */ + u8 *abNotindexed; /* True for 'notindexed' columns */ + sqlite3_tokenizer *pTokenizer; /* tokenizer for inserts and queries */ + char *zContentTbl; /* content=xxx option, or NULL */ + char *zLanguageid; /* languageid=xxx option, or NULL */ + int nAutoincrmerge; /* Value configured by 'automerge' */ + u32 nLeafAdd; /* Number of leaf blocks added this trans */ + int bLock; /* Used to prevent recursive content= tbls */ + + /* Precompiled statements used by the implementation. Each of these + ** statements is run and reset within a single virtual table API call. + */ + sqlite3_stmt *aStmt[40]; + sqlite3_stmt *pSeekStmt; /* Cache for fts3CursorSeekStmt() */ + + char *zReadExprlist; + char *zWriteExprlist; + + int nNodeSize; /* Soft limit for node size */ + u8 bFts4; /* True for FTS4, false for FTS3 */ + u8 bHasStat; /* True if %_stat table exists (2==unknown) */ + u8 bHasDocsize; /* True if %_docsize table exists */ + u8 bDescIdx; /* True if doclists are in reverse order */ + u8 bIgnoreSavepoint; /* True to ignore xSavepoint invocations */ + int nPgsz; /* Page size for host database */ + char *zSegmentsTbl; /* Name of %_segments table */ + sqlite3_blob *pSegments; /* Blob handle open on %_segments table */ + + /* + ** The following array of hash tables is used to buffer pending index + ** updates during transactions. All pending updates buffered at any one + ** time must share a common language-id (see the FTS4 langid= feature). + ** The current language id is stored in variable iPrevLangid. + ** + ** A single FTS4 table may have multiple full-text indexes. For each index + ** there is an entry in the aIndex[] array. Index 0 is an index of all the + ** terms that appear in the document set. Each subsequent index in aIndex[] + ** is an index of prefixes of a specific length. + ** + ** Variable nPendingData contains an estimate the memory consumed by the + ** pending data structures, including hash table overhead, but not including + ** malloc overhead. When nPendingData exceeds nMaxPendingData, all hash + ** tables are flushed to disk. Variable iPrevDocid is the docid of the most + ** recently inserted record. + */ + int nIndex; /* Size of aIndex[] */ + struct Fts3Index { + int nPrefix; /* Prefix length (0 for main terms index) */ + Fts3Hash hPending; /* Pending terms table for this index */ + } *aIndex; + int nMaxPendingData; /* Max pending data before flush to disk */ + int nPendingData; /* Current bytes of pending data */ + sqlite_int64 iPrevDocid; /* Docid of most recently inserted document */ + int iPrevLangid; /* Langid of recently inserted document */ + int bPrevDelete; /* True if last operation was a delete */ + +#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST) + /* State variables used for validating that the transaction control + ** methods of the virtual table are called at appropriate times. These + ** values do not contribute to FTS functionality; they are used for + ** verifying the operation of the SQLite core. + */ + int inTransaction; /* True after xBegin but before xCommit/xRollback */ + int mxSavepoint; /* Largest valid xSavepoint integer */ +#endif + +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + /* True to disable the incremental doclist optimization. This is controled + ** by special insert command 'test-no-incr-doclist'. */ + int bNoIncrDoclist; + + /* Number of segments in a level */ + int nMergeCount; +#endif +}; + +/* Macro to find the number of segments to merge */ +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) +# define MergeCount(P) ((P)->nMergeCount) +#else +# define MergeCount(P) FTS3_MERGE_COUNT +#endif + +/* +** When the core wants to read from the virtual table, it creates a +** virtual table cursor (an instance of the following structure) using +** the xOpen method. Cursors are destroyed using the xClose method. +*/ +struct Fts3Cursor { + sqlite3_vtab_cursor base; /* Base class used by SQLite core */ + i16 eSearch; /* Search strategy (see below) */ + u8 isEof; /* True if at End Of Results */ + u8 isRequireSeek; /* True if must seek pStmt to %_content row */ + u8 bSeekStmt; /* True if pStmt is a seek */ + sqlite3_stmt *pStmt; /* Prepared statement in use by the cursor */ + Fts3Expr *pExpr; /* Parsed MATCH query string */ + int iLangid; /* Language being queried for */ + int nPhrase; /* Number of matchable phrases in query */ + Fts3DeferredToken *pDeferred; /* Deferred search tokens, if any */ + sqlite3_int64 iPrevId; /* Previous id read from aDoclist */ + char *pNextId; /* Pointer into the body of aDoclist */ + char *aDoclist; /* List of docids for full-text queries */ + int nDoclist; /* Size of buffer at aDoclist */ + u8 bDesc; /* True to sort in descending order */ + int eEvalmode; /* An FTS3_EVAL_XX constant */ + int nRowAvg; /* Average size of database rows, in pages */ + sqlite3_int64 nDoc; /* Documents in table */ + i64 iMinDocid; /* Minimum docid to return */ + i64 iMaxDocid; /* Maximum docid to return */ + int isMatchinfoNeeded; /* True when aMatchinfo[] needs filling in */ + MatchinfoBuffer *pMIBuffer; /* Buffer for matchinfo data */ +}; + +#define FTS3_EVAL_FILTER 0 +#define FTS3_EVAL_NEXT 1 +#define FTS3_EVAL_MATCHINFO 2 + +/* +** The Fts3Cursor.eSearch member is always set to one of the following. +** Actualy, Fts3Cursor.eSearch can be greater than or equal to +** FTS3_FULLTEXT_SEARCH. If so, then Fts3Cursor.eSearch - 2 is the index +** of the column to be searched. For example, in +** +** CREATE VIRTUAL TABLE ex1 USING fts3(a,b,c,d); +** SELECT docid FROM ex1 WHERE b MATCH 'one two three'; +** +** Because the LHS of the MATCH operator is 2nd column "b", +** Fts3Cursor.eSearch will be set to FTS3_FULLTEXT_SEARCH+1. (+0 for a, +** +1 for b, +2 for c, +3 for d.) If the LHS of MATCH were "ex1" +** indicating that all columns should be searched, +** then eSearch would be set to FTS3_FULLTEXT_SEARCH+4. +*/ +#define FTS3_FULLSCAN_SEARCH 0 /* Linear scan of %_content table */ +#define FTS3_DOCID_SEARCH 1 /* Lookup by rowid on %_content table */ +#define FTS3_FULLTEXT_SEARCH 2 /* Full-text index search */ + +/* +** The lower 16-bits of the sqlite3_index_info.idxNum value set by +** the xBestIndex() method contains the Fts3Cursor.eSearch value described +** above. The upper 16-bits contain a combination of the following +** bits, used to describe extra constraints on full-text searches. +*/ +#define FTS3_HAVE_LANGID 0x00010000 /* languageid=? */ +#define FTS3_HAVE_DOCID_GE 0x00020000 /* docid>=? */ +#define FTS3_HAVE_DOCID_LE 0x00040000 /* docid<=? */ + +struct Fts3Doclist { + char *aAll; /* Array containing doclist (or NULL) */ + int nAll; /* Size of a[] in bytes */ + char *pNextDocid; /* Pointer to next docid */ + + sqlite3_int64 iDocid; /* Current docid (if pList!=0) */ + int bFreeList; /* True if pList should be sqlite3_free()d */ + char *pList; /* Pointer to position list following iDocid */ + int nList; /* Length of position list */ +}; + +/* +** A "phrase" is a sequence of one or more tokens that must match in +** sequence. A single token is the base case and the most common case. +** For a sequence of tokens contained in double-quotes (i.e. "one two three") +** nToken will be the number of tokens in the string. +*/ +struct Fts3PhraseToken { + char *z; /* Text of the token */ + int n; /* Number of bytes in buffer z */ + int isPrefix; /* True if token ends with a "*" character */ + int bFirst; /* True if token must appear at position 0 */ + + /* Variables above this point are populated when the expression is + ** parsed (by code in fts3_expr.c). Below this point the variables are + ** used when evaluating the expression. */ + Fts3DeferredToken *pDeferred; /* Deferred token object for this token */ + Fts3MultiSegReader *pSegcsr; /* Segment-reader for this token */ +}; + +struct Fts3Phrase { + /* Cache of doclist for this phrase. */ + Fts3Doclist doclist; + int bIncr; /* True if doclist is loaded incrementally */ + int iDoclistToken; + + /* Used by sqlite3Fts3EvalPhrasePoslist() if this is a descendent of an + ** OR condition. */ + char *pOrPoslist; + i64 iOrDocid; + + /* Variables below this point are populated by fts3_expr.c when parsing + ** a MATCH expression. Everything above is part of the evaluation phase. + */ + int nToken; /* Number of tokens in the phrase */ + int iColumn; /* Index of column this phrase must match */ + Fts3PhraseToken aToken[1]; /* One entry for each token in the phrase */ +}; + +/* +** A tree of these objects forms the RHS of a MATCH operator. +** +** If Fts3Expr.eType is FTSQUERY_PHRASE and isLoaded is true, then aDoclist +** points to a malloced buffer, size nDoclist bytes, containing the results +** of this phrase query in FTS3 doclist format. As usual, the initial +** "Length" field found in doclists stored on disk is omitted from this +** buffer. +** +** Variable aMI is used only for FTSQUERY_NEAR nodes to store the global +** matchinfo data. If it is not NULL, it points to an array of size nCol*3, +** where nCol is the number of columns in the queried FTS table. The array +** is populated as follows: +** +** aMI[iCol*3 + 0] = Undefined +** aMI[iCol*3 + 1] = Number of occurrences +** aMI[iCol*3 + 2] = Number of rows containing at least one instance +** +** The aMI array is allocated using sqlite3_malloc(). It should be freed +** when the expression node is. +*/ +struct Fts3Expr { + int eType; /* One of the FTSQUERY_XXX values defined below */ + int nNear; /* Valid if eType==FTSQUERY_NEAR */ + Fts3Expr *pParent; /* pParent->pLeft==this or pParent->pRight==this */ + Fts3Expr *pLeft; /* Left operand */ + Fts3Expr *pRight; /* Right operand */ + Fts3Phrase *pPhrase; /* Valid if eType==FTSQUERY_PHRASE */ + + /* The following are used by the fts3_eval.c module. */ + sqlite3_int64 iDocid; /* Current docid */ + u8 bEof; /* True this expression is at EOF already */ + u8 bStart; /* True if iDocid is valid */ + u8 bDeferred; /* True if this expression is entirely deferred */ + + /* The following are used by the fts3_snippet.c module. */ + int iPhrase; /* Index of this phrase in matchinfo() results */ + u32 *aMI; /* See above */ +}; + +/* +** Candidate values for Fts3Query.eType. Note that the order of the first +** four values is in order of precedence when parsing expressions. For +** example, the following: +** +** "a OR b AND c NOT d NEAR e" +** +** is equivalent to: +** +** "a OR (b AND (c NOT (d NEAR e)))" +*/ +#define FTSQUERY_NEAR 1 +#define FTSQUERY_NOT 2 +#define FTSQUERY_AND 3 +#define FTSQUERY_OR 4 +#define FTSQUERY_PHRASE 5 + + +/* fts3_write.c */ +SQLITE_PRIVATE int sqlite3Fts3UpdateMethod(sqlite3_vtab*,int,sqlite3_value**,sqlite3_int64*); +SQLITE_PRIVATE int sqlite3Fts3PendingTermsFlush(Fts3Table *); +SQLITE_PRIVATE void sqlite3Fts3PendingTermsClear(Fts3Table *); +SQLITE_PRIVATE int sqlite3Fts3Optimize(Fts3Table *); +SQLITE_PRIVATE int sqlite3Fts3SegReaderNew(int, int, sqlite3_int64, + sqlite3_int64, sqlite3_int64, const char *, int, Fts3SegReader**); +SQLITE_PRIVATE int sqlite3Fts3SegReaderPending( + Fts3Table*,int,const char*,int,int,Fts3SegReader**); +SQLITE_PRIVATE void sqlite3Fts3SegReaderFree(Fts3SegReader *); +SQLITE_PRIVATE int sqlite3Fts3AllSegdirs(Fts3Table*, int, int, int, sqlite3_stmt **); +SQLITE_PRIVATE int sqlite3Fts3ReadBlock(Fts3Table*, sqlite3_int64, char **, int*, int*); + +SQLITE_PRIVATE int sqlite3Fts3SelectDoctotal(Fts3Table *, sqlite3_stmt **); +SQLITE_PRIVATE int sqlite3Fts3SelectDocsize(Fts3Table *, sqlite3_int64, sqlite3_stmt **); + +#ifndef SQLITE_DISABLE_FTS4_DEFERRED +SQLITE_PRIVATE void sqlite3Fts3FreeDeferredTokens(Fts3Cursor *); +SQLITE_PRIVATE int sqlite3Fts3DeferToken(Fts3Cursor *, Fts3PhraseToken *, int); +SQLITE_PRIVATE int sqlite3Fts3CacheDeferredDoclists(Fts3Cursor *); +SQLITE_PRIVATE void sqlite3Fts3FreeDeferredDoclists(Fts3Cursor *); +SQLITE_PRIVATE int sqlite3Fts3DeferredTokenList(Fts3DeferredToken *, char **, int *); +#else +# define sqlite3Fts3FreeDeferredTokens(x) +# define sqlite3Fts3DeferToken(x,y,z) SQLITE_OK +# define sqlite3Fts3CacheDeferredDoclists(x) SQLITE_OK +# define sqlite3Fts3FreeDeferredDoclists(x) +# define sqlite3Fts3DeferredTokenList(x,y,z) SQLITE_OK +#endif + +SQLITE_PRIVATE void sqlite3Fts3SegmentsClose(Fts3Table *); +SQLITE_PRIVATE int sqlite3Fts3MaxLevel(Fts3Table *, int *); + +/* Special values interpreted by sqlite3SegReaderCursor() */ +#define FTS3_SEGCURSOR_PENDING -1 +#define FTS3_SEGCURSOR_ALL -2 + +SQLITE_PRIVATE int sqlite3Fts3SegReaderStart(Fts3Table*, Fts3MultiSegReader*, Fts3SegFilter*); +SQLITE_PRIVATE int sqlite3Fts3SegReaderStep(Fts3Table *, Fts3MultiSegReader *); +SQLITE_PRIVATE void sqlite3Fts3SegReaderFinish(Fts3MultiSegReader *); + +SQLITE_PRIVATE int sqlite3Fts3SegReaderCursor(Fts3Table *, + int, int, int, const char *, int, int, int, Fts3MultiSegReader *); + +/* Flags allowed as part of the 4th argument to SegmentReaderIterate() */ +#define FTS3_SEGMENT_REQUIRE_POS 0x00000001 +#define FTS3_SEGMENT_IGNORE_EMPTY 0x00000002 +#define FTS3_SEGMENT_COLUMN_FILTER 0x00000004 +#define FTS3_SEGMENT_PREFIX 0x00000008 +#define FTS3_SEGMENT_SCAN 0x00000010 +#define FTS3_SEGMENT_FIRST 0x00000020 + +/* Type passed as 4th argument to SegmentReaderIterate() */ +struct Fts3SegFilter { + const char *zTerm; + int nTerm; + int iCol; + int flags; +}; + +struct Fts3MultiSegReader { + /* Used internally by sqlite3Fts3SegReaderXXX() calls */ + Fts3SegReader **apSegment; /* Array of Fts3SegReader objects */ + int nSegment; /* Size of apSegment array */ + int nAdvance; /* How many seg-readers to advance */ + Fts3SegFilter *pFilter; /* Pointer to filter object */ + char *aBuffer; /* Buffer to merge doclists in */ + int nBuffer; /* Allocated size of aBuffer[] in bytes */ + + int iColFilter; /* If >=0, filter for this column */ + int bRestart; + + /* Used by fts3.c only. */ + int nCost; /* Cost of running iterator */ + int bLookup; /* True if a lookup of a single entry. */ + + /* Output values. Valid only after Fts3SegReaderStep() returns SQLITE_ROW. */ + char *zTerm; /* Pointer to term buffer */ + int nTerm; /* Size of zTerm in bytes */ + char *aDoclist; /* Pointer to doclist buffer */ + int nDoclist; /* Size of aDoclist[] in bytes */ +}; + +SQLITE_PRIVATE int sqlite3Fts3Incrmerge(Fts3Table*,int,int); + +#define fts3GetVarint32(p, piVal) ( \ + (*(u8*)(p)&0x80) ? sqlite3Fts3GetVarint32(p, piVal) : (*piVal=*(u8*)(p), 1) \ +) + +/* fts3.c */ +SQLITE_PRIVATE void sqlite3Fts3ErrMsg(char**,const char*,...); +SQLITE_PRIVATE int sqlite3Fts3PutVarint(char *, sqlite3_int64); +SQLITE_PRIVATE int sqlite3Fts3GetVarint(const char *, sqlite_int64 *); +SQLITE_PRIVATE int sqlite3Fts3GetVarintU(const char *, sqlite_uint64 *); +SQLITE_PRIVATE int sqlite3Fts3GetVarintBounded(const char*,const char*,sqlite3_int64*); +SQLITE_PRIVATE int sqlite3Fts3GetVarint32(const char *, int *); +SQLITE_PRIVATE int sqlite3Fts3VarintLen(sqlite3_uint64); +SQLITE_PRIVATE void sqlite3Fts3Dequote(char *); +SQLITE_PRIVATE void sqlite3Fts3DoclistPrev(int,char*,int,char**,sqlite3_int64*,int*,u8*); +SQLITE_PRIVATE int sqlite3Fts3EvalPhraseStats(Fts3Cursor *, Fts3Expr *, u32 *); +SQLITE_PRIVATE int sqlite3Fts3FirstFilter(sqlite3_int64, char *, int, char *); +SQLITE_PRIVATE void sqlite3Fts3CreateStatTable(int*, Fts3Table*); +SQLITE_PRIVATE int sqlite3Fts3EvalTestDeferred(Fts3Cursor *pCsr, int *pRc); +SQLITE_PRIVATE int sqlite3Fts3ReadInt(const char *z, int *pnOut); + +/* fts3_tokenizer.c */ +SQLITE_PRIVATE const char *sqlite3Fts3NextToken(const char *, int *); +SQLITE_PRIVATE int sqlite3Fts3InitHashTable(sqlite3 *, Fts3Hash *, const char *); +SQLITE_PRIVATE int sqlite3Fts3InitTokenizer(Fts3Hash *pHash, const char *, + sqlite3_tokenizer **, char ** +); +SQLITE_PRIVATE int sqlite3Fts3IsIdChar(char); + +/* fts3_snippet.c */ +SQLITE_PRIVATE void sqlite3Fts3Offsets(sqlite3_context*, Fts3Cursor*); +SQLITE_PRIVATE void sqlite3Fts3Snippet(sqlite3_context *, Fts3Cursor *, const char *, + const char *, const char *, int, int +); +SQLITE_PRIVATE void sqlite3Fts3Matchinfo(sqlite3_context *, Fts3Cursor *, const char *); +SQLITE_PRIVATE void sqlite3Fts3MIBufferFree(MatchinfoBuffer *p); + +/* fts3_expr.c */ +SQLITE_PRIVATE int sqlite3Fts3ExprParse(sqlite3_tokenizer *, int, + char **, int, int, int, const char *, int, Fts3Expr **, char ** +); +SQLITE_PRIVATE void sqlite3Fts3ExprFree(Fts3Expr *); +#ifdef SQLITE_TEST +SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3 *db, Fts3Hash*); +SQLITE_PRIVATE int sqlite3Fts3InitTerm(sqlite3 *db); +#endif + +SQLITE_PRIVATE int sqlite3Fts3OpenTokenizer(sqlite3_tokenizer *, int, const char *, int, + sqlite3_tokenizer_cursor ** +); + +/* fts3_aux.c */ +SQLITE_PRIVATE int sqlite3Fts3InitAux(sqlite3 *db); + +SQLITE_PRIVATE void sqlite3Fts3EvalPhraseCleanup(Fts3Phrase *); + +SQLITE_PRIVATE int sqlite3Fts3MsrIncrStart( + Fts3Table*, Fts3MultiSegReader*, int, const char*, int); +SQLITE_PRIVATE int sqlite3Fts3MsrIncrNext( + Fts3Table *, Fts3MultiSegReader *, sqlite3_int64 *, char **, int *); +SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol, char **); +SQLITE_PRIVATE int sqlite3Fts3MsrOvfl(Fts3Cursor *, Fts3MultiSegReader *, int *); +SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr); + +/* fts3_tokenize_vtab.c */ +SQLITE_PRIVATE int sqlite3Fts3InitTok(sqlite3*, Fts3Hash *); + +/* fts3_unicode2.c (functions generated by parsing unicode text files) */ +#ifndef SQLITE_DISABLE_FTS3_UNICODE +SQLITE_PRIVATE int sqlite3FtsUnicodeFold(int, int); +SQLITE_PRIVATE int sqlite3FtsUnicodeIsalnum(int); +SQLITE_PRIVATE int sqlite3FtsUnicodeIsdiacritic(int); +#endif + +#endif /* !SQLITE_CORE || SQLITE_ENABLE_FTS3 */ +#endif /* _FTSINT_H */ + +/************** End of fts3Int.h *********************************************/ +/************** Continuing where we left off in fts3.c ***********************/ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +#if defined(SQLITE_ENABLE_FTS3) && !defined(SQLITE_CORE) +# define SQLITE_CORE 1 +#endif + +/* #include */ +/* #include */ +/* #include */ +/* #include */ +/* #include */ +/* #include */ + +/* #include "fts3.h" */ +#ifndef SQLITE_CORE +/* # include "sqlite3ext.h" */ + SQLITE_EXTENSION_INIT1 +#endif + +static int fts3EvalNext(Fts3Cursor *pCsr); +static int fts3EvalStart(Fts3Cursor *pCsr); +static int fts3TermSegReaderCursor( + Fts3Cursor *, const char *, int, int, Fts3MultiSegReader **); + +#ifndef SQLITE_AMALGAMATION +# if defined(SQLITE_DEBUG) +SQLITE_PRIVATE int sqlite3Fts3Always(int b) { assert( b ); return b; } +SQLITE_PRIVATE int sqlite3Fts3Never(int b) { assert( !b ); return b; } +# endif +#endif + +/* +** This variable is set to false when running tests for which the on disk +** structures should not be corrupt. Otherwise, true. If it is false, extra +** assert() conditions in the fts3 code are activated - conditions that are +** only true if it is guaranteed that the fts3 database is not corrupt. +*/ +SQLITE_API int sqlite3_fts3_may_be_corrupt = 1; + +/* +** Write a 64-bit variable-length integer to memory starting at p[0]. +** The length of data written will be between 1 and FTS3_VARINT_MAX bytes. +** The number of bytes written is returned. +*/ +SQLITE_PRIVATE int sqlite3Fts3PutVarint(char *p, sqlite_int64 v){ + unsigned char *q = (unsigned char *) p; + sqlite_uint64 vu = v; + do{ + *q++ = (unsigned char) ((vu & 0x7f) | 0x80); + vu >>= 7; + }while( vu!=0 ); + q[-1] &= 0x7f; /* turn off high bit in final byte */ + assert( q - (unsigned char *)p <= FTS3_VARINT_MAX ); + return (int) (q - (unsigned char *)p); +} + +#define GETVARINT_STEP(v, ptr, shift, mask1, mask2, var, ret) \ + v = (v & mask1) | ( (*(const unsigned char*)(ptr++)) << shift ); \ + if( (v & mask2)==0 ){ var = v; return ret; } +#define GETVARINT_INIT(v, ptr, shift, mask1, mask2, var, ret) \ + v = (*ptr++); \ + if( (v & mask2)==0 ){ var = v; return ret; } + +SQLITE_PRIVATE int sqlite3Fts3GetVarintU(const char *pBuf, sqlite_uint64 *v){ + const unsigned char *p = (const unsigned char*)pBuf; + const unsigned char *pStart = p; + u32 a; + u64 b; + int shift; + + GETVARINT_INIT(a, p, 0, 0x00, 0x80, *v, 1); + GETVARINT_STEP(a, p, 7, 0x7F, 0x4000, *v, 2); + GETVARINT_STEP(a, p, 14, 0x3FFF, 0x200000, *v, 3); + GETVARINT_STEP(a, p, 21, 0x1FFFFF, 0x10000000, *v, 4); + b = (a & 0x0FFFFFFF ); + + for(shift=28; shift<=63; shift+=7){ + u64 c = *p++; + b += (c&0x7F) << shift; + if( (c & 0x80)==0 ) break; + } + *v = b; + return (int)(p - pStart); +} + +/* +** Read a 64-bit variable-length integer from memory starting at p[0]. +** Return the number of bytes read, or 0 on error. +** The value is stored in *v. +*/ +SQLITE_PRIVATE int sqlite3Fts3GetVarint(const char *pBuf, sqlite_int64 *v){ + return sqlite3Fts3GetVarintU(pBuf, (sqlite3_uint64*)v); +} + +/* +** Read a 64-bit variable-length integer from memory starting at p[0] and +** not extending past pEnd[-1]. +** Return the number of bytes read, or 0 on error. +** The value is stored in *v. +*/ +SQLITE_PRIVATE int sqlite3Fts3GetVarintBounded( + const char *pBuf, + const char *pEnd, + sqlite_int64 *v +){ + const unsigned char *p = (const unsigned char*)pBuf; + const unsigned char *pStart = p; + const unsigned char *pX = (const unsigned char*)pEnd; + u64 b = 0; + int shift; + for(shift=0; shift<=63; shift+=7){ + u64 c = p=0 ); + return 5; +} + +/* +** Return the number of bytes required to encode v as a varint +*/ +SQLITE_PRIVATE int sqlite3Fts3VarintLen(sqlite3_uint64 v){ + int i = 0; + do{ + i++; + v >>= 7; + }while( v!=0 ); + return i; +} + +/* +** Convert an SQL-style quoted string into a normal string by removing +** the quote characters. The conversion is done in-place. If the +** input does not begin with a quote character, then this routine +** is a no-op. +** +** Examples: +** +** "abc" becomes abc +** 'xyz' becomes xyz +** [pqr] becomes pqr +** `mno` becomes mno +** +*/ +SQLITE_PRIVATE void sqlite3Fts3Dequote(char *z){ + char quote; /* Quote character (if any ) */ + + quote = z[0]; + if( quote=='[' || quote=='\'' || quote=='"' || quote=='`' ){ + int iIn = 1; /* Index of next byte to read from input */ + int iOut = 0; /* Index of next byte to write to output */ + + /* If the first byte was a '[', then the close-quote character is a ']' */ + if( quote=='[' ) quote = ']'; + + while( z[iIn] ){ + if( z[iIn]==quote ){ + if( z[iIn+1]!=quote ) break; + z[iOut++] = quote; + iIn += 2; + }else{ + z[iOut++] = z[iIn++]; + } + } + z[iOut] = '\0'; + } +} + +/* +** Read a single varint from the doclist at *pp and advance *pp to point +** to the first byte past the end of the varint. Add the value of the varint +** to *pVal. +*/ +static void fts3GetDeltaVarint(char **pp, sqlite3_int64 *pVal){ + sqlite3_int64 iVal; + *pp += sqlite3Fts3GetVarint(*pp, &iVal); + *pVal += iVal; +} + +/* +** When this function is called, *pp points to the first byte following a +** varint that is part of a doclist (or position-list, or any other list +** of varints). This function moves *pp to point to the start of that varint, +** and sets *pVal by the varint value. +** +** Argument pStart points to the first byte of the doclist that the +** varint is part of. +*/ +static void fts3GetReverseVarint( + char **pp, + char *pStart, + sqlite3_int64 *pVal +){ + sqlite3_int64 iVal; + char *p; + + /* Pointer p now points at the first byte past the varint we are + ** interested in. So, unless the doclist is corrupt, the 0x80 bit is + ** clear on character p[-1]. */ + for(p = (*pp)-2; p>=pStart && *p&0x80; p--); + p++; + *pp = p; + + sqlite3Fts3GetVarint(p, &iVal); + *pVal = iVal; +} + +/* +** The xDisconnect() virtual table method. +*/ +static int fts3DisconnectMethod(sqlite3_vtab *pVtab){ + Fts3Table *p = (Fts3Table *)pVtab; + int i; + + assert( p->nPendingData==0 ); + assert( p->pSegments==0 ); + + /* Free any prepared statements held */ + sqlite3_finalize(p->pSeekStmt); + for(i=0; iaStmt); i++){ + sqlite3_finalize(p->aStmt[i]); + } + sqlite3_free(p->zSegmentsTbl); + sqlite3_free(p->zReadExprlist); + sqlite3_free(p->zWriteExprlist); + sqlite3_free(p->zContentTbl); + sqlite3_free(p->zLanguageid); + + /* Invoke the tokenizer destructor to free the tokenizer. */ + p->pTokenizer->pModule->xDestroy(p->pTokenizer); + + sqlite3_free(p); + return SQLITE_OK; +} + +/* +** Write an error message into *pzErr +*/ +SQLITE_PRIVATE void sqlite3Fts3ErrMsg(char **pzErr, const char *zFormat, ...){ + va_list ap; + sqlite3_free(*pzErr); + va_start(ap, zFormat); + *pzErr = sqlite3_vmprintf(zFormat, ap); + va_end(ap); +} + +/* +** Construct one or more SQL statements from the format string given +** and then evaluate those statements. The success code is written +** into *pRc. +** +** If *pRc is initially non-zero then this routine is a no-op. +*/ +static void fts3DbExec( + int *pRc, /* Success code */ + sqlite3 *db, /* Database in which to run SQL */ + const char *zFormat, /* Format string for SQL */ + ... /* Arguments to the format string */ +){ + va_list ap; + char *zSql; + if( *pRc ) return; + va_start(ap, zFormat); + zSql = sqlite3_vmprintf(zFormat, ap); + va_end(ap); + if( zSql==0 ){ + *pRc = SQLITE_NOMEM; + }else{ + *pRc = sqlite3_exec(db, zSql, 0, 0, 0); + sqlite3_free(zSql); + } +} + +/* +** The xDestroy() virtual table method. +*/ +static int fts3DestroyMethod(sqlite3_vtab *pVtab){ + Fts3Table *p = (Fts3Table *)pVtab; + int rc = SQLITE_OK; /* Return code */ + const char *zDb = p->zDb; /* Name of database (e.g. "main", "temp") */ + sqlite3 *db = p->db; /* Database handle */ + + /* Drop the shadow tables */ + fts3DbExec(&rc, db, + "DROP TABLE IF EXISTS %Q.'%q_segments';" + "DROP TABLE IF EXISTS %Q.'%q_segdir';" + "DROP TABLE IF EXISTS %Q.'%q_docsize';" + "DROP TABLE IF EXISTS %Q.'%q_stat';" + "%s DROP TABLE IF EXISTS %Q.'%q_content';", + zDb, p->zName, + zDb, p->zName, + zDb, p->zName, + zDb, p->zName, + (p->zContentTbl ? "--" : ""), zDb,p->zName + ); + + /* If everything has worked, invoke fts3DisconnectMethod() to free the + ** memory associated with the Fts3Table structure and return SQLITE_OK. + ** Otherwise, return an SQLite error code. + */ + return (rc==SQLITE_OK ? fts3DisconnectMethod(pVtab) : rc); +} + + +/* +** Invoke sqlite3_declare_vtab() to declare the schema for the FTS3 table +** passed as the first argument. This is done as part of the xConnect() +** and xCreate() methods. +** +** If *pRc is non-zero when this function is called, it is a no-op. +** Otherwise, if an error occurs, an SQLite error code is stored in *pRc +** before returning. +*/ +static void fts3DeclareVtab(int *pRc, Fts3Table *p){ + if( *pRc==SQLITE_OK ){ + int i; /* Iterator variable */ + int rc; /* Return code */ + char *zSql; /* SQL statement passed to declare_vtab() */ + char *zCols; /* List of user defined columns */ + const char *zLanguageid; + + zLanguageid = (p->zLanguageid ? p->zLanguageid : "__langid"); + sqlite3_vtab_config(p->db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1); + + /* Create a list of user columns for the virtual table */ + zCols = sqlite3_mprintf("%Q, ", p->azColumn[0]); + for(i=1; zCols && inColumn; i++){ + zCols = sqlite3_mprintf("%z%Q, ", zCols, p->azColumn[i]); + } + + /* Create the whole "CREATE TABLE" statement to pass to SQLite */ + zSql = sqlite3_mprintf( + "CREATE TABLE x(%s %Q HIDDEN, docid HIDDEN, %Q HIDDEN)", + zCols, p->zName, zLanguageid + ); + if( !zCols || !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_declare_vtab(p->db, zSql); + } + + sqlite3_free(zSql); + sqlite3_free(zCols); + *pRc = rc; + } +} + +/* +** Create the %_stat table if it does not already exist. +*/ +SQLITE_PRIVATE void sqlite3Fts3CreateStatTable(int *pRc, Fts3Table *p){ + fts3DbExec(pRc, p->db, + "CREATE TABLE IF NOT EXISTS %Q.'%q_stat'" + "(id INTEGER PRIMARY KEY, value BLOB);", + p->zDb, p->zName + ); + if( (*pRc)==SQLITE_OK ) p->bHasStat = 1; +} + +/* +** Create the backing store tables (%_content, %_segments and %_segdir) +** required by the FTS3 table passed as the only argument. This is done +** as part of the vtab xCreate() method. +** +** If the p->bHasDocsize boolean is true (indicating that this is an +** FTS4 table, not an FTS3 table) then also create the %_docsize and +** %_stat tables required by FTS4. +*/ +static int fts3CreateTables(Fts3Table *p){ + int rc = SQLITE_OK; /* Return code */ + int i; /* Iterator variable */ + sqlite3 *db = p->db; /* The database connection */ + + if( p->zContentTbl==0 ){ + const char *zLanguageid = p->zLanguageid; + char *zContentCols; /* Columns of %_content table */ + + /* Create a list of user columns for the content table */ + zContentCols = sqlite3_mprintf("docid INTEGER PRIMARY KEY"); + for(i=0; zContentCols && inColumn; i++){ + char *z = p->azColumn[i]; + zContentCols = sqlite3_mprintf("%z, 'c%d%q'", zContentCols, i, z); + } + if( zLanguageid && zContentCols ){ + zContentCols = sqlite3_mprintf("%z, langid", zContentCols, zLanguageid); + } + if( zContentCols==0 ) rc = SQLITE_NOMEM; + + /* Create the content table */ + fts3DbExec(&rc, db, + "CREATE TABLE %Q.'%q_content'(%s)", + p->zDb, p->zName, zContentCols + ); + sqlite3_free(zContentCols); + } + + /* Create other tables */ + fts3DbExec(&rc, db, + "CREATE TABLE %Q.'%q_segments'(blockid INTEGER PRIMARY KEY, block BLOB);", + p->zDb, p->zName + ); + fts3DbExec(&rc, db, + "CREATE TABLE %Q.'%q_segdir'(" + "level INTEGER," + "idx INTEGER," + "start_block INTEGER," + "leaves_end_block INTEGER," + "end_block INTEGER," + "root BLOB," + "PRIMARY KEY(level, idx)" + ");", + p->zDb, p->zName + ); + if( p->bHasDocsize ){ + fts3DbExec(&rc, db, + "CREATE TABLE %Q.'%q_docsize'(docid INTEGER PRIMARY KEY, size BLOB);", + p->zDb, p->zName + ); + } + assert( p->bHasStat==p->bFts4 ); + if( p->bHasStat ){ + sqlite3Fts3CreateStatTable(&rc, p); + } + return rc; +} + +/* +** Store the current database page-size in bytes in p->nPgsz. +** +** If *pRc is non-zero when this function is called, it is a no-op. +** Otherwise, if an error occurs, an SQLite error code is stored in *pRc +** before returning. +*/ +static void fts3DatabasePageSize(int *pRc, Fts3Table *p){ + if( *pRc==SQLITE_OK ){ + int rc; /* Return code */ + char *zSql; /* SQL text "PRAGMA %Q.page_size" */ + sqlite3_stmt *pStmt; /* Compiled "PRAGMA %Q.page_size" statement */ + + zSql = sqlite3_mprintf("PRAGMA %Q.page_size", p->zDb); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_step(pStmt); + p->nPgsz = sqlite3_column_int(pStmt, 0); + rc = sqlite3_finalize(pStmt); + }else if( rc==SQLITE_AUTH ){ + p->nPgsz = 1024; + rc = SQLITE_OK; + } + } + assert( p->nPgsz>0 || rc!=SQLITE_OK ); + sqlite3_free(zSql); + *pRc = rc; + } +} + +/* +** "Special" FTS4 arguments are column specifications of the following form: +** +** = +** +** There may not be whitespace surrounding the "=" character. The +** term may be quoted, but the may not. +*/ +static int fts3IsSpecialColumn( + const char *z, + int *pnKey, + char **pzValue +){ + char *zValue; + const char *zCsr = z; + + while( *zCsr!='=' ){ + if( *zCsr=='\0' ) return 0; + zCsr++; + } + + *pnKey = (int)(zCsr-z); + zValue = sqlite3_mprintf("%s", &zCsr[1]); + if( zValue ){ + sqlite3Fts3Dequote(zValue); + } + *pzValue = zValue; + return 1; +} + +/* +** Append the output of a printf() style formatting to an existing string. +*/ +static void fts3Appendf( + int *pRc, /* IN/OUT: Error code */ + char **pz, /* IN/OUT: Pointer to string buffer */ + const char *zFormat, /* Printf format string to append */ + ... /* Arguments for printf format string */ +){ + if( *pRc==SQLITE_OK ){ + va_list ap; + char *z; + va_start(ap, zFormat); + z = sqlite3_vmprintf(zFormat, ap); + va_end(ap); + if( z && *pz ){ + char *z2 = sqlite3_mprintf("%s%s", *pz, z); + sqlite3_free(z); + z = z2; + } + if( z==0 ) *pRc = SQLITE_NOMEM; + sqlite3_free(*pz); + *pz = z; + } +} + +/* +** Return a copy of input string zInput enclosed in double-quotes (") and +** with all double quote characters escaped. For example: +** +** fts3QuoteId("un \"zip\"") -> "un \"\"zip\"\"" +** +** The pointer returned points to memory obtained from sqlite3_malloc(). It +** is the callers responsibility to call sqlite3_free() to release this +** memory. +*/ +static char *fts3QuoteId(char const *zInput){ + sqlite3_int64 nRet; + char *zRet; + nRet = 2 + (int)strlen(zInput)*2 + 1; + zRet = sqlite3_malloc64(nRet); + if( zRet ){ + int i; + char *z = zRet; + *(z++) = '"'; + for(i=0; zInput[i]; i++){ + if( zInput[i]=='"' ) *(z++) = '"'; + *(z++) = zInput[i]; + } + *(z++) = '"'; + *(z++) = '\0'; + } + return zRet; +} + +/* +** Return a list of comma separated SQL expressions and a FROM clause that +** could be used in a SELECT statement such as the following: +** +** SELECT FROM %_content AS x ... +** +** to return the docid, followed by each column of text data in order +** from left to write. If parameter zFunc is not NULL, then instead of +** being returned directly each column of text data is passed to an SQL +** function named zFunc first. For example, if zFunc is "unzip" and the +** table has the three user-defined columns "a", "b", and "c", the following +** string is returned: +** +** "docid, unzip(x.'a'), unzip(x.'b'), unzip(x.'c') FROM %_content AS x" +** +** The pointer returned points to a buffer allocated by sqlite3_malloc(). It +** is the responsibility of the caller to eventually free it. +** +** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and +** a NULL pointer is returned). Otherwise, if an OOM error is encountered +** by this function, NULL is returned and *pRc is set to SQLITE_NOMEM. If +** no error occurs, *pRc is left unmodified. +*/ +static char *fts3ReadExprList(Fts3Table *p, const char *zFunc, int *pRc){ + char *zRet = 0; + char *zFree = 0; + char *zFunction; + int i; + + if( p->zContentTbl==0 ){ + if( !zFunc ){ + zFunction = ""; + }else{ + zFree = zFunction = fts3QuoteId(zFunc); + } + fts3Appendf(pRc, &zRet, "docid"); + for(i=0; inColumn; i++){ + fts3Appendf(pRc, &zRet, ",%s(x.'c%d%q')", zFunction, i, p->azColumn[i]); + } + if( p->zLanguageid ){ + fts3Appendf(pRc, &zRet, ", x.%Q", "langid"); + } + sqlite3_free(zFree); + }else{ + fts3Appendf(pRc, &zRet, "rowid"); + for(i=0; inColumn; i++){ + fts3Appendf(pRc, &zRet, ", x.'%q'", p->azColumn[i]); + } + if( p->zLanguageid ){ + fts3Appendf(pRc, &zRet, ", x.%Q", p->zLanguageid); + } + } + fts3Appendf(pRc, &zRet, " FROM '%q'.'%q%s' AS x", + p->zDb, + (p->zContentTbl ? p->zContentTbl : p->zName), + (p->zContentTbl ? "" : "_content") + ); + return zRet; +} + +/* +** Return a list of N comma separated question marks, where N is the number +** of columns in the %_content table (one for the docid plus one for each +** user-defined text column). +** +** If argument zFunc is not NULL, then all but the first question mark +** is preceded by zFunc and an open bracket, and followed by a closed +** bracket. For example, if zFunc is "zip" and the FTS3 table has three +** user-defined text columns, the following string is returned: +** +** "?, zip(?), zip(?), zip(?)" +** +** The pointer returned points to a buffer allocated by sqlite3_malloc(). It +** is the responsibility of the caller to eventually free it. +** +** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and +** a NULL pointer is returned). Otherwise, if an OOM error is encountered +** by this function, NULL is returned and *pRc is set to SQLITE_NOMEM. If +** no error occurs, *pRc is left unmodified. +*/ +static char *fts3WriteExprList(Fts3Table *p, const char *zFunc, int *pRc){ + char *zRet = 0; + char *zFree = 0; + char *zFunction; + int i; + + if( !zFunc ){ + zFunction = ""; + }else{ + zFree = zFunction = fts3QuoteId(zFunc); + } + fts3Appendf(pRc, &zRet, "?"); + for(i=0; inColumn; i++){ + fts3Appendf(pRc, &zRet, ",%s(?)", zFunction); + } + if( p->zLanguageid ){ + fts3Appendf(pRc, &zRet, ", ?"); + } + sqlite3_free(zFree); + return zRet; +} + +/* +** Buffer z contains a positive integer value encoded as utf-8 text. +** Decode this value and store it in *pnOut, returning the number of bytes +** consumed. If an overflow error occurs return a negative value. +*/ +SQLITE_PRIVATE int sqlite3Fts3ReadInt(const char *z, int *pnOut){ + u64 iVal = 0; + int i; + for(i=0; z[i]>='0' && z[i]<='9'; i++){ + iVal = iVal*10 + (z[i] - '0'); + if( iVal>0x7FFFFFFF ) return -1; + } + *pnOut = (int)iVal; + return i; +} + +/* +** This function interprets the string at (*pp) as a non-negative integer +** value. It reads the integer and sets *pnOut to the value read, then +** sets *pp to point to the byte immediately following the last byte of +** the integer value. +** +** Only decimal digits ('0'..'9') may be part of an integer value. +** +** If *pp does not being with a decimal digit SQLITE_ERROR is returned and +** the output value undefined. Otherwise SQLITE_OK is returned. +** +** This function is used when parsing the "prefix=" FTS4 parameter. +*/ +static int fts3GobbleInt(const char **pp, int *pnOut){ + const int MAX_NPREFIX = 10000000; + int nInt = 0; /* Output value */ + int nByte; + nByte = sqlite3Fts3ReadInt(*pp, &nInt); + if( nInt>MAX_NPREFIX ){ + nInt = 0; + } + if( nByte==0 ){ + return SQLITE_ERROR; + } + *pnOut = nInt; + *pp += nByte; + return SQLITE_OK; +} + +/* +** This function is called to allocate an array of Fts3Index structures +** representing the indexes maintained by the current FTS table. FTS tables +** always maintain the main "terms" index, but may also maintain one or +** more "prefix" indexes, depending on the value of the "prefix=" parameter +** (if any) specified as part of the CREATE VIRTUAL TABLE statement. +** +** Argument zParam is passed the value of the "prefix=" option if one was +** specified, or NULL otherwise. +** +** If no error occurs, SQLITE_OK is returned and *apIndex set to point to +** the allocated array. *pnIndex is set to the number of elements in the +** array. If an error does occur, an SQLite error code is returned. +** +** Regardless of whether or not an error is returned, it is the responsibility +** of the caller to call sqlite3_free() on the output array to free it. +*/ +static int fts3PrefixParameter( + const char *zParam, /* ABC in prefix=ABC parameter to parse */ + int *pnIndex, /* OUT: size of *apIndex[] array */ + struct Fts3Index **apIndex /* OUT: Array of indexes for this table */ +){ + struct Fts3Index *aIndex; /* Allocated array */ + int nIndex = 1; /* Number of entries in array */ + + if( zParam && zParam[0] ){ + const char *p; + nIndex++; + for(p=zParam; *p; p++){ + if( *p==',' ) nIndex++; + } + } + + aIndex = sqlite3_malloc64(sizeof(struct Fts3Index) * nIndex); + *apIndex = aIndex; + if( !aIndex ){ + return SQLITE_NOMEM; + } + + memset(aIndex, 0, sizeof(struct Fts3Index) * nIndex); + if( zParam ){ + const char *p = zParam; + int i; + for(i=1; i=0 ); + if( nPrefix==0 ){ + nIndex--; + i--; + }else{ + aIndex[i].nPrefix = nPrefix; + } + p++; + } + } + + *pnIndex = nIndex; + return SQLITE_OK; +} + +/* +** This function is called when initializing an FTS4 table that uses the +** content=xxx option. It determines the number of and names of the columns +** of the new FTS4 table. +** +** The third argument passed to this function is the value passed to the +** config=xxx option (i.e. "xxx"). This function queries the database for +** a table of that name. If found, the output variables are populated +** as follows: +** +** *pnCol: Set to the number of columns table xxx has, +** +** *pnStr: Set to the total amount of space required to store a copy +** of each columns name, including the nul-terminator. +** +** *pazCol: Set to point to an array of *pnCol strings. Each string is +** the name of the corresponding column in table xxx. The array +** and its contents are allocated using a single allocation. It +** is the responsibility of the caller to free this allocation +** by eventually passing the *pazCol value to sqlite3_free(). +** +** If the table cannot be found, an error code is returned and the output +** variables are undefined. Or, if an OOM is encountered, SQLITE_NOMEM is +** returned (and the output variables are undefined). +*/ +static int fts3ContentColumns( + sqlite3 *db, /* Database handle */ + const char *zDb, /* Name of db (i.e. "main", "temp" etc.) */ + const char *zTbl, /* Name of content table */ + const char ***pazCol, /* OUT: Malloc'd array of column names */ + int *pnCol, /* OUT: Size of array *pazCol */ + int *pnStr, /* OUT: Bytes of string content */ + char **pzErr /* OUT: error message */ +){ + int rc = SQLITE_OK; /* Return code */ + char *zSql; /* "SELECT *" statement on zTbl */ + sqlite3_stmt *pStmt = 0; /* Compiled version of zSql */ + + zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q", zDb, zTbl); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0); + if( rc!=SQLITE_OK ){ + sqlite3Fts3ErrMsg(pzErr, "%s", sqlite3_errmsg(db)); + } + } + sqlite3_free(zSql); + + if( rc==SQLITE_OK ){ + const char **azCol; /* Output array */ + sqlite3_int64 nStr = 0; /* Size of all column names (incl. 0x00) */ + int nCol; /* Number of table columns */ + int i; /* Used to iterate through columns */ + + /* Loop through the returned columns. Set nStr to the number of bytes of + ** space required to store a copy of each column name, including the + ** nul-terminator byte. */ + nCol = sqlite3_column_count(pStmt); + for(i=0; i module name ("fts3" or "fts4") +** argv[1] -> database name +** argv[2] -> table name +** argv[...] -> "column name" and other module argument fields. +*/ +static int fts3InitVtab( + int isCreate, /* True for xCreate, false for xConnect */ + sqlite3 *db, /* The SQLite database connection */ + void *pAux, /* Hash table containing tokenizers */ + int argc, /* Number of elements in argv array */ + const char * const *argv, /* xCreate/xConnect argument array */ + sqlite3_vtab **ppVTab, /* Write the resulting vtab structure here */ + char **pzErr /* Write any error message here */ +){ + Fts3Hash *pHash = (Fts3Hash *)pAux; + Fts3Table *p = 0; /* Pointer to allocated vtab */ + int rc = SQLITE_OK; /* Return code */ + int i; /* Iterator variable */ + sqlite3_int64 nByte; /* Size of allocation used for *p */ + int iCol; /* Column index */ + int nString = 0; /* Bytes required to hold all column names */ + int nCol = 0; /* Number of columns in the FTS table */ + char *zCsr; /* Space for holding column names */ + int nDb; /* Bytes required to hold database name */ + int nName; /* Bytes required to hold table name */ + int isFts4 = (argv[0][3]=='4'); /* True for FTS4, false for FTS3 */ + const char **aCol; /* Array of column names */ + sqlite3_tokenizer *pTokenizer = 0; /* Tokenizer for this table */ + + int nIndex = 0; /* Size of aIndex[] array */ + struct Fts3Index *aIndex = 0; /* Array of indexes for this table */ + + /* The results of parsing supported FTS4 key=value options: */ + int bNoDocsize = 0; /* True to omit %_docsize table */ + int bDescIdx = 0; /* True to store descending indexes */ + char *zPrefix = 0; /* Prefix parameter value (or NULL) */ + char *zCompress = 0; /* compress=? parameter (or NULL) */ + char *zUncompress = 0; /* uncompress=? parameter (or NULL) */ + char *zContent = 0; /* content=? parameter (or NULL) */ + char *zLanguageid = 0; /* languageid=? parameter (or NULL) */ + char **azNotindexed = 0; /* The set of notindexed= columns */ + int nNotindexed = 0; /* Size of azNotindexed[] array */ + + assert( strlen(argv[0])==4 ); + assert( (sqlite3_strnicmp(argv[0], "fts4", 4)==0 && isFts4) + || (sqlite3_strnicmp(argv[0], "fts3", 4)==0 && !isFts4) + ); + + nDb = (int)strlen(argv[1]) + 1; + nName = (int)strlen(argv[2]) + 1; + + nByte = sizeof(const char *) * (argc-2); + aCol = (const char **)sqlite3_malloc64(nByte); + if( aCol ){ + memset((void*)aCol, 0, nByte); + azNotindexed = (char **)sqlite3_malloc64(nByte); + } + if( azNotindexed ){ + memset(azNotindexed, 0, nByte); + } + if( !aCol || !azNotindexed ){ + rc = SQLITE_NOMEM; + goto fts3_init_out; + } + + /* Loop through all of the arguments passed by the user to the FTS3/4 + ** module (i.e. all the column names and special arguments). This loop + ** does the following: + ** + ** + Figures out the number of columns the FTSX table will have, and + ** the number of bytes of space that must be allocated to store copies + ** of the column names. + ** + ** + If there is a tokenizer specification included in the arguments, + ** initializes the tokenizer pTokenizer. + */ + for(i=3; rc==SQLITE_OK && i8 + && 0==sqlite3_strnicmp(z, "tokenize", 8) + && 0==sqlite3Fts3IsIdChar(z[8]) + ){ + rc = sqlite3Fts3InitTokenizer(pHash, &z[9], &pTokenizer, pzErr); + } + + /* Check if it is an FTS4 special argument. */ + else if( isFts4 && fts3IsSpecialColumn(z, &nKey, &zVal) ){ + struct Fts4Option { + const char *zOpt; + int nOpt; + } aFts4Opt[] = { + { "matchinfo", 9 }, /* 0 -> MATCHINFO */ + { "prefix", 6 }, /* 1 -> PREFIX */ + { "compress", 8 }, /* 2 -> COMPRESS */ + { "uncompress", 10 }, /* 3 -> UNCOMPRESS */ + { "order", 5 }, /* 4 -> ORDER */ + { "content", 7 }, /* 5 -> CONTENT */ + { "languageid", 10 }, /* 6 -> LANGUAGEID */ + { "notindexed", 10 } /* 7 -> NOTINDEXED */ + }; + + int iOpt; + if( !zVal ){ + rc = SQLITE_NOMEM; + }else{ + for(iOpt=0; iOptnOpt && !sqlite3_strnicmp(z, pOp->zOpt, pOp->nOpt) ){ + break; + } + } + switch( iOpt ){ + case 0: /* MATCHINFO */ + if( strlen(zVal)!=4 || sqlite3_strnicmp(zVal, "fts3", 4) ){ + sqlite3Fts3ErrMsg(pzErr, "unrecognized matchinfo: %s", zVal); + rc = SQLITE_ERROR; + } + bNoDocsize = 1; + break; + + case 1: /* PREFIX */ + sqlite3_free(zPrefix); + zPrefix = zVal; + zVal = 0; + break; + + case 2: /* COMPRESS */ + sqlite3_free(zCompress); + zCompress = zVal; + zVal = 0; + break; + + case 3: /* UNCOMPRESS */ + sqlite3_free(zUncompress); + zUncompress = zVal; + zVal = 0; + break; + + case 4: /* ORDER */ + if( (strlen(zVal)!=3 || sqlite3_strnicmp(zVal, "asc", 3)) + && (strlen(zVal)!=4 || sqlite3_strnicmp(zVal, "desc", 4)) + ){ + sqlite3Fts3ErrMsg(pzErr, "unrecognized order: %s", zVal); + rc = SQLITE_ERROR; + } + bDescIdx = (zVal[0]=='d' || zVal[0]=='D'); + break; + + case 5: /* CONTENT */ + sqlite3_free(zContent); + zContent = zVal; + zVal = 0; + break; + + case 6: /* LANGUAGEID */ + assert( iOpt==6 ); + sqlite3_free(zLanguageid); + zLanguageid = zVal; + zVal = 0; + break; + + case 7: /* NOTINDEXED */ + azNotindexed[nNotindexed++] = zVal; + zVal = 0; + break; + + default: + assert( iOpt==SizeofArray(aFts4Opt) ); + sqlite3Fts3ErrMsg(pzErr, "unrecognized parameter: %s", z); + rc = SQLITE_ERROR; + break; + } + sqlite3_free(zVal); + } + } + + /* Otherwise, the argument is a column name. */ + else { + nString += (int)(strlen(z) + 1); + aCol[nCol++] = z; + } + } + + /* If a content=xxx option was specified, the following: + ** + ** 1. Ignore any compress= and uncompress= options. + ** + ** 2. If no column names were specified as part of the CREATE VIRTUAL + ** TABLE statement, use all columns from the content table. + */ + if( rc==SQLITE_OK && zContent ){ + sqlite3_free(zCompress); + sqlite3_free(zUncompress); + zCompress = 0; + zUncompress = 0; + if( nCol==0 ){ + sqlite3_free((void*)aCol); + aCol = 0; + rc = fts3ContentColumns(db, argv[1], zContent,&aCol,&nCol,&nString,pzErr); + + /* If a languageid= option was specified, remove the language id + ** column from the aCol[] array. */ + if( rc==SQLITE_OK && zLanguageid ){ + int j; + for(j=0; jdb = db; + p->nColumn = nCol; + p->nPendingData = 0; + p->azColumn = (char **)&p[1]; + p->pTokenizer = pTokenizer; + p->nMaxPendingData = FTS3_MAX_PENDING_DATA; + p->bHasDocsize = (isFts4 && bNoDocsize==0); + p->bHasStat = (u8)isFts4; + p->bFts4 = (u8)isFts4; + p->bDescIdx = (u8)bDescIdx; + p->nAutoincrmerge = 0xff; /* 0xff means setting unknown */ + p->zContentTbl = zContent; + p->zLanguageid = zLanguageid; + zContent = 0; + zLanguageid = 0; + TESTONLY( p->inTransaction = -1 ); + TESTONLY( p->mxSavepoint = -1 ); + + p->aIndex = (struct Fts3Index *)&p->azColumn[nCol]; + memcpy(p->aIndex, aIndex, sizeof(struct Fts3Index) * nIndex); + p->nIndex = nIndex; + for(i=0; iaIndex[i].hPending, FTS3_HASH_STRING, 1); + } + p->abNotindexed = (u8 *)&p->aIndex[nIndex]; + + /* Fill in the zName and zDb fields of the vtab structure. */ + zCsr = (char *)&p->abNotindexed[nCol]; + p->zName = zCsr; + memcpy(zCsr, argv[2], nName); + zCsr += nName; + p->zDb = zCsr; + memcpy(zCsr, argv[1], nDb); + zCsr += nDb; + + /* Fill in the azColumn array */ + for(iCol=0; iCol0 ){ + memcpy(zCsr, z, n); + } + zCsr[n] = '\0'; + sqlite3Fts3Dequote(zCsr); + p->azColumn[iCol] = zCsr; + zCsr += n+1; + assert( zCsr <= &((char *)p)[nByte] ); + } + + /* Fill in the abNotindexed array */ + for(iCol=0; iColazColumn[iCol]); + for(i=0; iazColumn[iCol], zNot, n) + ){ + p->abNotindexed[iCol] = 1; + sqlite3_free(zNot); + azNotindexed[i] = 0; + } + } + } + for(i=0; izReadExprlist = fts3ReadExprList(p, zUncompress, &rc); + p->zWriteExprlist = fts3WriteExprList(p, zCompress, &rc); + if( rc!=SQLITE_OK ) goto fts3_init_out; + + /* If this is an xCreate call, create the underlying tables in the + ** database. TODO: For xConnect(), it could verify that said tables exist. + */ + if( isCreate ){ + rc = fts3CreateTables(p); + } + + /* Check to see if a legacy fts3 table has been "upgraded" by the + ** addition of a %_stat table so that it can use incremental merge. + */ + if( !isFts4 && !isCreate ){ + p->bHasStat = 2; + } + + /* Figure out the page-size for the database. This is required in order to + ** estimate the cost of loading large doclists from the database. */ + fts3DatabasePageSize(&rc, p); + p->nNodeSize = p->nPgsz-35; + +#if defined(SQLITE_DEBUG)||defined(SQLITE_TEST) + p->nMergeCount = FTS3_MERGE_COUNT; +#endif + + /* Declare the table schema to SQLite. */ + fts3DeclareVtab(&rc, p); + +fts3_init_out: + sqlite3_free(zPrefix); + sqlite3_free(aIndex); + sqlite3_free(zCompress); + sqlite3_free(zUncompress); + sqlite3_free(zContent); + sqlite3_free(zLanguageid); + for(i=0; ipModule->xDestroy(pTokenizer); + } + }else{ + assert( p->pSegments==0 ); + *ppVTab = &p->base; + } + return rc; +} + +/* +** The xConnect() and xCreate() methods for the virtual table. All the +** work is done in function fts3InitVtab(). +*/ +static int fts3ConnectMethod( + sqlite3 *db, /* Database connection */ + void *pAux, /* Pointer to tokenizer hash table */ + int argc, /* Number of elements in argv array */ + const char * const *argv, /* xCreate/xConnect argument array */ + sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */ + char **pzErr /* OUT: sqlite3_malloc'd error message */ +){ + return fts3InitVtab(0, db, pAux, argc, argv, ppVtab, pzErr); +} +static int fts3CreateMethod( + sqlite3 *db, /* Database connection */ + void *pAux, /* Pointer to tokenizer hash table */ + int argc, /* Number of elements in argv array */ + const char * const *argv, /* xCreate/xConnect argument array */ + sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */ + char **pzErr /* OUT: sqlite3_malloc'd error message */ +){ + return fts3InitVtab(1, db, pAux, argc, argv, ppVtab, pzErr); +} + +/* +** Set the pIdxInfo->estimatedRows variable to nRow. Unless this +** extension is currently being used by a version of SQLite too old to +** support estimatedRows. In that case this function is a no-op. +*/ +static void fts3SetEstimatedRows(sqlite3_index_info *pIdxInfo, i64 nRow){ +#if SQLITE_VERSION_NUMBER>=3008002 + if( sqlite3_libversion_number()>=3008002 ){ + pIdxInfo->estimatedRows = nRow; + } +#endif +} + +/* +** Set the SQLITE_INDEX_SCAN_UNIQUE flag in pIdxInfo->flags. Unless this +** extension is currently being used by a version of SQLite too old to +** support index-info flags. In that case this function is a no-op. +*/ +static void fts3SetUniqueFlag(sqlite3_index_info *pIdxInfo){ +#if SQLITE_VERSION_NUMBER>=3008012 + if( sqlite3_libversion_number()>=3008012 ){ + pIdxInfo->idxFlags |= SQLITE_INDEX_SCAN_UNIQUE; + } +#endif +} + +/* +** Implementation of the xBestIndex method for FTS3 tables. There +** are three possible strategies, in order of preference: +** +** 1. Direct lookup by rowid or docid. +** 2. Full-text search using a MATCH operator on a non-docid column. +** 3. Linear scan of %_content table. +*/ +static int fts3BestIndexMethod(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){ + Fts3Table *p = (Fts3Table *)pVTab; + int i; /* Iterator variable */ + int iCons = -1; /* Index of constraint to use */ + + int iLangidCons = -1; /* Index of langid=x constraint, if present */ + int iDocidGe = -1; /* Index of docid>=x constraint, if present */ + int iDocidLe = -1; /* Index of docid<=x constraint, if present */ + int iIdx; + + if( p->bLock ){ + return SQLITE_ERROR; + } + + /* By default use a full table scan. This is an expensive option, + ** so search through the constraints to see if a more efficient + ** strategy is possible. + */ + pInfo->idxNum = FTS3_FULLSCAN_SEARCH; + pInfo->estimatedCost = 5000000; + for(i=0; inConstraint; i++){ + int bDocid; /* True if this constraint is on docid */ + struct sqlite3_index_constraint *pCons = &pInfo->aConstraint[i]; + if( pCons->usable==0 ){ + if( pCons->op==SQLITE_INDEX_CONSTRAINT_MATCH ){ + /* There exists an unusable MATCH constraint. This means that if + ** the planner does elect to use the results of this call as part + ** of the overall query plan the user will see an "unable to use + ** function MATCH in the requested context" error. To discourage + ** this, return a very high cost here. */ + pInfo->idxNum = FTS3_FULLSCAN_SEARCH; + pInfo->estimatedCost = 1e50; + fts3SetEstimatedRows(pInfo, ((sqlite3_int64)1) << 50); + return SQLITE_OK; + } + continue; + } + + bDocid = (pCons->iColumn<0 || pCons->iColumn==p->nColumn+1); + + /* A direct lookup on the rowid or docid column. Assign a cost of 1.0. */ + if( iCons<0 && pCons->op==SQLITE_INDEX_CONSTRAINT_EQ && bDocid ){ + pInfo->idxNum = FTS3_DOCID_SEARCH; + pInfo->estimatedCost = 1.0; + iCons = i; + } + + /* A MATCH constraint. Use a full-text search. + ** + ** If there is more than one MATCH constraint available, use the first + ** one encountered. If there is both a MATCH constraint and a direct + ** rowid/docid lookup, prefer the MATCH strategy. This is done even + ** though the rowid/docid lookup is faster than a MATCH query, selecting + ** it would lead to an "unable to use function MATCH in the requested + ** context" error. + */ + if( pCons->op==SQLITE_INDEX_CONSTRAINT_MATCH + && pCons->iColumn>=0 && pCons->iColumn<=p->nColumn + ){ + pInfo->idxNum = FTS3_FULLTEXT_SEARCH + pCons->iColumn; + pInfo->estimatedCost = 2.0; + iCons = i; + } + + /* Equality constraint on the langid column */ + if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ + && pCons->iColumn==p->nColumn + 2 + ){ + iLangidCons = i; + } + + if( bDocid ){ + switch( pCons->op ){ + case SQLITE_INDEX_CONSTRAINT_GE: + case SQLITE_INDEX_CONSTRAINT_GT: + iDocidGe = i; + break; + + case SQLITE_INDEX_CONSTRAINT_LE: + case SQLITE_INDEX_CONSTRAINT_LT: + iDocidLe = i; + break; + } + } + } + + /* If using a docid=? or rowid=? strategy, set the UNIQUE flag. */ + if( pInfo->idxNum==FTS3_DOCID_SEARCH ) fts3SetUniqueFlag(pInfo); + + iIdx = 1; + if( iCons>=0 ){ + pInfo->aConstraintUsage[iCons].argvIndex = iIdx++; + pInfo->aConstraintUsage[iCons].omit = 1; + } + if( iLangidCons>=0 ){ + pInfo->idxNum |= FTS3_HAVE_LANGID; + pInfo->aConstraintUsage[iLangidCons].argvIndex = iIdx++; + } + if( iDocidGe>=0 ){ + pInfo->idxNum |= FTS3_HAVE_DOCID_GE; + pInfo->aConstraintUsage[iDocidGe].argvIndex = iIdx++; + } + if( iDocidLe>=0 ){ + pInfo->idxNum |= FTS3_HAVE_DOCID_LE; + pInfo->aConstraintUsage[iDocidLe].argvIndex = iIdx++; + } + + /* Regardless of the strategy selected, FTS can deliver rows in rowid (or + ** docid) order. Both ascending and descending are possible. + */ + if( pInfo->nOrderBy==1 ){ + struct sqlite3_index_orderby *pOrder = &pInfo->aOrderBy[0]; + if( pOrder->iColumn<0 || pOrder->iColumn==p->nColumn+1 ){ + if( pOrder->desc ){ + pInfo->idxStr = "DESC"; + }else{ + pInfo->idxStr = "ASC"; + } + pInfo->orderByConsumed = 1; + } + } + + assert( p->pSegments==0 ); + return SQLITE_OK; +} + +/* +** Implementation of xOpen method. +*/ +static int fts3OpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){ + sqlite3_vtab_cursor *pCsr; /* Allocated cursor */ + + UNUSED_PARAMETER(pVTab); + + /* Allocate a buffer large enough for an Fts3Cursor structure. If the + ** allocation succeeds, zero it and return SQLITE_OK. Otherwise, + ** if the allocation fails, return SQLITE_NOMEM. + */ + *ppCsr = pCsr = (sqlite3_vtab_cursor *)sqlite3_malloc(sizeof(Fts3Cursor)); + if( !pCsr ){ + return SQLITE_NOMEM; + } + memset(pCsr, 0, sizeof(Fts3Cursor)); + return SQLITE_OK; +} + +/* +** Finalize the statement handle at pCsr->pStmt. +** +** Or, if that statement handle is one created by fts3CursorSeekStmt(), +** and the Fts3Table.pSeekStmt slot is currently NULL, save the statement +** pointer there instead of finalizing it. +*/ +static void fts3CursorFinalizeStmt(Fts3Cursor *pCsr){ + if( pCsr->bSeekStmt ){ + Fts3Table *p = (Fts3Table *)pCsr->base.pVtab; + if( p->pSeekStmt==0 ){ + p->pSeekStmt = pCsr->pStmt; + sqlite3_reset(pCsr->pStmt); + pCsr->pStmt = 0; + } + pCsr->bSeekStmt = 0; + } + sqlite3_finalize(pCsr->pStmt); +} + +/* +** Free all resources currently held by the cursor passed as the only +** argument. +*/ +static void fts3ClearCursor(Fts3Cursor *pCsr){ + fts3CursorFinalizeStmt(pCsr); + sqlite3Fts3FreeDeferredTokens(pCsr); + sqlite3_free(pCsr->aDoclist); + sqlite3Fts3MIBufferFree(pCsr->pMIBuffer); + sqlite3Fts3ExprFree(pCsr->pExpr); + memset(&(&pCsr->base)[1], 0, sizeof(Fts3Cursor)-sizeof(sqlite3_vtab_cursor)); +} + +/* +** Close the cursor. For additional information see the documentation +** on the xClose method of the virtual table interface. +*/ +static int fts3CloseMethod(sqlite3_vtab_cursor *pCursor){ + Fts3Cursor *pCsr = (Fts3Cursor *)pCursor; + assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 ); + fts3ClearCursor(pCsr); + assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 ); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +/* +** If pCsr->pStmt has not been prepared (i.e. if pCsr->pStmt==0), then +** compose and prepare an SQL statement of the form: +** +** "SELECT FROM %_content WHERE rowid = ?" +** +** (or the equivalent for a content=xxx table) and set pCsr->pStmt to +** it. If an error occurs, return an SQLite error code. +*/ +static int fts3CursorSeekStmt(Fts3Cursor *pCsr){ + int rc = SQLITE_OK; + if( pCsr->pStmt==0 ){ + Fts3Table *p = (Fts3Table *)pCsr->base.pVtab; + char *zSql; + if( p->pSeekStmt ){ + pCsr->pStmt = p->pSeekStmt; + p->pSeekStmt = 0; + }else{ + zSql = sqlite3_mprintf("SELECT %s WHERE rowid = ?", p->zReadExprlist); + if( !zSql ) return SQLITE_NOMEM; + p->bLock++; + rc = sqlite3_prepare_v3( + p->db, zSql,-1,SQLITE_PREPARE_PERSISTENT,&pCsr->pStmt,0 + ); + p->bLock--; + sqlite3_free(zSql); + } + if( rc==SQLITE_OK ) pCsr->bSeekStmt = 1; + } + return rc; +} + +/* +** Position the pCsr->pStmt statement so that it is on the row +** of the %_content table that contains the last match. Return +** SQLITE_OK on success. +*/ +static int fts3CursorSeek(sqlite3_context *pContext, Fts3Cursor *pCsr){ + int rc = SQLITE_OK; + if( pCsr->isRequireSeek ){ + rc = fts3CursorSeekStmt(pCsr); + if( rc==SQLITE_OK ){ + Fts3Table *pTab = (Fts3Table*)pCsr->base.pVtab; + pTab->bLock++; + sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iPrevId); + pCsr->isRequireSeek = 0; + if( SQLITE_ROW==sqlite3_step(pCsr->pStmt) ){ + pTab->bLock--; + return SQLITE_OK; + }else{ + pTab->bLock--; + rc = sqlite3_reset(pCsr->pStmt); + if( rc==SQLITE_OK && ((Fts3Table *)pCsr->base.pVtab)->zContentTbl==0 ){ + /* If no row was found and no error has occurred, then the %_content + ** table is missing a row that is present in the full-text index. + ** The data structures are corrupt. */ + rc = FTS_CORRUPT_VTAB; + pCsr->isEof = 1; + } + } + } + } + + if( rc!=SQLITE_OK && pContext ){ + sqlite3_result_error_code(pContext, rc); + } + return rc; +} + +/* +** This function is used to process a single interior node when searching +** a b-tree for a term or term prefix. The node data is passed to this +** function via the zNode/nNode parameters. The term to search for is +** passed in zTerm/nTerm. +** +** If piFirst is not NULL, then this function sets *piFirst to the blockid +** of the child node that heads the sub-tree that may contain the term. +** +** If piLast is not NULL, then *piLast is set to the right-most child node +** that heads a sub-tree that may contain a term for which zTerm/nTerm is +** a prefix. +** +** If an OOM error occurs, SQLITE_NOMEM is returned. Otherwise, SQLITE_OK. +*/ +static int fts3ScanInteriorNode( + const char *zTerm, /* Term to select leaves for */ + int nTerm, /* Size of term zTerm in bytes */ + const char *zNode, /* Buffer containing segment interior node */ + int nNode, /* Size of buffer at zNode */ + sqlite3_int64 *piFirst, /* OUT: Selected child node */ + sqlite3_int64 *piLast /* OUT: Selected child node */ +){ + int rc = SQLITE_OK; /* Return code */ + const char *zCsr = zNode; /* Cursor to iterate through node */ + const char *zEnd = &zCsr[nNode];/* End of interior node buffer */ + char *zBuffer = 0; /* Buffer to load terms into */ + i64 nAlloc = 0; /* Size of allocated buffer */ + int isFirstTerm = 1; /* True when processing first term on page */ + sqlite3_int64 iChild; /* Block id of child node to descend to */ + int nBuffer = 0; /* Total term size */ + + /* Skip over the 'height' varint that occurs at the start of every + ** interior node. Then load the blockid of the left-child of the b-tree + ** node into variable iChild. + ** + ** Even if the data structure on disk is corrupted, this (reading two + ** varints from the buffer) does not risk an overread. If zNode is a + ** root node, then the buffer comes from a SELECT statement. SQLite does + ** not make this guarantee explicitly, but in practice there are always + ** either more than 20 bytes of allocated space following the nNode bytes of + ** contents, or two zero bytes. Or, if the node is read from the %_segments + ** table, then there are always 20 bytes of zeroed padding following the + ** nNode bytes of content (see sqlite3Fts3ReadBlock() for details). + */ + zCsr += sqlite3Fts3GetVarint(zCsr, &iChild); + zCsr += sqlite3Fts3GetVarint(zCsr, &iChild); + if( zCsr>zEnd ){ + return FTS_CORRUPT_VTAB; + } + + while( zCsrnBuffer ){ + rc = FTS_CORRUPT_VTAB; + goto finish_scan; + } + } + isFirstTerm = 0; + zCsr += fts3GetVarint32(zCsr, &nSuffix); + + assert( nPrefix>=0 && nSuffix>=0 ); + if( nPrefix>zCsr-zNode || nSuffix>zEnd-zCsr || nSuffix==0 ){ + rc = FTS_CORRUPT_VTAB; + goto finish_scan; + } + if( (i64)nPrefix+nSuffix>nAlloc ){ + char *zNew; + nAlloc = ((i64)nPrefix+nSuffix) * 2; + zNew = (char *)sqlite3_realloc64(zBuffer, nAlloc); + if( !zNew ){ + rc = SQLITE_NOMEM; + goto finish_scan; + } + zBuffer = zNew; + } + assert( zBuffer ); + memcpy(&zBuffer[nPrefix], zCsr, nSuffix); + nBuffer = nPrefix + nSuffix; + zCsr += nSuffix; + + /* Compare the term we are searching for with the term just loaded from + ** the interior node. If the specified term is greater than or equal + ** to the term from the interior node, then all terms on the sub-tree + ** headed by node iChild are smaller than zTerm. No need to search + ** iChild. + ** + ** If the interior node term is larger than the specified term, then + ** the tree headed by iChild may contain the specified term. + */ + cmp = memcmp(zTerm, zBuffer, (nBuffer>nTerm ? nTerm : nBuffer)); + if( piFirst && (cmp<0 || (cmp==0 && nBuffer>nTerm)) ){ + *piFirst = iChild; + piFirst = 0; + } + + if( piLast && cmp<0 ){ + *piLast = iChild; + piLast = 0; + } + + iChild++; + }; + + if( piFirst ) *piFirst = iChild; + if( piLast ) *piLast = iChild; + + finish_scan: + sqlite3_free(zBuffer); + return rc; +} + + +/* +** The buffer pointed to by argument zNode (size nNode bytes) contains an +** interior node of a b-tree segment. The zTerm buffer (size nTerm bytes) +** contains a term. This function searches the sub-tree headed by the zNode +** node for the range of leaf nodes that may contain the specified term +** or terms for which the specified term is a prefix. +** +** If piLeaf is not NULL, then *piLeaf is set to the blockid of the +** left-most leaf node in the tree that may contain the specified term. +** If piLeaf2 is not NULL, then *piLeaf2 is set to the blockid of the +** right-most leaf node that may contain a term for which the specified +** term is a prefix. +** +** It is possible that the range of returned leaf nodes does not contain +** the specified term or any terms for which it is a prefix. However, if the +** segment does contain any such terms, they are stored within the identified +** range. Because this function only inspects interior segment nodes (and +** never loads leaf nodes into memory), it is not possible to be sure. +** +** If an error occurs, an error code other than SQLITE_OK is returned. +*/ +static int fts3SelectLeaf( + Fts3Table *p, /* Virtual table handle */ + const char *zTerm, /* Term to select leaves for */ + int nTerm, /* Size of term zTerm in bytes */ + const char *zNode, /* Buffer containing segment interior node */ + int nNode, /* Size of buffer at zNode */ + sqlite3_int64 *piLeaf, /* Selected leaf node */ + sqlite3_int64 *piLeaf2 /* Selected leaf node */ +){ + int rc = SQLITE_OK; /* Return code */ + int iHeight; /* Height of this node in tree */ + + assert( piLeaf || piLeaf2 ); + + fts3GetVarint32(zNode, &iHeight); + rc = fts3ScanInteriorNode(zTerm, nTerm, zNode, nNode, piLeaf, piLeaf2); + assert_fts3_nc( !piLeaf2 || !piLeaf || rc!=SQLITE_OK || (*piLeaf<=*piLeaf2) ); + + if( rc==SQLITE_OK && iHeight>1 ){ + char *zBlob = 0; /* Blob read from %_segments table */ + int nBlob = 0; /* Size of zBlob in bytes */ + + if( piLeaf && piLeaf2 && (*piLeaf!=*piLeaf2) ){ + rc = sqlite3Fts3ReadBlock(p, *piLeaf, &zBlob, &nBlob, 0); + if( rc==SQLITE_OK ){ + rc = fts3SelectLeaf(p, zTerm, nTerm, zBlob, nBlob, piLeaf, 0); + } + sqlite3_free(zBlob); + piLeaf = 0; + zBlob = 0; + } + + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3ReadBlock(p, piLeaf?*piLeaf:*piLeaf2, &zBlob, &nBlob, 0); + } + if( rc==SQLITE_OK ){ + int iNewHeight = 0; + fts3GetVarint32(zBlob, &iNewHeight); + if( iNewHeight>=iHeight ){ + rc = FTS_CORRUPT_VTAB; + }else{ + rc = fts3SelectLeaf(p, zTerm, nTerm, zBlob, nBlob, piLeaf, piLeaf2); + } + } + sqlite3_free(zBlob); + } + + return rc; +} + +/* +** This function is used to create delta-encoded serialized lists of FTS3 +** varints. Each call to this function appends a single varint to a list. +*/ +static void fts3PutDeltaVarint( + char **pp, /* IN/OUT: Output pointer */ + sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */ + sqlite3_int64 iVal /* Write this value to the list */ +){ + assert_fts3_nc( iVal-*piPrev > 0 || (*piPrev==0 && iVal==0) ); + *pp += sqlite3Fts3PutVarint(*pp, iVal-*piPrev); + *piPrev = iVal; +} + +/* +** When this function is called, *ppPoslist is assumed to point to the +** start of a position-list. After it returns, *ppPoslist points to the +** first byte after the position-list. +** +** A position list is list of positions (delta encoded) and columns for +** a single document record of a doclist. So, in other words, this +** routine advances *ppPoslist so that it points to the next docid in +** the doclist, or to the first byte past the end of the doclist. +** +** If pp is not NULL, then the contents of the position list are copied +** to *pp. *pp is set to point to the first byte past the last byte copied +** before this function returns. +*/ +static void fts3PoslistCopy(char **pp, char **ppPoslist){ + char *pEnd = *ppPoslist; + char c = 0; + + /* The end of a position list is marked by a zero encoded as an FTS3 + ** varint. A single POS_END (0) byte. Except, if the 0 byte is preceded by + ** a byte with the 0x80 bit set, then it is not a varint 0, but the tail + ** of some other, multi-byte, value. + ** + ** The following while-loop moves pEnd to point to the first byte that is not + ** immediately preceded by a byte with the 0x80 bit set. Then increments + ** pEnd once more so that it points to the byte immediately following the + ** last byte in the position-list. + */ + while( *pEnd | c ){ + c = *pEnd++ & 0x80; + testcase( c!=0 && (*pEnd)==0 ); + } + pEnd++; /* Advance past the POS_END terminator byte */ + + if( pp ){ + int n = (int)(pEnd - *ppPoslist); + char *p = *pp; + memcpy(p, *ppPoslist, n); + p += n; + *pp = p; + } + *ppPoslist = pEnd; +} + +/* +** When this function is called, *ppPoslist is assumed to point to the +** start of a column-list. After it returns, *ppPoslist points to the +** to the terminator (POS_COLUMN or POS_END) byte of the column-list. +** +** A column-list is list of delta-encoded positions for a single column +** within a single document within a doclist. +** +** The column-list is terminated either by a POS_COLUMN varint (1) or +** a POS_END varint (0). This routine leaves *ppPoslist pointing to +** the POS_COLUMN or POS_END that terminates the column-list. +** +** If pp is not NULL, then the contents of the column-list are copied +** to *pp. *pp is set to point to the first byte past the last byte copied +** before this function returns. The POS_COLUMN or POS_END terminator +** is not copied into *pp. +*/ +static void fts3ColumnlistCopy(char **pp, char **ppPoslist){ + char *pEnd = *ppPoslist; + char c = 0; + + /* A column-list is terminated by either a 0x01 or 0x00 byte that is + ** not part of a multi-byte varint. + */ + while( 0xFE & (*pEnd | c) ){ + c = *pEnd++ & 0x80; + testcase( c!=0 && ((*pEnd)&0xfe)==0 ); + } + if( pp ){ + int n = (int)(pEnd - *ppPoslist); + char *p = *pp; + memcpy(p, *ppPoslist, n); + p += n; + *pp = p; + } + *ppPoslist = pEnd; +} + +/* +** Value used to signify the end of an position-list. This must be +** as large or larger than any value that might appear on the +** position-list, even a position list that has been corrupted. +*/ +#define POSITION_LIST_END LARGEST_INT64 + +/* +** This function is used to help parse position-lists. When this function is +** called, *pp may point to the start of the next varint in the position-list +** being parsed, or it may point to 1 byte past the end of the position-list +** (in which case **pp will be a terminator bytes POS_END (0) or +** (1)). +** +** If *pp points past the end of the current position-list, set *pi to +** POSITION_LIST_END and return. Otherwise, read the next varint from *pp, +** increment the current value of *pi by the value read, and set *pp to +** point to the next value before returning. +** +** Before calling this routine *pi must be initialized to the value of +** the previous position, or zero if we are reading the first position +** in the position-list. Because positions are delta-encoded, the value +** of the previous position is needed in order to compute the value of +** the next position. +*/ +static void fts3ReadNextPos( + char **pp, /* IN/OUT: Pointer into position-list buffer */ + sqlite3_int64 *pi /* IN/OUT: Value read from position-list */ +){ + if( (**pp)&0xFE ){ + int iVal; + *pp += fts3GetVarint32((*pp), &iVal); + *pi += iVal; + *pi -= 2; + }else{ + *pi = POSITION_LIST_END; + } +} + +/* +** If parameter iCol is not 0, write an POS_COLUMN (1) byte followed by +** the value of iCol encoded as a varint to *pp. This will start a new +** column list. +** +** Set *pp to point to the byte just after the last byte written before +** returning (do not modify it if iCol==0). Return the total number of bytes +** written (0 if iCol==0). +*/ +static int fts3PutColNumber(char **pp, int iCol){ + int n = 0; /* Number of bytes written */ + if( iCol ){ + char *p = *pp; /* Output pointer */ + n = 1 + sqlite3Fts3PutVarint(&p[1], iCol); + *p = 0x01; + *pp = &p[n]; + } + return n; +} + +/* +** Compute the union of two position lists. The output written +** into *pp contains all positions of both *pp1 and *pp2 in sorted +** order and with any duplicates removed. All pointers are +** updated appropriately. The caller is responsible for insuring +** that there is enough space in *pp to hold the complete output. +*/ +static int fts3PoslistMerge( + char **pp, /* Output buffer */ + char **pp1, /* Left input list */ + char **pp2 /* Right input list */ +){ + char *p = *pp; + char *p1 = *pp1; + char *p2 = *pp2; + + while( *p1 || *p2 ){ + int iCol1; /* The current column index in pp1 */ + int iCol2; /* The current column index in pp2 */ + + if( *p1==POS_COLUMN ){ + fts3GetVarint32(&p1[1], &iCol1); + if( iCol1==0 ) return FTS_CORRUPT_VTAB; + } + else if( *p1==POS_END ) iCol1 = 0x7fffffff; + else iCol1 = 0; + + if( *p2==POS_COLUMN ){ + fts3GetVarint32(&p2[1], &iCol2); + if( iCol2==0 ) return FTS_CORRUPT_VTAB; + } + else if( *p2==POS_END ) iCol2 = 0x7fffffff; + else iCol2 = 0; + + if( iCol1==iCol2 ){ + sqlite3_int64 i1 = 0; /* Last position from pp1 */ + sqlite3_int64 i2 = 0; /* Last position from pp2 */ + sqlite3_int64 iPrev = 0; + int n = fts3PutColNumber(&p, iCol1); + p1 += n; + p2 += n; + + /* At this point, both p1 and p2 point to the start of column-lists + ** for the same column (the column with index iCol1 and iCol2). + ** A column-list is a list of non-negative delta-encoded varints, each + ** incremented by 2 before being stored. Each list is terminated by a + ** POS_END (0) or POS_COLUMN (1). The following block merges the two lists + ** and writes the results to buffer p. p is left pointing to the byte + ** after the list written. No terminator (POS_END or POS_COLUMN) is + ** written to the output. + */ + fts3GetDeltaVarint(&p1, &i1); + fts3GetDeltaVarint(&p2, &i2); + if( i1<2 || i2<2 ){ + break; + } + do { + fts3PutDeltaVarint(&p, &iPrev, (i1pos(*pp1) && pos(*pp2)-pos(*pp1)<=nToken). i.e. +** when the *pp1 token appears before the *pp2 token, but not more than nToken +** slots before it. +** +** e.g. nToken==1 searches for adjacent positions. +*/ +static int fts3PoslistPhraseMerge( + char **pp, /* IN/OUT: Preallocated output buffer */ + int nToken, /* Maximum difference in token positions */ + int isSaveLeft, /* Save the left position */ + int isExact, /* If *pp1 is exactly nTokens before *pp2 */ + char **pp1, /* IN/OUT: Left input list */ + char **pp2 /* IN/OUT: Right input list */ +){ + char *p = *pp; + char *p1 = *pp1; + char *p2 = *pp2; + int iCol1 = 0; + int iCol2 = 0; + + /* Never set both isSaveLeft and isExact for the same invocation. */ + assert( isSaveLeft==0 || isExact==0 ); + + assert_fts3_nc( p!=0 && *p1!=0 && *p2!=0 ); + if( *p1==POS_COLUMN ){ + p1++; + p1 += fts3GetVarint32(p1, &iCol1); + } + if( *p2==POS_COLUMN ){ + p2++; + p2 += fts3GetVarint32(p2, &iCol2); + } + + while( 1 ){ + if( iCol1==iCol2 ){ + char *pSave = p; + sqlite3_int64 iPrev = 0; + sqlite3_int64 iPos1 = 0; + sqlite3_int64 iPos2 = 0; + + if( iCol1 ){ + *p++ = POS_COLUMN; + p += sqlite3Fts3PutVarint(p, iCol1); + } + + fts3GetDeltaVarint(&p1, &iPos1); iPos1 -= 2; + fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2; + if( iPos1<0 || iPos2<0 ) break; + + while( 1 ){ + if( iPos2==iPos1+nToken + || (isExact==0 && iPos2>iPos1 && iPos2<=iPos1+nToken) + ){ + sqlite3_int64 iSave; + iSave = isSaveLeft ? iPos1 : iPos2; + fts3PutDeltaVarint(&p, &iPrev, iSave+2); iPrev -= 2; + pSave = 0; + assert( p ); + } + if( (!isSaveLeft && iPos2<=(iPos1+nToken)) || iPos2<=iPos1 ){ + if( (*p2&0xFE)==0 ) break; + fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2; + }else{ + if( (*p1&0xFE)==0 ) break; + fts3GetDeltaVarint(&p1, &iPos1); iPos1 -= 2; + } + } + + if( pSave ){ + assert( pp && p ); + p = pSave; + } + + fts3ColumnlistCopy(0, &p1); + fts3ColumnlistCopy(0, &p2); + assert( (*p1&0xFE)==0 && (*p2&0xFE)==0 ); + if( 0==*p1 || 0==*p2 ) break; + + p1++; + p1 += fts3GetVarint32(p1, &iCol1); + p2++; + p2 += fts3GetVarint32(p2, &iCol2); + } + + /* Advance pointer p1 or p2 (whichever corresponds to the smaller of + ** iCol1 and iCol2) so that it points to either the 0x00 that marks the + ** end of the position list, or the 0x01 that precedes the next + ** column-number in the position list. + */ + else if( iCol1=pEnd ){ + *pp = 0; + }else{ + u64 iVal; + *pp += sqlite3Fts3GetVarintU(*pp, &iVal); + if( bDescIdx ){ + *pVal = (i64)((u64)*pVal - iVal); + }else{ + *pVal = (i64)((u64)*pVal + iVal); + } + } +} + +/* +** This function is used to write a single varint to a buffer. The varint +** is written to *pp. Before returning, *pp is set to point 1 byte past the +** end of the value written. +** +** If *pbFirst is zero when this function is called, the value written to +** the buffer is that of parameter iVal. +** +** If *pbFirst is non-zero when this function is called, then the value +** written is either (iVal-*piPrev) (if bDescIdx is zero) or (*piPrev-iVal) +** (if bDescIdx is non-zero). +** +** Before returning, this function always sets *pbFirst to 1 and *piPrev +** to the value of parameter iVal. +*/ +static void fts3PutDeltaVarint3( + char **pp, /* IN/OUT: Output pointer */ + int bDescIdx, /* True for descending docids */ + sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */ + int *pbFirst, /* IN/OUT: True after first int written */ + sqlite3_int64 iVal /* Write this value to the list */ +){ + sqlite3_uint64 iWrite; + if( bDescIdx==0 || *pbFirst==0 ){ + assert_fts3_nc( *pbFirst==0 || iVal>=*piPrev ); + iWrite = (u64)iVal - (u64)*piPrev; + }else{ + assert_fts3_nc( *piPrev>=iVal ); + iWrite = (u64)*piPrev - (u64)iVal; + } + assert( *pbFirst || *piPrev==0 ); + assert_fts3_nc( *pbFirst==0 || iWrite>0 ); + *pp += sqlite3Fts3PutVarint(*pp, iWrite); + *piPrev = iVal; + *pbFirst = 1; +} + + +/* +** This macro is used by various functions that merge doclists. The two +** arguments are 64-bit docid values. If the value of the stack variable +** bDescDoclist is 0 when this macro is invoked, then it returns (i1-i2). +** Otherwise, (i2-i1). +** +** Using this makes it easier to write code that can merge doclists that are +** sorted in either ascending or descending order. +*/ +/* #define DOCID_CMP(i1, i2) ((bDescDoclist?-1:1) * (i64)((u64)i1-i2)) */ +#define DOCID_CMP(i1, i2) ((bDescDoclist?-1:1) * (i1>i2?1:((i1==i2)?0:-1))) + +/* +** This function does an "OR" merge of two doclists (output contains all +** positions contained in either argument doclist). If the docids in the +** input doclists are sorted in ascending order, parameter bDescDoclist +** should be false. If they are sorted in ascending order, it should be +** passed a non-zero value. +** +** If no error occurs, *paOut is set to point at an sqlite3_malloc'd buffer +** containing the output doclist and SQLITE_OK is returned. In this case +** *pnOut is set to the number of bytes in the output doclist. +** +** If an error occurs, an SQLite error code is returned. The output values +** are undefined in this case. +*/ +static int fts3DoclistOrMerge( + int bDescDoclist, /* True if arguments are desc */ + char *a1, int n1, /* First doclist */ + char *a2, int n2, /* Second doclist */ + char **paOut, int *pnOut /* OUT: Malloc'd doclist */ +){ + int rc = SQLITE_OK; + sqlite3_int64 i1 = 0; + sqlite3_int64 i2 = 0; + sqlite3_int64 iPrev = 0; + char *pEnd1 = &a1[n1]; + char *pEnd2 = &a2[n2]; + char *p1 = a1; + char *p2 = a2; + char *p; + char *aOut; + int bFirstOut = 0; + + *paOut = 0; + *pnOut = 0; + + /* Allocate space for the output. Both the input and output doclists + ** are delta encoded. If they are in ascending order (bDescDoclist==0), + ** then the first docid in each list is simply encoded as a varint. For + ** each subsequent docid, the varint stored is the difference between the + ** current and previous docid (a positive number - since the list is in + ** ascending order). + ** + ** The first docid written to the output is therefore encoded using the + ** same number of bytes as it is in whichever of the input lists it is + ** read from. And each subsequent docid read from the same input list + ** consumes either the same or less bytes as it did in the input (since + ** the difference between it and the previous value in the output must + ** be a positive value less than or equal to the delta value read from + ** the input list). The same argument applies to all but the first docid + ** read from the 'other' list. And to the contents of all position lists + ** that will be copied and merged from the input to the output. + ** + ** However, if the first docid copied to the output is a negative number, + ** then the encoding of the first docid from the 'other' input list may + ** be larger in the output than it was in the input (since the delta value + ** may be a larger positive integer than the actual docid). + ** + ** The space required to store the output is therefore the sum of the + ** sizes of the two inputs, plus enough space for exactly one of the input + ** docids to grow. + ** + ** A symetric argument may be made if the doclists are in descending + ** order. + */ + aOut = sqlite3_malloc64((i64)n1+n2+FTS3_VARINT_MAX-1+FTS3_BUFFER_PADDING); + if( !aOut ) return SQLITE_NOMEM; + + p = aOut; + fts3GetDeltaVarint3(&p1, pEnd1, 0, &i1); + fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2); + while( p1 || p2 ){ + sqlite3_int64 iDiff = DOCID_CMP(i1, i2); + + if( p2 && p1 && iDiff==0 ){ + fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1); + rc = fts3PoslistMerge(&p, &p1, &p2); + if( rc ) break; + fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1); + fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2); + }else if( !p2 || (p1 && iDiff<0) ){ + fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1); + fts3PoslistCopy(&p, &p1); + fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1); + }else{ + fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i2); + fts3PoslistCopy(&p, &p2); + fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2); + } + + assert( (p-aOut)<=((p1?(p1-a1):n1)+(p2?(p2-a2):n2)+FTS3_VARINT_MAX-1) ); + } + + if( rc!=SQLITE_OK ){ + sqlite3_free(aOut); + p = aOut = 0; + }else{ + assert( (p-aOut)<=n1+n2+FTS3_VARINT_MAX-1 ); + memset(&aOut[(p-aOut)], 0, FTS3_BUFFER_PADDING); + } + *paOut = aOut; + *pnOut = (int)(p-aOut); + return rc; +} + +/* +** This function does a "phrase" merge of two doclists. In a phrase merge, +** the output contains a copy of each position from the right-hand input +** doclist for which there is a position in the left-hand input doclist +** exactly nDist tokens before it. +** +** If the docids in the input doclists are sorted in ascending order, +** parameter bDescDoclist should be false. If they are sorted in ascending +** order, it should be passed a non-zero value. +** +** The right-hand input doclist is overwritten by this function. +*/ +static int fts3DoclistPhraseMerge( + int bDescDoclist, /* True if arguments are desc */ + int nDist, /* Distance from left to right (1=adjacent) */ + char *aLeft, int nLeft, /* Left doclist */ + char **paRight, int *pnRight /* IN/OUT: Right/output doclist */ +){ + sqlite3_int64 i1 = 0; + sqlite3_int64 i2 = 0; + sqlite3_int64 iPrev = 0; + char *aRight = *paRight; + char *pEnd1 = &aLeft[nLeft]; + char *pEnd2 = &aRight[*pnRight]; + char *p1 = aLeft; + char *p2 = aRight; + char *p; + int bFirstOut = 0; + char *aOut; + + assert( nDist>0 ); + if( bDescDoclist ){ + aOut = sqlite3_malloc64((sqlite3_int64)*pnRight + FTS3_VARINT_MAX); + if( aOut==0 ) return SQLITE_NOMEM; + }else{ + aOut = aRight; + } + p = aOut; + + fts3GetDeltaVarint3(&p1, pEnd1, 0, &i1); + fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2); + + while( p1 && p2 ){ + sqlite3_int64 iDiff = DOCID_CMP(i1, i2); + if( iDiff==0 ){ + char *pSave = p; + sqlite3_int64 iPrevSave = iPrev; + int bFirstOutSave = bFirstOut; + + fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1); + if( 0==fts3PoslistPhraseMerge(&p, nDist, 0, 1, &p1, &p2) ){ + p = pSave; + iPrev = iPrevSave; + bFirstOut = bFirstOutSave; + } + fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1); + fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2); + }else if( iDiff<0 ){ + fts3PoslistCopy(0, &p1); + fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1); + }else{ + fts3PoslistCopy(0, &p2); + fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2); + } + } + + *pnRight = (int)(p - aOut); + if( bDescDoclist ){ + sqlite3_free(aRight); + *paRight = aOut; + } + + return SQLITE_OK; +} + +/* +** Argument pList points to a position list nList bytes in size. This +** function checks to see if the position list contains any entries for +** a token in position 0 (of any column). If so, it writes argument iDelta +** to the output buffer pOut, followed by a position list consisting only +** of the entries from pList at position 0, and terminated by an 0x00 byte. +** The value returned is the number of bytes written to pOut (if any). +*/ +SQLITE_PRIVATE int sqlite3Fts3FirstFilter( + sqlite3_int64 iDelta, /* Varint that may be written to pOut */ + char *pList, /* Position list (no 0x00 term) */ + int nList, /* Size of pList in bytes */ + char *pOut /* Write output here */ +){ + int nOut = 0; + int bWritten = 0; /* True once iDelta has been written */ + char *p = pList; + char *pEnd = &pList[nList]; + + if( *p!=0x01 ){ + if( *p==0x02 ){ + nOut += sqlite3Fts3PutVarint(&pOut[nOut], iDelta); + pOut[nOut++] = 0x02; + bWritten = 1; + } + fts3ColumnlistCopy(0, &p); + } + + while( paaOutput); i++){ + if( pTS->aaOutput[i] ){ + if( !aOut ){ + aOut = pTS->aaOutput[i]; + nOut = pTS->anOutput[i]; + pTS->aaOutput[i] = 0; + }else{ + int nNew; + char *aNew; + + int rc = fts3DoclistOrMerge(p->bDescIdx, + pTS->aaOutput[i], pTS->anOutput[i], aOut, nOut, &aNew, &nNew + ); + if( rc!=SQLITE_OK ){ + sqlite3_free(aOut); + return rc; + } + + sqlite3_free(pTS->aaOutput[i]); + sqlite3_free(aOut); + pTS->aaOutput[i] = 0; + aOut = aNew; + nOut = nNew; + } + } + } + + pTS->aaOutput[0] = aOut; + pTS->anOutput[0] = nOut; + return SQLITE_OK; +} + +/* +** Merge the doclist aDoclist/nDoclist into the TermSelect object passed +** as the first argument. The merge is an "OR" merge (see function +** fts3DoclistOrMerge() for details). +** +** This function is called with the doclist for each term that matches +** a queried prefix. It merges all these doclists into one, the doclist +** for the specified prefix. Since there can be a very large number of +** doclists to merge, the merging is done pair-wise using the TermSelect +** object. +** +** This function returns SQLITE_OK if the merge is successful, or an +** SQLite error code (SQLITE_NOMEM) if an error occurs. +*/ +static int fts3TermSelectMerge( + Fts3Table *p, /* FTS table handle */ + TermSelect *pTS, /* TermSelect object to merge into */ + char *aDoclist, /* Pointer to doclist */ + int nDoclist /* Size of aDoclist in bytes */ +){ + if( pTS->aaOutput[0]==0 ){ + /* If this is the first term selected, copy the doclist to the output + ** buffer using memcpy(). + ** + ** Add FTS3_VARINT_MAX bytes of unused space to the end of the + ** allocation. This is so as to ensure that the buffer is big enough + ** to hold the current doclist AND'd with any other doclist. If the + ** doclists are stored in order=ASC order, this padding would not be + ** required (since the size of [doclistA AND doclistB] is always less + ** than or equal to the size of [doclistA] in that case). But this is + ** not true for order=DESC. For example, a doclist containing (1, -1) + ** may be smaller than (-1), as in the first example the -1 may be stored + ** as a single-byte delta, whereas in the second it must be stored as a + ** FTS3_VARINT_MAX byte varint. + ** + ** Similar padding is added in the fts3DoclistOrMerge() function. + */ + pTS->aaOutput[0] = sqlite3_malloc(nDoclist + FTS3_VARINT_MAX + 1); + pTS->anOutput[0] = nDoclist; + if( pTS->aaOutput[0] ){ + memcpy(pTS->aaOutput[0], aDoclist, nDoclist); + memset(&pTS->aaOutput[0][nDoclist], 0, FTS3_VARINT_MAX); + }else{ + return SQLITE_NOMEM; + } + }else{ + char *aMerge = aDoclist; + int nMerge = nDoclist; + int iOut; + + for(iOut=0; iOutaaOutput); iOut++){ + if( pTS->aaOutput[iOut]==0 ){ + assert( iOut>0 ); + pTS->aaOutput[iOut] = aMerge; + pTS->anOutput[iOut] = nMerge; + break; + }else{ + char *aNew; + int nNew; + + int rc = fts3DoclistOrMerge(p->bDescIdx, aMerge, nMerge, + pTS->aaOutput[iOut], pTS->anOutput[iOut], &aNew, &nNew + ); + if( rc!=SQLITE_OK ){ + if( aMerge!=aDoclist ) sqlite3_free(aMerge); + return rc; + } + + if( aMerge!=aDoclist ) sqlite3_free(aMerge); + sqlite3_free(pTS->aaOutput[iOut]); + pTS->aaOutput[iOut] = 0; + + aMerge = aNew; + nMerge = nNew; + if( (iOut+1)==SizeofArray(pTS->aaOutput) ){ + pTS->aaOutput[iOut] = aMerge; + pTS->anOutput[iOut] = nMerge; + } + } + } + } + return SQLITE_OK; +} + +/* +** Append SegReader object pNew to the end of the pCsr->apSegment[] array. +*/ +static int fts3SegReaderCursorAppend( + Fts3MultiSegReader *pCsr, + Fts3SegReader *pNew +){ + if( (pCsr->nSegment%16)==0 ){ + Fts3SegReader **apNew; + sqlite3_int64 nByte = (pCsr->nSegment + 16)*sizeof(Fts3SegReader*); + apNew = (Fts3SegReader **)sqlite3_realloc64(pCsr->apSegment, nByte); + if( !apNew ){ + sqlite3Fts3SegReaderFree(pNew); + return SQLITE_NOMEM; + } + pCsr->apSegment = apNew; + } + pCsr->apSegment[pCsr->nSegment++] = pNew; + return SQLITE_OK; +} + +/* +** Add seg-reader objects to the Fts3MultiSegReader object passed as the +** 8th argument. +** +** This function returns SQLITE_OK if successful, or an SQLite error code +** otherwise. +*/ +static int fts3SegReaderCursor( + Fts3Table *p, /* FTS3 table handle */ + int iLangid, /* Language id */ + int iIndex, /* Index to search (from 0 to p->nIndex-1) */ + int iLevel, /* Level of segments to scan */ + const char *zTerm, /* Term to query for */ + int nTerm, /* Size of zTerm in bytes */ + int isPrefix, /* True for a prefix search */ + int isScan, /* True to scan from zTerm to EOF */ + Fts3MultiSegReader *pCsr /* Cursor object to populate */ +){ + int rc = SQLITE_OK; /* Error code */ + sqlite3_stmt *pStmt = 0; /* Statement to iterate through segments */ + int rc2; /* Result of sqlite3_reset() */ + + /* If iLevel is less than 0 and this is not a scan, include a seg-reader + ** for the pending-terms. If this is a scan, then this call must be being + ** made by an fts4aux module, not an FTS table. In this case calling + ** Fts3SegReaderPending might segfault, as the data structures used by + ** fts4aux are not completely populated. So it's easiest to filter these + ** calls out here. */ + if( iLevel<0 && p->aIndex && p->iPrevLangid==iLangid ){ + Fts3SegReader *pSeg = 0; + rc = sqlite3Fts3SegReaderPending(p, iIndex, zTerm, nTerm, isPrefix||isScan, &pSeg); + if( rc==SQLITE_OK && pSeg ){ + rc = fts3SegReaderCursorAppend(pCsr, pSeg); + } + } + + if( iLevel!=FTS3_SEGCURSOR_PENDING ){ + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3AllSegdirs(p, iLangid, iIndex, iLevel, &pStmt); + } + + while( rc==SQLITE_OK && SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){ + Fts3SegReader *pSeg = 0; + + /* Read the values returned by the SELECT into local variables. */ + sqlite3_int64 iStartBlock = sqlite3_column_int64(pStmt, 1); + sqlite3_int64 iLeavesEndBlock = sqlite3_column_int64(pStmt, 2); + sqlite3_int64 iEndBlock = sqlite3_column_int64(pStmt, 3); + int nRoot = sqlite3_column_bytes(pStmt, 4); + char const *zRoot = sqlite3_column_blob(pStmt, 4); + + /* If zTerm is not NULL, and this segment is not stored entirely on its + ** root node, the range of leaves scanned can be reduced. Do this. */ + if( iStartBlock && zTerm && zRoot ){ + sqlite3_int64 *pi = (isPrefix ? &iLeavesEndBlock : 0); + rc = fts3SelectLeaf(p, zTerm, nTerm, zRoot, nRoot, &iStartBlock, pi); + if( rc!=SQLITE_OK ) goto finished; + if( isPrefix==0 && isScan==0 ) iLeavesEndBlock = iStartBlock; + } + + rc = sqlite3Fts3SegReaderNew(pCsr->nSegment+1, + (isPrefix==0 && isScan==0), + iStartBlock, iLeavesEndBlock, + iEndBlock, zRoot, nRoot, &pSeg + ); + if( rc!=SQLITE_OK ) goto finished; + rc = fts3SegReaderCursorAppend(pCsr, pSeg); + } + } + + finished: + rc2 = sqlite3_reset(pStmt); + if( rc==SQLITE_DONE ) rc = rc2; + + return rc; +} + +/* +** Set up a cursor object for iterating through a full-text index or a +** single level therein. +*/ +SQLITE_PRIVATE int sqlite3Fts3SegReaderCursor( + Fts3Table *p, /* FTS3 table handle */ + int iLangid, /* Language-id to search */ + int iIndex, /* Index to search (from 0 to p->nIndex-1) */ + int iLevel, /* Level of segments to scan */ + const char *zTerm, /* Term to query for */ + int nTerm, /* Size of zTerm in bytes */ + int isPrefix, /* True for a prefix search */ + int isScan, /* True to scan from zTerm to EOF */ + Fts3MultiSegReader *pCsr /* Cursor object to populate */ +){ + assert( iIndex>=0 && iIndexnIndex ); + assert( iLevel==FTS3_SEGCURSOR_ALL + || iLevel==FTS3_SEGCURSOR_PENDING + || iLevel>=0 + ); + assert( iLevelbase.pVtab; + + if( isPrefix ){ + for(i=1; bFound==0 && inIndex; i++){ + if( p->aIndex[i].nPrefix==nTerm ){ + bFound = 1; + rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid, + i, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 0, 0, pSegcsr + ); + pSegcsr->bLookup = 1; + } + } + + for(i=1; bFound==0 && inIndex; i++){ + if( p->aIndex[i].nPrefix==nTerm+1 ){ + bFound = 1; + rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid, + i, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 1, 0, pSegcsr + ); + if( rc==SQLITE_OK ){ + rc = fts3SegReaderCursorAddZero( + p, pCsr->iLangid, zTerm, nTerm, pSegcsr + ); + } + } + } + } + + if( bFound==0 ){ + rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid, + 0, FTS3_SEGCURSOR_ALL, zTerm, nTerm, isPrefix, 0, pSegcsr + ); + pSegcsr->bLookup = !isPrefix; + } + } + + *ppSegcsr = pSegcsr; + return rc; +} + +/* +** Free an Fts3MultiSegReader allocated by fts3TermSegReaderCursor(). +*/ +static void fts3SegReaderCursorFree(Fts3MultiSegReader *pSegcsr){ + sqlite3Fts3SegReaderFinish(pSegcsr); + sqlite3_free(pSegcsr); +} + +/* +** This function retrieves the doclist for the specified term (or term +** prefix) from the database. +*/ +static int fts3TermSelect( + Fts3Table *p, /* Virtual table handle */ + Fts3PhraseToken *pTok, /* Token to query for */ + int iColumn, /* Column to query (or -ve for all columns) */ + int *pnOut, /* OUT: Size of buffer at *ppOut */ + char **ppOut /* OUT: Malloced result buffer */ +){ + int rc; /* Return code */ + Fts3MultiSegReader *pSegcsr; /* Seg-reader cursor for this term */ + TermSelect tsc; /* Object for pair-wise doclist merging */ + Fts3SegFilter filter; /* Segment term filter configuration */ + + pSegcsr = pTok->pSegcsr; + memset(&tsc, 0, sizeof(TermSelect)); + + filter.flags = FTS3_SEGMENT_IGNORE_EMPTY | FTS3_SEGMENT_REQUIRE_POS + | (pTok->isPrefix ? FTS3_SEGMENT_PREFIX : 0) + | (pTok->bFirst ? FTS3_SEGMENT_FIRST : 0) + | (iColumnnColumn ? FTS3_SEGMENT_COLUMN_FILTER : 0); + filter.iCol = iColumn; + filter.zTerm = pTok->z; + filter.nTerm = pTok->n; + + rc = sqlite3Fts3SegReaderStart(p, pSegcsr, &filter); + while( SQLITE_OK==rc + && SQLITE_ROW==(rc = sqlite3Fts3SegReaderStep(p, pSegcsr)) + ){ + rc = fts3TermSelectMerge(p, &tsc, pSegcsr->aDoclist, pSegcsr->nDoclist); + } + + if( rc==SQLITE_OK ){ + rc = fts3TermSelectFinishMerge(p, &tsc); + } + if( rc==SQLITE_OK ){ + *ppOut = tsc.aaOutput[0]; + *pnOut = tsc.anOutput[0]; + }else{ + int i; + for(i=0; ipSegcsr = 0; + return rc; +} + +/* +** This function counts the total number of docids in the doclist stored +** in buffer aList[], size nList bytes. +** +** If the isPoslist argument is true, then it is assumed that the doclist +** contains a position-list following each docid. Otherwise, it is assumed +** that the doclist is simply a list of docids stored as delta encoded +** varints. +*/ +static int fts3DoclistCountDocids(char *aList, int nList){ + int nDoc = 0; /* Return value */ + if( aList ){ + char *aEnd = &aList[nList]; /* Pointer to one byte after EOF */ + char *p = aList; /* Cursor */ + while( peSearch==FTS3_DOCID_SEARCH || pCsr->eSearch==FTS3_FULLSCAN_SEARCH ){ + Fts3Table *pTab = (Fts3Table*)pCursor->pVtab; + pTab->bLock++; + if( SQLITE_ROW!=sqlite3_step(pCsr->pStmt) ){ + pCsr->isEof = 1; + rc = sqlite3_reset(pCsr->pStmt); + }else{ + pCsr->iPrevId = sqlite3_column_int64(pCsr->pStmt, 0); + rc = SQLITE_OK; + } + pTab->bLock--; + }else{ + rc = fts3EvalNext((Fts3Cursor *)pCursor); + } + assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 ); + return rc; +} + +/* +** If the numeric type of argument pVal is "integer", then return it +** converted to a 64-bit signed integer. Otherwise, return a copy of +** the second parameter, iDefault. +*/ +static sqlite3_int64 fts3DocidRange(sqlite3_value *pVal, i64 iDefault){ + if( pVal ){ + int eType = sqlite3_value_numeric_type(pVal); + if( eType==SQLITE_INTEGER ){ + return sqlite3_value_int64(pVal); + } + } + return iDefault; +} + +/* +** This is the xFilter interface for the virtual table. See +** the virtual table xFilter method documentation for additional +** information. +** +** If idxNum==FTS3_FULLSCAN_SEARCH then do a full table scan against +** the %_content table. +** +** If idxNum==FTS3_DOCID_SEARCH then do a docid lookup for a single entry +** in the %_content table. +** +** If idxNum>=FTS3_FULLTEXT_SEARCH then use the full text index. The +** column on the left-hand side of the MATCH operator is column +** number idxNum-FTS3_FULLTEXT_SEARCH, 0 indexed. argv[0] is the right-hand +** side of the MATCH operator. +*/ +static int fts3FilterMethod( + sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */ + int idxNum, /* Strategy index */ + const char *idxStr, /* Unused */ + int nVal, /* Number of elements in apVal */ + sqlite3_value **apVal /* Arguments for the indexing scheme */ +){ + int rc = SQLITE_OK; + char *zSql; /* SQL statement used to access %_content */ + int eSearch; + Fts3Table *p = (Fts3Table *)pCursor->pVtab; + Fts3Cursor *pCsr = (Fts3Cursor *)pCursor; + + sqlite3_value *pCons = 0; /* The MATCH or rowid constraint, if any */ + sqlite3_value *pLangid = 0; /* The "langid = ?" constraint, if any */ + sqlite3_value *pDocidGe = 0; /* The "docid >= ?" constraint, if any */ + sqlite3_value *pDocidLe = 0; /* The "docid <= ?" constraint, if any */ + int iIdx; + + UNUSED_PARAMETER(idxStr); + UNUSED_PARAMETER(nVal); + + if( p->bLock ){ + return SQLITE_ERROR; + } + + eSearch = (idxNum & 0x0000FFFF); + assert( eSearch>=0 && eSearch<=(FTS3_FULLTEXT_SEARCH+p->nColumn) ); + assert( p->pSegments==0 ); + + /* Collect arguments into local variables */ + iIdx = 0; + if( eSearch!=FTS3_FULLSCAN_SEARCH ) pCons = apVal[iIdx++]; + if( idxNum & FTS3_HAVE_LANGID ) pLangid = apVal[iIdx++]; + if( idxNum & FTS3_HAVE_DOCID_GE ) pDocidGe = apVal[iIdx++]; + if( idxNum & FTS3_HAVE_DOCID_LE ) pDocidLe = apVal[iIdx++]; + assert( iIdx==nVal ); + + /* In case the cursor has been used before, clear it now. */ + fts3ClearCursor(pCsr); + + /* Set the lower and upper bounds on docids to return */ + pCsr->iMinDocid = fts3DocidRange(pDocidGe, SMALLEST_INT64); + pCsr->iMaxDocid = fts3DocidRange(pDocidLe, LARGEST_INT64); + + if( idxStr ){ + pCsr->bDesc = (idxStr[0]=='D'); + }else{ + pCsr->bDesc = p->bDescIdx; + } + pCsr->eSearch = (i16)eSearch; + + if( eSearch!=FTS3_DOCID_SEARCH && eSearch!=FTS3_FULLSCAN_SEARCH ){ + int iCol = eSearch-FTS3_FULLTEXT_SEARCH; + const char *zQuery = (const char *)sqlite3_value_text(pCons); + + if( zQuery==0 && sqlite3_value_type(pCons)!=SQLITE_NULL ){ + return SQLITE_NOMEM; + } + + pCsr->iLangid = 0; + if( pLangid ) pCsr->iLangid = sqlite3_value_int(pLangid); + + assert( p->base.zErrMsg==0 ); + rc = sqlite3Fts3ExprParse(p->pTokenizer, pCsr->iLangid, + p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr, + &p->base.zErrMsg + ); + if( rc!=SQLITE_OK ){ + return rc; + } + + rc = fts3EvalStart(pCsr); + sqlite3Fts3SegmentsClose(p); + if( rc!=SQLITE_OK ) return rc; + pCsr->pNextId = pCsr->aDoclist; + pCsr->iPrevId = 0; + } + + /* Compile a SELECT statement for this cursor. For a full-table-scan, the + ** statement loops through all rows of the %_content table. For a + ** full-text query or docid lookup, the statement retrieves a single + ** row by docid. + */ + if( eSearch==FTS3_FULLSCAN_SEARCH ){ + if( pDocidGe || pDocidLe ){ + zSql = sqlite3_mprintf( + "SELECT %s WHERE rowid BETWEEN %lld AND %lld ORDER BY rowid %s", + p->zReadExprlist, pCsr->iMinDocid, pCsr->iMaxDocid, + (pCsr->bDesc ? "DESC" : "ASC") + ); + }else{ + zSql = sqlite3_mprintf("SELECT %s ORDER BY rowid %s", + p->zReadExprlist, (pCsr->bDesc ? "DESC" : "ASC") + ); + } + if( zSql ){ + p->bLock++; + rc = sqlite3_prepare_v3( + p->db,zSql,-1,SQLITE_PREPARE_PERSISTENT,&pCsr->pStmt,0 + ); + p->bLock--; + sqlite3_free(zSql); + }else{ + rc = SQLITE_NOMEM; + } + }else if( eSearch==FTS3_DOCID_SEARCH ){ + rc = fts3CursorSeekStmt(pCsr); + if( rc==SQLITE_OK ){ + rc = sqlite3_bind_value(pCsr->pStmt, 1, pCons); + } + } + if( rc!=SQLITE_OK ) return rc; + + return fts3NextMethod(pCursor); +} + +/* +** This is the xEof method of the virtual table. SQLite calls this +** routine to find out if it has reached the end of a result set. +*/ +static int fts3EofMethod(sqlite3_vtab_cursor *pCursor){ + Fts3Cursor *pCsr = (Fts3Cursor*)pCursor; + if( pCsr->isEof ){ + fts3ClearCursor(pCsr); + pCsr->isEof = 1; + } + return pCsr->isEof; +} + +/* +** This is the xRowid method. The SQLite core calls this routine to +** retrieve the rowid for the current row of the result set. fts3 +** exposes %_content.docid as the rowid for the virtual table. The +** rowid should be written to *pRowid. +*/ +static int fts3RowidMethod(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){ + Fts3Cursor *pCsr = (Fts3Cursor *) pCursor; + *pRowid = pCsr->iPrevId; + return SQLITE_OK; +} + +/* +** This is the xColumn method, called by SQLite to request a value from +** the row that the supplied cursor currently points to. +** +** If: +** +** (iCol < p->nColumn) -> The value of the iCol'th user column. +** (iCol == p->nColumn) -> Magic column with the same name as the table. +** (iCol == p->nColumn+1) -> Docid column +** (iCol == p->nColumn+2) -> Langid column +*/ +static int fts3ColumnMethod( + sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */ + sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */ + int iCol /* Index of column to read value from */ +){ + int rc = SQLITE_OK; /* Return Code */ + Fts3Cursor *pCsr = (Fts3Cursor *) pCursor; + Fts3Table *p = (Fts3Table *)pCursor->pVtab; + + /* The column value supplied by SQLite must be in range. */ + assert( iCol>=0 && iCol<=p->nColumn+2 ); + + switch( iCol-p->nColumn ){ + case 0: + /* The special 'table-name' column */ + sqlite3_result_pointer(pCtx, pCsr, "fts3cursor", 0); + break; + + case 1: + /* The docid column */ + sqlite3_result_int64(pCtx, pCsr->iPrevId); + break; + + case 2: + if( pCsr->pExpr ){ + sqlite3_result_int64(pCtx, pCsr->iLangid); + break; + }else if( p->zLanguageid==0 ){ + sqlite3_result_int(pCtx, 0); + break; + }else{ + iCol = p->nColumn; + /* no break */ deliberate_fall_through + } + + default: + /* A user column. Or, if this is a full-table scan, possibly the + ** language-id column. Seek the cursor. */ + rc = fts3CursorSeek(0, pCsr); + if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)-1>iCol ){ + sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1)); + } + break; + } + + assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 ); + return rc; +} + +/* +** This function is the implementation of the xUpdate callback used by +** FTS3 virtual tables. It is invoked by SQLite each time a row is to be +** inserted, updated or deleted. +*/ +static int fts3UpdateMethod( + sqlite3_vtab *pVtab, /* Virtual table handle */ + int nArg, /* Size of argument array */ + sqlite3_value **apVal, /* Array of arguments */ + sqlite_int64 *pRowid /* OUT: The affected (or effected) rowid */ +){ + return sqlite3Fts3UpdateMethod(pVtab, nArg, apVal, pRowid); +} + +/* +** Implementation of xSync() method. Flush the contents of the pending-terms +** hash-table to the database. +*/ +static int fts3SyncMethod(sqlite3_vtab *pVtab){ + + /* Following an incremental-merge operation, assuming that the input + ** segments are not completely consumed (the usual case), they are updated + ** in place to remove the entries that have already been merged. This + ** involves updating the leaf block that contains the smallest unmerged + ** entry and each block (if any) between the leaf and the root node. So + ** if the height of the input segment b-trees is N, and input segments + ** are merged eight at a time, updating the input segments at the end + ** of an incremental-merge requires writing (8*(1+N)) blocks. N is usually + ** small - often between 0 and 2. So the overhead of the incremental + ** merge is somewhere between 8 and 24 blocks. To avoid this overhead + ** dwarfing the actual productive work accomplished, the incremental merge + ** is only attempted if it will write at least 64 leaf blocks. Hence + ** nMinMerge. + ** + ** Of course, updating the input segments also involves deleting a bunch + ** of blocks from the segments table. But this is not considered overhead + ** as it would also be required by a crisis-merge that used the same input + ** segments. + */ + const u32 nMinMerge = 64; /* Minimum amount of incr-merge work to do */ + + Fts3Table *p = (Fts3Table*)pVtab; + int rc; + i64 iLastRowid = sqlite3_last_insert_rowid(p->db); + + rc = sqlite3Fts3PendingTermsFlush(p); + if( rc==SQLITE_OK + && p->nLeafAdd>(nMinMerge/16) + && p->nAutoincrmerge && p->nAutoincrmerge!=0xff + ){ + int mxLevel = 0; /* Maximum relative level value in db */ + int A; /* Incr-merge parameter A */ + + rc = sqlite3Fts3MaxLevel(p, &mxLevel); + assert( rc==SQLITE_OK || mxLevel==0 ); + A = p->nLeafAdd * mxLevel; + A += (A/2); + if( A>(int)nMinMerge ) rc = sqlite3Fts3Incrmerge(p, A, p->nAutoincrmerge); + } + sqlite3Fts3SegmentsClose(p); + sqlite3_set_last_insert_rowid(p->db, iLastRowid); + return rc; +} + +/* +** If it is currently unknown whether or not the FTS table has an %_stat +** table (if p->bHasStat==2), attempt to determine this (set p->bHasStat +** to 0 or 1). Return SQLITE_OK if successful, or an SQLite error code +** if an error occurs. +*/ +static int fts3SetHasStat(Fts3Table *p){ + int rc = SQLITE_OK; + if( p->bHasStat==2 ){ + char *zTbl = sqlite3_mprintf("%s_stat", p->zName); + if( zTbl ){ + int res = sqlite3_table_column_metadata(p->db, p->zDb, zTbl, 0,0,0,0,0,0); + sqlite3_free(zTbl); + p->bHasStat = (res==SQLITE_OK); + }else{ + rc = SQLITE_NOMEM; + } + } + return rc; +} + +/* +** Implementation of xBegin() method. +*/ +static int fts3BeginMethod(sqlite3_vtab *pVtab){ + Fts3Table *p = (Fts3Table*)pVtab; + UNUSED_PARAMETER(pVtab); + assert( p->pSegments==0 ); + assert( p->nPendingData==0 ); + assert( p->inTransaction!=1 ); + TESTONLY( p->inTransaction = 1 ); + TESTONLY( p->mxSavepoint = -1; ); + p->nLeafAdd = 0; + return fts3SetHasStat(p); +} + +/* +** Implementation of xCommit() method. This is a no-op. The contents of +** the pending-terms hash-table have already been flushed into the database +** by fts3SyncMethod(). +*/ +static int fts3CommitMethod(sqlite3_vtab *pVtab){ + TESTONLY( Fts3Table *p = (Fts3Table*)pVtab ); + UNUSED_PARAMETER(pVtab); + assert( p->nPendingData==0 ); + assert( p->inTransaction!=0 ); + assert( p->pSegments==0 ); + TESTONLY( p->inTransaction = 0 ); + TESTONLY( p->mxSavepoint = -1; ); + return SQLITE_OK; +} + +/* +** Implementation of xRollback(). Discard the contents of the pending-terms +** hash-table. Any changes made to the database are reverted by SQLite. +*/ +static int fts3RollbackMethod(sqlite3_vtab *pVtab){ + Fts3Table *p = (Fts3Table*)pVtab; + sqlite3Fts3PendingTermsClear(p); + assert( p->inTransaction!=0 ); + TESTONLY( p->inTransaction = 0 ); + TESTONLY( p->mxSavepoint = -1; ); + return SQLITE_OK; +} + +/* +** When called, *ppPoslist must point to the byte immediately following the +** end of a position-list. i.e. ( (*ppPoslist)[-1]==POS_END ). This function +** moves *ppPoslist so that it instead points to the first byte of the +** same position list. +*/ +static void fts3ReversePoslist(char *pStart, char **ppPoslist){ + char *p = &(*ppPoslist)[-2]; + char c = 0; + + /* Skip backwards passed any trailing 0x00 bytes added by NearTrim() */ + while( p>pStart && (c=*p--)==0 ); + + /* Search backwards for a varint with value zero (the end of the previous + ** poslist). This is an 0x00 byte preceded by some byte that does not + ** have the 0x80 bit set. */ + while( p>pStart && (*p & 0x80) | c ){ + c = *p--; + } + assert( p==pStart || c==0 ); + + /* At this point p points to that preceding byte without the 0x80 bit + ** set. So to find the start of the poslist, skip forward 2 bytes then + ** over a varint. + ** + ** Normally. The other case is that p==pStart and the poslist to return + ** is the first in the doclist. In this case do not skip forward 2 bytes. + ** The second part of the if condition (c==0 && *ppPoslist>&p[2]) + ** is required for cases where the first byte of a doclist and the + ** doclist is empty. For example, if the first docid is 10, a doclist + ** that begins with: + ** + ** 0x0A 0x00 + */ + if( p>pStart || (c==0 && *ppPoslist>&p[2]) ){ p = &p[2]; } + while( *p++&0x80 ); + *ppPoslist = p; +} + +/* +** Helper function used by the implementation of the overloaded snippet(), +** offsets() and optimize() SQL functions. +** +** If the value passed as the third argument is a blob of size +** sizeof(Fts3Cursor*), then the blob contents are copied to the +** output variable *ppCsr and SQLITE_OK is returned. Otherwise, an error +** message is written to context pContext and SQLITE_ERROR returned. The +** string passed via zFunc is used as part of the error message. +*/ +static int fts3FunctionArg( + sqlite3_context *pContext, /* SQL function call context */ + const char *zFunc, /* Function name */ + sqlite3_value *pVal, /* argv[0] passed to function */ + Fts3Cursor **ppCsr /* OUT: Store cursor handle here */ +){ + int rc; + *ppCsr = (Fts3Cursor*)sqlite3_value_pointer(pVal, "fts3cursor"); + if( (*ppCsr)!=0 ){ + rc = SQLITE_OK; + }else{ + char *zErr = sqlite3_mprintf("illegal first argument to %s", zFunc); + sqlite3_result_error(pContext, zErr, -1); + sqlite3_free(zErr); + rc = SQLITE_ERROR; + } + return rc; +} + +/* +** Implementation of the snippet() function for FTS3 +*/ +static void fts3SnippetFunc( + sqlite3_context *pContext, /* SQLite function call context */ + int nVal, /* Size of apVal[] array */ + sqlite3_value **apVal /* Array of arguments */ +){ + Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */ + const char *zStart = ""; + const char *zEnd = ""; + const char *zEllipsis = "..."; + int iCol = -1; + int nToken = 15; /* Default number of tokens in snippet */ + + /* There must be at least one argument passed to this function (otherwise + ** the non-overloaded version would have been called instead of this one). + */ + assert( nVal>=1 ); + + if( nVal>6 ){ + sqlite3_result_error(pContext, + "wrong number of arguments to function snippet()", -1); + return; + } + if( fts3FunctionArg(pContext, "snippet", apVal[0], &pCsr) ) return; + + switch( nVal ){ + case 6: nToken = sqlite3_value_int(apVal[5]); + /* no break */ deliberate_fall_through + case 5: iCol = sqlite3_value_int(apVal[4]); + /* no break */ deliberate_fall_through + case 4: zEllipsis = (const char*)sqlite3_value_text(apVal[3]); + /* no break */ deliberate_fall_through + case 3: zEnd = (const char*)sqlite3_value_text(apVal[2]); + /* no break */ deliberate_fall_through + case 2: zStart = (const char*)sqlite3_value_text(apVal[1]); + } + if( !zEllipsis || !zEnd || !zStart ){ + sqlite3_result_error_nomem(pContext); + }else if( nToken==0 ){ + sqlite3_result_text(pContext, "", -1, SQLITE_STATIC); + }else if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){ + sqlite3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken); + } +} + +/* +** Implementation of the offsets() function for FTS3 +*/ +static void fts3OffsetsFunc( + sqlite3_context *pContext, /* SQLite function call context */ + int nVal, /* Size of argument array */ + sqlite3_value **apVal /* Array of arguments */ +){ + Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */ + + UNUSED_PARAMETER(nVal); + + assert( nVal==1 ); + if( fts3FunctionArg(pContext, "offsets", apVal[0], &pCsr) ) return; + assert( pCsr ); + if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){ + sqlite3Fts3Offsets(pContext, pCsr); + } +} + +/* +** Implementation of the special optimize() function for FTS3. This +** function merges all segments in the database to a single segment. +** Example usage is: +** +** SELECT optimize(t) FROM t LIMIT 1; +** +** where 't' is the name of an FTS3 table. +*/ +static void fts3OptimizeFunc( + sqlite3_context *pContext, /* SQLite function call context */ + int nVal, /* Size of argument array */ + sqlite3_value **apVal /* Array of arguments */ +){ + int rc; /* Return code */ + Fts3Table *p; /* Virtual table handle */ + Fts3Cursor *pCursor; /* Cursor handle passed through apVal[0] */ + + UNUSED_PARAMETER(nVal); + + assert( nVal==1 ); + if( fts3FunctionArg(pContext, "optimize", apVal[0], &pCursor) ) return; + p = (Fts3Table *)pCursor->base.pVtab; + assert( p ); + + rc = sqlite3Fts3Optimize(p); + + switch( rc ){ + case SQLITE_OK: + sqlite3_result_text(pContext, "Index optimized", -1, SQLITE_STATIC); + break; + case SQLITE_DONE: + sqlite3_result_text(pContext, "Index already optimal", -1, SQLITE_STATIC); + break; + default: + sqlite3_result_error_code(pContext, rc); + break; + } +} + +/* +** Implementation of the matchinfo() function for FTS3 +*/ +static void fts3MatchinfoFunc( + sqlite3_context *pContext, /* SQLite function call context */ + int nVal, /* Size of argument array */ + sqlite3_value **apVal /* Array of arguments */ +){ + Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */ + assert( nVal==1 || nVal==2 ); + if( SQLITE_OK==fts3FunctionArg(pContext, "matchinfo", apVal[0], &pCsr) ){ + const char *zArg = 0; + if( nVal>1 ){ + zArg = (const char *)sqlite3_value_text(apVal[1]); + } + sqlite3Fts3Matchinfo(pContext, pCsr, zArg); + } +} + +/* +** This routine implements the xFindFunction method for the FTS3 +** virtual table. +*/ +static int fts3FindFunctionMethod( + sqlite3_vtab *pVtab, /* Virtual table handle */ + int nArg, /* Number of SQL function arguments */ + const char *zName, /* Name of SQL function */ + void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */ + void **ppArg /* Unused */ +){ + struct Overloaded { + const char *zName; + void (*xFunc)(sqlite3_context*,int,sqlite3_value**); + } aOverload[] = { + { "snippet", fts3SnippetFunc }, + { "offsets", fts3OffsetsFunc }, + { "optimize", fts3OptimizeFunc }, + { "matchinfo", fts3MatchinfoFunc }, + }; + int i; /* Iterator variable */ + + UNUSED_PARAMETER(pVtab); + UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(ppArg); + + for(i=0; idb; /* Database connection */ + int rc; /* Return Code */ + + /* At this point it must be known if the %_stat table exists or not. + ** So bHasStat may not be 2. */ + rc = fts3SetHasStat(p); + + /* As it happens, the pending terms table is always empty here. This is + ** because an "ALTER TABLE RENAME TABLE" statement inside a transaction + ** always opens a savepoint transaction. And the xSavepoint() method + ** flushes the pending terms table. But leave the (no-op) call to + ** PendingTermsFlush() in in case that changes. + */ + assert( p->nPendingData==0 ); + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3PendingTermsFlush(p); + } + + if( p->zContentTbl==0 ){ + fts3DbExec(&rc, db, + "ALTER TABLE %Q.'%q_content' RENAME TO '%q_content';", + p->zDb, p->zName, zName + ); + } + + if( p->bHasDocsize ){ + fts3DbExec(&rc, db, + "ALTER TABLE %Q.'%q_docsize' RENAME TO '%q_docsize';", + p->zDb, p->zName, zName + ); + } + if( p->bHasStat ){ + fts3DbExec(&rc, db, + "ALTER TABLE %Q.'%q_stat' RENAME TO '%q_stat';", + p->zDb, p->zName, zName + ); + } + fts3DbExec(&rc, db, + "ALTER TABLE %Q.'%q_segments' RENAME TO '%q_segments';", + p->zDb, p->zName, zName + ); + fts3DbExec(&rc, db, + "ALTER TABLE %Q.'%q_segdir' RENAME TO '%q_segdir';", + p->zDb, p->zName, zName + ); + return rc; +} + +/* +** The xSavepoint() method. +** +** Flush the contents of the pending-terms table to disk. +*/ +static int fts3SavepointMethod(sqlite3_vtab *pVtab, int iSavepoint){ + int rc = SQLITE_OK; + UNUSED_PARAMETER(iSavepoint); + assert( ((Fts3Table *)pVtab)->inTransaction ); + assert( ((Fts3Table *)pVtab)->mxSavepoint <= iSavepoint ); + TESTONLY( ((Fts3Table *)pVtab)->mxSavepoint = iSavepoint ); + if( ((Fts3Table *)pVtab)->bIgnoreSavepoint==0 ){ + rc = fts3SyncMethod(pVtab); + } + return rc; +} + +/* +** The xRelease() method. +** +** This is a no-op. +*/ +static int fts3ReleaseMethod(sqlite3_vtab *pVtab, int iSavepoint){ + TESTONLY( Fts3Table *p = (Fts3Table*)pVtab ); + UNUSED_PARAMETER(iSavepoint); + UNUSED_PARAMETER(pVtab); + assert( p->inTransaction ); + assert( p->mxSavepoint >= iSavepoint ); + TESTONLY( p->mxSavepoint = iSavepoint-1 ); + return SQLITE_OK; +} + +/* +** The xRollbackTo() method. +** +** Discard the contents of the pending terms table. +*/ +static int fts3RollbackToMethod(sqlite3_vtab *pVtab, int iSavepoint){ + Fts3Table *p = (Fts3Table*)pVtab; + UNUSED_PARAMETER(iSavepoint); + assert( p->inTransaction ); + TESTONLY( p->mxSavepoint = iSavepoint ); + sqlite3Fts3PendingTermsClear(p); + return SQLITE_OK; +} + +/* +** Return true if zName is the extension on one of the shadow tables used +** by this module. +*/ +static int fts3ShadowName(const char *zName){ + static const char *azName[] = { + "content", "docsize", "segdir", "segments", "stat", + }; + unsigned int i; + for(i=0; ieType==FTSQUERY_PHRASE ){ + int i; + int nToken = pExpr->pPhrase->nToken; + *pnToken += nToken; + for(i=0; ipPhrase->aToken[i]; + int rc = fts3TermSegReaderCursor(pCsr, + pToken->z, pToken->n, pToken->isPrefix, &pToken->pSegcsr + ); + if( rc!=SQLITE_OK ){ + *pRc = rc; + return; + } + } + assert( pExpr->pPhrase->iDoclistToken==0 ); + pExpr->pPhrase->iDoclistToken = -1; + }else{ + *pnOr += (pExpr->eType==FTSQUERY_OR); + fts3EvalAllocateReaders(pCsr, pExpr->pLeft, pnToken, pnOr, pRc); + fts3EvalAllocateReaders(pCsr, pExpr->pRight, pnToken, pnOr, pRc); + } + } +} + +/* +** Arguments pList/nList contain the doclist for token iToken of phrase p. +** It is merged into the main doclist stored in p->doclist.aAll/nAll. +** +** This function assumes that pList points to a buffer allocated using +** sqlite3_malloc(). This function takes responsibility for eventually +** freeing the buffer. +** +** SQLITE_OK is returned if successful, or SQLITE_NOMEM if an error occurs. +*/ +static int fts3EvalPhraseMergeToken( + Fts3Table *pTab, /* FTS Table pointer */ + Fts3Phrase *p, /* Phrase to merge pList/nList into */ + int iToken, /* Token pList/nList corresponds to */ + char *pList, /* Pointer to doclist */ + int nList /* Number of bytes in pList */ +){ + int rc = SQLITE_OK; + assert( iToken!=p->iDoclistToken ); + + if( pList==0 ){ + sqlite3_free(p->doclist.aAll); + p->doclist.aAll = 0; + p->doclist.nAll = 0; + } + + else if( p->iDoclistToken<0 ){ + p->doclist.aAll = pList; + p->doclist.nAll = nList; + } + + else if( p->doclist.aAll==0 ){ + sqlite3_free(pList); + } + + else { + char *pLeft; + char *pRight; + int nLeft; + int nRight; + int nDiff; + + if( p->iDoclistTokendoclist.aAll; + nLeft = p->doclist.nAll; + pRight = pList; + nRight = nList; + nDiff = iToken - p->iDoclistToken; + }else{ + pRight = p->doclist.aAll; + nRight = p->doclist.nAll; + pLeft = pList; + nLeft = nList; + nDiff = p->iDoclistToken - iToken; + } + + rc = fts3DoclistPhraseMerge( + pTab->bDescIdx, nDiff, pLeft, nLeft, &pRight, &nRight + ); + sqlite3_free(pLeft); + p->doclist.aAll = pRight; + p->doclist.nAll = nRight; + } + + if( iToken>p->iDoclistToken ) p->iDoclistToken = iToken; + return rc; +} + +/* +** Load the doclist for phrase p into p->doclist.aAll/nAll. The loaded doclist +** does not take deferred tokens into account. +** +** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code. +*/ +static int fts3EvalPhraseLoad( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Phrase *p /* Phrase object */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int iToken; + int rc = SQLITE_OK; + + for(iToken=0; rc==SQLITE_OK && iTokennToken; iToken++){ + Fts3PhraseToken *pToken = &p->aToken[iToken]; + assert( pToken->pDeferred==0 || pToken->pSegcsr==0 ); + + if( pToken->pSegcsr ){ + int nThis = 0; + char *pThis = 0; + rc = fts3TermSelect(pTab, pToken, p->iColumn, &nThis, &pThis); + if( rc==SQLITE_OK ){ + rc = fts3EvalPhraseMergeToken(pTab, p, iToken, pThis, nThis); + } + } + assert( pToken->pSegcsr==0 ); + } + + return rc; +} + +#ifndef SQLITE_DISABLE_FTS4_DEFERRED +/* +** This function is called on each phrase after the position lists for +** any deferred tokens have been loaded into memory. It updates the phrases +** current position list to include only those positions that are really +** instances of the phrase (after considering deferred tokens). If this +** means that the phrase does not appear in the current row, doclist.pList +** and doclist.nList are both zeroed. +** +** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code. +*/ +static int fts3EvalDeferredPhrase(Fts3Cursor *pCsr, Fts3Phrase *pPhrase){ + int iToken; /* Used to iterate through phrase tokens */ + char *aPoslist = 0; /* Position list for deferred tokens */ + int nPoslist = 0; /* Number of bytes in aPoslist */ + int iPrev = -1; /* Token number of previous deferred token */ + + assert( pPhrase->doclist.bFreeList==0 ); + + for(iToken=0; iTokennToken; iToken++){ + Fts3PhraseToken *pToken = &pPhrase->aToken[iToken]; + Fts3DeferredToken *pDeferred = pToken->pDeferred; + + if( pDeferred ){ + char *pList; + int nList; + int rc = sqlite3Fts3DeferredTokenList(pDeferred, &pList, &nList); + if( rc!=SQLITE_OK ) return rc; + + if( pList==0 ){ + sqlite3_free(aPoslist); + pPhrase->doclist.pList = 0; + pPhrase->doclist.nList = 0; + return SQLITE_OK; + + }else if( aPoslist==0 ){ + aPoslist = pList; + nPoslist = nList; + + }else{ + char *aOut = pList; + char *p1 = aPoslist; + char *p2 = aOut; + + assert( iPrev>=0 ); + fts3PoslistPhraseMerge(&aOut, iToken-iPrev, 0, 1, &p1, &p2); + sqlite3_free(aPoslist); + aPoslist = pList; + nPoslist = (int)(aOut - aPoslist); + if( nPoslist==0 ){ + sqlite3_free(aPoslist); + pPhrase->doclist.pList = 0; + pPhrase->doclist.nList = 0; + return SQLITE_OK; + } + } + iPrev = iToken; + } + } + + if( iPrev>=0 ){ + int nMaxUndeferred = pPhrase->iDoclistToken; + if( nMaxUndeferred<0 ){ + pPhrase->doclist.pList = aPoslist; + pPhrase->doclist.nList = nPoslist; + pPhrase->doclist.iDocid = pCsr->iPrevId; + pPhrase->doclist.bFreeList = 1; + }else{ + int nDistance; + char *p1; + char *p2; + char *aOut; + + if( nMaxUndeferred>iPrev ){ + p1 = aPoslist; + p2 = pPhrase->doclist.pList; + nDistance = nMaxUndeferred - iPrev; + }else{ + p1 = pPhrase->doclist.pList; + p2 = aPoslist; + nDistance = iPrev - nMaxUndeferred; + } + + aOut = (char *)sqlite3_malloc(nPoslist+8); + if( !aOut ){ + sqlite3_free(aPoslist); + return SQLITE_NOMEM; + } + + pPhrase->doclist.pList = aOut; + if( fts3PoslistPhraseMerge(&aOut, nDistance, 0, 1, &p1, &p2) ){ + pPhrase->doclist.bFreeList = 1; + pPhrase->doclist.nList = (int)(aOut - pPhrase->doclist.pList); + }else{ + sqlite3_free(aOut); + pPhrase->doclist.pList = 0; + pPhrase->doclist.nList = 0; + } + sqlite3_free(aPoslist); + } + } + + return SQLITE_OK; +} +#endif /* SQLITE_DISABLE_FTS4_DEFERRED */ + +/* +** Maximum number of tokens a phrase may have to be considered for the +** incremental doclists strategy. +*/ +#define MAX_INCR_PHRASE_TOKENS 4 + +/* +** This function is called for each Fts3Phrase in a full-text query +** expression to initialize the mechanism for returning rows. Once this +** function has been called successfully on an Fts3Phrase, it may be +** used with fts3EvalPhraseNext() to iterate through the matching docids. +** +** If parameter bOptOk is true, then the phrase may (or may not) use the +** incremental loading strategy. Otherwise, the entire doclist is loaded into +** memory within this call. +** +** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code. +*/ +static int fts3EvalPhraseStart(Fts3Cursor *pCsr, int bOptOk, Fts3Phrase *p){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc = SQLITE_OK; /* Error code */ + int i; + + /* Determine if doclists may be loaded from disk incrementally. This is + ** possible if the bOptOk argument is true, the FTS doclists will be + ** scanned in forward order, and the phrase consists of + ** MAX_INCR_PHRASE_TOKENS or fewer tokens, none of which are are "^first" + ** tokens or prefix tokens that cannot use a prefix-index. */ + int bHaveIncr = 0; + int bIncrOk = (bOptOk + && pCsr->bDesc==pTab->bDescIdx + && p->nToken<=MAX_INCR_PHRASE_TOKENS && p->nToken>0 +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + && pTab->bNoIncrDoclist==0 +#endif + ); + for(i=0; bIncrOk==1 && inToken; i++){ + Fts3PhraseToken *pToken = &p->aToken[i]; + if( pToken->bFirst || (pToken->pSegcsr!=0 && !pToken->pSegcsr->bLookup) ){ + bIncrOk = 0; + } + if( pToken->pSegcsr ) bHaveIncr = 1; + } + + if( bIncrOk && bHaveIncr ){ + /* Use the incremental approach. */ + int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn); + for(i=0; rc==SQLITE_OK && inToken; i++){ + Fts3PhraseToken *pToken = &p->aToken[i]; + Fts3MultiSegReader *pSegcsr = pToken->pSegcsr; + if( pSegcsr ){ + rc = sqlite3Fts3MsrIncrStart(pTab, pSegcsr, iCol, pToken->z, pToken->n); + } + } + p->bIncr = 1; + }else{ + /* Load the full doclist for the phrase into memory. */ + rc = fts3EvalPhraseLoad(pCsr, p); + p->bIncr = 0; + } + + assert( rc!=SQLITE_OK || p->nToken<1 || p->aToken[0].pSegcsr==0 || p->bIncr ); + return rc; +} + +/* +** This function is used to iterate backwards (from the end to start) +** through doclists. It is used by this module to iterate through phrase +** doclists in reverse and by the fts3_write.c module to iterate through +** pending-terms lists when writing to databases with "order=desc". +** +** The doclist may be sorted in ascending (parameter bDescIdx==0) or +** descending (parameter bDescIdx==1) order of docid. Regardless, this +** function iterates from the end of the doclist to the beginning. +*/ +SQLITE_PRIVATE void sqlite3Fts3DoclistPrev( + int bDescIdx, /* True if the doclist is desc */ + char *aDoclist, /* Pointer to entire doclist */ + int nDoclist, /* Length of aDoclist in bytes */ + char **ppIter, /* IN/OUT: Iterator pointer */ + sqlite3_int64 *piDocid, /* IN/OUT: Docid pointer */ + int *pnList, /* OUT: List length pointer */ + u8 *pbEof /* OUT: End-of-file flag */ +){ + char *p = *ppIter; + + assert( nDoclist>0 ); + assert( *pbEof==0 ); + assert( p || *piDocid==0 ); + assert( !p || (p>aDoclist && p<&aDoclist[nDoclist]) ); + + if( p==0 ){ + sqlite3_int64 iDocid = 0; + char *pNext = 0; + char *pDocid = aDoclist; + char *pEnd = &aDoclist[nDoclist]; + int iMul = 1; + + while( pDocid0 ); + assert( *pbEof==0 ); + assert_fts3_nc( p || *piDocid==0 ); + assert( !p || (p>=aDoclist && p<=&aDoclist[nDoclist]) ); + + if( p==0 ){ + p = aDoclist; + p += sqlite3Fts3GetVarint(p, piDocid); + }else{ + fts3PoslistCopy(0, &p); + while( p<&aDoclist[nDoclist] && *p==0 ) p++; + if( p>=&aDoclist[nDoclist] ){ + *pbEof = 1; + }else{ + sqlite3_int64 iVar; + p += sqlite3Fts3GetVarint(p, &iVar); + *piDocid += ((bDescIdx ? -1 : 1) * iVar); + } + } + + *ppIter = p; +} + +/* +** Advance the iterator pDL to the next entry in pDL->aAll/nAll. Set *pbEof +** to true if EOF is reached. +*/ +static void fts3EvalDlPhraseNext( + Fts3Table *pTab, + Fts3Doclist *pDL, + u8 *pbEof +){ + char *pIter; /* Used to iterate through aAll */ + char *pEnd; /* 1 byte past end of aAll */ + + if( pDL->pNextDocid ){ + pIter = pDL->pNextDocid; + assert( pDL->aAll!=0 || pIter==0 ); + }else{ + pIter = pDL->aAll; + } + + if( pIter==0 || pIter>=(pEnd = pDL->aAll + pDL->nAll) ){ + /* We have already reached the end of this doclist. EOF. */ + *pbEof = 1; + }else{ + sqlite3_int64 iDelta; + pIter += sqlite3Fts3GetVarint(pIter, &iDelta); + if( pTab->bDescIdx==0 || pDL->pNextDocid==0 ){ + pDL->iDocid += iDelta; + }else{ + pDL->iDocid -= iDelta; + } + pDL->pList = pIter; + fts3PoslistCopy(0, &pIter); + pDL->nList = (int)(pIter - pDL->pList); + + /* pIter now points just past the 0x00 that terminates the position- + ** list for document pDL->iDocid. However, if this position-list was + ** edited in place by fts3EvalNearTrim(), then pIter may not actually + ** point to the start of the next docid value. The following line deals + ** with this case by advancing pIter past the zero-padding added by + ** fts3EvalNearTrim(). */ + while( pIterpNextDocid = pIter; + assert( pIter>=&pDL->aAll[pDL->nAll] || *pIter ); + *pbEof = 0; + } +} + +/* +** Helper type used by fts3EvalIncrPhraseNext() and incrPhraseTokenNext(). +*/ +typedef struct TokenDoclist TokenDoclist; +struct TokenDoclist { + int bIgnore; + sqlite3_int64 iDocid; + char *pList; + int nList; +}; + +/* +** Token pToken is an incrementally loaded token that is part of a +** multi-token phrase. Advance it to the next matching document in the +** database and populate output variable *p with the details of the new +** entry. Or, if the iterator has reached EOF, set *pbEof to true. +** +** If an error occurs, return an SQLite error code. Otherwise, return +** SQLITE_OK. +*/ +static int incrPhraseTokenNext( + Fts3Table *pTab, /* Virtual table handle */ + Fts3Phrase *pPhrase, /* Phrase to advance token of */ + int iToken, /* Specific token to advance */ + TokenDoclist *p, /* OUT: Docid and doclist for new entry */ + u8 *pbEof /* OUT: True if iterator is at EOF */ +){ + int rc = SQLITE_OK; + + if( pPhrase->iDoclistToken==iToken ){ + assert( p->bIgnore==0 ); + assert( pPhrase->aToken[iToken].pSegcsr==0 ); + fts3EvalDlPhraseNext(pTab, &pPhrase->doclist, pbEof); + p->pList = pPhrase->doclist.pList; + p->nList = pPhrase->doclist.nList; + p->iDocid = pPhrase->doclist.iDocid; + }else{ + Fts3PhraseToken *pToken = &pPhrase->aToken[iToken]; + assert( pToken->pDeferred==0 ); + assert( pToken->pSegcsr || pPhrase->iDoclistToken>=0 ); + if( pToken->pSegcsr ){ + assert( p->bIgnore==0 ); + rc = sqlite3Fts3MsrIncrNext( + pTab, pToken->pSegcsr, &p->iDocid, &p->pList, &p->nList + ); + if( p->pList==0 ) *pbEof = 1; + }else{ + p->bIgnore = 1; + } + } + + return rc; +} + + +/* +** The phrase iterator passed as the second argument: +** +** * features at least one token that uses an incremental doclist, and +** +** * does not contain any deferred tokens. +** +** Advance it to the next matching documnent in the database and populate +** the Fts3Doclist.pList and nList fields. +** +** If there is no "next" entry and no error occurs, then *pbEof is set to +** 1 before returning. Otherwise, if no error occurs and the iterator is +** successfully advanced, *pbEof is set to 0. +** +** If an error occurs, return an SQLite error code. Otherwise, return +** SQLITE_OK. +*/ +static int fts3EvalIncrPhraseNext( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Phrase *p, /* Phrase object to advance to next docid */ + u8 *pbEof /* OUT: Set to 1 if EOF */ +){ + int rc = SQLITE_OK; + Fts3Doclist *pDL = &p->doclist; + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + u8 bEof = 0; + + /* This is only called if it is guaranteed that the phrase has at least + ** one incremental token. In which case the bIncr flag is set. */ + assert( p->bIncr==1 ); + + if( p->nToken==1 ){ + rc = sqlite3Fts3MsrIncrNext(pTab, p->aToken[0].pSegcsr, + &pDL->iDocid, &pDL->pList, &pDL->nList + ); + if( pDL->pList==0 ) bEof = 1; + }else{ + int bDescDoclist = pCsr->bDesc; + struct TokenDoclist a[MAX_INCR_PHRASE_TOKENS]; + + memset(a, 0, sizeof(a)); + assert( p->nToken<=MAX_INCR_PHRASE_TOKENS ); + assert( p->iDoclistTokennToken && bEof==0; i++){ + rc = incrPhraseTokenNext(pTab, p, i, &a[i], &bEof); + if( a[i].bIgnore==0 && (bMaxSet==0 || DOCID_CMP(iMax, a[i].iDocid)<0) ){ + iMax = a[i].iDocid; + bMaxSet = 1; + } + } + assert( rc!=SQLITE_OK || (p->nToken>=1 && a[p->nToken-1].bIgnore==0) ); + assert( rc!=SQLITE_OK || bMaxSet ); + + /* Keep advancing iterators until they all point to the same document */ + for(i=0; inToken; i++){ + while( rc==SQLITE_OK && bEof==0 + && a[i].bIgnore==0 && DOCID_CMP(a[i].iDocid, iMax)<0 + ){ + rc = incrPhraseTokenNext(pTab, p, i, &a[i], &bEof); + if( DOCID_CMP(a[i].iDocid, iMax)>0 ){ + iMax = a[i].iDocid; + i = 0; + } + } + } + + /* Check if the current entries really are a phrase match */ + if( bEof==0 ){ + int nList = 0; + int nByte = a[p->nToken-1].nList; + char *aDoclist = sqlite3_malloc(nByte+FTS3_BUFFER_PADDING); + if( !aDoclist ) return SQLITE_NOMEM; + memcpy(aDoclist, a[p->nToken-1].pList, nByte+1); + memset(&aDoclist[nByte], 0, FTS3_BUFFER_PADDING); + + for(i=0; i<(p->nToken-1); i++){ + if( a[i].bIgnore==0 ){ + char *pL = a[i].pList; + char *pR = aDoclist; + char *pOut = aDoclist; + int nDist = p->nToken-1-i; + int res = fts3PoslistPhraseMerge(&pOut, nDist, 0, 1, &pL, &pR); + if( res==0 ) break; + nList = (int)(pOut - aDoclist); + } + } + if( i==(p->nToken-1) ){ + pDL->iDocid = iMax; + pDL->pList = aDoclist; + pDL->nList = nList; + pDL->bFreeList = 1; + break; + } + sqlite3_free(aDoclist); + } + } + } + + *pbEof = bEof; + return rc; +} + +/* +** Attempt to move the phrase iterator to point to the next matching docid. +** If an error occurs, return an SQLite error code. Otherwise, return +** SQLITE_OK. +** +** If there is no "next" entry and no error occurs, then *pbEof is set to +** 1 before returning. Otherwise, if no error occurs and the iterator is +** successfully advanced, *pbEof is set to 0. +*/ +static int fts3EvalPhraseNext( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Phrase *p, /* Phrase object to advance to next docid */ + u8 *pbEof /* OUT: Set to 1 if EOF */ +){ + int rc = SQLITE_OK; + Fts3Doclist *pDL = &p->doclist; + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + + if( p->bIncr ){ + rc = fts3EvalIncrPhraseNext(pCsr, p, pbEof); + }else if( pCsr->bDesc!=pTab->bDescIdx && pDL->nAll ){ + sqlite3Fts3DoclistPrev(pTab->bDescIdx, pDL->aAll, pDL->nAll, + &pDL->pNextDocid, &pDL->iDocid, &pDL->nList, pbEof + ); + pDL->pList = pDL->pNextDocid; + }else{ + fts3EvalDlPhraseNext(pTab, pDL, pbEof); + } + + return rc; +} + +/* +** +** If *pRc is not SQLITE_OK when this function is called, it is a no-op. +** Otherwise, fts3EvalPhraseStart() is called on all phrases within the +** expression. Also the Fts3Expr.bDeferred variable is set to true for any +** expressions for which all descendent tokens are deferred. +** +** If parameter bOptOk is zero, then it is guaranteed that the +** Fts3Phrase.doclist.aAll/nAll variables contain the entire doclist for +** each phrase in the expression (subject to deferred token processing). +** Or, if bOptOk is non-zero, then one or more tokens within the expression +** may be loaded incrementally, meaning doclist.aAll/nAll is not available. +** +** If an error occurs within this function, *pRc is set to an SQLite error +** code before returning. +*/ +static void fts3EvalStartReaders( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Expr *pExpr, /* Expression to initialize phrases in */ + int *pRc /* IN/OUT: Error code */ +){ + if( pExpr && SQLITE_OK==*pRc ){ + if( pExpr->eType==FTSQUERY_PHRASE ){ + int nToken = pExpr->pPhrase->nToken; + if( nToken ){ + int i; + for(i=0; ipPhrase->aToken[i].pDeferred==0 ) break; + } + pExpr->bDeferred = (i==nToken); + } + *pRc = fts3EvalPhraseStart(pCsr, 1, pExpr->pPhrase); + }else{ + fts3EvalStartReaders(pCsr, pExpr->pLeft, pRc); + fts3EvalStartReaders(pCsr, pExpr->pRight, pRc); + pExpr->bDeferred = (pExpr->pLeft->bDeferred && pExpr->pRight->bDeferred); + } + } +} + +/* +** An array of the following structures is assembled as part of the process +** of selecting tokens to defer before the query starts executing (as part +** of the xFilter() method). There is one element in the array for each +** token in the FTS expression. +** +** Tokens are divided into AND/NEAR clusters. All tokens in a cluster belong +** to phrases that are connected only by AND and NEAR operators (not OR or +** NOT). When determining tokens to defer, each AND/NEAR cluster is considered +** separately. The root of a tokens AND/NEAR cluster is stored in +** Fts3TokenAndCost.pRoot. +*/ +typedef struct Fts3TokenAndCost Fts3TokenAndCost; +struct Fts3TokenAndCost { + Fts3Phrase *pPhrase; /* The phrase the token belongs to */ + int iToken; /* Position of token in phrase */ + Fts3PhraseToken *pToken; /* The token itself */ + Fts3Expr *pRoot; /* Root of NEAR/AND cluster */ + int nOvfl; /* Number of overflow pages to load doclist */ + int iCol; /* The column the token must match */ +}; + +/* +** This function is used to populate an allocated Fts3TokenAndCost array. +** +** If *pRc is not SQLITE_OK when this function is called, it is a no-op. +** Otherwise, if an error occurs during execution, *pRc is set to an +** SQLite error code. +*/ +static void fts3EvalTokenCosts( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Expr *pRoot, /* Root of current AND/NEAR cluster */ + Fts3Expr *pExpr, /* Expression to consider */ + Fts3TokenAndCost **ppTC, /* Write new entries to *(*ppTC)++ */ + Fts3Expr ***ppOr, /* Write new OR root to *(*ppOr)++ */ + int *pRc /* IN/OUT: Error code */ +){ + if( *pRc==SQLITE_OK ){ + if( pExpr->eType==FTSQUERY_PHRASE ){ + Fts3Phrase *pPhrase = pExpr->pPhrase; + int i; + for(i=0; *pRc==SQLITE_OK && inToken; i++){ + Fts3TokenAndCost *pTC = (*ppTC)++; + pTC->pPhrase = pPhrase; + pTC->iToken = i; + pTC->pRoot = pRoot; + pTC->pToken = &pPhrase->aToken[i]; + pTC->iCol = pPhrase->iColumn; + *pRc = sqlite3Fts3MsrOvfl(pCsr, pTC->pToken->pSegcsr, &pTC->nOvfl); + } + }else if( pExpr->eType!=FTSQUERY_NOT ){ + assert( pExpr->eType==FTSQUERY_OR + || pExpr->eType==FTSQUERY_AND + || pExpr->eType==FTSQUERY_NEAR + ); + assert( pExpr->pLeft && pExpr->pRight ); + if( pExpr->eType==FTSQUERY_OR ){ + pRoot = pExpr->pLeft; + **ppOr = pRoot; + (*ppOr)++; + } + fts3EvalTokenCosts(pCsr, pRoot, pExpr->pLeft, ppTC, ppOr, pRc); + if( pExpr->eType==FTSQUERY_OR ){ + pRoot = pExpr->pRight; + **ppOr = pRoot; + (*ppOr)++; + } + fts3EvalTokenCosts(pCsr, pRoot, pExpr->pRight, ppTC, ppOr, pRc); + } + } +} + +/* +** Determine the average document (row) size in pages. If successful, +** write this value to *pnPage and return SQLITE_OK. Otherwise, return +** an SQLite error code. +** +** The average document size in pages is calculated by first calculating +** determining the average size in bytes, B. If B is less than the amount +** of data that will fit on a single leaf page of an intkey table in +** this database, then the average docsize is 1. Otherwise, it is 1 plus +** the number of overflow pages consumed by a record B bytes in size. +*/ +static int fts3EvalAverageDocsize(Fts3Cursor *pCsr, int *pnPage){ + int rc = SQLITE_OK; + if( pCsr->nRowAvg==0 ){ + /* The average document size, which is required to calculate the cost + ** of each doclist, has not yet been determined. Read the required + ** data from the %_stat table to calculate it. + ** + ** Entry 0 of the %_stat table is a blob containing (nCol+1) FTS3 + ** varints, where nCol is the number of columns in the FTS3 table. + ** The first varint is the number of documents currently stored in + ** the table. The following nCol varints contain the total amount of + ** data stored in all rows of each column of the table, from left + ** to right. + */ + Fts3Table *p = (Fts3Table*)pCsr->base.pVtab; + sqlite3_stmt *pStmt; + sqlite3_int64 nDoc = 0; + sqlite3_int64 nByte = 0; + const char *pEnd; + const char *a; + + rc = sqlite3Fts3SelectDoctotal(p, &pStmt); + if( rc!=SQLITE_OK ) return rc; + a = sqlite3_column_blob(pStmt, 0); + testcase( a==0 ); /* If %_stat.value set to X'' */ + if( a ){ + pEnd = &a[sqlite3_column_bytes(pStmt, 0)]; + a += sqlite3Fts3GetVarintBounded(a, pEnd, &nDoc); + while( anDoc = nDoc; + pCsr->nRowAvg = (int)(((nByte / nDoc) + p->nPgsz) / p->nPgsz); + assert( pCsr->nRowAvg>0 ); + rc = sqlite3_reset(pStmt); + } + + *pnPage = pCsr->nRowAvg; + return rc; +} + +/* +** This function is called to select the tokens (if any) that will be +** deferred. The array aTC[] has already been populated when this is +** called. +** +** This function is called once for each AND/NEAR cluster in the +** expression. Each invocation determines which tokens to defer within +** the cluster with root node pRoot. See comments above the definition +** of struct Fts3TokenAndCost for more details. +** +** If no error occurs, SQLITE_OK is returned and sqlite3Fts3DeferToken() +** called on each token to defer. Otherwise, an SQLite error code is +** returned. +*/ +static int fts3EvalSelectDeferred( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Expr *pRoot, /* Consider tokens with this root node */ + Fts3TokenAndCost *aTC, /* Array of expression tokens and costs */ + int nTC /* Number of entries in aTC[] */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int nDocSize = 0; /* Number of pages per doc loaded */ + int rc = SQLITE_OK; /* Return code */ + int ii; /* Iterator variable for various purposes */ + int nOvfl = 0; /* Total overflow pages used by doclists */ + int nToken = 0; /* Total number of tokens in cluster */ + + int nMinEst = 0; /* The minimum count for any phrase so far. */ + int nLoad4 = 1; /* (Phrases that will be loaded)^4. */ + + /* Tokens are never deferred for FTS tables created using the content=xxx + ** option. The reason being that it is not guaranteed that the content + ** table actually contains the same data as the index. To prevent this from + ** causing any problems, the deferred token optimization is completely + ** disabled for content=xxx tables. */ + if( pTab->zContentTbl ){ + return SQLITE_OK; + } + + /* Count the tokens in this AND/NEAR cluster. If none of the doclists + ** associated with the tokens spill onto overflow pages, or if there is + ** only 1 token, exit early. No tokens to defer in this case. */ + for(ii=0; ii0 ); + + + /* Iterate through all tokens in this AND/NEAR cluster, in ascending order + ** of the number of overflow pages that will be loaded by the pager layer + ** to retrieve the entire doclist for the token from the full-text index. + ** Load the doclists for tokens that are either: + ** + ** a. The cheapest token in the entire query (i.e. the one visited by the + ** first iteration of this loop), or + ** + ** b. Part of a multi-token phrase. + ** + ** After each token doclist is loaded, merge it with the others from the + ** same phrase and count the number of documents that the merged doclist + ** contains. Set variable "nMinEst" to the smallest number of documents in + ** any phrase doclist for which 1 or more token doclists have been loaded. + ** Let nOther be the number of other phrases for which it is certain that + ** one or more tokens will not be deferred. + ** + ** Then, for each token, defer it if loading the doclist would result in + ** loading N or more overflow pages into memory, where N is computed as: + ** + ** (nMinEst + 4^nOther - 1) / (4^nOther) + */ + for(ii=0; iinOvfl) + ){ + pTC = &aTC[iTC]; + } + } + assert( pTC ); + + if( ii && pTC->nOvfl>=((nMinEst+(nLoad4/4)-1)/(nLoad4/4))*nDocSize ){ + /* The number of overflow pages to load for this (and therefore all + ** subsequent) tokens is greater than the estimated number of pages + ** that will be loaded if all subsequent tokens are deferred. + */ + Fts3PhraseToken *pToken = pTC->pToken; + rc = sqlite3Fts3DeferToken(pCsr, pToken, pTC->iCol); + fts3SegReaderCursorFree(pToken->pSegcsr); + pToken->pSegcsr = 0; + }else{ + /* Set nLoad4 to the value of (4^nOther) for the next iteration of the + ** for-loop. Except, limit the value to 2^24 to prevent it from + ** overflowing the 32-bit integer it is stored in. */ + if( ii<12 ) nLoad4 = nLoad4*4; + + if( ii==0 || (pTC->pPhrase->nToken>1 && ii!=nToken-1) ){ + /* Either this is the cheapest token in the entire query, or it is + ** part of a multi-token phrase. Either way, the entire doclist will + ** (eventually) be loaded into memory. It may as well be now. */ + Fts3PhraseToken *pToken = pTC->pToken; + int nList = 0; + char *pList = 0; + rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList); + assert( rc==SQLITE_OK || pList==0 ); + if( rc==SQLITE_OK ){ + rc = fts3EvalPhraseMergeToken( + pTab, pTC->pPhrase, pTC->iToken,pList,nList + ); + } + if( rc==SQLITE_OK ){ + int nCount; + nCount = fts3DoclistCountDocids( + pTC->pPhrase->doclist.aAll, pTC->pPhrase->doclist.nAll + ); + if( ii==0 || nCountpToken = 0; + } + + return rc; +} + +/* +** This function is called from within the xFilter method. It initializes +** the full-text query currently stored in pCsr->pExpr. To iterate through +** the results of a query, the caller does: +** +** fts3EvalStart(pCsr); +** while( 1 ){ +** fts3EvalNext(pCsr); +** if( pCsr->bEof ) break; +** ... return row pCsr->iPrevId to the caller ... +** } +*/ +static int fts3EvalStart(Fts3Cursor *pCsr){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc = SQLITE_OK; + int nToken = 0; + int nOr = 0; + + /* Allocate a MultiSegReader for each token in the expression. */ + fts3EvalAllocateReaders(pCsr, pCsr->pExpr, &nToken, &nOr, &rc); + + /* Determine which, if any, tokens in the expression should be deferred. */ +#ifndef SQLITE_DISABLE_FTS4_DEFERRED + if( rc==SQLITE_OK && nToken>1 && pTab->bFts4 ){ + Fts3TokenAndCost *aTC; + Fts3Expr **apOr; + aTC = (Fts3TokenAndCost *)sqlite3_malloc64( + sizeof(Fts3TokenAndCost) * nToken + + sizeof(Fts3Expr *) * nOr * 2 + ); + apOr = (Fts3Expr **)&aTC[nToken]; + + if( !aTC ){ + rc = SQLITE_NOMEM; + }else{ + int ii; + Fts3TokenAndCost *pTC = aTC; + Fts3Expr **ppOr = apOr; + + fts3EvalTokenCosts(pCsr, 0, pCsr->pExpr, &pTC, &ppOr, &rc); + nToken = (int)(pTC-aTC); + nOr = (int)(ppOr-apOr); + + if( rc==SQLITE_OK ){ + rc = fts3EvalSelectDeferred(pCsr, 0, aTC, nToken); + for(ii=0; rc==SQLITE_OK && iipExpr, &rc); + return rc; +} + +/* +** Invalidate the current position list for phrase pPhrase. +*/ +static void fts3EvalInvalidatePoslist(Fts3Phrase *pPhrase){ + if( pPhrase->doclist.bFreeList ){ + sqlite3_free(pPhrase->doclist.pList); + } + pPhrase->doclist.pList = 0; + pPhrase->doclist.nList = 0; + pPhrase->doclist.bFreeList = 0; +} + +/* +** This function is called to edit the position list associated with +** the phrase object passed as the fifth argument according to a NEAR +** condition. For example: +** +** abc NEAR/5 "def ghi" +** +** Parameter nNear is passed the NEAR distance of the expression (5 in +** the example above). When this function is called, *paPoslist points to +** the position list, and *pnToken is the number of phrase tokens in the +** phrase on the other side of the NEAR operator to pPhrase. For example, +** if pPhrase refers to the "def ghi" phrase, then *paPoslist points to +** the position list associated with phrase "abc". +** +** All positions in the pPhrase position list that are not sufficiently +** close to a position in the *paPoslist position list are removed. If this +** leaves 0 positions, zero is returned. Otherwise, non-zero. +** +** Before returning, *paPoslist is set to point to the position lsit +** associated with pPhrase. And *pnToken is set to the number of tokens in +** pPhrase. +*/ +static int fts3EvalNearTrim( + int nNear, /* NEAR distance. As in "NEAR/nNear". */ + char *aTmp, /* Temporary space to use */ + char **paPoslist, /* IN/OUT: Position list */ + int *pnToken, /* IN/OUT: Tokens in phrase of *paPoslist */ + Fts3Phrase *pPhrase /* The phrase object to trim the doclist of */ +){ + int nParam1 = nNear + pPhrase->nToken; + int nParam2 = nNear + *pnToken; + int nNew; + char *p2; + char *pOut; + int res; + + assert( pPhrase->doclist.pList ); + + p2 = pOut = pPhrase->doclist.pList; + res = fts3PoslistNearMerge( + &pOut, aTmp, nParam1, nParam2, paPoslist, &p2 + ); + if( res ){ + nNew = (int)(pOut - pPhrase->doclist.pList) - 1; + if( nNew>=0 ){ + assert( pPhrase->doclist.pList[nNew]=='\0' ); + assert( nNew<=pPhrase->doclist.nList && nNew>0 ); + memset(&pPhrase->doclist.pList[nNew], 0, pPhrase->doclist.nList - nNew); + pPhrase->doclist.nList = nNew; + } + *paPoslist = pPhrase->doclist.pList; + *pnToken = pPhrase->nToken; + } + + return res; +} + +/* +** This function is a no-op if *pRc is other than SQLITE_OK when it is called. +** Otherwise, it advances the expression passed as the second argument to +** point to the next matching row in the database. Expressions iterate through +** matching rows in docid order. Ascending order if Fts3Cursor.bDesc is zero, +** or descending if it is non-zero. +** +** If an error occurs, *pRc is set to an SQLite error code. Otherwise, if +** successful, the following variables in pExpr are set: +** +** Fts3Expr.bEof (non-zero if EOF - there is no next row) +** Fts3Expr.iDocid (valid if bEof==0. The docid of the next row) +** +** If the expression is of type FTSQUERY_PHRASE, and the expression is not +** at EOF, then the following variables are populated with the position list +** for the phrase for the visited row: +** +** FTs3Expr.pPhrase->doclist.nList (length of pList in bytes) +** FTs3Expr.pPhrase->doclist.pList (pointer to position list) +** +** It says above that this function advances the expression to the next +** matching row. This is usually true, but there are the following exceptions: +** +** 1. Deferred tokens are not taken into account. If a phrase consists +** entirely of deferred tokens, it is assumed to match every row in +** the db. In this case the position-list is not populated at all. +** +** Or, if a phrase contains one or more deferred tokens and one or +** more non-deferred tokens, then the expression is advanced to the +** next possible match, considering only non-deferred tokens. In other +** words, if the phrase is "A B C", and "B" is deferred, the expression +** is advanced to the next row that contains an instance of "A * C", +** where "*" may match any single token. The position list in this case +** is populated as for "A * C" before returning. +** +** 2. NEAR is treated as AND. If the expression is "x NEAR y", it is +** advanced to point to the next row that matches "x AND y". +** +** See sqlite3Fts3EvalTestDeferred() for details on testing if a row is +** really a match, taking into account deferred tokens and NEAR operators. +*/ +static void fts3EvalNextRow( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Expr *pExpr, /* Expr. to advance to next matching row */ + int *pRc /* IN/OUT: Error code */ +){ + if( *pRc==SQLITE_OK ){ + int bDescDoclist = pCsr->bDesc; /* Used by DOCID_CMP() macro */ + assert( pExpr->bEof==0 ); + pExpr->bStart = 1; + + switch( pExpr->eType ){ + case FTSQUERY_NEAR: + case FTSQUERY_AND: { + Fts3Expr *pLeft = pExpr->pLeft; + Fts3Expr *pRight = pExpr->pRight; + assert( !pLeft->bDeferred || !pRight->bDeferred ); + + if( pLeft->bDeferred ){ + /* LHS is entirely deferred. So we assume it matches every row. + ** Advance the RHS iterator to find the next row visited. */ + fts3EvalNextRow(pCsr, pRight, pRc); + pExpr->iDocid = pRight->iDocid; + pExpr->bEof = pRight->bEof; + }else if( pRight->bDeferred ){ + /* RHS is entirely deferred. So we assume it matches every row. + ** Advance the LHS iterator to find the next row visited. */ + fts3EvalNextRow(pCsr, pLeft, pRc); + pExpr->iDocid = pLeft->iDocid; + pExpr->bEof = pLeft->bEof; + }else{ + /* Neither the RHS or LHS are deferred. */ + fts3EvalNextRow(pCsr, pLeft, pRc); + fts3EvalNextRow(pCsr, pRight, pRc); + while( !pLeft->bEof && !pRight->bEof && *pRc==SQLITE_OK ){ + sqlite3_int64 iDiff = DOCID_CMP(pLeft->iDocid, pRight->iDocid); + if( iDiff==0 ) break; + if( iDiff<0 ){ + fts3EvalNextRow(pCsr, pLeft, pRc); + }else{ + fts3EvalNextRow(pCsr, pRight, pRc); + } + } + pExpr->iDocid = pLeft->iDocid; + pExpr->bEof = (pLeft->bEof || pRight->bEof); + if( pExpr->eType==FTSQUERY_NEAR && pExpr->bEof ){ + assert( pRight->eType==FTSQUERY_PHRASE ); + if( pRight->pPhrase->doclist.aAll ){ + Fts3Doclist *pDl = &pRight->pPhrase->doclist; + while( *pRc==SQLITE_OK && pRight->bEof==0 ){ + memset(pDl->pList, 0, pDl->nList); + fts3EvalNextRow(pCsr, pRight, pRc); + } + } + if( pLeft->pPhrase && pLeft->pPhrase->doclist.aAll ){ + Fts3Doclist *pDl = &pLeft->pPhrase->doclist; + while( *pRc==SQLITE_OK && pLeft->bEof==0 ){ + memset(pDl->pList, 0, pDl->nList); + fts3EvalNextRow(pCsr, pLeft, pRc); + } + } + pRight->bEof = pLeft->bEof = 1; + } + } + break; + } + + case FTSQUERY_OR: { + Fts3Expr *pLeft = pExpr->pLeft; + Fts3Expr *pRight = pExpr->pRight; + sqlite3_int64 iCmp = DOCID_CMP(pLeft->iDocid, pRight->iDocid); + + assert( pLeft->bStart || pLeft->iDocid==pRight->iDocid ); + assert( pRight->bStart || pLeft->iDocid==pRight->iDocid ); + + if( pRight->bEof || (pLeft->bEof==0 && iCmp<0) ){ + fts3EvalNextRow(pCsr, pLeft, pRc); + }else if( pLeft->bEof || iCmp>0 ){ + fts3EvalNextRow(pCsr, pRight, pRc); + }else{ + fts3EvalNextRow(pCsr, pLeft, pRc); + fts3EvalNextRow(pCsr, pRight, pRc); + } + + pExpr->bEof = (pLeft->bEof && pRight->bEof); + iCmp = DOCID_CMP(pLeft->iDocid, pRight->iDocid); + if( pRight->bEof || (pLeft->bEof==0 && iCmp<0) ){ + pExpr->iDocid = pLeft->iDocid; + }else{ + pExpr->iDocid = pRight->iDocid; + } + + break; + } + + case FTSQUERY_NOT: { + Fts3Expr *pLeft = pExpr->pLeft; + Fts3Expr *pRight = pExpr->pRight; + + if( pRight->bStart==0 ){ + fts3EvalNextRow(pCsr, pRight, pRc); + assert( *pRc!=SQLITE_OK || pRight->bStart ); + } + + fts3EvalNextRow(pCsr, pLeft, pRc); + if( pLeft->bEof==0 ){ + while( !*pRc + && !pRight->bEof + && DOCID_CMP(pLeft->iDocid, pRight->iDocid)>0 + ){ + fts3EvalNextRow(pCsr, pRight, pRc); + } + } + pExpr->iDocid = pLeft->iDocid; + pExpr->bEof = pLeft->bEof; + break; + } + + default: { + Fts3Phrase *pPhrase = pExpr->pPhrase; + fts3EvalInvalidatePoslist(pPhrase); + *pRc = fts3EvalPhraseNext(pCsr, pPhrase, &pExpr->bEof); + pExpr->iDocid = pPhrase->doclist.iDocid; + break; + } + } + } +} + +/* +** If *pRc is not SQLITE_OK, or if pExpr is not the root node of a NEAR +** cluster, then this function returns 1 immediately. +** +** Otherwise, it checks if the current row really does match the NEAR +** expression, using the data currently stored in the position lists +** (Fts3Expr->pPhrase.doclist.pList/nList) for each phrase in the expression. +** +** If the current row is a match, the position list associated with each +** phrase in the NEAR expression is edited in place to contain only those +** phrase instances sufficiently close to their peers to satisfy all NEAR +** constraints. In this case it returns 1. If the NEAR expression does not +** match the current row, 0 is returned. The position lists may or may not +** be edited if 0 is returned. +*/ +static int fts3EvalNearTest(Fts3Expr *pExpr, int *pRc){ + int res = 1; + + /* The following block runs if pExpr is the root of a NEAR query. + ** For example, the query: + ** + ** "w" NEAR "x" NEAR "y" NEAR "z" + ** + ** which is represented in tree form as: + ** + ** | + ** +--NEAR--+ <-- root of NEAR query + ** | | + ** +--NEAR--+ "z" + ** | | + ** +--NEAR--+ "y" + ** | | + ** "w" "x" + ** + ** The right-hand child of a NEAR node is always a phrase. The + ** left-hand child may be either a phrase or a NEAR node. There are + ** no exceptions to this - it's the way the parser in fts3_expr.c works. + */ + if( *pRc==SQLITE_OK + && pExpr->eType==FTSQUERY_NEAR + && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR) + ){ + Fts3Expr *p; + sqlite3_int64 nTmp = 0; /* Bytes of temp space */ + char *aTmp; /* Temp space for PoslistNearMerge() */ + + /* Allocate temporary working space. */ + for(p=pExpr; p->pLeft; p=p->pLeft){ + assert( p->pRight->pPhrase->doclist.nList>0 ); + nTmp += p->pRight->pPhrase->doclist.nList; + } + nTmp += p->pPhrase->doclist.nList; + aTmp = sqlite3_malloc64(nTmp*2); + if( !aTmp ){ + *pRc = SQLITE_NOMEM; + res = 0; + }else{ + char *aPoslist = p->pPhrase->doclist.pList; + int nToken = p->pPhrase->nToken; + + for(p=p->pParent;res && p && p->eType==FTSQUERY_NEAR; p=p->pParent){ + Fts3Phrase *pPhrase = p->pRight->pPhrase; + int nNear = p->nNear; + res = fts3EvalNearTrim(nNear, aTmp, &aPoslist, &nToken, pPhrase); + } + + aPoslist = pExpr->pRight->pPhrase->doclist.pList; + nToken = pExpr->pRight->pPhrase->nToken; + for(p=pExpr->pLeft; p && res; p=p->pLeft){ + int nNear; + Fts3Phrase *pPhrase; + assert( p->pParent && p->pParent->pLeft==p ); + nNear = p->pParent->nNear; + pPhrase = ( + p->eType==FTSQUERY_NEAR ? p->pRight->pPhrase : p->pPhrase + ); + res = fts3EvalNearTrim(nNear, aTmp, &aPoslist, &nToken, pPhrase); + } + } + + sqlite3_free(aTmp); + } + + return res; +} + +/* +** This function is a helper function for sqlite3Fts3EvalTestDeferred(). +** Assuming no error occurs or has occurred, It returns non-zero if the +** expression passed as the second argument matches the row that pCsr +** currently points to, or zero if it does not. +** +** If *pRc is not SQLITE_OK when this function is called, it is a no-op. +** If an error occurs during execution of this function, *pRc is set to +** the appropriate SQLite error code. In this case the returned value is +** undefined. +*/ +static int fts3EvalTestExpr( + Fts3Cursor *pCsr, /* FTS cursor handle */ + Fts3Expr *pExpr, /* Expr to test. May or may not be root. */ + int *pRc /* IN/OUT: Error code */ +){ + int bHit = 1; /* Return value */ + if( *pRc==SQLITE_OK ){ + switch( pExpr->eType ){ + case FTSQUERY_NEAR: + case FTSQUERY_AND: + bHit = ( + fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc) + && fts3EvalTestExpr(pCsr, pExpr->pRight, pRc) + && fts3EvalNearTest(pExpr, pRc) + ); + + /* If the NEAR expression does not match any rows, zero the doclist for + ** all phrases involved in the NEAR. This is because the snippet(), + ** offsets() and matchinfo() functions are not supposed to recognize + ** any instances of phrases that are part of unmatched NEAR queries. + ** For example if this expression: + ** + ** ... MATCH 'a OR (b NEAR c)' + ** + ** is matched against a row containing: + ** + ** 'a b d e' + ** + ** then any snippet() should ony highlight the "a" term, not the "b" + ** (as "b" is part of a non-matching NEAR clause). + */ + if( bHit==0 + && pExpr->eType==FTSQUERY_NEAR + && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR) + ){ + Fts3Expr *p; + for(p=pExpr; p->pPhrase==0; p=p->pLeft){ + if( p->pRight->iDocid==pCsr->iPrevId ){ + fts3EvalInvalidatePoslist(p->pRight->pPhrase); + } + } + if( p->iDocid==pCsr->iPrevId ){ + fts3EvalInvalidatePoslist(p->pPhrase); + } + } + + break; + + case FTSQUERY_OR: { + int bHit1 = fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc); + int bHit2 = fts3EvalTestExpr(pCsr, pExpr->pRight, pRc); + bHit = bHit1 || bHit2; + break; + } + + case FTSQUERY_NOT: + bHit = ( + fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc) + && !fts3EvalTestExpr(pCsr, pExpr->pRight, pRc) + ); + break; + + default: { +#ifndef SQLITE_DISABLE_FTS4_DEFERRED + if( pCsr->pDeferred + && (pExpr->iDocid==pCsr->iPrevId || pExpr->bDeferred) + ){ + Fts3Phrase *pPhrase = pExpr->pPhrase; + assert( pExpr->bDeferred || pPhrase->doclist.bFreeList==0 ); + if( pExpr->bDeferred ){ + fts3EvalInvalidatePoslist(pPhrase); + } + *pRc = fts3EvalDeferredPhrase(pCsr, pPhrase); + bHit = (pPhrase->doclist.pList!=0); + pExpr->iDocid = pCsr->iPrevId; + }else +#endif + { + bHit = ( + pExpr->bEof==0 && pExpr->iDocid==pCsr->iPrevId + && pExpr->pPhrase->doclist.nList>0 + ); + } + break; + } + } + } + return bHit; +} + +/* +** This function is called as the second part of each xNext operation when +** iterating through the results of a full-text query. At this point the +** cursor points to a row that matches the query expression, with the +** following caveats: +** +** * Up until this point, "NEAR" operators in the expression have been +** treated as "AND". +** +** * Deferred tokens have not yet been considered. +** +** If *pRc is not SQLITE_OK when this function is called, it immediately +** returns 0. Otherwise, it tests whether or not after considering NEAR +** operators and deferred tokens the current row is still a match for the +** expression. It returns 1 if both of the following are true: +** +** 1. *pRc is SQLITE_OK when this function returns, and +** +** 2. After scanning the current FTS table row for the deferred tokens, +** it is determined that the row does *not* match the query. +** +** Or, if no error occurs and it seems the current row does match the FTS +** query, return 0. +*/ +SQLITE_PRIVATE int sqlite3Fts3EvalTestDeferred(Fts3Cursor *pCsr, int *pRc){ + int rc = *pRc; + int bMiss = 0; + if( rc==SQLITE_OK ){ + + /* If there are one or more deferred tokens, load the current row into + ** memory and scan it to determine the position list for each deferred + ** token. Then, see if this row is really a match, considering deferred + ** tokens and NEAR operators (neither of which were taken into account + ** earlier, by fts3EvalNextRow()). + */ + if( pCsr->pDeferred ){ + rc = fts3CursorSeek(0, pCsr); + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3CacheDeferredDoclists(pCsr); + } + } + bMiss = (0==fts3EvalTestExpr(pCsr, pCsr->pExpr, &rc)); + + /* Free the position-lists accumulated for each deferred token above. */ + sqlite3Fts3FreeDeferredDoclists(pCsr); + *pRc = rc; + } + return (rc==SQLITE_OK && bMiss); +} + +/* +** Advance to the next document that matches the FTS expression in +** Fts3Cursor.pExpr. +*/ +static int fts3EvalNext(Fts3Cursor *pCsr){ + int rc = SQLITE_OK; /* Return Code */ + Fts3Expr *pExpr = pCsr->pExpr; + assert( pCsr->isEof==0 ); + if( pExpr==0 ){ + pCsr->isEof = 1; + }else{ + do { + if( pCsr->isRequireSeek==0 ){ + sqlite3_reset(pCsr->pStmt); + } + assert( sqlite3_data_count(pCsr->pStmt)==0 ); + fts3EvalNextRow(pCsr, pExpr, &rc); + pCsr->isEof = pExpr->bEof; + pCsr->isRequireSeek = 1; + pCsr->isMatchinfoNeeded = 1; + pCsr->iPrevId = pExpr->iDocid; + }while( pCsr->isEof==0 && sqlite3Fts3EvalTestDeferred(pCsr, &rc) ); + } + + /* Check if the cursor is past the end of the docid range specified + ** by Fts3Cursor.iMinDocid/iMaxDocid. If so, set the EOF flag. */ + if( rc==SQLITE_OK && ( + (pCsr->bDesc==0 && pCsr->iPrevId>pCsr->iMaxDocid) + || (pCsr->bDesc!=0 && pCsr->iPrevIdiMinDocid) + )){ + pCsr->isEof = 1; + } + + return rc; +} + +/* +** Restart interation for expression pExpr so that the next call to +** fts3EvalNext() visits the first row. Do not allow incremental +** loading or merging of phrase doclists for this iteration. +** +** If *pRc is other than SQLITE_OK when this function is called, it is +** a no-op. If an error occurs within this function, *pRc is set to an +** SQLite error code before returning. +*/ +static void fts3EvalRestart( + Fts3Cursor *pCsr, + Fts3Expr *pExpr, + int *pRc +){ + if( pExpr && *pRc==SQLITE_OK ){ + Fts3Phrase *pPhrase = pExpr->pPhrase; + + if( pPhrase ){ + fts3EvalInvalidatePoslist(pPhrase); + if( pPhrase->bIncr ){ + int i; + for(i=0; inToken; i++){ + Fts3PhraseToken *pToken = &pPhrase->aToken[i]; + assert( pToken->pDeferred==0 ); + if( pToken->pSegcsr ){ + sqlite3Fts3MsrIncrRestart(pToken->pSegcsr); + } + } + *pRc = fts3EvalPhraseStart(pCsr, 0, pPhrase); + } + pPhrase->doclist.pNextDocid = 0; + pPhrase->doclist.iDocid = 0; + pPhrase->pOrPoslist = 0; + } + + pExpr->iDocid = 0; + pExpr->bEof = 0; + pExpr->bStart = 0; + + fts3EvalRestart(pCsr, pExpr->pLeft, pRc); + fts3EvalRestart(pCsr, pExpr->pRight, pRc); + } +} + +/* +** After allocating the Fts3Expr.aMI[] array for each phrase in the +** expression rooted at pExpr, the cursor iterates through all rows matched +** by pExpr, calling this function for each row. This function increments +** the values in Fts3Expr.aMI[] according to the position-list currently +** found in Fts3Expr.pPhrase->doclist.pList for each of the phrase +** expression nodes. +*/ +static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){ + if( pExpr ){ + Fts3Phrase *pPhrase = pExpr->pPhrase; + if( pPhrase && pPhrase->doclist.pList ){ + int iCol = 0; + char *p = pPhrase->doclist.pList; + + do{ + u8 c = 0; + int iCnt = 0; + while( 0xFE & (*p | c) ){ + if( (c&0x80)==0 ) iCnt++; + c = *p++ & 0x80; + } + + /* aMI[iCol*3 + 1] = Number of occurrences + ** aMI[iCol*3 + 2] = Number of rows containing at least one instance + */ + pExpr->aMI[iCol*3 + 1] += iCnt; + pExpr->aMI[iCol*3 + 2] += (iCnt>0); + if( *p==0x00 ) break; + p++; + p += fts3GetVarint32(p, &iCol); + }while( iColpLeft, nCol); + fts3EvalUpdateCounts(pExpr->pRight, nCol); + } +} + +/* +** Expression pExpr must be of type FTSQUERY_PHRASE. +** +** If it is not already allocated and populated, this function allocates and +** populates the Fts3Expr.aMI[] array for expression pExpr. If pExpr is part +** of a NEAR expression, then it also allocates and populates the same array +** for all other phrases that are part of the NEAR expression. +** +** SQLITE_OK is returned if the aMI[] array is successfully allocated and +** populated. Otherwise, if an error occurs, an SQLite error code is returned. +*/ +static int fts3EvalGatherStats( + Fts3Cursor *pCsr, /* Cursor object */ + Fts3Expr *pExpr /* FTSQUERY_PHRASE expression */ +){ + int rc = SQLITE_OK; /* Return code */ + + assert( pExpr->eType==FTSQUERY_PHRASE ); + if( pExpr->aMI==0 ){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + Fts3Expr *pRoot; /* Root of NEAR expression */ + Fts3Expr *p; /* Iterator used for several purposes */ + + sqlite3_int64 iPrevId = pCsr->iPrevId; + sqlite3_int64 iDocid; + u8 bEof; + + /* Find the root of the NEAR expression */ + pRoot = pExpr; + while( pRoot->pParent && pRoot->pParent->eType==FTSQUERY_NEAR ){ + pRoot = pRoot->pParent; + } + iDocid = pRoot->iDocid; + bEof = pRoot->bEof; + assert( pRoot->bStart ); + + /* Allocate space for the aMSI[] array of each FTSQUERY_PHRASE node */ + for(p=pRoot; p; p=p->pLeft){ + Fts3Expr *pE = (p->eType==FTSQUERY_PHRASE?p:p->pRight); + assert( pE->aMI==0 ); + pE->aMI = (u32 *)sqlite3_malloc64(pTab->nColumn * 3 * sizeof(u32)); + if( !pE->aMI ) return SQLITE_NOMEM; + memset(pE->aMI, 0, pTab->nColumn * 3 * sizeof(u32)); + } + + fts3EvalRestart(pCsr, pRoot, &rc); + + while( pCsr->isEof==0 && rc==SQLITE_OK ){ + + do { + /* Ensure the %_content statement is reset. */ + if( pCsr->isRequireSeek==0 ) sqlite3_reset(pCsr->pStmt); + assert( sqlite3_data_count(pCsr->pStmt)==0 ); + + /* Advance to the next document */ + fts3EvalNextRow(pCsr, pRoot, &rc); + pCsr->isEof = pRoot->bEof; + pCsr->isRequireSeek = 1; + pCsr->isMatchinfoNeeded = 1; + pCsr->iPrevId = pRoot->iDocid; + }while( pCsr->isEof==0 + && pRoot->eType==FTSQUERY_NEAR + && sqlite3Fts3EvalTestDeferred(pCsr, &rc) + ); + + if( rc==SQLITE_OK && pCsr->isEof==0 ){ + fts3EvalUpdateCounts(pRoot, pTab->nColumn); + } + } + + pCsr->isEof = 0; + pCsr->iPrevId = iPrevId; + + if( bEof ){ + pRoot->bEof = bEof; + }else{ + /* Caution: pRoot may iterate through docids in ascending or descending + ** order. For this reason, even though it seems more defensive, the + ** do loop can not be written: + ** + ** do {...} while( pRoot->iDocidbEof==0 ); + if( pRoot->bEof ) rc = FTS_CORRUPT_VTAB; + }while( pRoot->iDocid!=iDocid && rc==SQLITE_OK ); + } + } + return rc; +} + +/* +** This function is used by the matchinfo() module to query a phrase +** expression node for the following information: +** +** 1. The total number of occurrences of the phrase in each column of +** the FTS table (considering all rows), and +** +** 2. For each column, the number of rows in the table for which the +** column contains at least one instance of the phrase. +** +** If no error occurs, SQLITE_OK is returned and the values for each column +** written into the array aiOut as follows: +** +** aiOut[iCol*3 + 1] = Number of occurrences +** aiOut[iCol*3 + 2] = Number of rows containing at least one instance +** +** Caveats: +** +** * If a phrase consists entirely of deferred tokens, then all output +** values are set to the number of documents in the table. In other +** words we assume that very common tokens occur exactly once in each +** column of each row of the table. +** +** * If a phrase contains some deferred tokens (and some non-deferred +** tokens), count the potential occurrence identified by considering +** the non-deferred tokens instead of actual phrase occurrences. +** +** * If the phrase is part of a NEAR expression, then only phrase instances +** that meet the NEAR constraint are included in the counts. +*/ +SQLITE_PRIVATE int sqlite3Fts3EvalPhraseStats( + Fts3Cursor *pCsr, /* FTS cursor handle */ + Fts3Expr *pExpr, /* Phrase expression */ + u32 *aiOut /* Array to write results into (see above) */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc = SQLITE_OK; + int iCol; + + if( pExpr->bDeferred && pExpr->pParent->eType!=FTSQUERY_NEAR ){ + assert( pCsr->nDoc>0 ); + for(iCol=0; iColnColumn; iCol++){ + aiOut[iCol*3 + 1] = (u32)pCsr->nDoc; + aiOut[iCol*3 + 2] = (u32)pCsr->nDoc; + } + }else{ + rc = fts3EvalGatherStats(pCsr, pExpr); + if( rc==SQLITE_OK ){ + assert( pExpr->aMI ); + for(iCol=0; iColnColumn; iCol++){ + aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1]; + aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2]; + } + } + } + + return rc; +} + +/* +** The expression pExpr passed as the second argument to this function +** must be of type FTSQUERY_PHRASE. +** +** The returned value is either NULL or a pointer to a buffer containing +** a position-list indicating the occurrences of the phrase in column iCol +** of the current row. +** +** More specifically, the returned buffer contains 1 varint for each +** occurrence of the phrase in the column, stored using the normal (delta+2) +** compression and is terminated by either an 0x01 or 0x00 byte. For example, +** if the requested column contains "a b X c d X X" and the position-list +** for 'X' is requested, the buffer returned may contain: +** +** 0x04 0x05 0x03 0x01 or 0x04 0x05 0x03 0x00 +** +** This function works regardless of whether or not the phrase is deferred, +** incremental, or neither. +*/ +SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist( + Fts3Cursor *pCsr, /* FTS3 cursor object */ + Fts3Expr *pExpr, /* Phrase to return doclist for */ + int iCol, /* Column to return position list for */ + char **ppOut /* OUT: Pointer to position list */ +){ + Fts3Phrase *pPhrase = pExpr->pPhrase; + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + char *pIter; + int iThis; + sqlite3_int64 iDocid; + + /* If this phrase is applies specifically to some column other than + ** column iCol, return a NULL pointer. */ + *ppOut = 0; + assert( iCol>=0 && iColnColumn ); + if( (pPhrase->iColumnnColumn && pPhrase->iColumn!=iCol) ){ + return SQLITE_OK; + } + + iDocid = pExpr->iDocid; + pIter = pPhrase->doclist.pList; + if( iDocid!=pCsr->iPrevId || pExpr->bEof ){ + int rc = SQLITE_OK; + int bDescDoclist = pTab->bDescIdx; /* For DOCID_CMP macro */ + int bOr = 0; + u8 bTreeEof = 0; + Fts3Expr *p; /* Used to iterate from pExpr to root */ + Fts3Expr *pNear; /* Most senior NEAR ancestor (or pExpr) */ + int bMatch; + + /* Check if this phrase descends from an OR expression node. If not, + ** return NULL. Otherwise, the entry that corresponds to docid + ** pCsr->iPrevId may lie earlier in the doclist buffer. Or, if the + ** tree that the node is part of has been marked as EOF, but the node + ** itself is not EOF, then it may point to an earlier entry. */ + pNear = pExpr; + for(p=pExpr->pParent; p; p=p->pParent){ + if( p->eType==FTSQUERY_OR ) bOr = 1; + if( p->eType==FTSQUERY_NEAR ) pNear = p; + if( p->bEof ) bTreeEof = 1; + } + if( bOr==0 ) return SQLITE_OK; + + /* This is the descendent of an OR node. In this case we cannot use + ** an incremental phrase. Load the entire doclist for the phrase + ** into memory in this case. */ + if( pPhrase->bIncr ){ + int bEofSave = pNear->bEof; + fts3EvalRestart(pCsr, pNear, &rc); + while( rc==SQLITE_OK && !pNear->bEof ){ + fts3EvalNextRow(pCsr, pNear, &rc); + if( bEofSave==0 && pNear->iDocid==iDocid ) break; + } + assert( rc!=SQLITE_OK || pPhrase->bIncr==0 ); + } + if( bTreeEof ){ + while( rc==SQLITE_OK && !pNear->bEof ){ + fts3EvalNextRow(pCsr, pNear, &rc); + } + } + if( rc!=SQLITE_OK ) return rc; + + bMatch = 1; + for(p=pNear; p; p=p->pLeft){ + u8 bEof = 0; + Fts3Expr *pTest = p; + Fts3Phrase *pPh; + assert( pTest->eType==FTSQUERY_NEAR || pTest->eType==FTSQUERY_PHRASE ); + if( pTest->eType==FTSQUERY_NEAR ) pTest = pTest->pRight; + assert( pTest->eType==FTSQUERY_PHRASE ); + pPh = pTest->pPhrase; + + pIter = pPh->pOrPoslist; + iDocid = pPh->iOrDocid; + if( pCsr->bDesc==bDescDoclist ){ + bEof = !pPh->doclist.nAll || + (pIter >= (pPh->doclist.aAll + pPh->doclist.nAll)); + while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)<0 ) && bEof==0 ){ + sqlite3Fts3DoclistNext( + bDescDoclist, pPh->doclist.aAll, pPh->doclist.nAll, + &pIter, &iDocid, &bEof + ); + } + }else{ + bEof = !pPh->doclist.nAll || (pIter && pIter<=pPh->doclist.aAll); + while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)>0 ) && bEof==0 ){ + int dummy; + sqlite3Fts3DoclistPrev( + bDescDoclist, pPh->doclist.aAll, pPh->doclist.nAll, + &pIter, &iDocid, &dummy, &bEof + ); + } + } + pPh->pOrPoslist = pIter; + pPh->iOrDocid = iDocid; + if( bEof || iDocid!=pCsr->iPrevId ) bMatch = 0; + } + + if( bMatch ){ + pIter = pPhrase->pOrPoslist; + }else{ + pIter = 0; + } + } + if( pIter==0 ) return SQLITE_OK; + + if( *pIter==0x01 ){ + pIter++; + pIter += fts3GetVarint32(pIter, &iThis); + }else{ + iThis = 0; + } + while( iThisdoclist, and +** * any Fts3MultiSegReader objects held by phrase tokens. +*/ +SQLITE_PRIVATE void sqlite3Fts3EvalPhraseCleanup(Fts3Phrase *pPhrase){ + if( pPhrase ){ + int i; + sqlite3_free(pPhrase->doclist.aAll); + fts3EvalInvalidatePoslist(pPhrase); + memset(&pPhrase->doclist, 0, sizeof(Fts3Doclist)); + for(i=0; inToken; i++){ + fts3SegReaderCursorFree(pPhrase->aToken[i].pSegcsr); + pPhrase->aToken[i].pSegcsr = 0; + } + } +} + + +/* +** Return SQLITE_CORRUPT_VTAB. +*/ +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3Fts3Corrupt(){ + return SQLITE_CORRUPT_VTAB; +} +#endif + +#if !SQLITE_CORE +/* +** Initialize API pointer table, if required. +*/ +#ifdef _WIN32 +__declspec(dllexport) +#endif +SQLITE_API int sqlite3_fts3_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi +){ + SQLITE_EXTENSION_INIT2(pApi) + return sqlite3Fts3Init(db); +} +#endif + +#endif + +/************** End of fts3.c ************************************************/ +/************** Begin file fts3_aux.c ****************************************/ +/* +** 2011 Jan 27 +** +** 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. +** +****************************************************************************** +** +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ + +typedef struct Fts3auxTable Fts3auxTable; +typedef struct Fts3auxCursor Fts3auxCursor; + +struct Fts3auxTable { + sqlite3_vtab base; /* Base class used by SQLite core */ + Fts3Table *pFts3Tab; +}; + +struct Fts3auxCursor { + sqlite3_vtab_cursor base; /* Base class used by SQLite core */ + Fts3MultiSegReader csr; /* Must be right after "base" */ + Fts3SegFilter filter; + char *zStop; + int nStop; /* Byte-length of string zStop */ + int iLangid; /* Language id to query */ + int isEof; /* True if cursor is at EOF */ + sqlite3_int64 iRowid; /* Current rowid */ + + int iCol; /* Current value of 'col' column */ + int nStat; /* Size of aStat[] array */ + struct Fts3auxColstats { + sqlite3_int64 nDoc; /* 'documents' values for current csr row */ + sqlite3_int64 nOcc; /* 'occurrences' values for current csr row */ + } *aStat; +}; + +/* +** Schema of the terms table. +*/ +#define FTS3_AUX_SCHEMA \ + "CREATE TABLE x(term, col, documents, occurrences, languageid HIDDEN)" + +/* +** This function does all the work for both the xConnect and xCreate methods. +** These tables have no persistent representation of their own, so xConnect +** and xCreate are identical operations. +*/ +static int fts3auxConnectMethod( + sqlite3 *db, /* Database connection */ + void *pUnused, /* Unused */ + int argc, /* Number of elements in argv array */ + const char * const *argv, /* xCreate/xConnect argument array */ + sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */ + char **pzErr /* OUT: sqlite3_malloc'd error message */ +){ + char const *zDb; /* Name of database (e.g. "main") */ + char const *zFts3; /* Name of fts3 table */ + int nDb; /* Result of strlen(zDb) */ + int nFts3; /* Result of strlen(zFts3) */ + sqlite3_int64 nByte; /* Bytes of space to allocate here */ + int rc; /* value returned by declare_vtab() */ + Fts3auxTable *p; /* Virtual table object to return */ + + UNUSED_PARAMETER(pUnused); + + /* The user should invoke this in one of two forms: + ** + ** CREATE VIRTUAL TABLE xxx USING fts4aux(fts4-table); + ** CREATE VIRTUAL TABLE xxx USING fts4aux(fts4-table-db, fts4-table); + */ + if( argc!=4 && argc!=5 ) goto bad_args; + + zDb = argv[1]; + nDb = (int)strlen(zDb); + if( argc==5 ){ + if( nDb==4 && 0==sqlite3_strnicmp("temp", zDb, 4) ){ + zDb = argv[3]; + nDb = (int)strlen(zDb); + zFts3 = argv[4]; + }else{ + goto bad_args; + } + }else{ + zFts3 = argv[3]; + } + nFts3 = (int)strlen(zFts3); + + rc = sqlite3_declare_vtab(db, FTS3_AUX_SCHEMA); + if( rc!=SQLITE_OK ) return rc; + + nByte = sizeof(Fts3auxTable) + sizeof(Fts3Table) + nDb + nFts3 + 2; + p = (Fts3auxTable *)sqlite3_malloc64(nByte); + if( !p ) return SQLITE_NOMEM; + memset(p, 0, nByte); + + p->pFts3Tab = (Fts3Table *)&p[1]; + p->pFts3Tab->zDb = (char *)&p->pFts3Tab[1]; + p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1]; + p->pFts3Tab->db = db; + p->pFts3Tab->nIndex = 1; + + memcpy((char *)p->pFts3Tab->zDb, zDb, nDb); + memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3); + sqlite3Fts3Dequote((char *)p->pFts3Tab->zName); + + *ppVtab = (sqlite3_vtab *)p; + return SQLITE_OK; + + bad_args: + sqlite3Fts3ErrMsg(pzErr, "invalid arguments to fts4aux constructor"); + return SQLITE_ERROR; +} + +/* +** This function does the work for both the xDisconnect and xDestroy methods. +** These tables have no persistent representation of their own, so xDisconnect +** and xDestroy are identical operations. +*/ +static int fts3auxDisconnectMethod(sqlite3_vtab *pVtab){ + Fts3auxTable *p = (Fts3auxTable *)pVtab; + Fts3Table *pFts3 = p->pFts3Tab; + int i; + + /* Free any prepared statements held */ + for(i=0; iaStmt); i++){ + sqlite3_finalize(pFts3->aStmt[i]); + } + sqlite3_free(pFts3->zSegmentsTbl); + sqlite3_free(p); + return SQLITE_OK; +} + +#define FTS4AUX_EQ_CONSTRAINT 1 +#define FTS4AUX_GE_CONSTRAINT 2 +#define FTS4AUX_LE_CONSTRAINT 4 + +/* +** xBestIndex - Analyze a WHERE and ORDER BY clause. +*/ +static int fts3auxBestIndexMethod( + sqlite3_vtab *pVTab, + sqlite3_index_info *pInfo +){ + int i; + int iEq = -1; + int iGe = -1; + int iLe = -1; + int iLangid = -1; + int iNext = 1; /* Next free argvIndex value */ + + UNUSED_PARAMETER(pVTab); + + /* This vtab delivers always results in "ORDER BY term ASC" order. */ + if( pInfo->nOrderBy==1 + && pInfo->aOrderBy[0].iColumn==0 + && pInfo->aOrderBy[0].desc==0 + ){ + pInfo->orderByConsumed = 1; + } + + /* Search for equality and range constraints on the "term" column. + ** And equality constraints on the hidden "languageid" column. */ + for(i=0; inConstraint; i++){ + if( pInfo->aConstraint[i].usable ){ + int op = pInfo->aConstraint[i].op; + int iCol = pInfo->aConstraint[i].iColumn; + + if( iCol==0 ){ + if( op==SQLITE_INDEX_CONSTRAINT_EQ ) iEq = i; + if( op==SQLITE_INDEX_CONSTRAINT_LT ) iLe = i; + if( op==SQLITE_INDEX_CONSTRAINT_LE ) iLe = i; + if( op==SQLITE_INDEX_CONSTRAINT_GT ) iGe = i; + if( op==SQLITE_INDEX_CONSTRAINT_GE ) iGe = i; + } + if( iCol==4 ){ + if( op==SQLITE_INDEX_CONSTRAINT_EQ ) iLangid = i; + } + } + } + + if( iEq>=0 ){ + pInfo->idxNum = FTS4AUX_EQ_CONSTRAINT; + pInfo->aConstraintUsage[iEq].argvIndex = iNext++; + pInfo->estimatedCost = 5; + }else{ + pInfo->idxNum = 0; + pInfo->estimatedCost = 20000; + if( iGe>=0 ){ + pInfo->idxNum += FTS4AUX_GE_CONSTRAINT; + pInfo->aConstraintUsage[iGe].argvIndex = iNext++; + pInfo->estimatedCost /= 2; + } + if( iLe>=0 ){ + pInfo->idxNum += FTS4AUX_LE_CONSTRAINT; + pInfo->aConstraintUsage[iLe].argvIndex = iNext++; + pInfo->estimatedCost /= 2; + } + } + if( iLangid>=0 ){ + pInfo->aConstraintUsage[iLangid].argvIndex = iNext++; + pInfo->estimatedCost--; + } + + return SQLITE_OK; +} + +/* +** xOpen - Open a cursor. +*/ +static int fts3auxOpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){ + Fts3auxCursor *pCsr; /* Pointer to cursor object to return */ + + UNUSED_PARAMETER(pVTab); + + pCsr = (Fts3auxCursor *)sqlite3_malloc(sizeof(Fts3auxCursor)); + if( !pCsr ) return SQLITE_NOMEM; + memset(pCsr, 0, sizeof(Fts3auxCursor)); + + *ppCsr = (sqlite3_vtab_cursor *)pCsr; + return SQLITE_OK; +} + +/* +** xClose - Close a cursor. +*/ +static int fts3auxCloseMethod(sqlite3_vtab_cursor *pCursor){ + Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab; + Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor; + + sqlite3Fts3SegmentsClose(pFts3); + sqlite3Fts3SegReaderFinish(&pCsr->csr); + sqlite3_free((void *)pCsr->filter.zTerm); + sqlite3_free(pCsr->zStop); + sqlite3_free(pCsr->aStat); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +static int fts3auxGrowStatArray(Fts3auxCursor *pCsr, int nSize){ + if( nSize>pCsr->nStat ){ + struct Fts3auxColstats *aNew; + aNew = (struct Fts3auxColstats *)sqlite3_realloc64(pCsr->aStat, + sizeof(struct Fts3auxColstats) * nSize + ); + if( aNew==0 ) return SQLITE_NOMEM; + memset(&aNew[pCsr->nStat], 0, + sizeof(struct Fts3auxColstats) * (nSize - pCsr->nStat) + ); + pCsr->aStat = aNew; + pCsr->nStat = nSize; + } + return SQLITE_OK; +} + +/* +** xNext - Advance the cursor to the next row, if any. +*/ +static int fts3auxNextMethod(sqlite3_vtab_cursor *pCursor){ + Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor; + Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab; + int rc; + + /* Increment our pretend rowid value. */ + pCsr->iRowid++; + + for(pCsr->iCol++; pCsr->iColnStat; pCsr->iCol++){ + if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK; + } + + rc = sqlite3Fts3SegReaderStep(pFts3, &pCsr->csr); + if( rc==SQLITE_ROW ){ + int i = 0; + int nDoclist = pCsr->csr.nDoclist; + char *aDoclist = pCsr->csr.aDoclist; + int iCol; + + int eState = 0; + + if( pCsr->zStop ){ + int n = (pCsr->nStopcsr.nTerm) ? pCsr->nStop : pCsr->csr.nTerm; + int mc = memcmp(pCsr->zStop, pCsr->csr.zTerm, n); + if( mc<0 || (mc==0 && pCsr->csr.nTerm>pCsr->nStop) ){ + pCsr->isEof = 1; + return SQLITE_OK; + } + } + + if( fts3auxGrowStatArray(pCsr, 2) ) return SQLITE_NOMEM; + memset(pCsr->aStat, 0, sizeof(struct Fts3auxColstats) * pCsr->nStat); + iCol = 0; + + while( iaStat[0].nDoc++; + eState = 1; + iCol = 0; + break; + + /* State 1. In this state we are expecting either a 1, indicating + ** that the following integer will be a column number, or the + ** start of a position list for column 0. + ** + ** The only difference between state 1 and state 2 is that if the + ** integer encountered in state 1 is not 0 or 1, then we need to + ** increment the column 0 "nDoc" count for this term. + */ + case 1: + assert( iCol==0 ); + if( v>1 ){ + pCsr->aStat[1].nDoc++; + } + eState = 2; + /* fall through */ + + case 2: + if( v==0 ){ /* 0x00. Next integer will be a docid. */ + eState = 0; + }else if( v==1 ){ /* 0x01. Next integer will be a column number. */ + eState = 3; + }else{ /* 2 or greater. A position. */ + pCsr->aStat[iCol+1].nOcc++; + pCsr->aStat[0].nOcc++; + } + break; + + /* State 3. The integer just read is a column number. */ + default: assert( eState==3 ); + iCol = (int)v; + if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM; + pCsr->aStat[iCol+1].nDoc++; + eState = 2; + break; + } + } + + pCsr->iCol = 0; + rc = SQLITE_OK; + }else{ + pCsr->isEof = 1; + } + return rc; +} + +/* +** xFilter - Initialize a cursor to point at the start of its data. +*/ +static int fts3auxFilterMethod( + sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */ + int idxNum, /* Strategy index */ + const char *idxStr, /* Unused */ + int nVal, /* Number of elements in apVal */ + sqlite3_value **apVal /* Arguments for the indexing scheme */ +){ + Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor; + Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab; + int rc; + int isScan = 0; + int iLangVal = 0; /* Language id to query */ + + int iEq = -1; /* Index of term=? value in apVal */ + int iGe = -1; /* Index of term>=? value in apVal */ + int iLe = -1; /* Index of term<=? value in apVal */ + int iLangid = -1; /* Index of languageid=? value in apVal */ + int iNext = 0; + + UNUSED_PARAMETER(nVal); + UNUSED_PARAMETER(idxStr); + + assert( idxStr==0 ); + assert( idxNum==FTS4AUX_EQ_CONSTRAINT || idxNum==0 + || idxNum==FTS4AUX_LE_CONSTRAINT || idxNum==FTS4AUX_GE_CONSTRAINT + || idxNum==(FTS4AUX_LE_CONSTRAINT|FTS4AUX_GE_CONSTRAINT) + ); + + if( idxNum==FTS4AUX_EQ_CONSTRAINT ){ + iEq = iNext++; + }else{ + isScan = 1; + if( idxNum & FTS4AUX_GE_CONSTRAINT ){ + iGe = iNext++; + } + if( idxNum & FTS4AUX_LE_CONSTRAINT ){ + iLe = iNext++; + } + } + if( iNextfilter.zTerm); + sqlite3Fts3SegReaderFinish(&pCsr->csr); + sqlite3_free((void *)pCsr->filter.zTerm); + sqlite3_free(pCsr->aStat); + memset(&pCsr->csr, 0, ((u8*)&pCsr[1]) - (u8*)&pCsr->csr); + + pCsr->filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY; + if( isScan ) pCsr->filter.flags |= FTS3_SEGMENT_SCAN; + + if( iEq>=0 || iGe>=0 ){ + const unsigned char *zStr = sqlite3_value_text(apVal[0]); + assert( (iEq==0 && iGe==-1) || (iEq==-1 && iGe==0) ); + if( zStr ){ + pCsr->filter.zTerm = sqlite3_mprintf("%s", zStr); + if( pCsr->filter.zTerm==0 ) return SQLITE_NOMEM; + pCsr->filter.nTerm = (int)strlen(pCsr->filter.zTerm); + } + } + + if( iLe>=0 ){ + pCsr->zStop = sqlite3_mprintf("%s", sqlite3_value_text(apVal[iLe])); + if( pCsr->zStop==0 ) return SQLITE_NOMEM; + pCsr->nStop = (int)strlen(pCsr->zStop); + } + + if( iLangid>=0 ){ + iLangVal = sqlite3_value_int(apVal[iLangid]); + + /* If the user specified a negative value for the languageid, use zero + ** instead. This works, as the "languageid=?" constraint will also + ** be tested by the VDBE layer. The test will always be false (since + ** this module will not return a row with a negative languageid), and + ** so the overall query will return zero rows. */ + if( iLangVal<0 ) iLangVal = 0; + } + pCsr->iLangid = iLangVal; + + rc = sqlite3Fts3SegReaderCursor(pFts3, iLangVal, 0, FTS3_SEGCURSOR_ALL, + pCsr->filter.zTerm, pCsr->filter.nTerm, 0, isScan, &pCsr->csr + ); + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3SegReaderStart(pFts3, &pCsr->csr, &pCsr->filter); + } + + if( rc==SQLITE_OK ) rc = fts3auxNextMethod(pCursor); + return rc; +} + +/* +** xEof - Return true if the cursor is at EOF, or false otherwise. +*/ +static int fts3auxEofMethod(sqlite3_vtab_cursor *pCursor){ + Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor; + return pCsr->isEof; +} + +/* +** xColumn - Return a column value. +*/ +static int fts3auxColumnMethod( + sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */ + sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */ + int iCol /* Index of column to read value from */ +){ + Fts3auxCursor *p = (Fts3auxCursor *)pCursor; + + assert( p->isEof==0 ); + switch( iCol ){ + case 0: /* term */ + sqlite3_result_text(pCtx, p->csr.zTerm, p->csr.nTerm, SQLITE_TRANSIENT); + break; + + case 1: /* col */ + if( p->iCol ){ + sqlite3_result_int(pCtx, p->iCol-1); + }else{ + sqlite3_result_text(pCtx, "*", -1, SQLITE_STATIC); + } + break; + + case 2: /* documents */ + sqlite3_result_int64(pCtx, p->aStat[p->iCol].nDoc); + break; + + case 3: /* occurrences */ + sqlite3_result_int64(pCtx, p->aStat[p->iCol].nOcc); + break; + + default: /* languageid */ + assert( iCol==4 ); + sqlite3_result_int(pCtx, p->iLangid); + break; + } + + return SQLITE_OK; +} + +/* +** xRowid - Return the current rowid for the cursor. +*/ +static int fts3auxRowidMethod( + sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */ + sqlite_int64 *pRowid /* OUT: Rowid value */ +){ + Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor; + *pRowid = pCsr->iRowid; + return SQLITE_OK; +} + +/* +** Register the fts3aux module with database connection db. Return SQLITE_OK +** if successful or an error code if sqlite3_create_module() fails. +*/ +SQLITE_PRIVATE int sqlite3Fts3InitAux(sqlite3 *db){ + static const sqlite3_module fts3aux_module = { + 0, /* iVersion */ + fts3auxConnectMethod, /* xCreate */ + fts3auxConnectMethod, /* xConnect */ + fts3auxBestIndexMethod, /* xBestIndex */ + fts3auxDisconnectMethod, /* xDisconnect */ + fts3auxDisconnectMethod, /* xDestroy */ + fts3auxOpenMethod, /* xOpen */ + fts3auxCloseMethod, /* xClose */ + fts3auxFilterMethod, /* xFilter */ + fts3auxNextMethod, /* xNext */ + fts3auxEofMethod, /* xEof */ + fts3auxColumnMethod, /* xColumn */ + fts3auxRowidMethod, /* xRowid */ + 0, /* xUpdate */ + 0, /* xBegin */ + 0, /* xSync */ + 0, /* xCommit */ + 0, /* xRollback */ + 0, /* xFindFunction */ + 0, /* xRename */ + 0, /* xSavepoint */ + 0, /* xRelease */ + 0, /* xRollbackTo */ + 0 /* xShadowName */ + }; + int rc; /* Return code */ + + rc = sqlite3_create_module(db, "fts4aux", &fts3aux_module, 0); + return rc; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_aux.c ********************************************/ +/************** Begin file fts3_expr.c ***************************************/ +/* +** 2008 Nov 28 +** +** 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 module contains code that implements a parser for fts3 query strings +** (the right-hand argument to the MATCH operator). Because the supported +** syntax is relatively simple, the whole tokenizer/parser system is +** hand-coded. +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* +** By default, this module parses the legacy syntax that has been +** traditionally used by fts3. Or, if SQLITE_ENABLE_FTS3_PARENTHESIS +** is defined, then it uses the new syntax. The differences between +** the new and the old syntaxes are: +** +** a) The new syntax supports parenthesis. The old does not. +** +** b) The new syntax supports the AND and NOT operators. The old does not. +** +** c) The old syntax supports the "-" token qualifier. This is not +** supported by the new syntax (it is replaced by the NOT operator). +** +** d) When using the old syntax, the OR operator has a greater precedence +** than an implicit AND. When using the new, both implicity and explicit +** AND operators have a higher precedence than OR. +** +** If compiled with SQLITE_TEST defined, then this module exports the +** symbol "int sqlite3_fts3_enable_parentheses". Setting this variable +** to zero causes the module to use the old syntax. If it is set to +** non-zero the new syntax is activated. This is so both syntaxes can +** be tested using a single build of testfixture. +** +** The following describes the syntax supported by the fts3 MATCH +** operator in a similar format to that used by the lemon parser +** generator. This module does not use actually lemon, it uses a +** custom parser. +** +** query ::= andexpr (OR andexpr)*. +** +** andexpr ::= notexpr (AND? notexpr)*. +** +** notexpr ::= nearexpr (NOT nearexpr|-TOKEN)*. +** notexpr ::= LP query RP. +** +** nearexpr ::= phrase (NEAR distance_opt nearexpr)*. +** +** distance_opt ::= . +** distance_opt ::= / INTEGER. +** +** phrase ::= TOKEN. +** phrase ::= COLUMN:TOKEN. +** phrase ::= "TOKEN TOKEN TOKEN...". +*/ + +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_fts3_enable_parentheses = 0; +#else +# ifdef SQLITE_ENABLE_FTS3_PARENTHESIS +# define sqlite3_fts3_enable_parentheses 1 +# else +# define sqlite3_fts3_enable_parentheses 0 +# endif +#endif + +/* +** Default span for NEAR operators. +*/ +#define SQLITE_FTS3_DEFAULT_NEAR_PARAM 10 + +/* #include */ +/* #include */ + +/* +** isNot: +** This variable is used by function getNextNode(). When getNextNode() is +** called, it sets ParseContext.isNot to true if the 'next node' is a +** FTSQUERY_PHRASE with a unary "-" attached to it. i.e. "mysql" in the +** FTS3 query "sqlite -mysql". Otherwise, ParseContext.isNot is set to +** zero. +*/ +typedef struct ParseContext ParseContext; +struct ParseContext { + sqlite3_tokenizer *pTokenizer; /* Tokenizer module */ + int iLangid; /* Language id used with tokenizer */ + const char **azCol; /* Array of column names for fts3 table */ + int bFts4; /* True to allow FTS4-only syntax */ + int nCol; /* Number of entries in azCol[] */ + int iDefaultCol; /* Default column to query */ + int isNot; /* True if getNextNode() sees a unary - */ + sqlite3_context *pCtx; /* Write error message here */ + int nNest; /* Number of nested brackets */ +}; + +/* +** This function is equivalent to the standard isspace() function. +** +** The standard isspace() can be awkward to use safely, because although it +** is defined to accept an argument of type int, its behavior when passed +** an integer that falls outside of the range of the unsigned char type +** is undefined (and sometimes, "undefined" means segfault). This wrapper +** is defined to accept an argument of type char, and always returns 0 for +** any values that fall outside of the range of the unsigned char type (i.e. +** negative values). +*/ +static int fts3isspace(char c){ + return c==' ' || c=='\t' || c=='\n' || c=='\r' || c=='\v' || c=='\f'; +} + +/* +** Allocate nByte bytes of memory using sqlite3_malloc(). If successful, +** zero the memory before returning a pointer to it. If unsuccessful, +** return NULL. +*/ +static void *fts3MallocZero(sqlite3_int64 nByte){ + void *pRet = sqlite3_malloc64(nByte); + if( pRet ) memset(pRet, 0, nByte); + return pRet; +} + +SQLITE_PRIVATE int sqlite3Fts3OpenTokenizer( + sqlite3_tokenizer *pTokenizer, + int iLangid, + const char *z, + int n, + sqlite3_tokenizer_cursor **ppCsr +){ + sqlite3_tokenizer_module const *pModule = pTokenizer->pModule; + sqlite3_tokenizer_cursor *pCsr = 0; + int rc; + + rc = pModule->xOpen(pTokenizer, z, n, &pCsr); + assert( rc==SQLITE_OK || pCsr==0 ); + if( rc==SQLITE_OK ){ + pCsr->pTokenizer = pTokenizer; + if( pModule->iVersion>=1 ){ + rc = pModule->xLanguageid(pCsr, iLangid); + if( rc!=SQLITE_OK ){ + pModule->xClose(pCsr); + pCsr = 0; + } + } + } + *ppCsr = pCsr; + return rc; +} + +/* +** Function getNextNode(), which is called by fts3ExprParse(), may itself +** call fts3ExprParse(). So this forward declaration is required. +*/ +static int fts3ExprParse(ParseContext *, const char *, int, Fts3Expr **, int *); + +/* +** Extract the next token from buffer z (length n) using the tokenizer +** and other information (column names etc.) in pParse. Create an Fts3Expr +** structure of type FTSQUERY_PHRASE containing a phrase consisting of this +** single token and set *ppExpr to point to it. If the end of the buffer is +** reached before a token is found, set *ppExpr to zero. It is the +** responsibility of the caller to eventually deallocate the allocated +** Fts3Expr structure (if any) by passing it to sqlite3_free(). +** +** Return SQLITE_OK if successful, or SQLITE_NOMEM if a memory allocation +** fails. +*/ +static int getNextToken( + ParseContext *pParse, /* fts3 query parse context */ + int iCol, /* Value for Fts3Phrase.iColumn */ + const char *z, int n, /* Input string */ + Fts3Expr **ppExpr, /* OUT: expression */ + int *pnConsumed /* OUT: Number of bytes consumed */ +){ + sqlite3_tokenizer *pTokenizer = pParse->pTokenizer; + sqlite3_tokenizer_module const *pModule = pTokenizer->pModule; + int rc; + sqlite3_tokenizer_cursor *pCursor; + Fts3Expr *pRet = 0; + int i = 0; + + /* Set variable i to the maximum number of bytes of input to tokenize. */ + for(i=0; iiLangid, z, i, &pCursor); + if( rc==SQLITE_OK ){ + const char *zToken; + int nToken = 0, iStart = 0, iEnd = 0, iPosition = 0; + sqlite3_int64 nByte; /* total space to allocate */ + + rc = pModule->xNext(pCursor, &zToken, &nToken, &iStart, &iEnd, &iPosition); + if( rc==SQLITE_OK ){ + nByte = sizeof(Fts3Expr) + sizeof(Fts3Phrase) + nToken; + pRet = (Fts3Expr *)fts3MallocZero(nByte); + if( !pRet ){ + rc = SQLITE_NOMEM; + }else{ + pRet->eType = FTSQUERY_PHRASE; + pRet->pPhrase = (Fts3Phrase *)&pRet[1]; + pRet->pPhrase->nToken = 1; + pRet->pPhrase->iColumn = iCol; + pRet->pPhrase->aToken[0].n = nToken; + pRet->pPhrase->aToken[0].z = (char *)&pRet->pPhrase[1]; + memcpy(pRet->pPhrase->aToken[0].z, zToken, nToken); + + if( iEndpPhrase->aToken[0].isPrefix = 1; + iEnd++; + } + + while( 1 ){ + if( !sqlite3_fts3_enable_parentheses + && iStart>0 && z[iStart-1]=='-' + ){ + pParse->isNot = 1; + iStart--; + }else if( pParse->bFts4 && iStart>0 && z[iStart-1]=='^' ){ + pRet->pPhrase->aToken[0].bFirst = 1; + iStart--; + }else{ + break; + } + } + + } + *pnConsumed = iEnd; + }else if( i && rc==SQLITE_DONE ){ + rc = SQLITE_OK; + } + + pModule->xClose(pCursor); + } + + *ppExpr = pRet; + return rc; +} + + +/* +** Enlarge a memory allocation. If an out-of-memory allocation occurs, +** then free the old allocation. +*/ +static void *fts3ReallocOrFree(void *pOrig, sqlite3_int64 nNew){ + void *pRet = sqlite3_realloc64(pOrig, nNew); + if( !pRet ){ + sqlite3_free(pOrig); + } + return pRet; +} + +/* +** Buffer zInput, length nInput, contains the contents of a quoted string +** that appeared as part of an fts3 query expression. Neither quote character +** is included in the buffer. This function attempts to tokenize the entire +** input buffer and create an Fts3Expr structure of type FTSQUERY_PHRASE +** containing the results. +** +** If successful, SQLITE_OK is returned and *ppExpr set to point at the +** allocated Fts3Expr structure. Otherwise, either SQLITE_NOMEM (out of memory +** error) or SQLITE_ERROR (tokenization error) is returned and *ppExpr set +** to 0. +*/ +static int getNextString( + ParseContext *pParse, /* fts3 query parse context */ + const char *zInput, int nInput, /* Input string */ + Fts3Expr **ppExpr /* OUT: expression */ +){ + sqlite3_tokenizer *pTokenizer = pParse->pTokenizer; + sqlite3_tokenizer_module const *pModule = pTokenizer->pModule; + int rc; + Fts3Expr *p = 0; + sqlite3_tokenizer_cursor *pCursor = 0; + char *zTemp = 0; + int nTemp = 0; + + const int nSpace = sizeof(Fts3Expr) + sizeof(Fts3Phrase); + int nToken = 0; + + /* The final Fts3Expr data structure, including the Fts3Phrase, + ** Fts3PhraseToken structures token buffers are all stored as a single + ** allocation so that the expression can be freed with a single call to + ** sqlite3_free(). Setting this up requires a two pass approach. + ** + ** The first pass, in the block below, uses a tokenizer cursor to iterate + ** through the tokens in the expression. This pass uses fts3ReallocOrFree() + ** to assemble data in two dynamic buffers: + ** + ** Buffer p: Points to the Fts3Expr structure, followed by the Fts3Phrase + ** structure, followed by the array of Fts3PhraseToken + ** structures. This pass only populates the Fts3PhraseToken array. + ** + ** Buffer zTemp: Contains copies of all tokens. + ** + ** The second pass, in the block that begins "if( rc==SQLITE_DONE )" below, + ** appends buffer zTemp to buffer p, and fills in the Fts3Expr and Fts3Phrase + ** structures. + */ + rc = sqlite3Fts3OpenTokenizer( + pTokenizer, pParse->iLangid, zInput, nInput, &pCursor); + if( rc==SQLITE_OK ){ + int ii; + for(ii=0; rc==SQLITE_OK; ii++){ + const char *zByte; + int nByte = 0, iBegin = 0, iEnd = 0, iPos = 0; + rc = pModule->xNext(pCursor, &zByte, &nByte, &iBegin, &iEnd, &iPos); + if( rc==SQLITE_OK ){ + Fts3PhraseToken *pToken; + + p = fts3ReallocOrFree(p, nSpace + ii*sizeof(Fts3PhraseToken)); + if( !p ) goto no_mem; + + zTemp = fts3ReallocOrFree(zTemp, nTemp + nByte); + if( !zTemp ) goto no_mem; + + assert( nToken==ii ); + pToken = &((Fts3Phrase *)(&p[1]))->aToken[ii]; + memset(pToken, 0, sizeof(Fts3PhraseToken)); + + memcpy(&zTemp[nTemp], zByte, nByte); + nTemp += nByte; + + pToken->n = nByte; + pToken->isPrefix = (iEndbFirst = (iBegin>0 && zInput[iBegin-1]=='^'); + nToken = ii+1; + } + } + + pModule->xClose(pCursor); + pCursor = 0; + } + + if( rc==SQLITE_DONE ){ + int jj; + char *zBuf = 0; + + p = fts3ReallocOrFree(p, nSpace + nToken*sizeof(Fts3PhraseToken) + nTemp); + if( !p ) goto no_mem; + memset(p, 0, (char *)&(((Fts3Phrase *)&p[1])->aToken[0])-(char *)p); + p->eType = FTSQUERY_PHRASE; + p->pPhrase = (Fts3Phrase *)&p[1]; + p->pPhrase->iColumn = pParse->iDefaultCol; + p->pPhrase->nToken = nToken; + + zBuf = (char *)&p->pPhrase->aToken[nToken]; + if( zTemp ){ + memcpy(zBuf, zTemp, nTemp); + sqlite3_free(zTemp); + }else{ + assert( nTemp==0 ); + } + + for(jj=0; jjpPhrase->nToken; jj++){ + p->pPhrase->aToken[jj].z = zBuf; + zBuf += p->pPhrase->aToken[jj].n; + } + rc = SQLITE_OK; + } + + *ppExpr = p; + return rc; +no_mem: + + if( pCursor ){ + pModule->xClose(pCursor); + } + sqlite3_free(zTemp); + sqlite3_free(p); + *ppExpr = 0; + return SQLITE_NOMEM; +} + +/* +** The output variable *ppExpr is populated with an allocated Fts3Expr +** structure, or set to 0 if the end of the input buffer is reached. +** +** Returns an SQLite error code. SQLITE_OK if everything works, SQLITE_NOMEM +** if a malloc failure occurs, or SQLITE_ERROR if a parse error is encountered. +** If SQLITE_ERROR is returned, pContext is populated with an error message. +*/ +static int getNextNode( + ParseContext *pParse, /* fts3 query parse context */ + const char *z, int n, /* Input string */ + Fts3Expr **ppExpr, /* OUT: expression */ + int *pnConsumed /* OUT: Number of bytes consumed */ +){ + static const struct Fts3Keyword { + char *z; /* Keyword text */ + unsigned char n; /* Length of the keyword */ + unsigned char parenOnly; /* Only valid in paren mode */ + unsigned char eType; /* Keyword code */ + } aKeyword[] = { + { "OR" , 2, 0, FTSQUERY_OR }, + { "AND", 3, 1, FTSQUERY_AND }, + { "NOT", 3, 1, FTSQUERY_NOT }, + { "NEAR", 4, 0, FTSQUERY_NEAR } + }; + int ii; + int iCol; + int iColLen; + int rc; + Fts3Expr *pRet = 0; + + const char *zInput = z; + int nInput = n; + + pParse->isNot = 0; + + /* Skip over any whitespace before checking for a keyword, an open or + ** close bracket, or a quoted string. + */ + while( nInput>0 && fts3isspace(*zInput) ){ + nInput--; + zInput++; + } + if( nInput==0 ){ + return SQLITE_DONE; + } + + /* See if we are dealing with a keyword. */ + for(ii=0; ii<(int)(sizeof(aKeyword)/sizeof(struct Fts3Keyword)); ii++){ + const struct Fts3Keyword *pKey = &aKeyword[ii]; + + if( (pKey->parenOnly & ~sqlite3_fts3_enable_parentheses)!=0 ){ + continue; + } + + if( nInput>=pKey->n && 0==memcmp(zInput, pKey->z, pKey->n) ){ + int nNear = SQLITE_FTS3_DEFAULT_NEAR_PARAM; + int nKey = pKey->n; + char cNext; + + /* If this is a "NEAR" keyword, check for an explicit nearness. */ + if( pKey->eType==FTSQUERY_NEAR ){ + assert( nKey==4 ); + if( zInput[4]=='/' && zInput[5]>='0' && zInput[5]<='9' ){ + nKey += 1+sqlite3Fts3ReadInt(&zInput[nKey+1], &nNear); + } + } + + /* At this point this is probably a keyword. But for that to be true, + ** the next byte must contain either whitespace, an open or close + ** parenthesis, a quote character, or EOF. + */ + cNext = zInput[nKey]; + if( fts3isspace(cNext) + || cNext=='"' || cNext=='(' || cNext==')' || cNext==0 + ){ + pRet = (Fts3Expr *)fts3MallocZero(sizeof(Fts3Expr)); + if( !pRet ){ + return SQLITE_NOMEM; + } + pRet->eType = pKey->eType; + pRet->nNear = nNear; + *ppExpr = pRet; + *pnConsumed = (int)((zInput - z) + nKey); + return SQLITE_OK; + } + + /* Turns out that wasn't a keyword after all. This happens if the + ** user has supplied a token such as "ORacle". Continue. + */ + } + } + + /* See if we are dealing with a quoted phrase. If this is the case, then + ** search for the closing quote and pass the whole string to getNextString() + ** for processing. This is easy to do, as fts3 has no syntax for escaping + ** a quote character embedded in a string. + */ + if( *zInput=='"' ){ + for(ii=1; iinNest++; + rc = fts3ExprParse(pParse, zInput+1, nInput-1, ppExpr, &nConsumed); + *pnConsumed = (int)(zInput - z) + 1 + nConsumed; + return rc; + }else if( *zInput==')' ){ + pParse->nNest--; + *pnConsumed = (int)((zInput - z) + 1); + *ppExpr = 0; + return SQLITE_DONE; + } + } + + /* If control flows to this point, this must be a regular token, or + ** the end of the input. Read a regular token using the sqlite3_tokenizer + ** interface. Before doing so, figure out if there is an explicit + ** column specifier for the token. + ** + ** TODO: Strangely, it is not possible to associate a column specifier + ** with a quoted phrase, only with a single token. Not sure if this was + ** an implementation artifact or an intentional decision when fts3 was + ** first implemented. Whichever it was, this module duplicates the + ** limitation. + */ + iCol = pParse->iDefaultCol; + iColLen = 0; + for(ii=0; iinCol; ii++){ + const char *zStr = pParse->azCol[ii]; + int nStr = (int)strlen(zStr); + if( nInput>nStr && zInput[nStr]==':' + && sqlite3_strnicmp(zStr, zInput, nStr)==0 + ){ + iCol = ii; + iColLen = (int)((zInput - z) + nStr + 1); + break; + } + } + rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed); + *pnConsumed += iColLen; + return rc; +} + +/* +** The argument is an Fts3Expr structure for a binary operator (any type +** except an FTSQUERY_PHRASE). Return an integer value representing the +** precedence of the operator. Lower values have a higher precedence (i.e. +** group more tightly). For example, in the C language, the == operator +** groups more tightly than ||, and would therefore have a higher precedence. +** +** When using the new fts3 query syntax (when SQLITE_ENABLE_FTS3_PARENTHESIS +** is defined), the order of the operators in precedence from highest to +** lowest is: +** +** NEAR +** NOT +** AND (including implicit ANDs) +** OR +** +** Note that when using the old query syntax, the OR operator has a higher +** precedence than the AND operator. +*/ +static int opPrecedence(Fts3Expr *p){ + assert( p->eType!=FTSQUERY_PHRASE ); + if( sqlite3_fts3_enable_parentheses ){ + return p->eType; + }else if( p->eType==FTSQUERY_NEAR ){ + return 1; + }else if( p->eType==FTSQUERY_OR ){ + return 2; + } + assert( p->eType==FTSQUERY_AND ); + return 3; +} + +/* +** Argument ppHead contains a pointer to the current head of a query +** expression tree being parsed. pPrev is the expression node most recently +** inserted into the tree. This function adds pNew, which is always a binary +** operator node, into the expression tree based on the relative precedence +** of pNew and the existing nodes of the tree. This may result in the head +** of the tree changing, in which case *ppHead is set to the new root node. +*/ +static void insertBinaryOperator( + Fts3Expr **ppHead, /* Pointer to the root node of a tree */ + Fts3Expr *pPrev, /* Node most recently inserted into the tree */ + Fts3Expr *pNew /* New binary node to insert into expression tree */ +){ + Fts3Expr *pSplit = pPrev; + while( pSplit->pParent && opPrecedence(pSplit->pParent)<=opPrecedence(pNew) ){ + pSplit = pSplit->pParent; + } + + if( pSplit->pParent ){ + assert( pSplit->pParent->pRight==pSplit ); + pSplit->pParent->pRight = pNew; + pNew->pParent = pSplit->pParent; + }else{ + *ppHead = pNew; + } + pNew->pLeft = pSplit; + pSplit->pParent = pNew; +} + +/* +** Parse the fts3 query expression found in buffer z, length n. This function +** returns either when the end of the buffer is reached or an unmatched +** closing bracket - ')' - is encountered. +** +** If successful, SQLITE_OK is returned, *ppExpr is set to point to the +** parsed form of the expression and *pnConsumed is set to the number of +** bytes read from buffer z. Otherwise, *ppExpr is set to 0 and SQLITE_NOMEM +** (out of memory error) or SQLITE_ERROR (parse error) is returned. +*/ +static int fts3ExprParse( + ParseContext *pParse, /* fts3 query parse context */ + const char *z, int n, /* Text of MATCH query */ + Fts3Expr **ppExpr, /* OUT: Parsed query structure */ + int *pnConsumed /* OUT: Number of bytes consumed */ +){ + Fts3Expr *pRet = 0; + Fts3Expr *pPrev = 0; + Fts3Expr *pNotBranch = 0; /* Only used in legacy parse mode */ + int nIn = n; + const char *zIn = z; + int rc = SQLITE_OK; + int isRequirePhrase = 1; + + while( rc==SQLITE_OK ){ + Fts3Expr *p = 0; + int nByte = 0; + + rc = getNextNode(pParse, zIn, nIn, &p, &nByte); + assert( nByte>0 || (rc!=SQLITE_OK && p==0) ); + if( rc==SQLITE_OK ){ + if( p ){ + int isPhrase; + + if( !sqlite3_fts3_enable_parentheses + && p->eType==FTSQUERY_PHRASE && pParse->isNot + ){ + /* Create an implicit NOT operator. */ + Fts3Expr *pNot = fts3MallocZero(sizeof(Fts3Expr)); + if( !pNot ){ + sqlite3Fts3ExprFree(p); + rc = SQLITE_NOMEM; + goto exprparse_out; + } + pNot->eType = FTSQUERY_NOT; + pNot->pRight = p; + p->pParent = pNot; + if( pNotBranch ){ + pNot->pLeft = pNotBranch; + pNotBranch->pParent = pNot; + } + pNotBranch = pNot; + p = pPrev; + }else{ + int eType = p->eType; + isPhrase = (eType==FTSQUERY_PHRASE || p->pLeft); + + /* The isRequirePhrase variable is set to true if a phrase or + ** an expression contained in parenthesis is required. If a + ** binary operator (AND, OR, NOT or NEAR) is encounted when + ** isRequirePhrase is set, this is a syntax error. + */ + if( !isPhrase && isRequirePhrase ){ + sqlite3Fts3ExprFree(p); + rc = SQLITE_ERROR; + goto exprparse_out; + } + + if( isPhrase && !isRequirePhrase ){ + /* Insert an implicit AND operator. */ + Fts3Expr *pAnd; + assert( pRet && pPrev ); + pAnd = fts3MallocZero(sizeof(Fts3Expr)); + if( !pAnd ){ + sqlite3Fts3ExprFree(p); + rc = SQLITE_NOMEM; + goto exprparse_out; + } + pAnd->eType = FTSQUERY_AND; + insertBinaryOperator(&pRet, pPrev, pAnd); + pPrev = pAnd; + } + + /* This test catches attempts to make either operand of a NEAR + ** operator something other than a phrase. For example, either of + ** the following: + ** + ** (bracketed expression) NEAR phrase + ** phrase NEAR (bracketed expression) + ** + ** Return an error in either case. + */ + if( pPrev && ( + (eType==FTSQUERY_NEAR && !isPhrase && pPrev->eType!=FTSQUERY_PHRASE) + || (eType!=FTSQUERY_PHRASE && isPhrase && pPrev->eType==FTSQUERY_NEAR) + )){ + sqlite3Fts3ExprFree(p); + rc = SQLITE_ERROR; + goto exprparse_out; + } + + if( isPhrase ){ + if( pRet ){ + assert( pPrev && pPrev->pLeft && pPrev->pRight==0 ); + pPrev->pRight = p; + p->pParent = pPrev; + }else{ + pRet = p; + } + }else{ + insertBinaryOperator(&pRet, pPrev, p); + } + isRequirePhrase = !isPhrase; + } + pPrev = p; + } + assert( nByte>0 ); + } + assert( rc!=SQLITE_OK || (nByte>0 && nByte<=nIn) ); + nIn -= nByte; + zIn += nByte; + } + + if( rc==SQLITE_DONE && pRet && isRequirePhrase ){ + rc = SQLITE_ERROR; + } + + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + if( !sqlite3_fts3_enable_parentheses && pNotBranch ){ + if( !pRet ){ + rc = SQLITE_ERROR; + }else{ + Fts3Expr *pIter = pNotBranch; + while( pIter->pLeft ){ + pIter = pIter->pLeft; + } + pIter->pLeft = pRet; + pRet->pParent = pIter; + pRet = pNotBranch; + } + } + } + *pnConsumed = n - nIn; + +exprparse_out: + if( rc!=SQLITE_OK ){ + sqlite3Fts3ExprFree(pRet); + sqlite3Fts3ExprFree(pNotBranch); + pRet = 0; + } + *ppExpr = pRet; + return rc; +} + +/* +** Return SQLITE_ERROR if the maximum depth of the expression tree passed +** as the only argument is more than nMaxDepth. +*/ +static int fts3ExprCheckDepth(Fts3Expr *p, int nMaxDepth){ + int rc = SQLITE_OK; + if( p ){ + if( nMaxDepth<0 ){ + rc = SQLITE_TOOBIG; + }else{ + rc = fts3ExprCheckDepth(p->pLeft, nMaxDepth-1); + if( rc==SQLITE_OK ){ + rc = fts3ExprCheckDepth(p->pRight, nMaxDepth-1); + } + } + } + return rc; +} + +/* +** This function attempts to transform the expression tree at (*pp) to +** an equivalent but more balanced form. The tree is modified in place. +** If successful, SQLITE_OK is returned and (*pp) set to point to the +** new root expression node. +** +** nMaxDepth is the maximum allowable depth of the balanced sub-tree. +** +** Otherwise, if an error occurs, an SQLite error code is returned and +** expression (*pp) freed. +*/ +static int fts3ExprBalance(Fts3Expr **pp, int nMaxDepth){ + int rc = SQLITE_OK; /* Return code */ + Fts3Expr *pRoot = *pp; /* Initial root node */ + Fts3Expr *pFree = 0; /* List of free nodes. Linked by pParent. */ + int eType = pRoot->eType; /* Type of node in this tree */ + + if( nMaxDepth==0 ){ + rc = SQLITE_ERROR; + } + + if( rc==SQLITE_OK ){ + if( (eType==FTSQUERY_AND || eType==FTSQUERY_OR) ){ + Fts3Expr **apLeaf; + apLeaf = (Fts3Expr **)sqlite3_malloc64(sizeof(Fts3Expr *) * nMaxDepth); + if( 0==apLeaf ){ + rc = SQLITE_NOMEM; + }else{ + memset(apLeaf, 0, sizeof(Fts3Expr *) * nMaxDepth); + } + + if( rc==SQLITE_OK ){ + int i; + Fts3Expr *p; + + /* Set $p to point to the left-most leaf in the tree of eType nodes. */ + for(p=pRoot; p->eType==eType; p=p->pLeft){ + assert( p->pParent==0 || p->pParent->pLeft==p ); + assert( p->pLeft && p->pRight ); + } + + /* This loop runs once for each leaf in the tree of eType nodes. */ + while( 1 ){ + int iLvl; + Fts3Expr *pParent = p->pParent; /* Current parent of p */ + + assert( pParent==0 || pParent->pLeft==p ); + p->pParent = 0; + if( pParent ){ + pParent->pLeft = 0; + }else{ + pRoot = 0; + } + rc = fts3ExprBalance(&p, nMaxDepth-1); + if( rc!=SQLITE_OK ) break; + + for(iLvl=0; p && iLvlpLeft = apLeaf[iLvl]; + pFree->pRight = p; + pFree->pLeft->pParent = pFree; + pFree->pRight->pParent = pFree; + + p = pFree; + pFree = pFree->pParent; + p->pParent = 0; + apLeaf[iLvl] = 0; + } + } + if( p ){ + sqlite3Fts3ExprFree(p); + rc = SQLITE_TOOBIG; + break; + } + + /* If that was the last leaf node, break out of the loop */ + if( pParent==0 ) break; + + /* Set $p to point to the next leaf in the tree of eType nodes */ + for(p=pParent->pRight; p->eType==eType; p=p->pLeft); + + /* Remove pParent from the original tree. */ + assert( pParent->pParent==0 || pParent->pParent->pLeft==pParent ); + pParent->pRight->pParent = pParent->pParent; + if( pParent->pParent ){ + pParent->pParent->pLeft = pParent->pRight; + }else{ + assert( pParent==pRoot ); + pRoot = pParent->pRight; + } + + /* Link pParent into the free node list. It will be used as an + ** internal node of the new tree. */ + pParent->pParent = pFree; + pFree = pParent; + } + + if( rc==SQLITE_OK ){ + p = 0; + for(i=0; ipParent = 0; + }else{ + assert( pFree!=0 ); + pFree->pRight = p; + pFree->pLeft = apLeaf[i]; + pFree->pLeft->pParent = pFree; + pFree->pRight->pParent = pFree; + + p = pFree; + pFree = pFree->pParent; + p->pParent = 0; + } + } + } + pRoot = p; + }else{ + /* An error occurred. Delete the contents of the apLeaf[] array + ** and pFree list. Everything else is cleaned up by the call to + ** sqlite3Fts3ExprFree(pRoot) below. */ + Fts3Expr *pDel; + for(i=0; ipParent; + sqlite3_free(pDel); + } + } + + assert( pFree==0 ); + sqlite3_free( apLeaf ); + } + }else if( eType==FTSQUERY_NOT ){ + Fts3Expr *pLeft = pRoot->pLeft; + Fts3Expr *pRight = pRoot->pRight; + + pRoot->pLeft = 0; + pRoot->pRight = 0; + pLeft->pParent = 0; + pRight->pParent = 0; + + rc = fts3ExprBalance(&pLeft, nMaxDepth-1); + if( rc==SQLITE_OK ){ + rc = fts3ExprBalance(&pRight, nMaxDepth-1); + } + + if( rc!=SQLITE_OK ){ + sqlite3Fts3ExprFree(pRight); + sqlite3Fts3ExprFree(pLeft); + }else{ + assert( pLeft && pRight ); + pRoot->pLeft = pLeft; + pLeft->pParent = pRoot; + pRoot->pRight = pRight; + pRight->pParent = pRoot; + } + } + } + + if( rc!=SQLITE_OK ){ + sqlite3Fts3ExprFree(pRoot); + pRoot = 0; + } + *pp = pRoot; + return rc; +} + +/* +** This function is similar to sqlite3Fts3ExprParse(), with the following +** differences: +** +** 1. It does not do expression rebalancing. +** 2. It does not check that the expression does not exceed the +** maximum allowable depth. +** 3. Even if it fails, *ppExpr may still be set to point to an +** expression tree. It should be deleted using sqlite3Fts3ExprFree() +** in this case. +*/ +static int fts3ExprParseUnbalanced( + sqlite3_tokenizer *pTokenizer, /* Tokenizer module */ + int iLangid, /* Language id for tokenizer */ + char **azCol, /* Array of column names for fts3 table */ + int bFts4, /* True to allow FTS4-only syntax */ + int nCol, /* Number of entries in azCol[] */ + int iDefaultCol, /* Default column to query */ + const char *z, int n, /* Text of MATCH query */ + Fts3Expr **ppExpr /* OUT: Parsed query structure */ +){ + int nParsed; + int rc; + ParseContext sParse; + + memset(&sParse, 0, sizeof(ParseContext)); + sParse.pTokenizer = pTokenizer; + sParse.iLangid = iLangid; + sParse.azCol = (const char **)azCol; + sParse.nCol = nCol; + sParse.iDefaultCol = iDefaultCol; + sParse.bFts4 = bFts4; + if( z==0 ){ + *ppExpr = 0; + return SQLITE_OK; + } + if( n<0 ){ + n = (int)strlen(z); + } + rc = fts3ExprParse(&sParse, z, n, ppExpr, &nParsed); + assert( rc==SQLITE_OK || *ppExpr==0 ); + + /* Check for mismatched parenthesis */ + if( rc==SQLITE_OK && sParse.nNest ){ + rc = SQLITE_ERROR; + } + + return rc; +} + +/* +** Parameters z and n contain a pointer to and length of a buffer containing +** an fts3 query expression, respectively. This function attempts to parse the +** query expression and create a tree of Fts3Expr structures representing the +** parsed expression. If successful, *ppExpr is set to point to the head +** of the parsed expression tree and SQLITE_OK is returned. If an error +** occurs, either SQLITE_NOMEM (out-of-memory error) or SQLITE_ERROR (parse +** error) is returned and *ppExpr is set to 0. +** +** If parameter n is a negative number, then z is assumed to point to a +** nul-terminated string and the length is determined using strlen(). +** +** The first parameter, pTokenizer, is passed the fts3 tokenizer module to +** use to normalize query tokens while parsing the expression. The azCol[] +** array, which is assumed to contain nCol entries, should contain the names +** of each column in the target fts3 table, in order from left to right. +** Column names must be nul-terminated strings. +** +** The iDefaultCol parameter should be passed the index of the table column +** that appears on the left-hand-side of the MATCH operator (the default +** column to match against for tokens for which a column name is not explicitly +** specified as part of the query string), or -1 if tokens may by default +** match any table column. +*/ +SQLITE_PRIVATE int sqlite3Fts3ExprParse( + sqlite3_tokenizer *pTokenizer, /* Tokenizer module */ + int iLangid, /* Language id for tokenizer */ + char **azCol, /* Array of column names for fts3 table */ + int bFts4, /* True to allow FTS4-only syntax */ + int nCol, /* Number of entries in azCol[] */ + int iDefaultCol, /* Default column to query */ + const char *z, int n, /* Text of MATCH query */ + Fts3Expr **ppExpr, /* OUT: Parsed query structure */ + char **pzErr /* OUT: Error message (sqlite3_malloc) */ +){ + int rc = fts3ExprParseUnbalanced( + pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr + ); + + /* Rebalance the expression. And check that its depth does not exceed + ** SQLITE_FTS3_MAX_EXPR_DEPTH. */ + if( rc==SQLITE_OK && *ppExpr ){ + rc = fts3ExprBalance(ppExpr, SQLITE_FTS3_MAX_EXPR_DEPTH); + if( rc==SQLITE_OK ){ + rc = fts3ExprCheckDepth(*ppExpr, SQLITE_FTS3_MAX_EXPR_DEPTH); + } + } + + if( rc!=SQLITE_OK ){ + sqlite3Fts3ExprFree(*ppExpr); + *ppExpr = 0; + if( rc==SQLITE_TOOBIG ){ + sqlite3Fts3ErrMsg(pzErr, + "FTS expression tree is too large (maximum depth %d)", + SQLITE_FTS3_MAX_EXPR_DEPTH + ); + rc = SQLITE_ERROR; + }else if( rc==SQLITE_ERROR ){ + sqlite3Fts3ErrMsg(pzErr, "malformed MATCH expression: [%s]", z); + } + } + + return rc; +} + +/* +** Free a single node of an expression tree. +*/ +static void fts3FreeExprNode(Fts3Expr *p){ + assert( p->eType==FTSQUERY_PHRASE || p->pPhrase==0 ); + sqlite3Fts3EvalPhraseCleanup(p->pPhrase); + sqlite3_free(p->aMI); + sqlite3_free(p); +} + +/* +** Free a parsed fts3 query expression allocated by sqlite3Fts3ExprParse(). +** +** This function would be simpler if it recursively called itself. But +** that would mean passing a sufficiently large expression to ExprParse() +** could cause a stack overflow. +*/ +SQLITE_PRIVATE void sqlite3Fts3ExprFree(Fts3Expr *pDel){ + Fts3Expr *p; + assert( pDel==0 || pDel->pParent==0 ); + for(p=pDel; p && (p->pLeft||p->pRight); p=(p->pLeft ? p->pLeft : p->pRight)){ + assert( p->pParent==0 || p==p->pParent->pRight || p==p->pParent->pLeft ); + } + while( p ){ + Fts3Expr *pParent = p->pParent; + fts3FreeExprNode(p); + if( pParent && p==pParent->pLeft && pParent->pRight ){ + p = pParent->pRight; + while( p && (p->pLeft || p->pRight) ){ + assert( p==p->pParent->pRight || p==p->pParent->pLeft ); + p = (p->pLeft ? p->pLeft : p->pRight); + } + }else{ + p = pParent; + } + } +} + +/**************************************************************************** +***************************************************************************** +** Everything after this point is just test code. +*/ + +#ifdef SQLITE_TEST + +/* #include */ + +/* +** Return a pointer to a buffer containing a text representation of the +** expression passed as the first argument. The buffer is obtained from +** sqlite3_malloc(). It is the responsibility of the caller to use +** sqlite3_free() to release the memory. If an OOM condition is encountered, +** NULL is returned. +** +** If the second argument is not NULL, then its contents are prepended to +** the returned expression text and then freed using sqlite3_free(). +*/ +static char *exprToString(Fts3Expr *pExpr, char *zBuf){ + if( pExpr==0 ){ + return sqlite3_mprintf(""); + } + switch( pExpr->eType ){ + case FTSQUERY_PHRASE: { + Fts3Phrase *pPhrase = pExpr->pPhrase; + int i; + zBuf = sqlite3_mprintf( + "%zPHRASE %d 0", zBuf, pPhrase->iColumn); + for(i=0; zBuf && inToken; i++){ + zBuf = sqlite3_mprintf("%z %.*s%s", zBuf, + pPhrase->aToken[i].n, pPhrase->aToken[i].z, + (pPhrase->aToken[i].isPrefix?"+":"") + ); + } + return zBuf; + } + + case FTSQUERY_NEAR: + zBuf = sqlite3_mprintf("%zNEAR/%d ", zBuf, pExpr->nNear); + break; + case FTSQUERY_NOT: + zBuf = sqlite3_mprintf("%zNOT ", zBuf); + break; + case FTSQUERY_AND: + zBuf = sqlite3_mprintf("%zAND ", zBuf); + break; + case FTSQUERY_OR: + zBuf = sqlite3_mprintf("%zOR ", zBuf); + break; + } + + if( zBuf ) zBuf = sqlite3_mprintf("%z{", zBuf); + if( zBuf ) zBuf = exprToString(pExpr->pLeft, zBuf); + if( zBuf ) zBuf = sqlite3_mprintf("%z} {", zBuf); + + if( zBuf ) zBuf = exprToString(pExpr->pRight, zBuf); + if( zBuf ) zBuf = sqlite3_mprintf("%z}", zBuf); + + return zBuf; +} + +/* +** This is the implementation of a scalar SQL function used to test the +** expression parser. It should be called as follows: +** +** fts3_exprtest(, , , ...); +** +** The first argument, , is the name of the fts3 tokenizer used +** to parse the query expression (see README.tokenizers). The second argument +** is the query expression to parse. Each subsequent argument is the name +** of a column of the fts3 table that the query expression may refer to. +** For example: +** +** SELECT fts3_exprtest('simple', 'Bill col2:Bloggs', 'col1', 'col2'); +*/ +static void fts3ExprTestCommon( + int bRebalance, + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + sqlite3_tokenizer *pTokenizer = 0; + int rc; + char **azCol = 0; + const char *zExpr; + int nExpr; + int nCol; + int ii; + Fts3Expr *pExpr; + char *zBuf = 0; + Fts3Hash *pHash = (Fts3Hash*)sqlite3_user_data(context); + const char *zTokenizer = 0; + char *zErr = 0; + + if( argc<3 ){ + sqlite3_result_error(context, + "Usage: fts3_exprtest(tokenizer, expr, col1, ...", -1 + ); + return; + } + + zTokenizer = (const char*)sqlite3_value_text(argv[0]); + rc = sqlite3Fts3InitTokenizer(pHash, zTokenizer, &pTokenizer, &zErr); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_NOMEM ){ + sqlite3_result_error_nomem(context); + }else{ + sqlite3_result_error(context, zErr, -1); + } + sqlite3_free(zErr); + return; + } + + zExpr = (const char *)sqlite3_value_text(argv[1]); + nExpr = sqlite3_value_bytes(argv[1]); + nCol = argc-2; + azCol = (char **)sqlite3_malloc64(nCol*sizeof(char *)); + if( !azCol ){ + sqlite3_result_error_nomem(context); + goto exprtest_out; + } + for(ii=0; iipModule->xDestroy(pTokenizer); + } + sqlite3_free(azCol); +} + +static void fts3ExprTest( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + fts3ExprTestCommon(0, context, argc, argv); +} +static void fts3ExprTestRebalance( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + fts3ExprTestCommon(1, context, argc, argv); +} + +/* +** Register the query expression parser test function fts3_exprtest() +** with database connection db. +*/ +SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3 *db, Fts3Hash *pHash){ + int rc = sqlite3_create_function( + db, "fts3_exprtest", -1, SQLITE_UTF8, (void*)pHash, fts3ExprTest, 0, 0 + ); + if( rc==SQLITE_OK ){ + rc = sqlite3_create_function(db, "fts3_exprtest_rebalance", + -1, SQLITE_UTF8, (void*)pHash, fts3ExprTestRebalance, 0, 0 + ); + } + return rc; +} + +#endif +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_expr.c *******************************************/ +/************** Begin file fts3_hash.c ***************************************/ +/* +** 2001 September 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the implementation of generic hash-tables used in SQLite. +** We've modified it slightly to serve as a standalone hash table +** implementation for the full-text indexing module. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ +/* #include */ + +/* #include "fts3_hash.h" */ + +/* +** Malloc and Free functions +*/ +static void *fts3HashMalloc(sqlite3_int64 n){ + void *p = sqlite3_malloc64(n); + if( p ){ + memset(p, 0, n); + } + return p; +} +static void fts3HashFree(void *p){ + sqlite3_free(p); +} + +/* Turn bulk memory into a hash table object by initializing the +** fields of the Hash structure. +** +** "pNew" is a pointer to the hash table that is to be initialized. +** keyClass is one of the constants +** FTS3_HASH_BINARY or FTS3_HASH_STRING. The value of keyClass +** determines what kind of key the hash table will use. "copyKey" is +** true if the hash table should make its own private copy of keys and +** false if it should just use the supplied pointer. +*/ +SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey){ + assert( pNew!=0 ); + assert( keyClass>=FTS3_HASH_STRING && keyClass<=FTS3_HASH_BINARY ); + pNew->keyClass = keyClass; + pNew->copyKey = copyKey; + pNew->first = 0; + pNew->count = 0; + pNew->htsize = 0; + pNew->ht = 0; +} + +/* Remove all entries from a hash table. Reclaim all memory. +** Call this routine to delete a hash table or to reset a hash table +** to the empty state. +*/ +SQLITE_PRIVATE void sqlite3Fts3HashClear(Fts3Hash *pH){ + Fts3HashElem *elem; /* For looping over all elements of the table */ + + assert( pH!=0 ); + elem = pH->first; + pH->first = 0; + fts3HashFree(pH->ht); + pH->ht = 0; + pH->htsize = 0; + while( elem ){ + Fts3HashElem *next_elem = elem->next; + if( pH->copyKey && elem->pKey ){ + fts3HashFree(elem->pKey); + } + fts3HashFree(elem); + elem = next_elem; + } + pH->count = 0; +} + +/* +** Hash and comparison functions when the mode is FTS3_HASH_STRING +*/ +static int fts3StrHash(const void *pKey, int nKey){ + const char *z = (const char *)pKey; + unsigned h = 0; + if( nKey<=0 ) nKey = (int) strlen(z); + while( nKey > 0 ){ + h = (h<<3) ^ h ^ *z++; + nKey--; + } + return (int)(h & 0x7fffffff); +} +static int fts3StrCompare(const void *pKey1, int n1, const void *pKey2, int n2){ + if( n1!=n2 ) return 1; + return strncmp((const char*)pKey1,(const char*)pKey2,n1); +} + +/* +** Hash and comparison functions when the mode is FTS3_HASH_BINARY +*/ +static int fts3BinHash(const void *pKey, int nKey){ + int h = 0; + const char *z = (const char *)pKey; + while( nKey-- > 0 ){ + h = (h<<3) ^ h ^ *(z++); + } + return h & 0x7fffffff; +} +static int fts3BinCompare(const void *pKey1, int n1, const void *pKey2, int n2){ + if( n1!=n2 ) return 1; + return memcmp(pKey1,pKey2,n1); +} + +/* +** Return a pointer to the appropriate hash function given the key class. +** +** The C syntax in this function definition may be unfamilar to some +** programmers, so we provide the following additional explanation: +** +** The name of the function is "ftsHashFunction". The function takes a +** single parameter "keyClass". The return value of ftsHashFunction() +** is a pointer to another function. Specifically, the return value +** of ftsHashFunction() is a pointer to a function that takes two parameters +** with types "const void*" and "int" and returns an "int". +*/ +static int (*ftsHashFunction(int keyClass))(const void*,int){ + if( keyClass==FTS3_HASH_STRING ){ + return &fts3StrHash; + }else{ + assert( keyClass==FTS3_HASH_BINARY ); + return &fts3BinHash; + } +} + +/* +** Return a pointer to the appropriate hash function given the key class. +** +** For help in interpreted the obscure C code in the function definition, +** see the header comment on the previous function. +*/ +static int (*ftsCompareFunction(int keyClass))(const void*,int,const void*,int){ + if( keyClass==FTS3_HASH_STRING ){ + return &fts3StrCompare; + }else{ + assert( keyClass==FTS3_HASH_BINARY ); + return &fts3BinCompare; + } +} + +/* Link an element into the hash table +*/ +static void fts3HashInsertElement( + Fts3Hash *pH, /* The complete hash table */ + struct _fts3ht *pEntry, /* The entry into which pNew is inserted */ + Fts3HashElem *pNew /* The element to be inserted */ +){ + Fts3HashElem *pHead; /* First element already in pEntry */ + pHead = pEntry->chain; + if( pHead ){ + pNew->next = pHead; + pNew->prev = pHead->prev; + if( pHead->prev ){ pHead->prev->next = pNew; } + else { pH->first = pNew; } + pHead->prev = pNew; + }else{ + pNew->next = pH->first; + if( pH->first ){ pH->first->prev = pNew; } + pNew->prev = 0; + pH->first = pNew; + } + pEntry->count++; + pEntry->chain = pNew; +} + + +/* Resize the hash table so that it cantains "new_size" buckets. +** "new_size" must be a power of 2. The hash table might fail +** to resize if sqliteMalloc() fails. +** +** Return non-zero if a memory allocation error occurs. +*/ +static int fts3Rehash(Fts3Hash *pH, int new_size){ + struct _fts3ht *new_ht; /* The new hash table */ + Fts3HashElem *elem, *next_elem; /* For looping over existing elements */ + int (*xHash)(const void*,int); /* The hash function */ + + assert( (new_size & (new_size-1))==0 ); + new_ht = (struct _fts3ht *)fts3HashMalloc( new_size*sizeof(struct _fts3ht) ); + if( new_ht==0 ) return 1; + fts3HashFree(pH->ht); + pH->ht = new_ht; + pH->htsize = new_size; + xHash = ftsHashFunction(pH->keyClass); + for(elem=pH->first, pH->first=0; elem; elem = next_elem){ + int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1); + next_elem = elem->next; + fts3HashInsertElement(pH, &new_ht[h], elem); + } + return 0; +} + +/* This function (for internal use only) locates an element in an +** hash table that matches the given key. The hash for this key has +** already been computed and is passed as the 4th parameter. +*/ +static Fts3HashElem *fts3FindElementByHash( + const Fts3Hash *pH, /* The pH to be searched */ + const void *pKey, /* The key we are searching for */ + int nKey, + int h /* The hash for this key. */ +){ + Fts3HashElem *elem; /* Used to loop thru the element list */ + int count; /* Number of elements left to test */ + int (*xCompare)(const void*,int,const void*,int); /* comparison function */ + + if( pH->ht ){ + struct _fts3ht *pEntry = &pH->ht[h]; + elem = pEntry->chain; + count = pEntry->count; + xCompare = ftsCompareFunction(pH->keyClass); + while( count-- && elem ){ + if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){ + return elem; + } + elem = elem->next; + } + } + return 0; +} + +/* Remove a single entry from the hash table given a pointer to that +** element and a hash on the element's key. +*/ +static void fts3RemoveElementByHash( + Fts3Hash *pH, /* The pH containing "elem" */ + Fts3HashElem* elem, /* The element to be removed from the pH */ + int h /* Hash value for the element */ +){ + struct _fts3ht *pEntry; + if( elem->prev ){ + elem->prev->next = elem->next; + }else{ + pH->first = elem->next; + } + if( elem->next ){ + elem->next->prev = elem->prev; + } + pEntry = &pH->ht[h]; + if( pEntry->chain==elem ){ + pEntry->chain = elem->next; + } + pEntry->count--; + if( pEntry->count<=0 ){ + pEntry->chain = 0; + } + if( pH->copyKey && elem->pKey ){ + fts3HashFree(elem->pKey); + } + fts3HashFree( elem ); + pH->count--; + if( pH->count<=0 ){ + assert( pH->first==0 ); + assert( pH->count==0 ); + fts3HashClear(pH); + } +} + +SQLITE_PRIVATE Fts3HashElem *sqlite3Fts3HashFindElem( + const Fts3Hash *pH, + const void *pKey, + int nKey +){ + int h; /* A hash on key */ + int (*xHash)(const void*,int); /* The hash function */ + + if( pH==0 || pH->ht==0 ) return 0; + xHash = ftsHashFunction(pH->keyClass); + assert( xHash!=0 ); + h = (*xHash)(pKey,nKey); + assert( (pH->htsize & (pH->htsize-1))==0 ); + return fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1)); +} + +/* +** Attempt to locate an element of the hash table pH with a key +** that matches pKey,nKey. Return the data for this element if it is +** found, or NULL if there is no match. +*/ +SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){ + Fts3HashElem *pElem; /* The element that matches key (if any) */ + + pElem = sqlite3Fts3HashFindElem(pH, pKey, nKey); + return pElem ? pElem->data : 0; +} + +/* Insert an element into the hash table pH. The key is pKey,nKey +** and the data is "data". +** +** If no element exists with a matching key, then a new +** element is created. A copy of the key is made if the copyKey +** flag is set. NULL is returned. +** +** If another element already exists with the same key, then the +** new data replaces the old data and the old data is returned. +** The key is not copied in this instance. If a malloc fails, then +** the new data is returned and the hash table is unchanged. +** +** If the "data" parameter to this function is NULL, then the +** element corresponding to "key" is removed from the hash table. +*/ +SQLITE_PRIVATE void *sqlite3Fts3HashInsert( + Fts3Hash *pH, /* The hash table to insert into */ + const void *pKey, /* The key */ + int nKey, /* Number of bytes in the key */ + void *data /* The data */ +){ + int hraw; /* Raw hash value of the key */ + int h; /* the hash of the key modulo hash table size */ + Fts3HashElem *elem; /* Used to loop thru the element list */ + Fts3HashElem *new_elem; /* New element added to the pH */ + int (*xHash)(const void*,int); /* The hash function */ + + assert( pH!=0 ); + xHash = ftsHashFunction(pH->keyClass); + assert( xHash!=0 ); + hraw = (*xHash)(pKey, nKey); + assert( (pH->htsize & (pH->htsize-1))==0 ); + h = hraw & (pH->htsize-1); + elem = fts3FindElementByHash(pH,pKey,nKey,h); + if( elem ){ + void *old_data = elem->data; + if( data==0 ){ + fts3RemoveElementByHash(pH,elem,h); + }else{ + elem->data = data; + } + return old_data; + } + if( data==0 ) return 0; + if( (pH->htsize==0 && fts3Rehash(pH,8)) + || (pH->count>=pH->htsize && fts3Rehash(pH, pH->htsize*2)) + ){ + pH->count = 0; + return data; + } + assert( pH->htsize>0 ); + new_elem = (Fts3HashElem*)fts3HashMalloc( sizeof(Fts3HashElem) ); + if( new_elem==0 ) return data; + if( pH->copyKey && pKey!=0 ){ + new_elem->pKey = fts3HashMalloc( nKey ); + if( new_elem->pKey==0 ){ + fts3HashFree(new_elem); + return data; + } + memcpy((void*)new_elem->pKey, pKey, nKey); + }else{ + new_elem->pKey = (void*)pKey; + } + new_elem->nKey = nKey; + pH->count++; + assert( pH->htsize>0 ); + assert( (pH->htsize & (pH->htsize-1))==0 ); + h = hraw & (pH->htsize-1); + fts3HashInsertElement(pH, &pH->ht[h], new_elem); + new_elem->data = data; + return 0; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_hash.c *******************************************/ +/************** Begin file fts3_porter.c *************************************/ +/* +** 2006 September 30 +** +** 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. +** +************************************************************************* +** Implementation of the full-text-search tokenizer that implements +** a Porter stemmer. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ +/* #include */ +/* #include */ + +/* #include "fts3_tokenizer.h" */ + +/* +** Class derived from sqlite3_tokenizer +*/ +typedef struct porter_tokenizer { + sqlite3_tokenizer base; /* Base class */ +} porter_tokenizer; + +/* +** Class derived from sqlite3_tokenizer_cursor +*/ +typedef struct porter_tokenizer_cursor { + sqlite3_tokenizer_cursor base; + const char *zInput; /* input we are tokenizing */ + int nInput; /* size of the input */ + int iOffset; /* current position in zInput */ + int iToken; /* index of next token to be returned */ + char *zToken; /* storage for current token */ + int nAllocated; /* space allocated to zToken buffer */ +} porter_tokenizer_cursor; + + +/* +** Create a new tokenizer instance. +*/ +static int porterCreate( + int argc, const char * const *argv, + sqlite3_tokenizer **ppTokenizer +){ + porter_tokenizer *t; + + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(argv); + + t = (porter_tokenizer *) sqlite3_malloc(sizeof(*t)); + if( t==NULL ) return SQLITE_NOMEM; + memset(t, 0, sizeof(*t)); + *ppTokenizer = &t->base; + return SQLITE_OK; +} + +/* +** Destroy a tokenizer +*/ +static int porterDestroy(sqlite3_tokenizer *pTokenizer){ + sqlite3_free(pTokenizer); + return SQLITE_OK; +} + +/* +** Prepare to begin tokenizing a particular string. The input +** string to be tokenized is zInput[0..nInput-1]. A cursor +** used to incrementally tokenize this string is returned in +** *ppCursor. +*/ +static int porterOpen( + sqlite3_tokenizer *pTokenizer, /* The tokenizer */ + const char *zInput, int nInput, /* String to be tokenized */ + sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */ +){ + porter_tokenizer_cursor *c; + + UNUSED_PARAMETER(pTokenizer); + + c = (porter_tokenizer_cursor *) sqlite3_malloc(sizeof(*c)); + if( c==NULL ) return SQLITE_NOMEM; + + c->zInput = zInput; + if( zInput==0 ){ + c->nInput = 0; + }else if( nInput<0 ){ + c->nInput = (int)strlen(zInput); + }else{ + c->nInput = nInput; + } + c->iOffset = 0; /* start tokenizing at the beginning */ + c->iToken = 0; + c->zToken = NULL; /* no space allocated, yet. */ + c->nAllocated = 0; + + *ppCursor = &c->base; + return SQLITE_OK; +} + +/* +** Close a tokenization cursor previously opened by a call to +** porterOpen() above. +*/ +static int porterClose(sqlite3_tokenizer_cursor *pCursor){ + porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor; + sqlite3_free(c->zToken); + sqlite3_free(c); + return SQLITE_OK; +} +/* +** Vowel or consonant +*/ +static const char cType[] = { + 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 2, 1 +}; + +/* +** isConsonant() and isVowel() determine if their first character in +** the string they point to is a consonant or a vowel, according +** to Porter ruls. +** +** A consonate is any letter other than 'a', 'e', 'i', 'o', or 'u'. +** 'Y' is a consonant unless it follows another consonant, +** in which case it is a vowel. +** +** In these routine, the letters are in reverse order. So the 'y' rule +** is that 'y' is a consonant unless it is followed by another +** consonent. +*/ +static int isVowel(const char*); +static int isConsonant(const char *z){ + int j; + char x = *z; + if( x==0 ) return 0; + assert( x>='a' && x<='z' ); + j = cType[x-'a']; + if( j<2 ) return j; + return z[1]==0 || isVowel(z + 1); +} +static int isVowel(const char *z){ + int j; + char x = *z; + if( x==0 ) return 0; + assert( x>='a' && x<='z' ); + j = cType[x-'a']; + if( j<2 ) return 1-j; + return isConsonant(z + 1); +} + +/* +** Let any sequence of one or more vowels be represented by V and let +** C be sequence of one or more consonants. Then every word can be +** represented as: +** +** [C] (VC){m} [V] +** +** In prose: A word is an optional consonant followed by zero or +** vowel-consonant pairs followed by an optional vowel. "m" is the +** number of vowel consonant pairs. This routine computes the value +** of m for the first i bytes of a word. +** +** Return true if the m-value for z is 1 or more. In other words, +** return true if z contains at least one vowel that is followed +** by a consonant. +** +** In this routine z[] is in reverse order. So we are really looking +** for an instance of a consonant followed by a vowel. +*/ +static int m_gt_0(const char *z){ + while( isVowel(z) ){ z++; } + if( *z==0 ) return 0; + while( isConsonant(z) ){ z++; } + return *z!=0; +} + +/* Like mgt0 above except we are looking for a value of m which is +** exactly 1 +*/ +static int m_eq_1(const char *z){ + while( isVowel(z) ){ z++; } + if( *z==0 ) return 0; + while( isConsonant(z) ){ z++; } + if( *z==0 ) return 0; + while( isVowel(z) ){ z++; } + if( *z==0 ) return 1; + while( isConsonant(z) ){ z++; } + return *z==0; +} + +/* Like mgt0 above except we are looking for a value of m>1 instead +** or m>0 +*/ +static int m_gt_1(const char *z){ + while( isVowel(z) ){ z++; } + if( *z==0 ) return 0; + while( isConsonant(z) ){ z++; } + if( *z==0 ) return 0; + while( isVowel(z) ){ z++; } + if( *z==0 ) return 0; + while( isConsonant(z) ){ z++; } + return *z!=0; +} + +/* +** Return TRUE if there is a vowel anywhere within z[0..n-1] +*/ +static int hasVowel(const char *z){ + while( isConsonant(z) ){ z++; } + return *z!=0; +} + +/* +** Return TRUE if the word ends in a double consonant. +** +** The text is reversed here. So we are really looking at +** the first two characters of z[]. +*/ +static int doubleConsonant(const char *z){ + return isConsonant(z) && z[0]==z[1]; +} + +/* +** Return TRUE if the word ends with three letters which +** are consonant-vowel-consonent and where the final consonant +** is not 'w', 'x', or 'y'. +** +** The word is reversed here. So we are really checking the +** first three letters and the first one cannot be in [wxy]. +*/ +static int star_oh(const char *z){ + return + isConsonant(z) && + z[0]!='w' && z[0]!='x' && z[0]!='y' && + isVowel(z+1) && + isConsonant(z+2); +} + +/* +** If the word ends with zFrom and xCond() is true for the stem +** of the word that preceeds the zFrom ending, then change the +** ending to zTo. +** +** The input word *pz and zFrom are both in reverse order. zTo +** is in normal order. +** +** Return TRUE if zFrom matches. Return FALSE if zFrom does not +** match. Not that TRUE is returned even if xCond() fails and +** no substitution occurs. +*/ +static int stem( + char **pz, /* The word being stemmed (Reversed) */ + const char *zFrom, /* If the ending matches this... (Reversed) */ + const char *zTo, /* ... change the ending to this (not reversed) */ + int (*xCond)(const char*) /* Condition that must be true */ +){ + char *z = *pz; + while( *zFrom && *zFrom==*z ){ z++; zFrom++; } + if( *zFrom!=0 ) return 0; + if( xCond && !xCond(z) ) return 1; + while( *zTo ){ + *(--z) = *(zTo++); + } + *pz = z; + return 1; +} + +/* +** This is the fallback stemmer used when the porter stemmer is +** inappropriate. The input word is copied into the output with +** US-ASCII case folding. If the input word is too long (more +** than 20 bytes if it contains no digits or more than 6 bytes if +** it contains digits) then word is truncated to 20 or 6 bytes +** by taking 10 or 3 bytes from the beginning and end. +*/ +static void copy_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){ + int i, mx, j; + int hasDigit = 0; + for(i=0; i='A' && c<='Z' ){ + zOut[i] = c - 'A' + 'a'; + }else{ + if( c>='0' && c<='9' ) hasDigit = 1; + zOut[i] = c; + } + } + mx = hasDigit ? 3 : 10; + if( nIn>mx*2 ){ + for(j=mx, i=nIn-mx; i=(int)sizeof(zReverse)-7 ){ + /* The word is too big or too small for the porter stemmer. + ** Fallback to the copy stemmer */ + copy_stemmer(zIn, nIn, zOut, pnOut); + return; + } + for(i=0, j=sizeof(zReverse)-6; i='A' && c<='Z' ){ + zReverse[j] = c + 'a' - 'A'; + }else if( c>='a' && c<='z' ){ + zReverse[j] = c; + }else{ + /* The use of a character not in [a-zA-Z] means that we fallback + ** to the copy stemmer */ + copy_stemmer(zIn, nIn, zOut, pnOut); + return; + } + } + memset(&zReverse[sizeof(zReverse)-5], 0, 5); + z = &zReverse[j+1]; + + + /* Step 1a */ + if( z[0]=='s' ){ + if( + !stem(&z, "sess", "ss", 0) && + !stem(&z, "sei", "i", 0) && + !stem(&z, "ss", "ss", 0) + ){ + z++; + } + } + + /* Step 1b */ + z2 = z; + if( stem(&z, "dee", "ee", m_gt_0) ){ + /* Do nothing. The work was all in the test */ + }else if( + (stem(&z, "gni", "", hasVowel) || stem(&z, "de", "", hasVowel)) + && z!=z2 + ){ + if( stem(&z, "ta", "ate", 0) || + stem(&z, "lb", "ble", 0) || + stem(&z, "zi", "ize", 0) ){ + /* Do nothing. The work was all in the test */ + }else if( doubleConsonant(z) && (*z!='l' && *z!='s' && *z!='z') ){ + z++; + }else if( m_eq_1(z) && star_oh(z) ){ + *(--z) = 'e'; + } + } + + /* Step 1c */ + if( z[0]=='y' && hasVowel(z+1) ){ + z[0] = 'i'; + } + + /* Step 2 */ + switch( z[1] ){ + case 'a': + if( !stem(&z, "lanoita", "ate", m_gt_0) ){ + stem(&z, "lanoit", "tion", m_gt_0); + } + break; + case 'c': + if( !stem(&z, "icne", "ence", m_gt_0) ){ + stem(&z, "icna", "ance", m_gt_0); + } + break; + case 'e': + stem(&z, "rezi", "ize", m_gt_0); + break; + case 'g': + stem(&z, "igol", "log", m_gt_0); + break; + case 'l': + if( !stem(&z, "ilb", "ble", m_gt_0) + && !stem(&z, "illa", "al", m_gt_0) + && !stem(&z, "iltne", "ent", m_gt_0) + && !stem(&z, "ile", "e", m_gt_0) + ){ + stem(&z, "ilsuo", "ous", m_gt_0); + } + break; + case 'o': + if( !stem(&z, "noitazi", "ize", m_gt_0) + && !stem(&z, "noita", "ate", m_gt_0) + ){ + stem(&z, "rota", "ate", m_gt_0); + } + break; + case 's': + if( !stem(&z, "msila", "al", m_gt_0) + && !stem(&z, "ssenevi", "ive", m_gt_0) + && !stem(&z, "ssenluf", "ful", m_gt_0) + ){ + stem(&z, "ssensuo", "ous", m_gt_0); + } + break; + case 't': + if( !stem(&z, "itila", "al", m_gt_0) + && !stem(&z, "itivi", "ive", m_gt_0) + ){ + stem(&z, "itilib", "ble", m_gt_0); + } + break; + } + + /* Step 3 */ + switch( z[0] ){ + case 'e': + if( !stem(&z, "etaci", "ic", m_gt_0) + && !stem(&z, "evita", "", m_gt_0) + ){ + stem(&z, "ezila", "al", m_gt_0); + } + break; + case 'i': + stem(&z, "itici", "ic", m_gt_0); + break; + case 'l': + if( !stem(&z, "laci", "ic", m_gt_0) ){ + stem(&z, "luf", "", m_gt_0); + } + break; + case 's': + stem(&z, "ssen", "", m_gt_0); + break; + } + + /* Step 4 */ + switch( z[1] ){ + case 'a': + if( z[0]=='l' && m_gt_1(z+2) ){ + z += 2; + } + break; + case 'c': + if( z[0]=='e' && z[2]=='n' && (z[3]=='a' || z[3]=='e') && m_gt_1(z+4) ){ + z += 4; + } + break; + case 'e': + if( z[0]=='r' && m_gt_1(z+2) ){ + z += 2; + } + break; + case 'i': + if( z[0]=='c' && m_gt_1(z+2) ){ + z += 2; + } + break; + case 'l': + if( z[0]=='e' && z[2]=='b' && (z[3]=='a' || z[3]=='i') && m_gt_1(z+4) ){ + z += 4; + } + break; + case 'n': + if( z[0]=='t' ){ + if( z[2]=='a' ){ + if( m_gt_1(z+3) ){ + z += 3; + } + }else if( z[2]=='e' ){ + if( !stem(&z, "tneme", "", m_gt_1) + && !stem(&z, "tnem", "", m_gt_1) + ){ + stem(&z, "tne", "", m_gt_1); + } + } + } + break; + case 'o': + if( z[0]=='u' ){ + if( m_gt_1(z+2) ){ + z += 2; + } + }else if( z[3]=='s' || z[3]=='t' ){ + stem(&z, "noi", "", m_gt_1); + } + break; + case 's': + if( z[0]=='m' && z[2]=='i' && m_gt_1(z+3) ){ + z += 3; + } + break; + case 't': + if( !stem(&z, "eta", "", m_gt_1) ){ + stem(&z, "iti", "", m_gt_1); + } + break; + case 'u': + if( z[0]=='s' && z[2]=='o' && m_gt_1(z+3) ){ + z += 3; + } + break; + case 'v': + case 'z': + if( z[0]=='e' && z[2]=='i' && m_gt_1(z+3) ){ + z += 3; + } + break; + } + + /* Step 5a */ + if( z[0]=='e' ){ + if( m_gt_1(z+1) ){ + z++; + }else if( m_eq_1(z+1) && !star_oh(z+1) ){ + z++; + } + } + + /* Step 5b */ + if( m_gt_1(z) && z[0]=='l' && z[1]=='l' ){ + z++; + } + + /* z[] is now the stemmed word in reverse order. Flip it back + ** around into forward order and return. + */ + *pnOut = i = (int)strlen(z); + zOut[i] = 0; + while( *z ){ + zOut[--i] = *(z++); + } +} + +/* +** Characters that can be part of a token. We assume any character +** whose value is greater than 0x80 (any UTF character) can be +** part of a token. In other words, delimiters all must have +** values of 0x7f or lower. +*/ +static const char porterIdChar[] = { +/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 3x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 4x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 5x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 7x */ +}; +#define isDelim(C) (((ch=C)&0x80)==0 && (ch<0x30 || !porterIdChar[ch-0x30])) + +/* +** Extract the next token from a tokenization cursor. The cursor must +** have been opened by a prior call to porterOpen(). +*/ +static int porterNext( + sqlite3_tokenizer_cursor *pCursor, /* Cursor returned by porterOpen */ + const char **pzToken, /* OUT: *pzToken is the token text */ + int *pnBytes, /* OUT: Number of bytes in token */ + int *piStartOffset, /* OUT: Starting offset of token */ + int *piEndOffset, /* OUT: Ending offset of token */ + int *piPosition /* OUT: Position integer of token */ +){ + porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor; + const char *z = c->zInput; + + while( c->iOffsetnInput ){ + int iStartOffset, ch; + + /* Scan past delimiter characters */ + while( c->iOffsetnInput && isDelim(z[c->iOffset]) ){ + c->iOffset++; + } + + /* Count non-delimiter characters. */ + iStartOffset = c->iOffset; + while( c->iOffsetnInput && !isDelim(z[c->iOffset]) ){ + c->iOffset++; + } + + if( c->iOffset>iStartOffset ){ + int n = c->iOffset-iStartOffset; + if( n>c->nAllocated ){ + char *pNew; + c->nAllocated = n+20; + pNew = sqlite3_realloc(c->zToken, c->nAllocated); + if( !pNew ) return SQLITE_NOMEM; + c->zToken = pNew; + } + porter_stemmer(&z[iStartOffset], n, c->zToken, pnBytes); + *pzToken = c->zToken; + *piStartOffset = iStartOffset; + *piEndOffset = c->iOffset; + *piPosition = c->iToken++; + return SQLITE_OK; + } + } + return SQLITE_DONE; +} + +/* +** The set of routines that implement the porter-stemmer tokenizer +*/ +static const sqlite3_tokenizer_module porterTokenizerModule = { + 0, + porterCreate, + porterDestroy, + porterOpen, + porterClose, + porterNext, + 0 +}; + +/* +** Allocate a new porter tokenizer. Return a pointer to the new +** tokenizer in *ppModule +*/ +SQLITE_PRIVATE void sqlite3Fts3PorterTokenizerModule( + sqlite3_tokenizer_module const**ppModule +){ + *ppModule = &porterTokenizerModule; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_porter.c *****************************************/ +/************** Begin file fts3_tokenizer.c **********************************/ +/* +** 2007 June 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This is part of an SQLite module implementing full-text search. +** This particular file implements the generic tokenizer interface. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ + +/* +** Return true if the two-argument version of fts3_tokenizer() +** has been activated via a prior call to sqlite3_db_config(db, +** SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 1, 0); +*/ +static int fts3TokenizerEnabled(sqlite3_context *context){ + sqlite3 *db = sqlite3_context_db_handle(context); + int isEnabled = 0; + sqlite3_db_config(db,SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER,-1,&isEnabled); + return isEnabled; +} + +/* +** Implementation of the SQL scalar function for accessing the underlying +** hash table. This function may be called as follows: +** +** SELECT (); +** SELECT (, ); +** +** where is the name passed as the second argument +** to the sqlite3Fts3InitHashTable() function (e.g. 'fts3_tokenizer'). +** +** If the argument is specified, it must be a blob value +** containing a pointer to be stored as the hash data corresponding +** to the string . If is not specified, then +** the string must already exist in the has table. Otherwise, +** an error is returned. +** +** Whether or not the argument is specified, the value returned +** is a blob containing the pointer stored as the hash data corresponding +** to string (after the hash-table is updated, if applicable). +*/ +static void fts3TokenizerFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + Fts3Hash *pHash; + void *pPtr = 0; + const unsigned char *zName; + int nName; + + assert( argc==1 || argc==2 ); + + pHash = (Fts3Hash *)sqlite3_user_data(context); + + zName = sqlite3_value_text(argv[0]); + nName = sqlite3_value_bytes(argv[0])+1; + + if( argc==2 ){ + if( fts3TokenizerEnabled(context) || sqlite3_value_frombind(argv[1]) ){ + void *pOld; + int n = sqlite3_value_bytes(argv[1]); + if( zName==0 || n!=sizeof(pPtr) ){ + sqlite3_result_error(context, "argument type mismatch", -1); + return; + } + pPtr = *(void **)sqlite3_value_blob(argv[1]); + pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr); + if( pOld==pPtr ){ + sqlite3_result_error(context, "out of memory", -1); + } + }else{ + sqlite3_result_error(context, "fts3tokenize disabled", -1); + return; + } + }else{ + if( zName ){ + pPtr = sqlite3Fts3HashFind(pHash, zName, nName); + } + if( !pPtr ){ + char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName); + sqlite3_result_error(context, zErr, -1); + sqlite3_free(zErr); + return; + } + } + if( fts3TokenizerEnabled(context) || sqlite3_value_frombind(argv[0]) ){ + sqlite3_result_blob(context, (void *)&pPtr, sizeof(pPtr), SQLITE_TRANSIENT); + } +} + +SQLITE_PRIVATE int sqlite3Fts3IsIdChar(char c){ + static const char isFtsIdChar[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */ + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 3x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 4x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 5x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 7x */ + }; + return (c&0x80 || isFtsIdChar[(int)(c)]); +} + +SQLITE_PRIVATE const char *sqlite3Fts3NextToken(const char *zStr, int *pn){ + const char *z1; + const char *z2 = 0; + + /* Find the start of the next token. */ + z1 = zStr; + while( z2==0 ){ + char c = *z1; + switch( c ){ + case '\0': return 0; /* No more tokens here */ + case '\'': + case '"': + case '`': { + z2 = z1; + while( *++z2 && (*z2!=c || *++z2==c) ); + break; + } + case '[': + z2 = &z1[1]; + while( *z2 && z2[0]!=']' ) z2++; + if( *z2 ) z2++; + break; + + default: + if( sqlite3Fts3IsIdChar(*z1) ){ + z2 = &z1[1]; + while( sqlite3Fts3IsIdChar(*z2) ) z2++; + }else{ + z1++; + } + } + } + + *pn = (int)(z2-z1); + return z1; +} + +SQLITE_PRIVATE int sqlite3Fts3InitTokenizer( + Fts3Hash *pHash, /* Tokenizer hash table */ + const char *zArg, /* Tokenizer name */ + sqlite3_tokenizer **ppTok, /* OUT: Tokenizer (if applicable) */ + char **pzErr /* OUT: Set to malloced error message */ +){ + int rc; + char *z = (char *)zArg; + int n = 0; + char *zCopy; + char *zEnd; /* Pointer to nul-term of zCopy */ + sqlite3_tokenizer_module *m; + + zCopy = sqlite3_mprintf("%s", zArg); + if( !zCopy ) return SQLITE_NOMEM; + zEnd = &zCopy[strlen(zCopy)]; + + z = (char *)sqlite3Fts3NextToken(zCopy, &n); + if( z==0 ){ + assert( n==0 ); + z = zCopy; + } + z[n] = '\0'; + sqlite3Fts3Dequote(z); + + m = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash,z,(int)strlen(z)+1); + if( !m ){ + sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", z); + rc = SQLITE_ERROR; + }else{ + char const **aArg = 0; + int iArg = 0; + z = &z[n+1]; + while( zxCreate(iArg, aArg, ppTok); + assert( rc!=SQLITE_OK || *ppTok ); + if( rc!=SQLITE_OK ){ + sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer"); + }else{ + (*ppTok)->pModule = m; + } + sqlite3_free((void *)aArg); + } + + sqlite3_free(zCopy); + return rc; +} + + +#ifdef SQLITE_TEST + +#if defined(INCLUDE_SQLITE_TCL_H) +# include "sqlite_tcl.h" +#else +# include "tcl.h" +#endif +/* #include */ + +/* +** Implementation of a special SQL scalar function for testing tokenizers +** designed to be used in concert with the Tcl testing framework. This +** function must be called with two or more arguments: +** +** SELECT (, ..., ); +** +** where is the name passed as the second argument +** to the sqlite3Fts3InitHashTable() function (e.g. 'fts3_tokenizer') +** concatenated with the string '_test' (e.g. 'fts3_tokenizer_test'). +** +** The return value is a string that may be interpreted as a Tcl +** list. For each token in the , three elements are +** added to the returned list. The first is the token position, the +** second is the token text (folded, stemmed, etc.) and the third is the +** substring of associated with the token. For example, +** using the built-in "simple" tokenizer: +** +** SELECT fts_tokenizer_test('simple', 'I don't see how'); +** +** will return the string: +** +** "{0 i I 1 dont don't 2 see see 3 how how}" +** +*/ +static void testFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + Fts3Hash *pHash; + sqlite3_tokenizer_module *p; + sqlite3_tokenizer *pTokenizer = 0; + sqlite3_tokenizer_cursor *pCsr = 0; + + const char *zErr = 0; + + const char *zName; + int nName; + const char *zInput; + int nInput; + + const char *azArg[64]; + + const char *zToken; + int nToken = 0; + int iStart = 0; + int iEnd = 0; + int iPos = 0; + int i; + + Tcl_Obj *pRet; + + if( argc<2 ){ + sqlite3_result_error(context, "insufficient arguments", -1); + return; + } + + nName = sqlite3_value_bytes(argv[0]); + zName = (const char *)sqlite3_value_text(argv[0]); + nInput = sqlite3_value_bytes(argv[argc-1]); + zInput = (const char *)sqlite3_value_text(argv[argc-1]); + + pHash = (Fts3Hash *)sqlite3_user_data(context); + p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1); + + if( !p ){ + char *zErr2 = sqlite3_mprintf("unknown tokenizer: %s", zName); + sqlite3_result_error(context, zErr2, -1); + sqlite3_free(zErr2); + return; + } + + pRet = Tcl_NewObj(); + Tcl_IncrRefCount(pRet); + + for(i=1; ixCreate(argc-2, azArg, &pTokenizer) ){ + zErr = "error in xCreate()"; + goto finish; + } + pTokenizer->pModule = p; + if( sqlite3Fts3OpenTokenizer(pTokenizer, 0, zInput, nInput, &pCsr) ){ + zErr = "error in xOpen()"; + goto finish; + } + + while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){ + Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(iPos)); + Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken)); + zToken = &zInput[iStart]; + nToken = iEnd-iStart; + Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken)); + } + + if( SQLITE_OK!=p->xClose(pCsr) ){ + zErr = "error in xClose()"; + goto finish; + } + if( SQLITE_OK!=p->xDestroy(pTokenizer) ){ + zErr = "error in xDestroy()"; + goto finish; + } + +finish: + if( zErr ){ + sqlite3_result_error(context, zErr, -1); + }else{ + sqlite3_result_text(context, Tcl_GetString(pRet), -1, SQLITE_TRANSIENT); + } + Tcl_DecrRefCount(pRet); +} + +static +int registerTokenizer( + sqlite3 *db, + char *zName, + const sqlite3_tokenizer_module *p +){ + int rc; + sqlite3_stmt *pStmt; + const char zSql[] = "SELECT fts3_tokenizer(?, ?)"; + + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + + sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC); + sqlite3_bind_blob(pStmt, 2, &p, sizeof(p), SQLITE_STATIC); + sqlite3_step(pStmt); + + return sqlite3_finalize(pStmt); +} + + +static +int queryTokenizer( + sqlite3 *db, + char *zName, + const sqlite3_tokenizer_module **pp +){ + int rc; + sqlite3_stmt *pStmt; + const char zSql[] = "SELECT fts3_tokenizer(?)"; + + *pp = 0; + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + + sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC); + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + if( sqlite3_column_type(pStmt, 0)==SQLITE_BLOB + && sqlite3_column_bytes(pStmt, 0)==sizeof(*pp) + ){ + memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp)); + } + } + + return sqlite3_finalize(pStmt); +} + +SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule); + +/* +** Implementation of the scalar function fts3_tokenizer_internal_test(). +** This function is used for testing only, it is not included in the +** build unless SQLITE_TEST is defined. +** +** The purpose of this is to test that the fts3_tokenizer() function +** can be used as designed by the C-code in the queryTokenizer and +** registerTokenizer() functions above. These two functions are repeated +** in the README.tokenizer file as an example, so it is important to +** test them. +** +** To run the tests, evaluate the fts3_tokenizer_internal_test() scalar +** function with no arguments. An assert() will fail if a problem is +** detected. i.e.: +** +** SELECT fts3_tokenizer_internal_test(); +** +*/ +static void intTestFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int rc; + const sqlite3_tokenizer_module *p1; + const sqlite3_tokenizer_module *p2; + sqlite3 *db = (sqlite3 *)sqlite3_user_data(context); + + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(argv); + + /* Test the query function */ + sqlite3Fts3SimpleTokenizerModule(&p1); + rc = queryTokenizer(db, "simple", &p2); + assert( rc==SQLITE_OK ); + assert( p1==p2 ); + rc = queryTokenizer(db, "nosuchtokenizer", &p2); + assert( rc==SQLITE_ERROR ); + assert( p2==0 ); + assert( 0==strcmp(sqlite3_errmsg(db), "unknown tokenizer: nosuchtokenizer") ); + + /* Test the storage function */ + if( fts3TokenizerEnabled(context) ){ + rc = registerTokenizer(db, "nosuchtokenizer", p1); + assert( rc==SQLITE_OK ); + rc = queryTokenizer(db, "nosuchtokenizer", &p2); + assert( rc==SQLITE_OK ); + assert( p2==p1 ); + } + + sqlite3_result_text(context, "ok", -1, SQLITE_STATIC); +} + +#endif + +/* +** Set up SQL objects in database db used to access the contents of +** the hash table pointed to by argument pHash. The hash table must +** been initialized to use string keys, and to take a private copy +** of the key when a value is inserted. i.e. by a call similar to: +** +** sqlite3Fts3HashInit(pHash, FTS3_HASH_STRING, 1); +** +** This function adds a scalar function (see header comment above +** fts3TokenizerFunc() in this file for details) and, if ENABLE_TABLE is +** defined at compilation time, a temporary virtual table (see header +** comment above struct HashTableVtab) to the database schema. Both +** provide read/write access to the contents of *pHash. +** +** The third argument to this function, zName, is used as the name +** of both the scalar and, if created, the virtual table. +*/ +SQLITE_PRIVATE int sqlite3Fts3InitHashTable( + sqlite3 *db, + Fts3Hash *pHash, + const char *zName +){ + int rc = SQLITE_OK; + void *p = (void *)pHash; + const int any = SQLITE_UTF8|SQLITE_DIRECTONLY; + +#ifdef SQLITE_TEST + char *zTest = 0; + char *zTest2 = 0; + void *pdb = (void *)db; + zTest = sqlite3_mprintf("%s_test", zName); + zTest2 = sqlite3_mprintf("%s_internal_test", zName); + if( !zTest || !zTest2 ){ + rc = SQLITE_NOMEM; + } +#endif + + if( SQLITE_OK==rc ){ + rc = sqlite3_create_function(db, zName, 1, any, p, fts3TokenizerFunc, 0, 0); + } + if( SQLITE_OK==rc ){ + rc = sqlite3_create_function(db, zName, 2, any, p, fts3TokenizerFunc, 0, 0); + } +#ifdef SQLITE_TEST + if( SQLITE_OK==rc ){ + rc = sqlite3_create_function(db, zTest, -1, any, p, testFunc, 0, 0); + } + if( SQLITE_OK==rc ){ + rc = sqlite3_create_function(db, zTest2, 0, any, pdb, intTestFunc, 0, 0); + } +#endif + +#ifdef SQLITE_TEST + sqlite3_free(zTest); + sqlite3_free(zTest2); +#endif + + return rc; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_tokenizer.c **************************************/ +/************** Begin file fts3_tokenizer1.c *********************************/ +/* +** 2006 Oct 10 +** +** 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. +** +****************************************************************************** +** +** Implementation of the "simple" full-text-search tokenizer. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ +/* #include */ +/* #include */ + +/* #include "fts3_tokenizer.h" */ + +typedef struct simple_tokenizer { + sqlite3_tokenizer base; + char delim[128]; /* flag ASCII delimiters */ +} simple_tokenizer; + +typedef struct simple_tokenizer_cursor { + sqlite3_tokenizer_cursor base; + const char *pInput; /* input we are tokenizing */ + int nBytes; /* size of the input */ + int iOffset; /* current position in pInput */ + int iToken; /* index of next token to be returned */ + char *pToken; /* storage for current token */ + int nTokenAllocated; /* space allocated to zToken buffer */ +} simple_tokenizer_cursor; + + +static int simpleDelim(simple_tokenizer *t, unsigned char c){ + return c<0x80 && t->delim[c]; +} +static int fts3_isalnum(int x){ + return (x>='0' && x<='9') || (x>='A' && x<='Z') || (x>='a' && x<='z'); +} + +/* +** Create a new tokenizer instance. +*/ +static int simpleCreate( + int argc, const char * const *argv, + sqlite3_tokenizer **ppTokenizer +){ + simple_tokenizer *t; + + t = (simple_tokenizer *) sqlite3_malloc(sizeof(*t)); + if( t==NULL ) return SQLITE_NOMEM; + memset(t, 0, sizeof(*t)); + + /* TODO(shess) Delimiters need to remain the same from run to run, + ** else we need to reindex. One solution would be a meta-table to + ** track such information in the database, then we'd only want this + ** information on the initial create. + */ + if( argc>1 ){ + int i, n = (int)strlen(argv[1]); + for(i=0; i=0x80 ){ + sqlite3_free(t); + return SQLITE_ERROR; + } + t->delim[ch] = 1; + } + } else { + /* Mark non-alphanumeric ASCII characters as delimiters */ + int i; + for(i=1; i<0x80; i++){ + t->delim[i] = !fts3_isalnum(i) ? -1 : 0; + } + } + + *ppTokenizer = &t->base; + return SQLITE_OK; +} + +/* +** Destroy a tokenizer +*/ +static int simpleDestroy(sqlite3_tokenizer *pTokenizer){ + sqlite3_free(pTokenizer); + return SQLITE_OK; +} + +/* +** Prepare to begin tokenizing a particular string. The input +** string to be tokenized is pInput[0..nBytes-1]. A cursor +** used to incrementally tokenize this string is returned in +** *ppCursor. +*/ +static int simpleOpen( + sqlite3_tokenizer *pTokenizer, /* The tokenizer */ + const char *pInput, int nBytes, /* String to be tokenized */ + sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */ +){ + simple_tokenizer_cursor *c; + + UNUSED_PARAMETER(pTokenizer); + + c = (simple_tokenizer_cursor *) sqlite3_malloc(sizeof(*c)); + if( c==NULL ) return SQLITE_NOMEM; + + c->pInput = pInput; + if( pInput==0 ){ + c->nBytes = 0; + }else if( nBytes<0 ){ + c->nBytes = (int)strlen(pInput); + }else{ + c->nBytes = nBytes; + } + c->iOffset = 0; /* start tokenizing at the beginning */ + c->iToken = 0; + c->pToken = NULL; /* no space allocated, yet. */ + c->nTokenAllocated = 0; + + *ppCursor = &c->base; + return SQLITE_OK; +} + +/* +** Close a tokenization cursor previously opened by a call to +** simpleOpen() above. +*/ +static int simpleClose(sqlite3_tokenizer_cursor *pCursor){ + simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor; + sqlite3_free(c->pToken); + sqlite3_free(c); + return SQLITE_OK; +} + +/* +** Extract the next token from a tokenization cursor. The cursor must +** have been opened by a prior call to simpleOpen(). +*/ +static int simpleNext( + sqlite3_tokenizer_cursor *pCursor, /* Cursor returned by simpleOpen */ + const char **ppToken, /* OUT: *ppToken is the token text */ + int *pnBytes, /* OUT: Number of bytes in token */ + int *piStartOffset, /* OUT: Starting offset of token */ + int *piEndOffset, /* OUT: Ending offset of token */ + int *piPosition /* OUT: Position integer of token */ +){ + simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor; + simple_tokenizer *t = (simple_tokenizer *) pCursor->pTokenizer; + unsigned char *p = (unsigned char *)c->pInput; + + while( c->iOffsetnBytes ){ + int iStartOffset; + + /* Scan past delimiter characters */ + while( c->iOffsetnBytes && simpleDelim(t, p[c->iOffset]) ){ + c->iOffset++; + } + + /* Count non-delimiter characters. */ + iStartOffset = c->iOffset; + while( c->iOffsetnBytes && !simpleDelim(t, p[c->iOffset]) ){ + c->iOffset++; + } + + if( c->iOffset>iStartOffset ){ + int i, n = c->iOffset-iStartOffset; + if( n>c->nTokenAllocated ){ + char *pNew; + c->nTokenAllocated = n+20; + pNew = sqlite3_realloc(c->pToken, c->nTokenAllocated); + if( !pNew ) return SQLITE_NOMEM; + c->pToken = pNew; + } + for(i=0; ipToken[i] = (char)((ch>='A' && ch<='Z') ? ch-'A'+'a' : ch); + } + *ppToken = c->pToken; + *pnBytes = n; + *piStartOffset = iStartOffset; + *piEndOffset = c->iOffset; + *piPosition = c->iToken++; + + return SQLITE_OK; + } + } + return SQLITE_DONE; +} + +/* +** The set of routines that implement the simple tokenizer +*/ +static const sqlite3_tokenizer_module simpleTokenizerModule = { + 0, + simpleCreate, + simpleDestroy, + simpleOpen, + simpleClose, + simpleNext, + 0, +}; + +/* +** Allocate a new simple tokenizer. Return a pointer to the new +** tokenizer in *ppModule +*/ +SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule( + sqlite3_tokenizer_module const**ppModule +){ + *ppModule = &simpleTokenizerModule; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_tokenizer1.c *************************************/ +/************** Begin file fts3_tokenize_vtab.c ******************************/ +/* +** 2013 Apr 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains code for the "fts3tokenize" virtual table module. +** An fts3tokenize virtual table is created as follows: +** +** CREATE VIRTUAL TABLE USING fts3tokenize( +** , , ... +** ); +** +** The table created has the following schema: +** +** CREATE TABLE (input, token, start, end, position) +** +** When queried, the query must include a WHERE clause of type: +** +** input = +** +** The virtual table module tokenizes this , using the FTS3 +** tokenizer specified by the arguments to the CREATE VIRTUAL TABLE +** statement and returns one row for each token in the result. With +** fields set as follows: +** +** input: Always set to a copy of +** token: A token from the input. +** start: Byte offset of the token within the input . +** end: Byte offset of the byte immediately following the end of the +** token within the input string. +** pos: Token offset of token within input. +** +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ + +typedef struct Fts3tokTable Fts3tokTable; +typedef struct Fts3tokCursor Fts3tokCursor; + +/* +** Virtual table structure. +*/ +struct Fts3tokTable { + sqlite3_vtab base; /* Base class used by SQLite core */ + const sqlite3_tokenizer_module *pMod; + sqlite3_tokenizer *pTok; +}; + +/* +** Virtual table cursor structure. +*/ +struct Fts3tokCursor { + sqlite3_vtab_cursor base; /* Base class used by SQLite core */ + char *zInput; /* Input string */ + sqlite3_tokenizer_cursor *pCsr; /* Cursor to iterate through zInput */ + int iRowid; /* Current 'rowid' value */ + const char *zToken; /* Current 'token' value */ + int nToken; /* Size of zToken in bytes */ + int iStart; /* Current 'start' value */ + int iEnd; /* Current 'end' value */ + int iPos; /* Current 'pos' value */ +}; + +/* +** Query FTS for the tokenizer implementation named zName. +*/ +static int fts3tokQueryTokenizer( + Fts3Hash *pHash, + const char *zName, + const sqlite3_tokenizer_module **pp, + char **pzErr +){ + sqlite3_tokenizer_module *p; + int nName = (int)strlen(zName); + + p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1); + if( !p ){ + sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", zName); + return SQLITE_ERROR; + } + + *pp = p; + return SQLITE_OK; +} + +/* +** The second argument, argv[], is an array of pointers to nul-terminated +** strings. This function makes a copy of the array and strings into a +** single block of memory. It then dequotes any of the strings that appear +** to be quoted. +** +** If successful, output parameter *pazDequote is set to point at the +** array of dequoted strings and SQLITE_OK is returned. The caller is +** responsible for eventually calling sqlite3_free() to free the array +** in this case. Or, if an error occurs, an SQLite error code is returned. +** The final value of *pazDequote is undefined in this case. +*/ +static int fts3tokDequoteArray( + int argc, /* Number of elements in argv[] */ + const char * const *argv, /* Input array */ + char ***pazDequote /* Output array */ +){ + int rc = SQLITE_OK; /* Return code */ + if( argc==0 ){ + *pazDequote = 0; + }else{ + int i; + int nByte = 0; + char **azDequote; + + for(i=0; i1 ) azArg = (const char * const *)&azDequote[1]; + rc = pMod->xCreate((nDequote>1 ? nDequote-1 : 0), azArg, &pTok); + } + + if( rc==SQLITE_OK ){ + pTab = (Fts3tokTable *)sqlite3_malloc(sizeof(Fts3tokTable)); + if( pTab==0 ){ + rc = SQLITE_NOMEM; + } + } + + if( rc==SQLITE_OK ){ + memset(pTab, 0, sizeof(Fts3tokTable)); + pTab->pMod = pMod; + pTab->pTok = pTok; + *ppVtab = &pTab->base; + }else{ + if( pTok ){ + pMod->xDestroy(pTok); + } + } + + sqlite3_free(azDequote); + return rc; +} + +/* +** This function does the work for both the xDisconnect and xDestroy methods. +** These tables have no persistent representation of their own, so xDisconnect +** and xDestroy are identical operations. +*/ +static int fts3tokDisconnectMethod(sqlite3_vtab *pVtab){ + Fts3tokTable *pTab = (Fts3tokTable *)pVtab; + + pTab->pMod->xDestroy(pTab->pTok); + sqlite3_free(pTab); + return SQLITE_OK; +} + +/* +** xBestIndex - Analyze a WHERE and ORDER BY clause. +*/ +static int fts3tokBestIndexMethod( + sqlite3_vtab *pVTab, + sqlite3_index_info *pInfo +){ + int i; + UNUSED_PARAMETER(pVTab); + + for(i=0; inConstraint; i++){ + if( pInfo->aConstraint[i].usable + && pInfo->aConstraint[i].iColumn==0 + && pInfo->aConstraint[i].op==SQLITE_INDEX_CONSTRAINT_EQ + ){ + pInfo->idxNum = 1; + pInfo->aConstraintUsage[i].argvIndex = 1; + pInfo->aConstraintUsage[i].omit = 1; + pInfo->estimatedCost = 1; + return SQLITE_OK; + } + } + + pInfo->idxNum = 0; + assert( pInfo->estimatedCost>1000000.0 ); + + return SQLITE_OK; +} + +/* +** xOpen - Open a cursor. +*/ +static int fts3tokOpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){ + Fts3tokCursor *pCsr; + UNUSED_PARAMETER(pVTab); + + pCsr = (Fts3tokCursor *)sqlite3_malloc(sizeof(Fts3tokCursor)); + if( pCsr==0 ){ + return SQLITE_NOMEM; + } + memset(pCsr, 0, sizeof(Fts3tokCursor)); + + *ppCsr = (sqlite3_vtab_cursor *)pCsr; + return SQLITE_OK; +} + +/* +** Reset the tokenizer cursor passed as the only argument. As if it had +** just been returned by fts3tokOpenMethod(). +*/ +static void fts3tokResetCursor(Fts3tokCursor *pCsr){ + if( pCsr->pCsr ){ + Fts3tokTable *pTab = (Fts3tokTable *)(pCsr->base.pVtab); + pTab->pMod->xClose(pCsr->pCsr); + pCsr->pCsr = 0; + } + sqlite3_free(pCsr->zInput); + pCsr->zInput = 0; + pCsr->zToken = 0; + pCsr->nToken = 0; + pCsr->iStart = 0; + pCsr->iEnd = 0; + pCsr->iPos = 0; + pCsr->iRowid = 0; +} + +/* +** xClose - Close a cursor. +*/ +static int fts3tokCloseMethod(sqlite3_vtab_cursor *pCursor){ + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + + fts3tokResetCursor(pCsr); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +/* +** xNext - Advance the cursor to the next row, if any. +*/ +static int fts3tokNextMethod(sqlite3_vtab_cursor *pCursor){ + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab); + int rc; /* Return code */ + + pCsr->iRowid++; + rc = pTab->pMod->xNext(pCsr->pCsr, + &pCsr->zToken, &pCsr->nToken, + &pCsr->iStart, &pCsr->iEnd, &pCsr->iPos + ); + + if( rc!=SQLITE_OK ){ + fts3tokResetCursor(pCsr); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + } + + return rc; +} + +/* +** xFilter - Initialize a cursor to point at the start of its data. +*/ +static int fts3tokFilterMethod( + sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */ + int idxNum, /* Strategy index */ + const char *idxStr, /* Unused */ + int nVal, /* Number of elements in apVal */ + sqlite3_value **apVal /* Arguments for the indexing scheme */ +){ + int rc = SQLITE_ERROR; + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab); + UNUSED_PARAMETER(idxStr); + UNUSED_PARAMETER(nVal); + + fts3tokResetCursor(pCsr); + if( idxNum==1 ){ + const char *zByte = (const char *)sqlite3_value_text(apVal[0]); + int nByte = sqlite3_value_bytes(apVal[0]); + pCsr->zInput = sqlite3_malloc64(nByte+1); + if( pCsr->zInput==0 ){ + rc = SQLITE_NOMEM; + }else{ + if( nByte>0 ) memcpy(pCsr->zInput, zByte, nByte); + pCsr->zInput[nByte] = 0; + rc = pTab->pMod->xOpen(pTab->pTok, pCsr->zInput, nByte, &pCsr->pCsr); + if( rc==SQLITE_OK ){ + pCsr->pCsr->pTokenizer = pTab->pTok; + } + } + } + + if( rc!=SQLITE_OK ) return rc; + return fts3tokNextMethod(pCursor); +} + +/* +** xEof - Return true if the cursor is at EOF, or false otherwise. +*/ +static int fts3tokEofMethod(sqlite3_vtab_cursor *pCursor){ + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + return (pCsr->zToken==0); +} + +/* +** xColumn - Return a column value. +*/ +static int fts3tokColumnMethod( + sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */ + sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */ + int iCol /* Index of column to read value from */ +){ + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + + /* CREATE TABLE x(input, token, start, end, position) */ + switch( iCol ){ + case 0: + sqlite3_result_text(pCtx, pCsr->zInput, -1, SQLITE_TRANSIENT); + break; + case 1: + sqlite3_result_text(pCtx, pCsr->zToken, pCsr->nToken, SQLITE_TRANSIENT); + break; + case 2: + sqlite3_result_int(pCtx, pCsr->iStart); + break; + case 3: + sqlite3_result_int(pCtx, pCsr->iEnd); + break; + default: + assert( iCol==4 ); + sqlite3_result_int(pCtx, pCsr->iPos); + break; + } + return SQLITE_OK; +} + +/* +** xRowid - Return the current rowid for the cursor. +*/ +static int fts3tokRowidMethod( + sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */ + sqlite_int64 *pRowid /* OUT: Rowid value */ +){ + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + *pRowid = (sqlite3_int64)pCsr->iRowid; + return SQLITE_OK; +} + +/* +** Register the fts3tok module with database connection db. Return SQLITE_OK +** if successful or an error code if sqlite3_create_module() fails. +*/ +SQLITE_PRIVATE int sqlite3Fts3InitTok(sqlite3 *db, Fts3Hash *pHash){ + static const sqlite3_module fts3tok_module = { + 0, /* iVersion */ + fts3tokConnectMethod, /* xCreate */ + fts3tokConnectMethod, /* xConnect */ + fts3tokBestIndexMethod, /* xBestIndex */ + fts3tokDisconnectMethod, /* xDisconnect */ + fts3tokDisconnectMethod, /* xDestroy */ + fts3tokOpenMethod, /* xOpen */ + fts3tokCloseMethod, /* xClose */ + fts3tokFilterMethod, /* xFilter */ + fts3tokNextMethod, /* xNext */ + fts3tokEofMethod, /* xEof */ + fts3tokColumnMethod, /* xColumn */ + fts3tokRowidMethod, /* xRowid */ + 0, /* xUpdate */ + 0, /* xBegin */ + 0, /* xSync */ + 0, /* xCommit */ + 0, /* xRollback */ + 0, /* xFindFunction */ + 0, /* xRename */ + 0, /* xSavepoint */ + 0, /* xRelease */ + 0, /* xRollbackTo */ + 0 /* xShadowName */ + }; + int rc; /* Return code */ + + rc = sqlite3_create_module(db, "fts3tokenize", &fts3tok_module, (void*)pHash); + return rc; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_tokenize_vtab.c **********************************/ +/************** Begin file fts3_write.c **************************************/ +/* +** 2009 Oct 23 +** +** 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 is part of the SQLite FTS3 extension module. Specifically, +** this file contains code to insert, update and delete rows from FTS3 +** tables. It also contains code to merge FTS3 b-tree segments. Some +** of the sub-routines used to merge segments are also used by the query +** code in fts3.c. +*/ + +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ +/* #include */ +/* #include */ + +#define FTS_MAX_APPENDABLE_HEIGHT 16 + +/* +** When full-text index nodes are loaded from disk, the buffer that they +** are loaded into has the following number of bytes of padding at the end +** of it. i.e. if a full-text index node is 900 bytes in size, then a buffer +** of 920 bytes is allocated for it. +** +** This means that if we have a pointer into a buffer containing node data, +** it is always safe to read up to two varints from it without risking an +** overread, even if the node data is corrupted. +*/ +#define FTS3_NODE_PADDING (FTS3_VARINT_MAX*2) + +/* +** Under certain circumstances, b-tree nodes (doclists) can be loaded into +** memory incrementally instead of all at once. This can be a big performance +** win (reduced IO and CPU) if SQLite stops calling the virtual table xNext() +** method before retrieving all query results (as may happen, for example, +** if a query has a LIMIT clause). +** +** Incremental loading is used for b-tree nodes FTS3_NODE_CHUNK_THRESHOLD +** bytes and larger. Nodes are loaded in chunks of FTS3_NODE_CHUNKSIZE bytes. +** The code is written so that the hard lower-limit for each of these values +** is 1. Clearly such small values would be inefficient, but can be useful +** for testing purposes. +** +** If this module is built with SQLITE_TEST defined, these constants may +** be overridden at runtime for testing purposes. File fts3_test.c contains +** a Tcl interface to read and write the values. +*/ +#ifdef SQLITE_TEST +int test_fts3_node_chunksize = (4*1024); +int test_fts3_node_chunk_threshold = (4*1024)*4; +# define FTS3_NODE_CHUNKSIZE test_fts3_node_chunksize +# define FTS3_NODE_CHUNK_THRESHOLD test_fts3_node_chunk_threshold +#else +# define FTS3_NODE_CHUNKSIZE (4*1024) +# define FTS3_NODE_CHUNK_THRESHOLD (FTS3_NODE_CHUNKSIZE*4) +#endif + +/* +** The values that may be meaningfully bound to the :1 parameter in +** statements SQL_REPLACE_STAT and SQL_SELECT_STAT. +*/ +#define FTS_STAT_DOCTOTAL 0 +#define FTS_STAT_INCRMERGEHINT 1 +#define FTS_STAT_AUTOINCRMERGE 2 + +/* +** If FTS_LOG_MERGES is defined, call sqlite3_log() to report each automatic +** and incremental merge operation that takes place. This is used for +** debugging FTS only, it should not usually be turned on in production +** systems. +*/ +#ifdef FTS3_LOG_MERGES +static void fts3LogMerge(int nMerge, sqlite3_int64 iAbsLevel){ + sqlite3_log(SQLITE_OK, "%d-way merge from level %d", nMerge, (int)iAbsLevel); +} +#else +#define fts3LogMerge(x, y) +#endif + + +typedef struct PendingList PendingList; +typedef struct SegmentNode SegmentNode; +typedef struct SegmentWriter SegmentWriter; + +/* +** An instance of the following data structure is used to build doclists +** incrementally. See function fts3PendingListAppend() for details. +*/ +struct PendingList { + int nData; + char *aData; + int nSpace; + sqlite3_int64 iLastDocid; + sqlite3_int64 iLastCol; + sqlite3_int64 iLastPos; +}; + + +/* +** Each cursor has a (possibly empty) linked list of the following objects. +*/ +struct Fts3DeferredToken { + Fts3PhraseToken *pToken; /* Pointer to corresponding expr token */ + int iCol; /* Column token must occur in */ + Fts3DeferredToken *pNext; /* Next in list of deferred tokens */ + PendingList *pList; /* Doclist is assembled here */ +}; + +/* +** An instance of this structure is used to iterate through the terms on +** a contiguous set of segment b-tree leaf nodes. Although the details of +** this structure are only manipulated by code in this file, opaque handles +** of type Fts3SegReader* are also used by code in fts3.c to iterate through +** terms when querying the full-text index. See functions: +** +** sqlite3Fts3SegReaderNew() +** sqlite3Fts3SegReaderFree() +** sqlite3Fts3SegReaderIterate() +** +** Methods used to manipulate Fts3SegReader structures: +** +** fts3SegReaderNext() +** fts3SegReaderFirstDocid() +** fts3SegReaderNextDocid() +*/ +struct Fts3SegReader { + int iIdx; /* Index within level, or 0x7FFFFFFF for PT */ + u8 bLookup; /* True for a lookup only */ + u8 rootOnly; /* True for a root-only reader */ + + sqlite3_int64 iStartBlock; /* Rowid of first leaf block to traverse */ + sqlite3_int64 iLeafEndBlock; /* Rowid of final leaf block to traverse */ + sqlite3_int64 iEndBlock; /* Rowid of final block in segment (or 0) */ + sqlite3_int64 iCurrentBlock; /* Current leaf block (or 0) */ + + char *aNode; /* Pointer to node data (or NULL) */ + int nNode; /* Size of buffer at aNode (or 0) */ + int nPopulate; /* If >0, bytes of buffer aNode[] loaded */ + sqlite3_blob *pBlob; /* If not NULL, blob handle to read node */ + + Fts3HashElem **ppNextElem; + + /* Variables set by fts3SegReaderNext(). These may be read directly + ** by the caller. They are valid from the time SegmentReaderNew() returns + ** until SegmentReaderNext() returns something other than SQLITE_OK + ** (i.e. SQLITE_DONE). + */ + int nTerm; /* Number of bytes in current term */ + char *zTerm; /* Pointer to current term */ + int nTermAlloc; /* Allocated size of zTerm buffer */ + char *aDoclist; /* Pointer to doclist of current entry */ + int nDoclist; /* Size of doclist in current entry */ + + /* The following variables are used by fts3SegReaderNextDocid() to iterate + ** through the current doclist (aDoclist/nDoclist). + */ + char *pOffsetList; + int nOffsetList; /* For descending pending seg-readers only */ + sqlite3_int64 iDocid; +}; + +#define fts3SegReaderIsPending(p) ((p)->ppNextElem!=0) +#define fts3SegReaderIsRootOnly(p) ((p)->rootOnly!=0) + +/* +** An instance of this structure is used to create a segment b-tree in the +** database. The internal details of this type are only accessed by the +** following functions: +** +** fts3SegWriterAdd() +** fts3SegWriterFlush() +** fts3SegWriterFree() +*/ +struct SegmentWriter { + SegmentNode *pTree; /* Pointer to interior tree structure */ + sqlite3_int64 iFirst; /* First slot in %_segments written */ + sqlite3_int64 iFree; /* Next free slot in %_segments */ + char *zTerm; /* Pointer to previous term buffer */ + int nTerm; /* Number of bytes in zTerm */ + int nMalloc; /* Size of malloc'd buffer at zMalloc */ + char *zMalloc; /* Malloc'd space (possibly) used for zTerm */ + int nSize; /* Size of allocation at aData */ + int nData; /* Bytes of data in aData */ + char *aData; /* Pointer to block from malloc() */ + i64 nLeafData; /* Number of bytes of leaf data written */ +}; + +/* +** Type SegmentNode is used by the following three functions to create +** the interior part of the segment b+-tree structures (everything except +** the leaf nodes). These functions and type are only ever used by code +** within the fts3SegWriterXXX() family of functions described above. +** +** fts3NodeAddTerm() +** fts3NodeWrite() +** fts3NodeFree() +** +** When a b+tree is written to the database (either as a result of a merge +** or the pending-terms table being flushed), leaves are written into the +** database file as soon as they are completely populated. The interior of +** the tree is assembled in memory and written out only once all leaves have +** been populated and stored. This is Ok, as the b+-tree fanout is usually +** very large, meaning that the interior of the tree consumes relatively +** little memory. +*/ +struct SegmentNode { + SegmentNode *pParent; /* Parent node (or NULL for root node) */ + SegmentNode *pRight; /* Pointer to right-sibling */ + SegmentNode *pLeftmost; /* Pointer to left-most node of this depth */ + int nEntry; /* Number of terms written to node so far */ + char *zTerm; /* Pointer to previous term buffer */ + int nTerm; /* Number of bytes in zTerm */ + int nMalloc; /* Size of malloc'd buffer at zMalloc */ + char *zMalloc; /* Malloc'd space (possibly) used for zTerm */ + int nData; /* Bytes of valid data so far */ + char *aData; /* Node data */ +}; + +/* +** Valid values for the second argument to fts3SqlStmt(). +*/ +#define SQL_DELETE_CONTENT 0 +#define SQL_IS_EMPTY 1 +#define SQL_DELETE_ALL_CONTENT 2 +#define SQL_DELETE_ALL_SEGMENTS 3 +#define SQL_DELETE_ALL_SEGDIR 4 +#define SQL_DELETE_ALL_DOCSIZE 5 +#define SQL_DELETE_ALL_STAT 6 +#define SQL_SELECT_CONTENT_BY_ROWID 7 +#define SQL_NEXT_SEGMENT_INDEX 8 +#define SQL_INSERT_SEGMENTS 9 +#define SQL_NEXT_SEGMENTS_ID 10 +#define SQL_INSERT_SEGDIR 11 +#define SQL_SELECT_LEVEL 12 +#define SQL_SELECT_LEVEL_RANGE 13 +#define SQL_SELECT_LEVEL_COUNT 14 +#define SQL_SELECT_SEGDIR_MAX_LEVEL 15 +#define SQL_DELETE_SEGDIR_LEVEL 16 +#define SQL_DELETE_SEGMENTS_RANGE 17 +#define SQL_CONTENT_INSERT 18 +#define SQL_DELETE_DOCSIZE 19 +#define SQL_REPLACE_DOCSIZE 20 +#define SQL_SELECT_DOCSIZE 21 +#define SQL_SELECT_STAT 22 +#define SQL_REPLACE_STAT 23 + +#define SQL_SELECT_ALL_PREFIX_LEVEL 24 +#define SQL_DELETE_ALL_TERMS_SEGDIR 25 +#define SQL_DELETE_SEGDIR_RANGE 26 +#define SQL_SELECT_ALL_LANGID 27 +#define SQL_FIND_MERGE_LEVEL 28 +#define SQL_MAX_LEAF_NODE_ESTIMATE 29 +#define SQL_DELETE_SEGDIR_ENTRY 30 +#define SQL_SHIFT_SEGDIR_ENTRY 31 +#define SQL_SELECT_SEGDIR 32 +#define SQL_CHOMP_SEGDIR 33 +#define SQL_SEGMENT_IS_APPENDABLE 34 +#define SQL_SELECT_INDEXES 35 +#define SQL_SELECT_MXLEVEL 36 + +#define SQL_SELECT_LEVEL_RANGE2 37 +#define SQL_UPDATE_LEVEL_IDX 38 +#define SQL_UPDATE_LEVEL 39 + +/* +** This function is used to obtain an SQLite prepared statement handle +** for the statement identified by the second argument. If successful, +** *pp is set to the requested statement handle and SQLITE_OK returned. +** Otherwise, an SQLite error code is returned and *pp is set to 0. +** +** If argument apVal is not NULL, then it must point to an array with +** at least as many entries as the requested statement has bound +** parameters. The values are bound to the statements parameters before +** returning. +*/ +static int fts3SqlStmt( + Fts3Table *p, /* Virtual table handle */ + int eStmt, /* One of the SQL_XXX constants above */ + sqlite3_stmt **pp, /* OUT: Statement handle */ + sqlite3_value **apVal /* Values to bind to statement */ +){ + const char *azSql[] = { +/* 0 */ "DELETE FROM %Q.'%q_content' WHERE rowid = ?", +/* 1 */ "SELECT NOT EXISTS(SELECT docid FROM %Q.'%q_content' WHERE rowid!=?)", +/* 2 */ "DELETE FROM %Q.'%q_content'", +/* 3 */ "DELETE FROM %Q.'%q_segments'", +/* 4 */ "DELETE FROM %Q.'%q_segdir'", +/* 5 */ "DELETE FROM %Q.'%q_docsize'", +/* 6 */ "DELETE FROM %Q.'%q_stat'", +/* 7 */ "SELECT %s WHERE rowid=?", +/* 8 */ "SELECT (SELECT max(idx) FROM %Q.'%q_segdir' WHERE level = ?) + 1", +/* 9 */ "REPLACE INTO %Q.'%q_segments'(blockid, block) VALUES(?, ?)", +/* 10 */ "SELECT coalesce((SELECT max(blockid) FROM %Q.'%q_segments') + 1, 1)", +/* 11 */ "REPLACE INTO %Q.'%q_segdir' VALUES(?,?,?,?,?,?)", + + /* Return segments in order from oldest to newest.*/ +/* 12 */ "SELECT idx, start_block, leaves_end_block, end_block, root " + "FROM %Q.'%q_segdir' WHERE level = ? ORDER BY idx ASC", +/* 13 */ "SELECT idx, start_block, leaves_end_block, end_block, root " + "FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?" + "ORDER BY level DESC, idx ASC", + +/* 14 */ "SELECT count(*) FROM %Q.'%q_segdir' WHERE level = ?", +/* 15 */ "SELECT max(level) FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?", + +/* 16 */ "DELETE FROM %Q.'%q_segdir' WHERE level = ?", +/* 17 */ "DELETE FROM %Q.'%q_segments' WHERE blockid BETWEEN ? AND ?", +/* 18 */ "INSERT INTO %Q.'%q_content' VALUES(%s)", +/* 19 */ "DELETE FROM %Q.'%q_docsize' WHERE docid = ?", +/* 20 */ "REPLACE INTO %Q.'%q_docsize' VALUES(?,?)", +/* 21 */ "SELECT size FROM %Q.'%q_docsize' WHERE docid=?", +/* 22 */ "SELECT value FROM %Q.'%q_stat' WHERE id=?", +/* 23 */ "REPLACE INTO %Q.'%q_stat' VALUES(?,?)", +/* 24 */ "", +/* 25 */ "", + +/* 26 */ "DELETE FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?", +/* 27 */ "SELECT ? UNION SELECT level / (1024 * ?) FROM %Q.'%q_segdir'", + +/* This statement is used to determine which level to read the input from +** when performing an incremental merge. It returns the absolute level number +** of the oldest level in the db that contains at least ? segments. Or, +** if no level in the FTS index contains more than ? segments, the statement +** returns zero rows. */ +/* 28 */ "SELECT level, count(*) AS cnt FROM %Q.'%q_segdir' " + " GROUP BY level HAVING cnt>=?" + " ORDER BY (level %% 1024) ASC, 2 DESC LIMIT 1", + +/* Estimate the upper limit on the number of leaf nodes in a new segment +** created by merging the oldest :2 segments from absolute level :1. See +** function sqlite3Fts3Incrmerge() for details. */ +/* 29 */ "SELECT 2 * total(1 + leaves_end_block - start_block) " + " FROM (SELECT * FROM %Q.'%q_segdir' " + " WHERE level = ? ORDER BY idx ASC LIMIT ?" + " )", + +/* SQL_DELETE_SEGDIR_ENTRY +** Delete the %_segdir entry on absolute level :1 with index :2. */ +/* 30 */ "DELETE FROM %Q.'%q_segdir' WHERE level = ? AND idx = ?", + +/* SQL_SHIFT_SEGDIR_ENTRY +** Modify the idx value for the segment with idx=:3 on absolute level :2 +** to :1. */ +/* 31 */ "UPDATE %Q.'%q_segdir' SET idx = ? WHERE level=? AND idx=?", + +/* SQL_SELECT_SEGDIR +** Read a single entry from the %_segdir table. The entry from absolute +** level :1 with index value :2. */ +/* 32 */ "SELECT idx, start_block, leaves_end_block, end_block, root " + "FROM %Q.'%q_segdir' WHERE level = ? AND idx = ?", + +/* SQL_CHOMP_SEGDIR +** Update the start_block (:1) and root (:2) fields of the %_segdir +** entry located on absolute level :3 with index :4. */ +/* 33 */ "UPDATE %Q.'%q_segdir' SET start_block = ?, root = ?" + "WHERE level = ? AND idx = ?", + +/* SQL_SEGMENT_IS_APPENDABLE +** Return a single row if the segment with end_block=? is appendable. Or +** no rows otherwise. */ +/* 34 */ "SELECT 1 FROM %Q.'%q_segments' WHERE blockid=? AND block IS NULL", + +/* SQL_SELECT_INDEXES +** Return the list of valid segment indexes for absolute level ? */ +/* 35 */ "SELECT idx FROM %Q.'%q_segdir' WHERE level=? ORDER BY 1 ASC", + +/* SQL_SELECT_MXLEVEL +** Return the largest relative level in the FTS index or indexes. */ +/* 36 */ "SELECT max( level %% 1024 ) FROM %Q.'%q_segdir'", + + /* Return segments in order from oldest to newest.*/ +/* 37 */ "SELECT level, idx, end_block " + "FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ? " + "ORDER BY level DESC, idx ASC", + + /* Update statements used while promoting segments */ +/* 38 */ "UPDATE OR FAIL %Q.'%q_segdir' SET level=-1,idx=? " + "WHERE level=? AND idx=?", +/* 39 */ "UPDATE OR FAIL %Q.'%q_segdir' SET level=? WHERE level=-1" + + }; + int rc = SQLITE_OK; + sqlite3_stmt *pStmt; + + assert( SizeofArray(azSql)==SizeofArray(p->aStmt) ); + assert( eStmt=0 ); + + pStmt = p->aStmt[eStmt]; + if( !pStmt ){ + int f = SQLITE_PREPARE_PERSISTENT|SQLITE_PREPARE_NO_VTAB; + char *zSql; + if( eStmt==SQL_CONTENT_INSERT ){ + zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist); + }else if( eStmt==SQL_SELECT_CONTENT_BY_ROWID ){ + f &= ~SQLITE_PREPARE_NO_VTAB; + zSql = sqlite3_mprintf(azSql[eStmt], p->zReadExprlist); + }else{ + zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName); + } + if( !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v3(p->db, zSql, -1, f, &pStmt, NULL); + sqlite3_free(zSql); + assert( rc==SQLITE_OK || pStmt==0 ); + p->aStmt[eStmt] = pStmt; + } + } + if( apVal ){ + int i; + int nParam = sqlite3_bind_parameter_count(pStmt); + for(i=0; rc==SQLITE_OK && inPendingData==0 ){ + sqlite3_stmt *pStmt; + rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_LEVEL, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_null(pStmt, 1); + sqlite3_step(pStmt); + rc = sqlite3_reset(pStmt); + } + } + + return rc; +} + +/* +** FTS maintains a separate indexes for each language-id (a 32-bit integer). +** Within each language id, a separate index is maintained to store the +** document terms, and each configured prefix size (configured the FTS +** "prefix=" option). And each index consists of multiple levels ("relative +** levels"). +** +** All three of these values (the language id, the specific index and the +** level within the index) are encoded in 64-bit integer values stored +** in the %_segdir table on disk. This function is used to convert three +** separate component values into the single 64-bit integer value that +** can be used to query the %_segdir table. +** +** Specifically, each language-id/index combination is allocated 1024 +** 64-bit integer level values ("absolute levels"). The main terms index +** for language-id 0 is allocate values 0-1023. The first prefix index +** (if any) for language-id 0 is allocated values 1024-2047. And so on. +** Language 1 indexes are allocated immediately following language 0. +** +** So, for a system with nPrefix prefix indexes configured, the block of +** absolute levels that corresponds to language-id iLangid and index +** iIndex starts at absolute level ((iLangid * (nPrefix+1) + iIndex) * 1024). +*/ +static sqlite3_int64 getAbsoluteLevel( + Fts3Table *p, /* FTS3 table handle */ + int iLangid, /* Language id */ + int iIndex, /* Index in p->aIndex[] */ + int iLevel /* Level of segments */ +){ + sqlite3_int64 iBase; /* First absolute level for iLangid/iIndex */ + assert_fts3_nc( iLangid>=0 ); + assert( p->nIndex>0 ); + assert( iIndex>=0 && iIndexnIndex ); + + iBase = ((sqlite3_int64)iLangid * p->nIndex + iIndex) * FTS3_SEGDIR_MAXLEVEL; + return iBase + iLevel; +} + +/* +** Set *ppStmt to a statement handle that may be used to iterate through +** all rows in the %_segdir table, from oldest to newest. If successful, +** return SQLITE_OK. If an error occurs while preparing the statement, +** return an SQLite error code. +** +** There is only ever one instance of this SQL statement compiled for +** each FTS3 table. +** +** The statement returns the following columns from the %_segdir table: +** +** 0: idx +** 1: start_block +** 2: leaves_end_block +** 3: end_block +** 4: root +*/ +SQLITE_PRIVATE int sqlite3Fts3AllSegdirs( + Fts3Table *p, /* FTS3 table */ + int iLangid, /* Language being queried */ + int iIndex, /* Index for p->aIndex[] */ + int iLevel, /* Level to select (relative level) */ + sqlite3_stmt **ppStmt /* OUT: Compiled statement */ +){ + int rc; + sqlite3_stmt *pStmt = 0; + + assert( iLevel==FTS3_SEGCURSOR_ALL || iLevel>=0 ); + assert( iLevel=0 && iIndexnIndex ); + + if( iLevel<0 ){ + /* "SELECT * FROM %_segdir WHERE level BETWEEN ? AND ? ORDER BY ..." */ + rc = fts3SqlStmt(p, SQL_SELECT_LEVEL_RANGE, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex, 0)); + sqlite3_bind_int64(pStmt, 2, + getAbsoluteLevel(p, iLangid, iIndex, FTS3_SEGDIR_MAXLEVEL-1) + ); + } + }else{ + /* "SELECT * FROM %_segdir WHERE level = ? ORDER BY ..." */ + rc = fts3SqlStmt(p, SQL_SELECT_LEVEL, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex,iLevel)); + } + } + *ppStmt = pStmt; + return rc; +} + + +/* +** Append a single varint to a PendingList buffer. SQLITE_OK is returned +** if successful, or an SQLite error code otherwise. +** +** This function also serves to allocate the PendingList structure itself. +** For example, to create a new PendingList structure containing two +** varints: +** +** PendingList *p = 0; +** fts3PendingListAppendVarint(&p, 1); +** fts3PendingListAppendVarint(&p, 2); +*/ +static int fts3PendingListAppendVarint( + PendingList **pp, /* IN/OUT: Pointer to PendingList struct */ + sqlite3_int64 i /* Value to append to data */ +){ + PendingList *p = *pp; + + /* Allocate or grow the PendingList as required. */ + if( !p ){ + p = sqlite3_malloc(sizeof(*p) + 100); + if( !p ){ + return SQLITE_NOMEM; + } + p->nSpace = 100; + p->aData = (char *)&p[1]; + p->nData = 0; + } + else if( p->nData+FTS3_VARINT_MAX+1>p->nSpace ){ + int nNew = p->nSpace * 2; + p = sqlite3_realloc(p, sizeof(*p) + nNew); + if( !p ){ + sqlite3_free(*pp); + *pp = 0; + return SQLITE_NOMEM; + } + p->nSpace = nNew; + p->aData = (char *)&p[1]; + } + + /* Append the new serialized varint to the end of the list. */ + p->nData += sqlite3Fts3PutVarint(&p->aData[p->nData], i); + p->aData[p->nData] = '\0'; + *pp = p; + return SQLITE_OK; +} + +/* +** Add a docid/column/position entry to a PendingList structure. Non-zero +** is returned if the structure is sqlite3_realloced as part of adding +** the entry. Otherwise, zero. +** +** If an OOM error occurs, *pRc is set to SQLITE_NOMEM before returning. +** Zero is always returned in this case. Otherwise, if no OOM error occurs, +** it is set to SQLITE_OK. +*/ +static int fts3PendingListAppend( + PendingList **pp, /* IN/OUT: PendingList structure */ + sqlite3_int64 iDocid, /* Docid for entry to add */ + sqlite3_int64 iCol, /* Column for entry to add */ + sqlite3_int64 iPos, /* Position of term for entry to add */ + int *pRc /* OUT: Return code */ +){ + PendingList *p = *pp; + int rc = SQLITE_OK; + + assert( !p || p->iLastDocid<=iDocid ); + + if( !p || p->iLastDocid!=iDocid ){ + u64 iDelta = (u64)iDocid - (u64)(p ? p->iLastDocid : 0); + if( p ){ + assert( p->nDatanSpace ); + assert( p->aData[p->nData]==0 ); + p->nData++; + } + if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iDelta)) ){ + goto pendinglistappend_out; + } + p->iLastCol = -1; + p->iLastPos = 0; + p->iLastDocid = iDocid; + } + if( iCol>0 && p->iLastCol!=iCol ){ + if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, 1)) + || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol)) + ){ + goto pendinglistappend_out; + } + p->iLastCol = iCol; + p->iLastPos = 0; + } + if( iCol>=0 ){ + assert( iPos>p->iLastPos || (iPos==0 && p->iLastPos==0) ); + rc = fts3PendingListAppendVarint(&p, 2+iPos-p->iLastPos); + if( rc==SQLITE_OK ){ + p->iLastPos = iPos; + } + } + + pendinglistappend_out: + *pRc = rc; + if( p!=*pp ){ + *pp = p; + return 1; + } + return 0; +} + +/* +** Free a PendingList object allocated by fts3PendingListAppend(). +*/ +static void fts3PendingListDelete(PendingList *pList){ + sqlite3_free(pList); +} + +/* +** Add an entry to one of the pending-terms hash tables. +*/ +static int fts3PendingTermsAddOne( + Fts3Table *p, + int iCol, + int iPos, + Fts3Hash *pHash, /* Pending terms hash table to add entry to */ + const char *zToken, + int nToken +){ + PendingList *pList; + int rc = SQLITE_OK; + + pList = (PendingList *)fts3HashFind(pHash, zToken, nToken); + if( pList ){ + p->nPendingData -= (pList->nData + nToken + sizeof(Fts3HashElem)); + } + if( fts3PendingListAppend(&pList, p->iPrevDocid, iCol, iPos, &rc) ){ + if( pList==fts3HashInsert(pHash, zToken, nToken, pList) ){ + /* Malloc failed while inserting the new entry. This can only + ** happen if there was no previous entry for this token. + */ + assert( 0==fts3HashFind(pHash, zToken, nToken) ); + sqlite3_free(pList); + rc = SQLITE_NOMEM; + } + } + if( rc==SQLITE_OK ){ + p->nPendingData += (pList->nData + nToken + sizeof(Fts3HashElem)); + } + return rc; +} + +/* +** Tokenize the nul-terminated string zText and add all tokens to the +** pending-terms hash-table. The docid used is that currently stored in +** p->iPrevDocid, and the column is specified by argument iCol. +** +** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code. +*/ +static int fts3PendingTermsAdd( + Fts3Table *p, /* Table into which text will be inserted */ + int iLangid, /* Language id to use */ + const char *zText, /* Text of document to be inserted */ + int iCol, /* Column into which text is being inserted */ + u32 *pnWord /* IN/OUT: Incr. by number tokens inserted */ +){ + int rc; + int iStart = 0; + int iEnd = 0; + int iPos = 0; + int nWord = 0; + + char const *zToken; + int nToken = 0; + + sqlite3_tokenizer *pTokenizer = p->pTokenizer; + sqlite3_tokenizer_module const *pModule = pTokenizer->pModule; + sqlite3_tokenizer_cursor *pCsr; + int (*xNext)(sqlite3_tokenizer_cursor *pCursor, + const char**,int*,int*,int*,int*); + + assert( pTokenizer && pModule ); + + /* If the user has inserted a NULL value, this function may be called with + ** zText==0. In this case, add zero token entries to the hash table and + ** return early. */ + if( zText==0 ){ + *pnWord = 0; + return SQLITE_OK; + } + + rc = sqlite3Fts3OpenTokenizer(pTokenizer, iLangid, zText, -1, &pCsr); + if( rc!=SQLITE_OK ){ + return rc; + } + + xNext = pModule->xNext; + while( SQLITE_OK==rc + && SQLITE_OK==(rc = xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos)) + ){ + int i; + if( iPos>=nWord ) nWord = iPos+1; + + /* Positions cannot be negative; we use -1 as a terminator internally. + ** Tokens must have a non-zero length. + */ + if( iPos<0 || !zToken || nToken<=0 ){ + rc = SQLITE_ERROR; + break; + } + + /* Add the term to the terms index */ + rc = fts3PendingTermsAddOne( + p, iCol, iPos, &p->aIndex[0].hPending, zToken, nToken + ); + + /* Add the term to each of the prefix indexes that it is not too + ** short for. */ + for(i=1; rc==SQLITE_OK && inIndex; i++){ + struct Fts3Index *pIndex = &p->aIndex[i]; + if( nTokennPrefix ) continue; + rc = fts3PendingTermsAddOne( + p, iCol, iPos, &pIndex->hPending, zToken, pIndex->nPrefix + ); + } + } + + pModule->xClose(pCsr); + *pnWord += nWord; + return (rc==SQLITE_DONE ? SQLITE_OK : rc); +} + +/* +** Calling this function indicates that subsequent calls to +** fts3PendingTermsAdd() are to add term/position-list pairs for the +** contents of the document with docid iDocid. +*/ +static int fts3PendingTermsDocid( + Fts3Table *p, /* Full-text table handle */ + int bDelete, /* True if this op is a delete */ + int iLangid, /* Language id of row being written */ + sqlite_int64 iDocid /* Docid of row being written */ +){ + assert( iLangid>=0 ); + assert( bDelete==1 || bDelete==0 ); + + /* TODO(shess) Explore whether partially flushing the buffer on + ** forced-flush would provide better performance. I suspect that if + ** we ordered the doclists by size and flushed the largest until the + ** buffer was half empty, that would let the less frequent terms + ** generate longer doclists. + */ + if( iDocidiPrevDocid + || (iDocid==p->iPrevDocid && p->bPrevDelete==0) + || p->iPrevLangid!=iLangid + || p->nPendingData>p->nMaxPendingData + ){ + int rc = sqlite3Fts3PendingTermsFlush(p); + if( rc!=SQLITE_OK ) return rc; + } + p->iPrevDocid = iDocid; + p->iPrevLangid = iLangid; + p->bPrevDelete = bDelete; + return SQLITE_OK; +} + +/* +** Discard the contents of the pending-terms hash tables. +*/ +SQLITE_PRIVATE void sqlite3Fts3PendingTermsClear(Fts3Table *p){ + int i; + for(i=0; inIndex; i++){ + Fts3HashElem *pElem; + Fts3Hash *pHash = &p->aIndex[i].hPending; + for(pElem=fts3HashFirst(pHash); pElem; pElem=fts3HashNext(pElem)){ + PendingList *pList = (PendingList *)fts3HashData(pElem); + fts3PendingListDelete(pList); + } + fts3HashClear(pHash); + } + p->nPendingData = 0; +} + +/* +** This function is called by the xUpdate() method as part of an INSERT +** operation. It adds entries for each term in the new record to the +** pendingTerms hash table. +** +** Argument apVal is the same as the similarly named argument passed to +** fts3InsertData(). Parameter iDocid is the docid of the new row. +*/ +static int fts3InsertTerms( + Fts3Table *p, + int iLangid, + sqlite3_value **apVal, + u32 *aSz +){ + int i; /* Iterator variable */ + for(i=2; inColumn+2; i++){ + int iCol = i-2; + if( p->abNotindexed[iCol]==0 ){ + const char *zText = (const char *)sqlite3_value_text(apVal[i]); + int rc = fts3PendingTermsAdd(p, iLangid, zText, iCol, &aSz[iCol]); + if( rc!=SQLITE_OK ){ + return rc; + } + aSz[p->nColumn] += sqlite3_value_bytes(apVal[i]); + } + } + return SQLITE_OK; +} + +/* +** This function is called by the xUpdate() method for an INSERT operation. +** The apVal parameter is passed a copy of the apVal argument passed by +** SQLite to the xUpdate() method. i.e: +** +** apVal[0] Not used for INSERT. +** apVal[1] rowid +** apVal[2] Left-most user-defined column +** ... +** apVal[p->nColumn+1] Right-most user-defined column +** apVal[p->nColumn+2] Hidden column with same name as table +** apVal[p->nColumn+3] Hidden "docid" column (alias for rowid) +** apVal[p->nColumn+4] Hidden languageid column +*/ +static int fts3InsertData( + Fts3Table *p, /* Full-text table */ + sqlite3_value **apVal, /* Array of values to insert */ + sqlite3_int64 *piDocid /* OUT: Docid for row just inserted */ +){ + int rc; /* Return code */ + sqlite3_stmt *pContentInsert; /* INSERT INTO %_content VALUES(...) */ + + if( p->zContentTbl ){ + sqlite3_value *pRowid = apVal[p->nColumn+3]; + if( sqlite3_value_type(pRowid)==SQLITE_NULL ){ + pRowid = apVal[1]; + } + if( sqlite3_value_type(pRowid)!=SQLITE_INTEGER ){ + return SQLITE_CONSTRAINT; + } + *piDocid = sqlite3_value_int64(pRowid); + return SQLITE_OK; + } + + /* Locate the statement handle used to insert data into the %_content + ** table. The SQL for this statement is: + ** + ** INSERT INTO %_content VALUES(?, ?, ?, ...) + ** + ** The statement features N '?' variables, where N is the number of user + ** defined columns in the FTS3 table, plus one for the docid field. + */ + rc = fts3SqlStmt(p, SQL_CONTENT_INSERT, &pContentInsert, &apVal[1]); + if( rc==SQLITE_OK && p->zLanguageid ){ + rc = sqlite3_bind_int( + pContentInsert, p->nColumn+2, + sqlite3_value_int(apVal[p->nColumn+4]) + ); + } + if( rc!=SQLITE_OK ) return rc; + + /* There is a quirk here. The users INSERT statement may have specified + ** a value for the "rowid" field, for the "docid" field, or for both. + ** Which is a problem, since "rowid" and "docid" are aliases for the + ** same value. For example: + ** + ** INSERT INTO fts3tbl(rowid, docid) VALUES(1, 2); + ** + ** In FTS3, this is an error. It is an error to specify non-NULL values + ** for both docid and some other rowid alias. + */ + if( SQLITE_NULL!=sqlite3_value_type(apVal[3+p->nColumn]) ){ + if( SQLITE_NULL==sqlite3_value_type(apVal[0]) + && SQLITE_NULL!=sqlite3_value_type(apVal[1]) + ){ + /* A rowid/docid conflict. */ + return SQLITE_ERROR; + } + rc = sqlite3_bind_value(pContentInsert, 1, apVal[3+p->nColumn]); + if( rc!=SQLITE_OK ) return rc; + } + + /* Execute the statement to insert the record. Set *piDocid to the + ** new docid value. + */ + sqlite3_step(pContentInsert); + rc = sqlite3_reset(pContentInsert); + + *piDocid = sqlite3_last_insert_rowid(p->db); + return rc; +} + + + +/* +** Remove all data from the FTS3 table. Clear the hash table containing +** pending terms. +*/ +static int fts3DeleteAll(Fts3Table *p, int bContent){ + int rc = SQLITE_OK; /* Return code */ + + /* Discard the contents of the pending-terms hash table. */ + sqlite3Fts3PendingTermsClear(p); + + /* Delete everything from the shadow tables. Except, leave %_content as + ** is if bContent is false. */ + assert( p->zContentTbl==0 || bContent==0 ); + if( bContent ) fts3SqlExec(&rc, p, SQL_DELETE_ALL_CONTENT, 0); + fts3SqlExec(&rc, p, SQL_DELETE_ALL_SEGMENTS, 0); + fts3SqlExec(&rc, p, SQL_DELETE_ALL_SEGDIR, 0); + if( p->bHasDocsize ){ + fts3SqlExec(&rc, p, SQL_DELETE_ALL_DOCSIZE, 0); + } + if( p->bHasStat ){ + fts3SqlExec(&rc, p, SQL_DELETE_ALL_STAT, 0); + } + return rc; +} + +/* +** +*/ +static int langidFromSelect(Fts3Table *p, sqlite3_stmt *pSelect){ + int iLangid = 0; + if( p->zLanguageid ) iLangid = sqlite3_column_int(pSelect, p->nColumn+1); + return iLangid; +} + +/* +** The first element in the apVal[] array is assumed to contain the docid +** (an integer) of a row about to be deleted. Remove all terms from the +** full-text index. +*/ +static void fts3DeleteTerms( + int *pRC, /* Result code */ + Fts3Table *p, /* The FTS table to delete from */ + sqlite3_value *pRowid, /* The docid to be deleted */ + u32 *aSz, /* Sizes of deleted document written here */ + int *pbFound /* OUT: Set to true if row really does exist */ +){ + int rc; + sqlite3_stmt *pSelect; + + assert( *pbFound==0 ); + if( *pRC ) return; + rc = fts3SqlStmt(p, SQL_SELECT_CONTENT_BY_ROWID, &pSelect, &pRowid); + if( rc==SQLITE_OK ){ + if( SQLITE_ROW==sqlite3_step(pSelect) ){ + int i; + int iLangid = langidFromSelect(p, pSelect); + i64 iDocid = sqlite3_column_int64(pSelect, 0); + rc = fts3PendingTermsDocid(p, 1, iLangid, iDocid); + for(i=1; rc==SQLITE_OK && i<=p->nColumn; i++){ + int iCol = i-1; + if( p->abNotindexed[iCol]==0 ){ + const char *zText = (const char *)sqlite3_column_text(pSelect, i); + rc = fts3PendingTermsAdd(p, iLangid, zText, -1, &aSz[iCol]); + aSz[p->nColumn] += sqlite3_column_bytes(pSelect, i); + } + } + if( rc!=SQLITE_OK ){ + sqlite3_reset(pSelect); + *pRC = rc; + return; + } + *pbFound = 1; + } + rc = sqlite3_reset(pSelect); + }else{ + sqlite3_reset(pSelect); + } + *pRC = rc; +} + +/* +** Forward declaration to account for the circular dependency between +** functions fts3SegmentMerge() and fts3AllocateSegdirIdx(). +*/ +static int fts3SegmentMerge(Fts3Table *, int, int, int); + +/* +** This function allocates a new level iLevel index in the segdir table. +** Usually, indexes are allocated within a level sequentially starting +** with 0, so the allocated index is one greater than the value returned +** by: +** +** SELECT max(idx) FROM %_segdir WHERE level = :iLevel +** +** However, if there are already FTS3_MERGE_COUNT indexes at the requested +** level, they are merged into a single level (iLevel+1) segment and the +** allocated index is 0. +** +** If successful, *piIdx is set to the allocated index slot and SQLITE_OK +** returned. Otherwise, an SQLite error code is returned. +*/ +static int fts3AllocateSegdirIdx( + Fts3Table *p, + int iLangid, /* Language id */ + int iIndex, /* Index for p->aIndex */ + int iLevel, + int *piIdx +){ + int rc; /* Return Code */ + sqlite3_stmt *pNextIdx; /* Query for next idx at level iLevel */ + int iNext = 0; /* Result of query pNextIdx */ + + assert( iLangid>=0 ); + assert( p->nIndex>=1 ); + + /* Set variable iNext to the next available segdir index at level iLevel. */ + rc = fts3SqlStmt(p, SQL_NEXT_SEGMENT_INDEX, &pNextIdx, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64( + pNextIdx, 1, getAbsoluteLevel(p, iLangid, iIndex, iLevel) + ); + if( SQLITE_ROW==sqlite3_step(pNextIdx) ){ + iNext = sqlite3_column_int(pNextIdx, 0); + } + rc = sqlite3_reset(pNextIdx); + } + + if( rc==SQLITE_OK ){ + /* If iNext is FTS3_MERGE_COUNT, indicating that level iLevel is already + ** full, merge all segments in level iLevel into a single iLevel+1 + ** segment and allocate (newly freed) index 0 at level iLevel. Otherwise, + ** if iNext is less than FTS3_MERGE_COUNT, allocate index iNext. + */ + if( iNext>=MergeCount(p) ){ + fts3LogMerge(16, getAbsoluteLevel(p, iLangid, iIndex, iLevel)); + rc = fts3SegmentMerge(p, iLangid, iIndex, iLevel); + *piIdx = 0; + }else{ + *piIdx = iNext; + } + } + + return rc; +} + +/* +** The %_segments table is declared as follows: +** +** CREATE TABLE %_segments(blockid INTEGER PRIMARY KEY, block BLOB) +** +** This function reads data from a single row of the %_segments table. The +** specific row is identified by the iBlockid parameter. If paBlob is not +** NULL, then a buffer is allocated using sqlite3_malloc() and populated +** with the contents of the blob stored in the "block" column of the +** identified table row is. Whether or not paBlob is NULL, *pnBlob is set +** to the size of the blob in bytes before returning. +** +** If an error occurs, or the table does not contain the specified row, +** an SQLite error code is returned. Otherwise, SQLITE_OK is returned. If +** paBlob is non-NULL, then it is the responsibility of the caller to +** eventually free the returned buffer. +** +** This function may leave an open sqlite3_blob* handle in the +** Fts3Table.pSegments variable. This handle is reused by subsequent calls +** to this function. The handle may be closed by calling the +** sqlite3Fts3SegmentsClose() function. Reusing a blob handle is a handy +** performance improvement, but the blob handle should always be closed +** before control is returned to the user (to prevent a lock being held +** on the database file for longer than necessary). Thus, any virtual table +** method (xFilter etc.) that may directly or indirectly call this function +** must call sqlite3Fts3SegmentsClose() before returning. +*/ +SQLITE_PRIVATE int sqlite3Fts3ReadBlock( + Fts3Table *p, /* FTS3 table handle */ + sqlite3_int64 iBlockid, /* Access the row with blockid=$iBlockid */ + char **paBlob, /* OUT: Blob data in malloc'd buffer */ + int *pnBlob, /* OUT: Size of blob data */ + int *pnLoad /* OUT: Bytes actually loaded */ +){ + int rc; /* Return code */ + + /* pnBlob must be non-NULL. paBlob may be NULL or non-NULL. */ + assert( pnBlob ); + + if( p->pSegments ){ + rc = sqlite3_blob_reopen(p->pSegments, iBlockid); + }else{ + if( 0==p->zSegmentsTbl ){ + p->zSegmentsTbl = sqlite3_mprintf("%s_segments", p->zName); + if( 0==p->zSegmentsTbl ) return SQLITE_NOMEM; + } + rc = sqlite3_blob_open( + p->db, p->zDb, p->zSegmentsTbl, "block", iBlockid, 0, &p->pSegments + ); + } + + if( rc==SQLITE_OK ){ + int nByte = sqlite3_blob_bytes(p->pSegments); + *pnBlob = nByte; + if( paBlob ){ + char *aByte = sqlite3_malloc(nByte + FTS3_NODE_PADDING); + if( !aByte ){ + rc = SQLITE_NOMEM; + }else{ + if( pnLoad && nByte>(FTS3_NODE_CHUNK_THRESHOLD) ){ + nByte = FTS3_NODE_CHUNKSIZE; + *pnLoad = nByte; + } + rc = sqlite3_blob_read(p->pSegments, aByte, nByte, 0); + memset(&aByte[nByte], 0, FTS3_NODE_PADDING); + if( rc!=SQLITE_OK ){ + sqlite3_free(aByte); + aByte = 0; + } + } + *paBlob = aByte; + } + }else if( rc==SQLITE_ERROR ){ + rc = FTS_CORRUPT_VTAB; + } + + return rc; +} + +/* +** Close the blob handle at p->pSegments, if it is open. See comments above +** the sqlite3Fts3ReadBlock() function for details. +*/ +SQLITE_PRIVATE void sqlite3Fts3SegmentsClose(Fts3Table *p){ + sqlite3_blob_close(p->pSegments); + p->pSegments = 0; +} + +static int fts3SegReaderIncrRead(Fts3SegReader *pReader){ + int nRead; /* Number of bytes to read */ + int rc; /* Return code */ + + nRead = MIN(pReader->nNode - pReader->nPopulate, FTS3_NODE_CHUNKSIZE); + rc = sqlite3_blob_read( + pReader->pBlob, + &pReader->aNode[pReader->nPopulate], + nRead, + pReader->nPopulate + ); + + if( rc==SQLITE_OK ){ + pReader->nPopulate += nRead; + memset(&pReader->aNode[pReader->nPopulate], 0, FTS3_NODE_PADDING); + if( pReader->nPopulate==pReader->nNode ){ + sqlite3_blob_close(pReader->pBlob); + pReader->pBlob = 0; + pReader->nPopulate = 0; + } + } + return rc; +} + +static int fts3SegReaderRequire(Fts3SegReader *pReader, char *pFrom, int nByte){ + int rc = SQLITE_OK; + assert( !pReader->pBlob + || (pFrom>=pReader->aNode && pFrom<&pReader->aNode[pReader->nNode]) + ); + while( pReader->pBlob && rc==SQLITE_OK + && (pFrom - pReader->aNode + nByte)>pReader->nPopulate + ){ + rc = fts3SegReaderIncrRead(pReader); + } + return rc; +} + +/* +** Set an Fts3SegReader cursor to point at EOF. +*/ +static void fts3SegReaderSetEof(Fts3SegReader *pSeg){ + if( !fts3SegReaderIsRootOnly(pSeg) ){ + sqlite3_free(pSeg->aNode); + sqlite3_blob_close(pSeg->pBlob); + pSeg->pBlob = 0; + } + pSeg->aNode = 0; +} + +/* +** Move the iterator passed as the first argument to the next term in the +** segment. If successful, SQLITE_OK is returned. If there is no next term, +** SQLITE_DONE. Otherwise, an SQLite error code. +*/ +static int fts3SegReaderNext( + Fts3Table *p, + Fts3SegReader *pReader, + int bIncr +){ + int rc; /* Return code of various sub-routines */ + char *pNext; /* Cursor variable */ + int nPrefix; /* Number of bytes in term prefix */ + int nSuffix; /* Number of bytes in term suffix */ + + if( !pReader->aDoclist ){ + pNext = pReader->aNode; + }else{ + pNext = &pReader->aDoclist[pReader->nDoclist]; + } + + if( !pNext || pNext>=&pReader->aNode[pReader->nNode] ){ + + if( fts3SegReaderIsPending(pReader) ){ + Fts3HashElem *pElem = *(pReader->ppNextElem); + sqlite3_free(pReader->aNode); + pReader->aNode = 0; + if( pElem ){ + char *aCopy; + PendingList *pList = (PendingList *)fts3HashData(pElem); + int nCopy = pList->nData+1; + pReader->zTerm = (char *)fts3HashKey(pElem); + pReader->nTerm = fts3HashKeysize(pElem); + aCopy = (char*)sqlite3_malloc(nCopy); + if( !aCopy ) return SQLITE_NOMEM; + memcpy(aCopy, pList->aData, nCopy); + pReader->nNode = pReader->nDoclist = nCopy; + pReader->aNode = pReader->aDoclist = aCopy; + pReader->ppNextElem++; + assert( pReader->aNode ); + } + return SQLITE_OK; + } + + fts3SegReaderSetEof(pReader); + + /* If iCurrentBlock>=iLeafEndBlock, this is an EOF condition. All leaf + ** blocks have already been traversed. */ +#ifdef CORRUPT_DB + assert( pReader->iCurrentBlock<=pReader->iLeafEndBlock || CORRUPT_DB ); +#endif + if( pReader->iCurrentBlock>=pReader->iLeafEndBlock ){ + return SQLITE_OK; + } + + rc = sqlite3Fts3ReadBlock( + p, ++pReader->iCurrentBlock, &pReader->aNode, &pReader->nNode, + (bIncr ? &pReader->nPopulate : 0) + ); + if( rc!=SQLITE_OK ) return rc; + assert( pReader->pBlob==0 ); + if( bIncr && pReader->nPopulatenNode ){ + pReader->pBlob = p->pSegments; + p->pSegments = 0; + } + pNext = pReader->aNode; + } + + assert( !fts3SegReaderIsPending(pReader) ); + + rc = fts3SegReaderRequire(pReader, pNext, FTS3_VARINT_MAX*2); + if( rc!=SQLITE_OK ) return rc; + + /* Because of the FTS3_NODE_PADDING bytes of padding, the following is + ** safe (no risk of overread) even if the node data is corrupted. */ + pNext += fts3GetVarint32(pNext, &nPrefix); + pNext += fts3GetVarint32(pNext, &nSuffix); + if( nSuffix<=0 + || (&pReader->aNode[pReader->nNode] - pNext)pReader->nTerm + ){ + return FTS_CORRUPT_VTAB; + } + + /* Both nPrefix and nSuffix were read by fts3GetVarint32() and so are + ** between 0 and 0x7FFFFFFF. But the sum of the two may cause integer + ** overflow - hence the (i64) casts. */ + if( (i64)nPrefix+nSuffix>(i64)pReader->nTermAlloc ){ + i64 nNew = ((i64)nPrefix+nSuffix)*2; + char *zNew = sqlite3_realloc64(pReader->zTerm, nNew); + if( !zNew ){ + return SQLITE_NOMEM; + } + pReader->zTerm = zNew; + pReader->nTermAlloc = nNew; + } + + rc = fts3SegReaderRequire(pReader, pNext, nSuffix+FTS3_VARINT_MAX); + if( rc!=SQLITE_OK ) return rc; + + memcpy(&pReader->zTerm[nPrefix], pNext, nSuffix); + pReader->nTerm = nPrefix+nSuffix; + pNext += nSuffix; + pNext += fts3GetVarint32(pNext, &pReader->nDoclist); + pReader->aDoclist = pNext; + pReader->pOffsetList = 0; + + /* Check that the doclist does not appear to extend past the end of the + ** b-tree node. And that the final byte of the doclist is 0x00. If either + ** of these statements is untrue, then the data structure is corrupt. + */ + if( pReader->nDoclist > pReader->nNode-(pReader->aDoclist-pReader->aNode) + || (pReader->nPopulate==0 && pReader->aDoclist[pReader->nDoclist-1]) + || pReader->nDoclist==0 + ){ + return FTS_CORRUPT_VTAB; + } + return SQLITE_OK; +} + +/* +** Set the SegReader to point to the first docid in the doclist associated +** with the current term. +*/ +static int fts3SegReaderFirstDocid(Fts3Table *pTab, Fts3SegReader *pReader){ + int rc = SQLITE_OK; + assert( pReader->aDoclist ); + assert( !pReader->pOffsetList ); + if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){ + u8 bEof = 0; + pReader->iDocid = 0; + pReader->nOffsetList = 0; + sqlite3Fts3DoclistPrev(0, + pReader->aDoclist, pReader->nDoclist, &pReader->pOffsetList, + &pReader->iDocid, &pReader->nOffsetList, &bEof + ); + }else{ + rc = fts3SegReaderRequire(pReader, pReader->aDoclist, FTS3_VARINT_MAX); + if( rc==SQLITE_OK ){ + int n = sqlite3Fts3GetVarint(pReader->aDoclist, &pReader->iDocid); + pReader->pOffsetList = &pReader->aDoclist[n]; + } + } + return rc; +} + +/* +** Advance the SegReader to point to the next docid in the doclist +** associated with the current term. +** +** If arguments ppOffsetList and pnOffsetList are not NULL, then +** *ppOffsetList is set to point to the first column-offset list +** in the doclist entry (i.e. immediately past the docid varint). +** *pnOffsetList is set to the length of the set of column-offset +** lists, not including the nul-terminator byte. For example: +*/ +static int fts3SegReaderNextDocid( + Fts3Table *pTab, + Fts3SegReader *pReader, /* Reader to advance to next docid */ + char **ppOffsetList, /* OUT: Pointer to current position-list */ + int *pnOffsetList /* OUT: Length of *ppOffsetList in bytes */ +){ + int rc = SQLITE_OK; + char *p = pReader->pOffsetList; + char c = 0; + + assert( p ); + + if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){ + /* A pending-terms seg-reader for an FTS4 table that uses order=desc. + ** Pending-terms doclists are always built up in ascending order, so + ** we have to iterate through them backwards here. */ + u8 bEof = 0; + if( ppOffsetList ){ + *ppOffsetList = pReader->pOffsetList; + *pnOffsetList = pReader->nOffsetList - 1; + } + sqlite3Fts3DoclistPrev(0, + pReader->aDoclist, pReader->nDoclist, &p, &pReader->iDocid, + &pReader->nOffsetList, &bEof + ); + if( bEof ){ + pReader->pOffsetList = 0; + }else{ + pReader->pOffsetList = p; + } + }else{ + char *pEnd = &pReader->aDoclist[pReader->nDoclist]; + + /* Pointer p currently points at the first byte of an offset list. The + ** following block advances it to point one byte past the end of + ** the same offset list. */ + while( 1 ){ + + /* The following line of code (and the "p++" below the while() loop) is + ** normally all that is required to move pointer p to the desired + ** position. The exception is if this node is being loaded from disk + ** incrementally and pointer "p" now points to the first byte past + ** the populated part of pReader->aNode[]. + */ + while( *p | c ) c = *p++ & 0x80; + assert( *p==0 ); + + if( pReader->pBlob==0 || p<&pReader->aNode[pReader->nPopulate] ) break; + rc = fts3SegReaderIncrRead(pReader); + if( rc!=SQLITE_OK ) return rc; + } + p++; + + /* If required, populate the output variables with a pointer to and the + ** size of the previous offset-list. + */ + if( ppOffsetList ){ + *ppOffsetList = pReader->pOffsetList; + *pnOffsetList = (int)(p - pReader->pOffsetList - 1); + } + + /* List may have been edited in place by fts3EvalNearTrim() */ + while( p=pEnd ){ + pReader->pOffsetList = 0; + }else{ + rc = fts3SegReaderRequire(pReader, p, FTS3_VARINT_MAX); + if( rc==SQLITE_OK ){ + u64 iDelta; + pReader->pOffsetList = p + sqlite3Fts3GetVarintU(p, &iDelta); + if( pTab->bDescIdx ){ + pReader->iDocid = (i64)((u64)pReader->iDocid - iDelta); + }else{ + pReader->iDocid = (i64)((u64)pReader->iDocid + iDelta); + } + } + } + } + + return rc; +} + + +SQLITE_PRIVATE int sqlite3Fts3MsrOvfl( + Fts3Cursor *pCsr, + Fts3MultiSegReader *pMsr, + int *pnOvfl +){ + Fts3Table *p = (Fts3Table*)pCsr->base.pVtab; + int nOvfl = 0; + int ii; + int rc = SQLITE_OK; + int pgsz = p->nPgsz; + + assert( p->bFts4 ); + assert( pgsz>0 ); + + for(ii=0; rc==SQLITE_OK && iinSegment; ii++){ + Fts3SegReader *pReader = pMsr->apSegment[ii]; + if( !fts3SegReaderIsPending(pReader) + && !fts3SegReaderIsRootOnly(pReader) + ){ + sqlite3_int64 jj; + for(jj=pReader->iStartBlock; jj<=pReader->iLeafEndBlock; jj++){ + int nBlob; + rc = sqlite3Fts3ReadBlock(p, jj, 0, &nBlob, 0); + if( rc!=SQLITE_OK ) break; + if( (nBlob+35)>pgsz ){ + nOvfl += (nBlob + 34)/pgsz; + } + } + } + } + *pnOvfl = nOvfl; + return rc; +} + +/* +** Free all allocations associated with the iterator passed as the +** second argument. +*/ +SQLITE_PRIVATE void sqlite3Fts3SegReaderFree(Fts3SegReader *pReader){ + if( pReader ){ + if( !fts3SegReaderIsPending(pReader) ){ + sqlite3_free(pReader->zTerm); + } + if( !fts3SegReaderIsRootOnly(pReader) ){ + sqlite3_free(pReader->aNode); + } + sqlite3_blob_close(pReader->pBlob); + } + sqlite3_free(pReader); +} + +/* +** Allocate a new SegReader object. +*/ +SQLITE_PRIVATE int sqlite3Fts3SegReaderNew( + int iAge, /* Segment "age". */ + int bLookup, /* True for a lookup only */ + sqlite3_int64 iStartLeaf, /* First leaf to traverse */ + sqlite3_int64 iEndLeaf, /* Final leaf to traverse */ + sqlite3_int64 iEndBlock, /* Final block of segment */ + const char *zRoot, /* Buffer containing root node */ + int nRoot, /* Size of buffer containing root node */ + Fts3SegReader **ppReader /* OUT: Allocated Fts3SegReader */ +){ + Fts3SegReader *pReader; /* Newly allocated SegReader object */ + int nExtra = 0; /* Bytes to allocate segment root node */ + + assert( zRoot!=0 || nRoot==0 ); +#ifdef CORRUPT_DB + assert( zRoot!=0 || CORRUPT_DB ); +#endif + + if( iStartLeaf==0 ){ + if( iEndLeaf!=0 ) return FTS_CORRUPT_VTAB; + nExtra = nRoot + FTS3_NODE_PADDING; + } + + pReader = (Fts3SegReader *)sqlite3_malloc(sizeof(Fts3SegReader) + nExtra); + if( !pReader ){ + return SQLITE_NOMEM; + } + memset(pReader, 0, sizeof(Fts3SegReader)); + pReader->iIdx = iAge; + pReader->bLookup = bLookup!=0; + pReader->iStartBlock = iStartLeaf; + pReader->iLeafEndBlock = iEndLeaf; + pReader->iEndBlock = iEndBlock; + + if( nExtra ){ + /* The entire segment is stored in the root node. */ + pReader->aNode = (char *)&pReader[1]; + pReader->rootOnly = 1; + pReader->nNode = nRoot; + if( nRoot ) memcpy(pReader->aNode, zRoot, nRoot); + memset(&pReader->aNode[nRoot], 0, FTS3_NODE_PADDING); + }else{ + pReader->iCurrentBlock = iStartLeaf-1; + } + *ppReader = pReader; + return SQLITE_OK; +} + +/* +** This is a comparison function used as a qsort() callback when sorting +** an array of pending terms by term. This occurs as part of flushing +** the contents of the pending-terms hash table to the database. +*/ +static int SQLITE_CDECL fts3CompareElemByTerm( + const void *lhs, + const void *rhs +){ + char *z1 = fts3HashKey(*(Fts3HashElem **)lhs); + char *z2 = fts3HashKey(*(Fts3HashElem **)rhs); + int n1 = fts3HashKeysize(*(Fts3HashElem **)lhs); + int n2 = fts3HashKeysize(*(Fts3HashElem **)rhs); + + int n = (n1aIndex */ + const char *zTerm, /* Term to search for */ + int nTerm, /* Size of buffer zTerm */ + int bPrefix, /* True for a prefix iterator */ + Fts3SegReader **ppReader /* OUT: SegReader for pending-terms */ +){ + Fts3SegReader *pReader = 0; /* Fts3SegReader object to return */ + Fts3HashElem *pE; /* Iterator variable */ + Fts3HashElem **aElem = 0; /* Array of term hash entries to scan */ + int nElem = 0; /* Size of array at aElem */ + int rc = SQLITE_OK; /* Return Code */ + Fts3Hash *pHash; + + pHash = &p->aIndex[iIndex].hPending; + if( bPrefix ){ + int nAlloc = 0; /* Size of allocated array at aElem */ + + for(pE=fts3HashFirst(pHash); pE; pE=fts3HashNext(pE)){ + char *zKey = (char *)fts3HashKey(pE); + int nKey = fts3HashKeysize(pE); + if( nTerm==0 || (nKey>=nTerm && 0==memcmp(zKey, zTerm, nTerm)) ){ + if( nElem==nAlloc ){ + Fts3HashElem **aElem2; + nAlloc += 16; + aElem2 = (Fts3HashElem **)sqlite3_realloc( + aElem, nAlloc*sizeof(Fts3HashElem *) + ); + if( !aElem2 ){ + rc = SQLITE_NOMEM; + nElem = 0; + break; + } + aElem = aElem2; + } + + aElem[nElem++] = pE; + } + } + + /* If more than one term matches the prefix, sort the Fts3HashElem + ** objects in term order using qsort(). This uses the same comparison + ** callback as is used when flushing terms to disk. + */ + if( nElem>1 ){ + qsort(aElem, nElem, sizeof(Fts3HashElem *), fts3CompareElemByTerm); + } + + }else{ + /* The query is a simple term lookup that matches at most one term in + ** the index. All that is required is a straight hash-lookup. + ** + ** Because the stack address of pE may be accessed via the aElem pointer + ** below, the "Fts3HashElem *pE" must be declared so that it is valid + ** within this entire function, not just this "else{...}" block. + */ + pE = fts3HashFindElem(pHash, zTerm, nTerm); + if( pE ){ + aElem = &pE; + nElem = 1; + } + } + + if( nElem>0 ){ + sqlite3_int64 nByte; + nByte = sizeof(Fts3SegReader) + (nElem+1)*sizeof(Fts3HashElem *); + pReader = (Fts3SegReader *)sqlite3_malloc64(nByte); + if( !pReader ){ + rc = SQLITE_NOMEM; + }else{ + memset(pReader, 0, nByte); + pReader->iIdx = 0x7FFFFFFF; + pReader->ppNextElem = (Fts3HashElem **)&pReader[1]; + memcpy(pReader->ppNextElem, aElem, nElem*sizeof(Fts3HashElem *)); + } + } + + if( bPrefix ){ + sqlite3_free(aElem); + } + *ppReader = pReader; + return rc; +} + +/* +** Compare the entries pointed to by two Fts3SegReader structures. +** Comparison is as follows: +** +** 1) EOF is greater than not EOF. +** +** 2) The current terms (if any) are compared using memcmp(). If one +** term is a prefix of another, the longer term is considered the +** larger. +** +** 3) By segment age. An older segment is considered larger. +*/ +static int fts3SegReaderCmp(Fts3SegReader *pLhs, Fts3SegReader *pRhs){ + int rc; + if( pLhs->aNode && pRhs->aNode ){ + int rc2 = pLhs->nTerm - pRhs->nTerm; + if( rc2<0 ){ + rc = memcmp(pLhs->zTerm, pRhs->zTerm, pLhs->nTerm); + }else{ + rc = memcmp(pLhs->zTerm, pRhs->zTerm, pRhs->nTerm); + } + if( rc==0 ){ + rc = rc2; + } + }else{ + rc = (pLhs->aNode==0) - (pRhs->aNode==0); + } + if( rc==0 ){ + rc = pRhs->iIdx - pLhs->iIdx; + } + assert( rc!=0 ); + return rc; +} + +/* +** A different comparison function for SegReader structures. In this +** version, it is assumed that each SegReader points to an entry in +** a doclist for identical terms. Comparison is made as follows: +** +** 1) EOF (end of doclist in this case) is greater than not EOF. +** +** 2) By current docid. +** +** 3) By segment age. An older segment is considered larger. +*/ +static int fts3SegReaderDoclistCmp(Fts3SegReader *pLhs, Fts3SegReader *pRhs){ + int rc = (pLhs->pOffsetList==0)-(pRhs->pOffsetList==0); + if( rc==0 ){ + if( pLhs->iDocid==pRhs->iDocid ){ + rc = pRhs->iIdx - pLhs->iIdx; + }else{ + rc = (pLhs->iDocid > pRhs->iDocid) ? 1 : -1; + } + } + assert( pLhs->aNode && pRhs->aNode ); + return rc; +} +static int fts3SegReaderDoclistCmpRev(Fts3SegReader *pLhs, Fts3SegReader *pRhs){ + int rc = (pLhs->pOffsetList==0)-(pRhs->pOffsetList==0); + if( rc==0 ){ + if( pLhs->iDocid==pRhs->iDocid ){ + rc = pRhs->iIdx - pLhs->iIdx; + }else{ + rc = (pLhs->iDocid < pRhs->iDocid) ? 1 : -1; + } + } + assert( pLhs->aNode && pRhs->aNode ); + return rc; +} + +/* +** Compare the term that the Fts3SegReader object passed as the first argument +** points to with the term specified by arguments zTerm and nTerm. +** +** If the pSeg iterator is already at EOF, return 0. Otherwise, return +** -ve if the pSeg term is less than zTerm/nTerm, 0 if the two terms are +** equal, or +ve if the pSeg term is greater than zTerm/nTerm. +*/ +static int fts3SegReaderTermCmp( + Fts3SegReader *pSeg, /* Segment reader object */ + const char *zTerm, /* Term to compare to */ + int nTerm /* Size of term zTerm in bytes */ +){ + int res = 0; + if( pSeg->aNode ){ + if( pSeg->nTerm>nTerm ){ + res = memcmp(pSeg->zTerm, zTerm, nTerm); + }else{ + res = memcmp(pSeg->zTerm, zTerm, pSeg->nTerm); + } + if( res==0 ){ + res = pSeg->nTerm-nTerm; + } + } + return res; +} + +/* +** Argument apSegment is an array of nSegment elements. It is known that +** the final (nSegment-nSuspect) members are already in sorted order +** (according to the comparison function provided). This function shuffles +** the array around until all entries are in sorted order. +*/ +static void fts3SegReaderSort( + Fts3SegReader **apSegment, /* Array to sort entries of */ + int nSegment, /* Size of apSegment array */ + int nSuspect, /* Unsorted entry count */ + int (*xCmp)(Fts3SegReader *, Fts3SegReader *) /* Comparison function */ +){ + int i; /* Iterator variable */ + + assert( nSuspect<=nSegment ); + + if( nSuspect==nSegment ) nSuspect--; + for(i=nSuspect-1; i>=0; i--){ + int j; + for(j=i; j<(nSegment-1); j++){ + Fts3SegReader *pTmp; + if( xCmp(apSegment[j], apSegment[j+1])<0 ) break; + pTmp = apSegment[j+1]; + apSegment[j+1] = apSegment[j]; + apSegment[j] = pTmp; + } + } + +#ifndef NDEBUG + /* Check that the list really is sorted now. */ + for(i=0; i<(nSuspect-1); i++){ + assert( xCmp(apSegment[i], apSegment[i+1])<0 ); + } +#endif +} + +/* +** Insert a record into the %_segments table. +*/ +static int fts3WriteSegment( + Fts3Table *p, /* Virtual table handle */ + sqlite3_int64 iBlock, /* Block id for new block */ + char *z, /* Pointer to buffer containing block data */ + int n /* Size of buffer z in bytes */ +){ + sqlite3_stmt *pStmt; + int rc = fts3SqlStmt(p, SQL_INSERT_SEGMENTS, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pStmt, 1, iBlock); + sqlite3_bind_blob(pStmt, 2, z, n, SQLITE_STATIC); + sqlite3_step(pStmt); + rc = sqlite3_reset(pStmt); + sqlite3_bind_null(pStmt, 2); + } + return rc; +} + +/* +** Find the largest relative level number in the table. If successful, set +** *pnMax to this value and return SQLITE_OK. Otherwise, if an error occurs, +** set *pnMax to zero and return an SQLite error code. +*/ +SQLITE_PRIVATE int sqlite3Fts3MaxLevel(Fts3Table *p, int *pnMax){ + int rc; + int mxLevel = 0; + sqlite3_stmt *pStmt = 0; + + rc = fts3SqlStmt(p, SQL_SELECT_MXLEVEL, &pStmt, 0); + if( rc==SQLITE_OK ){ + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + mxLevel = sqlite3_column_int(pStmt, 0); + } + rc = sqlite3_reset(pStmt); + } + *pnMax = mxLevel; + return rc; +} + +/* +** Insert a record into the %_segdir table. +*/ +static int fts3WriteSegdir( + Fts3Table *p, /* Virtual table handle */ + sqlite3_int64 iLevel, /* Value for "level" field (absolute level) */ + int iIdx, /* Value for "idx" field */ + sqlite3_int64 iStartBlock, /* Value for "start_block" field */ + sqlite3_int64 iLeafEndBlock, /* Value for "leaves_end_block" field */ + sqlite3_int64 iEndBlock, /* Value for "end_block" field */ + sqlite3_int64 nLeafData, /* Bytes of leaf data in segment */ + char *zRoot, /* Blob value for "root" field */ + int nRoot /* Number of bytes in buffer zRoot */ +){ + sqlite3_stmt *pStmt; + int rc = fts3SqlStmt(p, SQL_INSERT_SEGDIR, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pStmt, 1, iLevel); + sqlite3_bind_int(pStmt, 2, iIdx); + sqlite3_bind_int64(pStmt, 3, iStartBlock); + sqlite3_bind_int64(pStmt, 4, iLeafEndBlock); + if( nLeafData==0 ){ + sqlite3_bind_int64(pStmt, 5, iEndBlock); + }else{ + char *zEnd = sqlite3_mprintf("%lld %lld", iEndBlock, nLeafData); + if( !zEnd ) return SQLITE_NOMEM; + sqlite3_bind_text(pStmt, 5, zEnd, -1, sqlite3_free); + } + sqlite3_bind_blob(pStmt, 6, zRoot, nRoot, SQLITE_STATIC); + sqlite3_step(pStmt); + rc = sqlite3_reset(pStmt); + sqlite3_bind_null(pStmt, 6); + } + return rc; +} + +/* +** Return the size of the common prefix (if any) shared by zPrev and +** zNext, in bytes. For example, +** +** fts3PrefixCompress("abc", 3, "abcdef", 6) // returns 3 +** fts3PrefixCompress("abX", 3, "abcdef", 6) // returns 2 +** fts3PrefixCompress("abX", 3, "Xbcdef", 6) // returns 0 +*/ +static int fts3PrefixCompress( + const char *zPrev, /* Buffer containing previous term */ + int nPrev, /* Size of buffer zPrev in bytes */ + const char *zNext, /* Buffer containing next term */ + int nNext /* Size of buffer zNext in bytes */ +){ + int n; + UNUSED_PARAMETER(nNext); + for(n=0; nnData; /* Current size of node in bytes */ + int nReq = nData; /* Required space after adding zTerm */ + int nPrefix; /* Number of bytes of prefix compression */ + int nSuffix; /* Suffix length */ + + nPrefix = fts3PrefixCompress(pTree->zTerm, pTree->nTerm, zTerm, nTerm); + nSuffix = nTerm-nPrefix; + + /* If nSuffix is zero or less, then zTerm/nTerm must be a prefix of + ** pWriter->zTerm/pWriter->nTerm. i.e. must be equal to or less than when + ** compared with BINARY collation. This indicates corruption. */ + if( nSuffix<=0 ) return FTS_CORRUPT_VTAB; + + nReq += sqlite3Fts3VarintLen(nPrefix)+sqlite3Fts3VarintLen(nSuffix)+nSuffix; + if( nReq<=p->nNodeSize || !pTree->zTerm ){ + + if( nReq>p->nNodeSize ){ + /* An unusual case: this is the first term to be added to the node + ** and the static node buffer (p->nNodeSize bytes) is not large + ** enough. Use a separately malloced buffer instead This wastes + ** p->nNodeSize bytes, but since this scenario only comes about when + ** the database contain two terms that share a prefix of almost 2KB, + ** this is not expected to be a serious problem. + */ + assert( pTree->aData==(char *)&pTree[1] ); + pTree->aData = (char *)sqlite3_malloc(nReq); + if( !pTree->aData ){ + return SQLITE_NOMEM; + } + } + + if( pTree->zTerm ){ + /* There is no prefix-length field for first term in a node */ + nData += sqlite3Fts3PutVarint(&pTree->aData[nData], nPrefix); + } + + nData += sqlite3Fts3PutVarint(&pTree->aData[nData], nSuffix); + memcpy(&pTree->aData[nData], &zTerm[nPrefix], nSuffix); + pTree->nData = nData + nSuffix; + pTree->nEntry++; + + if( isCopyTerm ){ + if( pTree->nMalloczMalloc, nTerm*2); + if( !zNew ){ + return SQLITE_NOMEM; + } + pTree->nMalloc = nTerm*2; + pTree->zMalloc = zNew; + } + pTree->zTerm = pTree->zMalloc; + memcpy(pTree->zTerm, zTerm, nTerm); + pTree->nTerm = nTerm; + }else{ + pTree->zTerm = (char *)zTerm; + pTree->nTerm = nTerm; + } + return SQLITE_OK; + } + } + + /* If control flows to here, it was not possible to append zTerm to the + ** current node. Create a new node (a right-sibling of the current node). + ** If this is the first node in the tree, the term is added to it. + ** + ** Otherwise, the term is not added to the new node, it is left empty for + ** now. Instead, the term is inserted into the parent of pTree. If pTree + ** has no parent, one is created here. + */ + pNew = (SegmentNode *)sqlite3_malloc(sizeof(SegmentNode) + p->nNodeSize); + if( !pNew ){ + return SQLITE_NOMEM; + } + memset(pNew, 0, sizeof(SegmentNode)); + pNew->nData = 1 + FTS3_VARINT_MAX; + pNew->aData = (char *)&pNew[1]; + + if( pTree ){ + SegmentNode *pParent = pTree->pParent; + rc = fts3NodeAddTerm(p, &pParent, isCopyTerm, zTerm, nTerm); + if( pTree->pParent==0 ){ + pTree->pParent = pParent; + } + pTree->pRight = pNew; + pNew->pLeftmost = pTree->pLeftmost; + pNew->pParent = pParent; + pNew->zMalloc = pTree->zMalloc; + pNew->nMalloc = pTree->nMalloc; + pTree->zMalloc = 0; + }else{ + pNew->pLeftmost = pNew; + rc = fts3NodeAddTerm(p, &pNew, isCopyTerm, zTerm, nTerm); + } + + *ppTree = pNew; + return rc; +} + +/* +** Helper function for fts3NodeWrite(). +*/ +static int fts3TreeFinishNode( + SegmentNode *pTree, + int iHeight, + sqlite3_int64 iLeftChild +){ + int nStart; + assert( iHeight>=1 && iHeight<128 ); + nStart = FTS3_VARINT_MAX - sqlite3Fts3VarintLen(iLeftChild); + pTree->aData[nStart] = (char)iHeight; + sqlite3Fts3PutVarint(&pTree->aData[nStart+1], iLeftChild); + return nStart; +} + +/* +** Write the buffer for the segment node pTree and all of its peers to the +** database. Then call this function recursively to write the parent of +** pTree and its peers to the database. +** +** Except, if pTree is a root node, do not write it to the database. Instead, +** set output variables *paRoot and *pnRoot to contain the root node. +** +** If successful, SQLITE_OK is returned and output variable *piLast is +** set to the largest blockid written to the database (or zero if no +** blocks were written to the db). Otherwise, an SQLite error code is +** returned. +*/ +static int fts3NodeWrite( + Fts3Table *p, /* Virtual table handle */ + SegmentNode *pTree, /* SegmentNode handle */ + int iHeight, /* Height of this node in tree */ + sqlite3_int64 iLeaf, /* Block id of first leaf node */ + sqlite3_int64 iFree, /* Block id of next free slot in %_segments */ + sqlite3_int64 *piLast, /* OUT: Block id of last entry written */ + char **paRoot, /* OUT: Data for root node */ + int *pnRoot /* OUT: Size of root node in bytes */ +){ + int rc = SQLITE_OK; + + if( !pTree->pParent ){ + /* Root node of the tree. */ + int nStart = fts3TreeFinishNode(pTree, iHeight, iLeaf); + *piLast = iFree-1; + *pnRoot = pTree->nData - nStart; + *paRoot = &pTree->aData[nStart]; + }else{ + SegmentNode *pIter; + sqlite3_int64 iNextFree = iFree; + sqlite3_int64 iNextLeaf = iLeaf; + for(pIter=pTree->pLeftmost; pIter && rc==SQLITE_OK; pIter=pIter->pRight){ + int nStart = fts3TreeFinishNode(pIter, iHeight, iNextLeaf); + int nWrite = pIter->nData - nStart; + + rc = fts3WriteSegment(p, iNextFree, &pIter->aData[nStart], nWrite); + iNextFree++; + iNextLeaf += (pIter->nEntry+1); + } + if( rc==SQLITE_OK ){ + assert( iNextLeaf==iFree ); + rc = fts3NodeWrite( + p, pTree->pParent, iHeight+1, iFree, iNextFree, piLast, paRoot, pnRoot + ); + } + } + + return rc; +} + +/* +** Free all memory allocations associated with the tree pTree. +*/ +static void fts3NodeFree(SegmentNode *pTree){ + if( pTree ){ + SegmentNode *p = pTree->pLeftmost; + fts3NodeFree(p->pParent); + while( p ){ + SegmentNode *pRight = p->pRight; + if( p->aData!=(char *)&p[1] ){ + sqlite3_free(p->aData); + } + assert( pRight==0 || p->zMalloc==0 ); + sqlite3_free(p->zMalloc); + sqlite3_free(p); + p = pRight; + } + } +} + +/* +** Add a term to the segment being constructed by the SegmentWriter object +** *ppWriter. When adding the first term to a segment, *ppWriter should +** be passed NULL. This function will allocate a new SegmentWriter object +** and return it via the input/output variable *ppWriter in this case. +** +** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code. +*/ +static int fts3SegWriterAdd( + Fts3Table *p, /* Virtual table handle */ + SegmentWriter **ppWriter, /* IN/OUT: SegmentWriter handle */ + int isCopyTerm, /* True if buffer zTerm must be copied */ + const char *zTerm, /* Pointer to buffer containing term */ + int nTerm, /* Size of term in bytes */ + const char *aDoclist, /* Pointer to buffer containing doclist */ + int nDoclist /* Size of doclist in bytes */ +){ + int nPrefix; /* Size of term prefix in bytes */ + int nSuffix; /* Size of term suffix in bytes */ + int nReq; /* Number of bytes required on leaf page */ + int nData; + SegmentWriter *pWriter = *ppWriter; + + if( !pWriter ){ + int rc; + sqlite3_stmt *pStmt; + + /* Allocate the SegmentWriter structure */ + pWriter = (SegmentWriter *)sqlite3_malloc(sizeof(SegmentWriter)); + if( !pWriter ) return SQLITE_NOMEM; + memset(pWriter, 0, sizeof(SegmentWriter)); + *ppWriter = pWriter; + + /* Allocate a buffer in which to accumulate data */ + pWriter->aData = (char *)sqlite3_malloc(p->nNodeSize); + if( !pWriter->aData ) return SQLITE_NOMEM; + pWriter->nSize = p->nNodeSize; + + /* Find the next free blockid in the %_segments table */ + rc = fts3SqlStmt(p, SQL_NEXT_SEGMENTS_ID, &pStmt, 0); + if( rc!=SQLITE_OK ) return rc; + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + pWriter->iFree = sqlite3_column_int64(pStmt, 0); + pWriter->iFirst = pWriter->iFree; + } + rc = sqlite3_reset(pStmt); + if( rc!=SQLITE_OK ) return rc; + } + nData = pWriter->nData; + + nPrefix = fts3PrefixCompress(pWriter->zTerm, pWriter->nTerm, zTerm, nTerm); + nSuffix = nTerm-nPrefix; + + /* If nSuffix is zero or less, then zTerm/nTerm must be a prefix of + ** pWriter->zTerm/pWriter->nTerm. i.e. must be equal to or less than when + ** compared with BINARY collation. This indicates corruption. */ + if( nSuffix<=0 ) return FTS_CORRUPT_VTAB; + + /* Figure out how many bytes are required by this new entry */ + nReq = sqlite3Fts3VarintLen(nPrefix) + /* varint containing prefix size */ + sqlite3Fts3VarintLen(nSuffix) + /* varint containing suffix size */ + nSuffix + /* Term suffix */ + sqlite3Fts3VarintLen(nDoclist) + /* Size of doclist */ + nDoclist; /* Doclist data */ + + if( nData>0 && nData+nReq>p->nNodeSize ){ + int rc; + + /* The current leaf node is full. Write it out to the database. */ + if( pWriter->iFree==LARGEST_INT64 ) return FTS_CORRUPT_VTAB; + rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, nData); + if( rc!=SQLITE_OK ) return rc; + p->nLeafAdd++; + + /* Add the current term to the interior node tree. The term added to + ** the interior tree must: + ** + ** a) be greater than the largest term on the leaf node just written + ** to the database (still available in pWriter->zTerm), and + ** + ** b) be less than or equal to the term about to be added to the new + ** leaf node (zTerm/nTerm). + ** + ** In other words, it must be the prefix of zTerm 1 byte longer than + ** the common prefix (if any) of zTerm and pWriter->zTerm. + */ + assert( nPrefixpTree, isCopyTerm, zTerm, nPrefix+1); + if( rc!=SQLITE_OK ) return rc; + + nData = 0; + pWriter->nTerm = 0; + + nPrefix = 0; + nSuffix = nTerm; + nReq = 1 + /* varint containing prefix size */ + sqlite3Fts3VarintLen(nTerm) + /* varint containing suffix size */ + nTerm + /* Term suffix */ + sqlite3Fts3VarintLen(nDoclist) + /* Size of doclist */ + nDoclist; /* Doclist data */ + } + + /* Increase the total number of bytes written to account for the new entry. */ + pWriter->nLeafData += nReq; + + /* If the buffer currently allocated is too small for this entry, realloc + ** the buffer to make it large enough. + */ + if( nReq>pWriter->nSize ){ + char *aNew = sqlite3_realloc(pWriter->aData, nReq); + if( !aNew ) return SQLITE_NOMEM; + pWriter->aData = aNew; + pWriter->nSize = nReq; + } + assert( nData+nReq<=pWriter->nSize ); + + /* Append the prefix-compressed term and doclist to the buffer. */ + nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nPrefix); + nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nSuffix); + assert( nSuffix>0 ); + memcpy(&pWriter->aData[nData], &zTerm[nPrefix], nSuffix); + nData += nSuffix; + nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nDoclist); + assert( nDoclist>0 ); + memcpy(&pWriter->aData[nData], aDoclist, nDoclist); + pWriter->nData = nData + nDoclist; + + /* Save the current term so that it can be used to prefix-compress the next. + ** If the isCopyTerm parameter is true, then the buffer pointed to by + ** zTerm is transient, so take a copy of the term data. Otherwise, just + ** store a copy of the pointer. + */ + if( isCopyTerm ){ + if( nTerm>pWriter->nMalloc ){ + char *zNew = sqlite3_realloc(pWriter->zMalloc, nTerm*2); + if( !zNew ){ + return SQLITE_NOMEM; + } + pWriter->nMalloc = nTerm*2; + pWriter->zMalloc = zNew; + pWriter->zTerm = zNew; + } + assert( pWriter->zTerm==pWriter->zMalloc ); + assert( nTerm>0 ); + memcpy(pWriter->zTerm, zTerm, nTerm); + }else{ + pWriter->zTerm = (char *)zTerm; + } + pWriter->nTerm = nTerm; + + return SQLITE_OK; +} + +/* +** Flush all data associated with the SegmentWriter object pWriter to the +** database. This function must be called after all terms have been added +** to the segment using fts3SegWriterAdd(). If successful, SQLITE_OK is +** returned. Otherwise, an SQLite error code. +*/ +static int fts3SegWriterFlush( + Fts3Table *p, /* Virtual table handle */ + SegmentWriter *pWriter, /* SegmentWriter to flush to the db */ + sqlite3_int64 iLevel, /* Value for 'level' column of %_segdir */ + int iIdx /* Value for 'idx' column of %_segdir */ +){ + int rc; /* Return code */ + if( pWriter->pTree ){ + sqlite3_int64 iLast = 0; /* Largest block id written to database */ + sqlite3_int64 iLastLeaf; /* Largest leaf block id written to db */ + char *zRoot = NULL; /* Pointer to buffer containing root node */ + int nRoot = 0; /* Size of buffer zRoot */ + + iLastLeaf = pWriter->iFree; + rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, pWriter->nData); + if( rc==SQLITE_OK ){ + rc = fts3NodeWrite(p, pWriter->pTree, 1, + pWriter->iFirst, pWriter->iFree, &iLast, &zRoot, &nRoot); + } + if( rc==SQLITE_OK ){ + rc = fts3WriteSegdir(p, iLevel, iIdx, + pWriter->iFirst, iLastLeaf, iLast, pWriter->nLeafData, zRoot, nRoot); + } + }else{ + /* The entire tree fits on the root node. Write it to the segdir table. */ + rc = fts3WriteSegdir(p, iLevel, iIdx, + 0, 0, 0, pWriter->nLeafData, pWriter->aData, pWriter->nData); + } + p->nLeafAdd++; + return rc; +} + +/* +** Release all memory held by the SegmentWriter object passed as the +** first argument. +*/ +static void fts3SegWriterFree(SegmentWriter *pWriter){ + if( pWriter ){ + sqlite3_free(pWriter->aData); + sqlite3_free(pWriter->zMalloc); + fts3NodeFree(pWriter->pTree); + sqlite3_free(pWriter); + } +} + +/* +** The first value in the apVal[] array is assumed to contain an integer. +** This function tests if there exist any documents with docid values that +** are different from that integer. i.e. if deleting the document with docid +** pRowid would mean the FTS3 table were empty. +** +** If successful, *pisEmpty is set to true if the table is empty except for +** document pRowid, or false otherwise, and SQLITE_OK is returned. If an +** error occurs, an SQLite error code is returned. +*/ +static int fts3IsEmpty(Fts3Table *p, sqlite3_value *pRowid, int *pisEmpty){ + sqlite3_stmt *pStmt; + int rc; + if( p->zContentTbl ){ + /* If using the content=xxx option, assume the table is never empty */ + *pisEmpty = 0; + rc = SQLITE_OK; + }else{ + rc = fts3SqlStmt(p, SQL_IS_EMPTY, &pStmt, &pRowid); + if( rc==SQLITE_OK ){ + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + *pisEmpty = sqlite3_column_int(pStmt, 0); + } + rc = sqlite3_reset(pStmt); + } + } + return rc; +} + +/* +** Set *pnMax to the largest segment level in the database for the index +** iIndex. +** +** Segment levels are stored in the 'level' column of the %_segdir table. +** +** Return SQLITE_OK if successful, or an SQLite error code if not. +*/ +static int fts3SegmentMaxLevel( + Fts3Table *p, + int iLangid, + int iIndex, + sqlite3_int64 *pnMax +){ + sqlite3_stmt *pStmt; + int rc; + assert( iIndex>=0 && iIndexnIndex ); + + /* Set pStmt to the compiled version of: + ** + ** SELECT max(level) FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ? + ** + ** (1024 is actually the value of macro FTS3_SEGDIR_PREFIXLEVEL_STR). + */ + rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR_MAX_LEVEL, &pStmt, 0); + if( rc!=SQLITE_OK ) return rc; + sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex, 0)); + sqlite3_bind_int64(pStmt, 2, + getAbsoluteLevel(p, iLangid, iIndex, FTS3_SEGDIR_MAXLEVEL-1) + ); + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + *pnMax = sqlite3_column_int64(pStmt, 0); + } + return sqlite3_reset(pStmt); +} + +/* +** iAbsLevel is an absolute level that may be assumed to exist within +** the database. This function checks if it is the largest level number +** within its index. Assuming no error occurs, *pbMax is set to 1 if +** iAbsLevel is indeed the largest level, or 0 otherwise, and SQLITE_OK +** is returned. If an error occurs, an error code is returned and the +** final value of *pbMax is undefined. +*/ +static int fts3SegmentIsMaxLevel(Fts3Table *p, i64 iAbsLevel, int *pbMax){ + + /* Set pStmt to the compiled version of: + ** + ** SELECT max(level) FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ? + ** + ** (1024 is actually the value of macro FTS3_SEGDIR_PREFIXLEVEL_STR). + */ + sqlite3_stmt *pStmt; + int rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR_MAX_LEVEL, &pStmt, 0); + if( rc!=SQLITE_OK ) return rc; + sqlite3_bind_int64(pStmt, 1, iAbsLevel+1); + sqlite3_bind_int64(pStmt, 2, + (((u64)iAbsLevel/FTS3_SEGDIR_MAXLEVEL)+1) * FTS3_SEGDIR_MAXLEVEL + ); + + *pbMax = 0; + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + *pbMax = sqlite3_column_type(pStmt, 0)==SQLITE_NULL; + } + return sqlite3_reset(pStmt); +} + +/* +** Delete all entries in the %_segments table associated with the segment +** opened with seg-reader pSeg. This function does not affect the contents +** of the %_segdir table. +*/ +static int fts3DeleteSegment( + Fts3Table *p, /* FTS table handle */ + Fts3SegReader *pSeg /* Segment to delete */ +){ + int rc = SQLITE_OK; /* Return code */ + if( pSeg->iStartBlock ){ + sqlite3_stmt *pDelete; /* SQL statement to delete rows */ + rc = fts3SqlStmt(p, SQL_DELETE_SEGMENTS_RANGE, &pDelete, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pDelete, 1, pSeg->iStartBlock); + sqlite3_bind_int64(pDelete, 2, pSeg->iEndBlock); + sqlite3_step(pDelete); + rc = sqlite3_reset(pDelete); + } + } + return rc; +} + +/* +** This function is used after merging multiple segments into a single large +** segment to delete the old, now redundant, segment b-trees. Specifically, +** it: +** +** 1) Deletes all %_segments entries for the segments associated with +** each of the SegReader objects in the array passed as the third +** argument, and +** +** 2) deletes all %_segdir entries with level iLevel, or all %_segdir +** entries regardless of level if (iLevel<0). +** +** SQLITE_OK is returned if successful, otherwise an SQLite error code. +*/ +static int fts3DeleteSegdir( + Fts3Table *p, /* Virtual table handle */ + int iLangid, /* Language id */ + int iIndex, /* Index for p->aIndex */ + int iLevel, /* Level of %_segdir entries to delete */ + Fts3SegReader **apSegment, /* Array of SegReader objects */ + int nReader /* Size of array apSegment */ +){ + int rc = SQLITE_OK; /* Return Code */ + int i; /* Iterator variable */ + sqlite3_stmt *pDelete = 0; /* SQL statement to delete rows */ + + for(i=0; rc==SQLITE_OK && i=0 || iLevel==FTS3_SEGCURSOR_ALL ); + if( iLevel==FTS3_SEGCURSOR_ALL ){ + rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_RANGE, &pDelete, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pDelete, 1, getAbsoluteLevel(p, iLangid, iIndex, 0)); + sqlite3_bind_int64(pDelete, 2, + getAbsoluteLevel(p, iLangid, iIndex, FTS3_SEGDIR_MAXLEVEL-1) + ); + } + }else{ + rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_LEVEL, &pDelete, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64( + pDelete, 1, getAbsoluteLevel(p, iLangid, iIndex, iLevel) + ); + } + } + + if( rc==SQLITE_OK ){ + sqlite3_step(pDelete); + rc = sqlite3_reset(pDelete); + } + + return rc; +} + +/* +** When this function is called, buffer *ppList (size *pnList bytes) contains +** a position list that may (or may not) feature multiple columns. This +** function adjusts the pointer *ppList and the length *pnList so that they +** identify the subset of the position list that corresponds to column iCol. +** +** If there are no entries in the input position list for column iCol, then +** *pnList is set to zero before returning. +** +** If parameter bZero is non-zero, then any part of the input list following +** the end of the output list is zeroed before returning. +*/ +static void fts3ColumnFilter( + int iCol, /* Column to filter on */ + int bZero, /* Zero out anything following *ppList */ + char **ppList, /* IN/OUT: Pointer to position list */ + int *pnList /* IN/OUT: Size of buffer *ppList in bytes */ +){ + char *pList = *ppList; + int nList = *pnList; + char *pEnd = &pList[nList]; + int iCurrent = 0; + char *p = pList; + + assert( iCol>=0 ); + while( 1 ){ + char c = 0; + while( p0){ + memset(&pList[nList], 0, pEnd - &pList[nList]); + } + *ppList = pList; + *pnList = nList; +} + +/* +** Cache data in the Fts3MultiSegReader.aBuffer[] buffer (overwriting any +** existing data). Grow the buffer if required. +** +** If successful, return SQLITE_OK. Otherwise, if an OOM error is encountered +** trying to resize the buffer, return SQLITE_NOMEM. +*/ +static int fts3MsrBufferData( + Fts3MultiSegReader *pMsr, /* Multi-segment-reader handle */ + char *pList, + int nList +){ + if( nList>pMsr->nBuffer ){ + char *pNew; + pMsr->nBuffer = nList*2; + pNew = (char *)sqlite3_realloc(pMsr->aBuffer, pMsr->nBuffer); + if( !pNew ) return SQLITE_NOMEM; + pMsr->aBuffer = pNew; + } + + assert( nList>0 ); + memcpy(pMsr->aBuffer, pList, nList); + return SQLITE_OK; +} + +SQLITE_PRIVATE int sqlite3Fts3MsrIncrNext( + Fts3Table *p, /* Virtual table handle */ + Fts3MultiSegReader *pMsr, /* Multi-segment-reader handle */ + sqlite3_int64 *piDocid, /* OUT: Docid value */ + char **paPoslist, /* OUT: Pointer to position list */ + int *pnPoslist /* OUT: Size of position list in bytes */ +){ + int nMerge = pMsr->nAdvance; + Fts3SegReader **apSegment = pMsr->apSegment; + int (*xCmp)(Fts3SegReader *, Fts3SegReader *) = ( + p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp + ); + + if( nMerge==0 ){ + *paPoslist = 0; + return SQLITE_OK; + } + + while( 1 ){ + Fts3SegReader *pSeg; + pSeg = pMsr->apSegment[0]; + + if( pSeg->pOffsetList==0 ){ + *paPoslist = 0; + break; + }else{ + int rc; + char *pList; + int nList; + int j; + sqlite3_int64 iDocid = apSegment[0]->iDocid; + + rc = fts3SegReaderNextDocid(p, apSegment[0], &pList, &nList); + j = 1; + while( rc==SQLITE_OK + && jpOffsetList + && apSegment[j]->iDocid==iDocid + ){ + rc = fts3SegReaderNextDocid(p, apSegment[j], 0, 0); + j++; + } + if( rc!=SQLITE_OK ) return rc; + fts3SegReaderSort(pMsr->apSegment, nMerge, j, xCmp); + + if( nList>0 && fts3SegReaderIsPending(apSegment[0]) ){ + rc = fts3MsrBufferData(pMsr, pList, nList+1); + if( rc!=SQLITE_OK ) return rc; + assert( (pMsr->aBuffer[nList] & 0xFE)==0x00 ); + pList = pMsr->aBuffer; + } + + if( pMsr->iColFilter>=0 ){ + fts3ColumnFilter(pMsr->iColFilter, 1, &pList, &nList); + } + + if( nList>0 ){ + *paPoslist = pList; + *piDocid = iDocid; + *pnPoslist = nList; + break; + } + } + } + + return SQLITE_OK; +} + +static int fts3SegReaderStart( + Fts3Table *p, /* Virtual table handle */ + Fts3MultiSegReader *pCsr, /* Cursor object */ + const char *zTerm, /* Term searched for (or NULL) */ + int nTerm /* Length of zTerm in bytes */ +){ + int i; + int nSeg = pCsr->nSegment; + + /* If the Fts3SegFilter defines a specific term (or term prefix) to search + ** for, then advance each segment iterator until it points to a term of + ** equal or greater value than the specified term. This prevents many + ** unnecessary merge/sort operations for the case where single segment + ** b-tree leaf nodes contain more than one term. + */ + for(i=0; pCsr->bRestart==0 && inSegment; i++){ + int res = 0; + Fts3SegReader *pSeg = pCsr->apSegment[i]; + do { + int rc = fts3SegReaderNext(p, pSeg, 0); + if( rc!=SQLITE_OK ) return rc; + }while( zTerm && (res = fts3SegReaderTermCmp(pSeg, zTerm, nTerm))<0 ); + + if( pSeg->bLookup && res!=0 ){ + fts3SegReaderSetEof(pSeg); + } + } + fts3SegReaderSort(pCsr->apSegment, nSeg, nSeg, fts3SegReaderCmp); + + return SQLITE_OK; +} + +SQLITE_PRIVATE int sqlite3Fts3SegReaderStart( + Fts3Table *p, /* Virtual table handle */ + Fts3MultiSegReader *pCsr, /* Cursor object */ + Fts3SegFilter *pFilter /* Restrictions on range of iteration */ +){ + pCsr->pFilter = pFilter; + return fts3SegReaderStart(p, pCsr, pFilter->zTerm, pFilter->nTerm); +} + +SQLITE_PRIVATE int sqlite3Fts3MsrIncrStart( + Fts3Table *p, /* Virtual table handle */ + Fts3MultiSegReader *pCsr, /* Cursor object */ + int iCol, /* Column to match on. */ + const char *zTerm, /* Term to iterate through a doclist for */ + int nTerm /* Number of bytes in zTerm */ +){ + int i; + int rc; + int nSegment = pCsr->nSegment; + int (*xCmp)(Fts3SegReader *, Fts3SegReader *) = ( + p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp + ); + + assert( pCsr->pFilter==0 ); + assert( zTerm && nTerm>0 ); + + /* Advance each segment iterator until it points to the term zTerm/nTerm. */ + rc = fts3SegReaderStart(p, pCsr, zTerm, nTerm); + if( rc!=SQLITE_OK ) return rc; + + /* Determine how many of the segments actually point to zTerm/nTerm. */ + for(i=0; iapSegment[i]; + if( !pSeg->aNode || fts3SegReaderTermCmp(pSeg, zTerm, nTerm) ){ + break; + } + } + pCsr->nAdvance = i; + + /* Advance each of the segments to point to the first docid. */ + for(i=0; inAdvance; i++){ + rc = fts3SegReaderFirstDocid(p, pCsr->apSegment[i]); + if( rc!=SQLITE_OK ) return rc; + } + fts3SegReaderSort(pCsr->apSegment, i, i, xCmp); + + assert( iCol<0 || iColnColumn ); + pCsr->iColFilter = iCol; + + return SQLITE_OK; +} + +/* +** This function is called on a MultiSegReader that has been started using +** sqlite3Fts3MsrIncrStart(). One or more calls to MsrIncrNext() may also +** have been made. Calling this function puts the MultiSegReader in such +** a state that if the next two calls are: +** +** sqlite3Fts3SegReaderStart() +** sqlite3Fts3SegReaderStep() +** +** then the entire doclist for the term is available in +** MultiSegReader.aDoclist/nDoclist. +*/ +SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr){ + int i; /* Used to iterate through segment-readers */ + + assert( pCsr->zTerm==0 ); + assert( pCsr->nTerm==0 ); + assert( pCsr->aDoclist==0 ); + assert( pCsr->nDoclist==0 ); + + pCsr->nAdvance = 0; + pCsr->bRestart = 1; + for(i=0; inSegment; i++){ + pCsr->apSegment[i]->pOffsetList = 0; + pCsr->apSegment[i]->nOffsetList = 0; + pCsr->apSegment[i]->iDocid = 0; + } + + return SQLITE_OK; +} + +static int fts3GrowSegReaderBuffer(Fts3MultiSegReader *pCsr, int nReq){ + if( nReq>pCsr->nBuffer ){ + char *aNew; + pCsr->nBuffer = nReq*2; + aNew = sqlite3_realloc(pCsr->aBuffer, pCsr->nBuffer); + if( !aNew ){ + return SQLITE_NOMEM; + } + pCsr->aBuffer = aNew; + } + return SQLITE_OK; +} + + +SQLITE_PRIVATE int sqlite3Fts3SegReaderStep( + Fts3Table *p, /* Virtual table handle */ + Fts3MultiSegReader *pCsr /* Cursor object */ +){ + int rc = SQLITE_OK; + + int isIgnoreEmpty = (pCsr->pFilter->flags & FTS3_SEGMENT_IGNORE_EMPTY); + int isRequirePos = (pCsr->pFilter->flags & FTS3_SEGMENT_REQUIRE_POS); + int isColFilter = (pCsr->pFilter->flags & FTS3_SEGMENT_COLUMN_FILTER); + int isPrefix = (pCsr->pFilter->flags & FTS3_SEGMENT_PREFIX); + int isScan = (pCsr->pFilter->flags & FTS3_SEGMENT_SCAN); + int isFirst = (pCsr->pFilter->flags & FTS3_SEGMENT_FIRST); + + Fts3SegReader **apSegment = pCsr->apSegment; + int nSegment = pCsr->nSegment; + Fts3SegFilter *pFilter = pCsr->pFilter; + int (*xCmp)(Fts3SegReader *, Fts3SegReader *) = ( + p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp + ); + + if( pCsr->nSegment==0 ) return SQLITE_OK; + + do { + int nMerge; + int i; + + /* Advance the first pCsr->nAdvance entries in the apSegment[] array + ** forward. Then sort the list in order of current term again. + */ + for(i=0; inAdvance; i++){ + Fts3SegReader *pSeg = apSegment[i]; + if( pSeg->bLookup ){ + fts3SegReaderSetEof(pSeg); + }else{ + rc = fts3SegReaderNext(p, pSeg, 0); + } + if( rc!=SQLITE_OK ) return rc; + } + fts3SegReaderSort(apSegment, nSegment, pCsr->nAdvance, fts3SegReaderCmp); + pCsr->nAdvance = 0; + + /* If all the seg-readers are at EOF, we're finished. return SQLITE_OK. */ + assert( rc==SQLITE_OK ); + if( apSegment[0]->aNode==0 ) break; + + pCsr->nTerm = apSegment[0]->nTerm; + pCsr->zTerm = apSegment[0]->zTerm; + + /* If this is a prefix-search, and if the term that apSegment[0] points + ** to does not share a suffix with pFilter->zTerm/nTerm, then all + ** required callbacks have been made. In this case exit early. + ** + ** Similarly, if this is a search for an exact match, and the first term + ** of segment apSegment[0] is not a match, exit early. + */ + if( pFilter->zTerm && !isScan ){ + if( pCsr->nTermnTerm + || (!isPrefix && pCsr->nTerm>pFilter->nTerm) + || memcmp(pCsr->zTerm, pFilter->zTerm, pFilter->nTerm) + ){ + break; + } + } + + nMerge = 1; + while( nMergeaNode + && apSegment[nMerge]->nTerm==pCsr->nTerm + && 0==memcmp(pCsr->zTerm, apSegment[nMerge]->zTerm, pCsr->nTerm) + ){ + nMerge++; + } + + assert( isIgnoreEmpty || (isRequirePos && !isColFilter) ); + if( nMerge==1 + && !isIgnoreEmpty + && !isFirst + && (p->bDescIdx==0 || fts3SegReaderIsPending(apSegment[0])==0) + ){ + pCsr->nDoclist = apSegment[0]->nDoclist; + if( fts3SegReaderIsPending(apSegment[0]) ){ + rc = fts3MsrBufferData(pCsr, apSegment[0]->aDoclist, pCsr->nDoclist); + pCsr->aDoclist = pCsr->aBuffer; + }else{ + pCsr->aDoclist = apSegment[0]->aDoclist; + } + if( rc==SQLITE_OK ) rc = SQLITE_ROW; + }else{ + int nDoclist = 0; /* Size of doclist */ + sqlite3_int64 iPrev = 0; /* Previous docid stored in doclist */ + + /* The current term of the first nMerge entries in the array + ** of Fts3SegReader objects is the same. The doclists must be merged + ** and a single term returned with the merged doclist. + */ + for(i=0; ipOffsetList ){ + int j; /* Number of segments that share a docid */ + char *pList = 0; + int nList = 0; + int nByte; + sqlite3_int64 iDocid = apSegment[0]->iDocid; + fts3SegReaderNextDocid(p, apSegment[0], &pList, &nList); + j = 1; + while( jpOffsetList + && apSegment[j]->iDocid==iDocid + ){ + fts3SegReaderNextDocid(p, apSegment[j], 0, 0); + j++; + } + + if( isColFilter ){ + fts3ColumnFilter(pFilter->iCol, 0, &pList, &nList); + } + + if( !isIgnoreEmpty || nList>0 ){ + + /* Calculate the 'docid' delta value to write into the merged + ** doclist. */ + sqlite3_int64 iDelta; + if( p->bDescIdx && nDoclist>0 ){ + if( iPrev<=iDocid ) return FTS_CORRUPT_VTAB; + iDelta = (i64)((u64)iPrev - (u64)iDocid); + }else{ + if( nDoclist>0 && iPrev>=iDocid ) return FTS_CORRUPT_VTAB; + iDelta = (i64)((u64)iDocid - (u64)iPrev); + } + + nByte = sqlite3Fts3VarintLen(iDelta) + (isRequirePos?nList+1:0); + + rc = fts3GrowSegReaderBuffer(pCsr, nByte+nDoclist); + if( rc ) return rc; + + if( isFirst ){ + char *a = &pCsr->aBuffer[nDoclist]; + int nWrite; + + nWrite = sqlite3Fts3FirstFilter(iDelta, pList, nList, a); + if( nWrite ){ + iPrev = iDocid; + nDoclist += nWrite; + } + }else{ + nDoclist += sqlite3Fts3PutVarint(&pCsr->aBuffer[nDoclist], iDelta); + iPrev = iDocid; + if( isRequirePos ){ + memcpy(&pCsr->aBuffer[nDoclist], pList, nList); + nDoclist += nList; + pCsr->aBuffer[nDoclist++] = '\0'; + } + } + } + + fts3SegReaderSort(apSegment, nMerge, j, xCmp); + } + if( nDoclist>0 ){ + rc = fts3GrowSegReaderBuffer(pCsr, nDoclist+FTS3_NODE_PADDING); + if( rc ) return rc; + memset(&pCsr->aBuffer[nDoclist], 0, FTS3_NODE_PADDING); + pCsr->aDoclist = pCsr->aBuffer; + pCsr->nDoclist = nDoclist; + rc = SQLITE_ROW; + } + } + pCsr->nAdvance = nMerge; + }while( rc==SQLITE_OK ); + + return rc; +} + + +SQLITE_PRIVATE void sqlite3Fts3SegReaderFinish( + Fts3MultiSegReader *pCsr /* Cursor object */ +){ + if( pCsr ){ + int i; + for(i=0; inSegment; i++){ + sqlite3Fts3SegReaderFree(pCsr->apSegment[i]); + } + sqlite3_free(pCsr->apSegment); + sqlite3_free(pCsr->aBuffer); + + pCsr->nSegment = 0; + pCsr->apSegment = 0; + pCsr->aBuffer = 0; + } +} + +/* +** Decode the "end_block" field, selected by column iCol of the SELECT +** statement passed as the first argument. +** +** The "end_block" field may contain either an integer, or a text field +** containing the text representation of two non-negative integers separated +** by one or more space (0x20) characters. In the first case, set *piEndBlock +** to the integer value and *pnByte to zero before returning. In the second, +** set *piEndBlock to the first value and *pnByte to the second. +*/ +static void fts3ReadEndBlockField( + sqlite3_stmt *pStmt, + int iCol, + i64 *piEndBlock, + i64 *pnByte +){ + const unsigned char *zText = sqlite3_column_text(pStmt, iCol); + if( zText ){ + int i; + int iMul = 1; + u64 iVal = 0; + for(i=0; zText[i]>='0' && zText[i]<='9'; i++){ + iVal = iVal*10 + (zText[i] - '0'); + } + *piEndBlock = (i64)iVal; + while( zText[i]==' ' ) i++; + iVal = 0; + if( zText[i]=='-' ){ + i++; + iMul = -1; + } + for(/* no-op */; zText[i]>='0' && zText[i]<='9'; i++){ + iVal = iVal*10 + (zText[i] - '0'); + } + *pnByte = ((i64)iVal * (i64)iMul); + } +} + + +/* +** A segment of size nByte bytes has just been written to absolute level +** iAbsLevel. Promote any segments that should be promoted as a result. +*/ +static int fts3PromoteSegments( + Fts3Table *p, /* FTS table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level just updated */ + sqlite3_int64 nByte /* Size of new segment at iAbsLevel */ +){ + int rc = SQLITE_OK; + sqlite3_stmt *pRange; + + rc = fts3SqlStmt(p, SQL_SELECT_LEVEL_RANGE2, &pRange, 0); + + if( rc==SQLITE_OK ){ + int bOk = 0; + i64 iLast = (iAbsLevel/FTS3_SEGDIR_MAXLEVEL + 1) * FTS3_SEGDIR_MAXLEVEL - 1; + i64 nLimit = (nByte*3)/2; + + /* Loop through all entries in the %_segdir table corresponding to + ** segments in this index on levels greater than iAbsLevel. If there is + ** at least one such segment, and it is possible to determine that all + ** such segments are smaller than nLimit bytes in size, they will be + ** promoted to level iAbsLevel. */ + sqlite3_bind_int64(pRange, 1, iAbsLevel+1); + sqlite3_bind_int64(pRange, 2, iLast); + while( SQLITE_ROW==sqlite3_step(pRange) ){ + i64 nSize = 0, dummy; + fts3ReadEndBlockField(pRange, 2, &dummy, &nSize); + if( nSize<=0 || nSize>nLimit ){ + /* If nSize==0, then the %_segdir.end_block field does not not + ** contain a size value. This happens if it was written by an + ** old version of FTS. In this case it is not possible to determine + ** the size of the segment, and so segment promotion does not + ** take place. */ + bOk = 0; + break; + } + bOk = 1; + } + rc = sqlite3_reset(pRange); + + if( bOk ){ + int iIdx = 0; + sqlite3_stmt *pUpdate1 = 0; + sqlite3_stmt *pUpdate2 = 0; + + if( rc==SQLITE_OK ){ + rc = fts3SqlStmt(p, SQL_UPDATE_LEVEL_IDX, &pUpdate1, 0); + } + if( rc==SQLITE_OK ){ + rc = fts3SqlStmt(p, SQL_UPDATE_LEVEL, &pUpdate2, 0); + } + + if( rc==SQLITE_OK ){ + + /* Loop through all %_segdir entries for segments in this index with + ** levels equal to or greater than iAbsLevel. As each entry is visited, + ** updated it to set (level = -1) and (idx = N), where N is 0 for the + ** oldest segment in the range, 1 for the next oldest, and so on. + ** + ** In other words, move all segments being promoted to level -1, + ** setting the "idx" fields as appropriate to keep them in the same + ** order. The contents of level -1 (which is never used, except + ** transiently here), will be moved back to level iAbsLevel below. */ + sqlite3_bind_int64(pRange, 1, iAbsLevel); + while( SQLITE_ROW==sqlite3_step(pRange) ){ + sqlite3_bind_int(pUpdate1, 1, iIdx++); + sqlite3_bind_int(pUpdate1, 2, sqlite3_column_int(pRange, 0)); + sqlite3_bind_int(pUpdate1, 3, sqlite3_column_int(pRange, 1)); + sqlite3_step(pUpdate1); + rc = sqlite3_reset(pUpdate1); + if( rc!=SQLITE_OK ){ + sqlite3_reset(pRange); + break; + } + } + } + if( rc==SQLITE_OK ){ + rc = sqlite3_reset(pRange); + } + + /* Move level -1 to level iAbsLevel */ + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pUpdate2, 1, iAbsLevel); + sqlite3_step(pUpdate2); + rc = sqlite3_reset(pUpdate2); + } + } + } + + + return rc; +} + +/* +** Merge all level iLevel segments in the database into a single +** iLevel+1 segment. Or, if iLevel<0, merge all segments into a +** single segment with a level equal to the numerically largest level +** currently present in the database. +** +** If this function is called with iLevel<0, but there is only one +** segment in the database, SQLITE_DONE is returned immediately. +** Otherwise, if successful, SQLITE_OK is returned. If an error occurs, +** an SQLite error code is returned. +*/ +static int fts3SegmentMerge( + Fts3Table *p, + int iLangid, /* Language id to merge */ + int iIndex, /* Index in p->aIndex[] to merge */ + int iLevel /* Level to merge */ +){ + int rc; /* Return code */ + int iIdx = 0; /* Index of new segment */ + sqlite3_int64 iNewLevel = 0; /* Level/index to create new segment at */ + SegmentWriter *pWriter = 0; /* Used to write the new, merged, segment */ + Fts3SegFilter filter; /* Segment term filter condition */ + Fts3MultiSegReader csr; /* Cursor to iterate through level(s) */ + int bIgnoreEmpty = 0; /* True to ignore empty segments */ + i64 iMaxLevel = 0; /* Max level number for this index/langid */ + + assert( iLevel==FTS3_SEGCURSOR_ALL + || iLevel==FTS3_SEGCURSOR_PENDING + || iLevel>=0 + ); + assert( iLevel=0 && iIndexnIndex ); + + rc = sqlite3Fts3SegReaderCursor(p, iLangid, iIndex, iLevel, 0, 0, 1, 0, &csr); + if( rc!=SQLITE_OK || csr.nSegment==0 ) goto finished; + + if( iLevel!=FTS3_SEGCURSOR_PENDING ){ + rc = fts3SegmentMaxLevel(p, iLangid, iIndex, &iMaxLevel); + if( rc!=SQLITE_OK ) goto finished; + } + + if( iLevel==FTS3_SEGCURSOR_ALL ){ + /* This call is to merge all segments in the database to a single + ** segment. The level of the new segment is equal to the numerically + ** greatest segment level currently present in the database for this + ** index. The idx of the new segment is always 0. */ + if( csr.nSegment==1 && 0==fts3SegReaderIsPending(csr.apSegment[0]) ){ + rc = SQLITE_DONE; + goto finished; + } + iNewLevel = iMaxLevel; + bIgnoreEmpty = 1; + + }else{ + /* This call is to merge all segments at level iLevel. find the next + ** available segment index at level iLevel+1. The call to + ** fts3AllocateSegdirIdx() will merge the segments at level iLevel+1 to + ** a single iLevel+2 segment if necessary. */ + assert( FTS3_SEGCURSOR_PENDING==-1 ); + iNewLevel = getAbsoluteLevel(p, iLangid, iIndex, iLevel+1); + rc = fts3AllocateSegdirIdx(p, iLangid, iIndex, iLevel+1, &iIdx); + bIgnoreEmpty = (iLevel!=FTS3_SEGCURSOR_PENDING) && (iNewLevel>iMaxLevel); + } + if( rc!=SQLITE_OK ) goto finished; + + assert( csr.nSegment>0 ); + assert_fts3_nc( iNewLevel>=getAbsoluteLevel(p, iLangid, iIndex, 0) ); + assert_fts3_nc( + iNewLevelnLeafData); + } + } + } + + finished: + fts3SegWriterFree(pWriter); + sqlite3Fts3SegReaderFinish(&csr); + return rc; +} + + +/* +** Flush the contents of pendingTerms to level 0 segments. +*/ +SQLITE_PRIVATE int sqlite3Fts3PendingTermsFlush(Fts3Table *p){ + int rc = SQLITE_OK; + int i; + + for(i=0; rc==SQLITE_OK && inIndex; i++){ + rc = fts3SegmentMerge(p, p->iPrevLangid, i, FTS3_SEGCURSOR_PENDING); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + } + sqlite3Fts3PendingTermsClear(p); + + /* Determine the auto-incr-merge setting if unknown. If enabled, + ** estimate the number of leaf blocks of content to be written + */ + if( rc==SQLITE_OK && p->bHasStat + && p->nAutoincrmerge==0xff && p->nLeafAdd>0 + ){ + sqlite3_stmt *pStmt = 0; + rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int(pStmt, 1, FTS_STAT_AUTOINCRMERGE); + rc = sqlite3_step(pStmt); + if( rc==SQLITE_ROW ){ + p->nAutoincrmerge = sqlite3_column_int(pStmt, 0); + if( p->nAutoincrmerge==1 ) p->nAutoincrmerge = 8; + }else if( rc==SQLITE_DONE ){ + p->nAutoincrmerge = 0; + } + rc = sqlite3_reset(pStmt); + } + } + return rc; +} + +/* +** Encode N integers as varints into a blob. +*/ +static void fts3EncodeIntArray( + int N, /* The number of integers to encode */ + u32 *a, /* The integer values */ + char *zBuf, /* Write the BLOB here */ + int *pNBuf /* Write number of bytes if zBuf[] used here */ +){ + int i, j; + for(i=j=0; iiPrevDocid. The sizes are encoded as +** a blob of varints. +*/ +static void fts3InsertDocsize( + int *pRC, /* Result code */ + Fts3Table *p, /* Table into which to insert */ + u32 *aSz /* Sizes of each column, in tokens */ +){ + char *pBlob; /* The BLOB encoding of the document size */ + int nBlob; /* Number of bytes in the BLOB */ + sqlite3_stmt *pStmt; /* Statement used to insert the encoding */ + int rc; /* Result code from subfunctions */ + + if( *pRC ) return; + pBlob = sqlite3_malloc64( 10*(sqlite3_int64)p->nColumn ); + if( pBlob==0 ){ + *pRC = SQLITE_NOMEM; + return; + } + fts3EncodeIntArray(p->nColumn, aSz, pBlob, &nBlob); + rc = fts3SqlStmt(p, SQL_REPLACE_DOCSIZE, &pStmt, 0); + if( rc ){ + sqlite3_free(pBlob); + *pRC = rc; + return; + } + sqlite3_bind_int64(pStmt, 1, p->iPrevDocid); + sqlite3_bind_blob(pStmt, 2, pBlob, nBlob, sqlite3_free); + sqlite3_step(pStmt); + *pRC = sqlite3_reset(pStmt); +} + +/* +** Record 0 of the %_stat table contains a blob consisting of N varints, +** where N is the number of user defined columns in the fts3 table plus +** two. If nCol is the number of user defined columns, then values of the +** varints are set as follows: +** +** Varint 0: Total number of rows in the table. +** +** Varint 1..nCol: For each column, the total number of tokens stored in +** the column for all rows of the table. +** +** Varint 1+nCol: The total size, in bytes, of all text values in all +** columns of all rows of the table. +** +*/ +static void fts3UpdateDocTotals( + int *pRC, /* The result code */ + Fts3Table *p, /* Table being updated */ + u32 *aSzIns, /* Size increases */ + u32 *aSzDel, /* Size decreases */ + int nChng /* Change in the number of documents */ +){ + char *pBlob; /* Storage for BLOB written into %_stat */ + int nBlob; /* Size of BLOB written into %_stat */ + u32 *a; /* Array of integers that becomes the BLOB */ + sqlite3_stmt *pStmt; /* Statement for reading and writing */ + int i; /* Loop counter */ + int rc; /* Result code from subfunctions */ + + const int nStat = p->nColumn+2; + + if( *pRC ) return; + a = sqlite3_malloc64( (sizeof(u32)+10)*(sqlite3_int64)nStat ); + if( a==0 ){ + *pRC = SQLITE_NOMEM; + return; + } + pBlob = (char*)&a[nStat]; + rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pStmt, 0); + if( rc ){ + sqlite3_free(a); + *pRC = rc; + return; + } + sqlite3_bind_int(pStmt, 1, FTS_STAT_DOCTOTAL); + if( sqlite3_step(pStmt)==SQLITE_ROW ){ + fts3DecodeIntArray(nStat, a, + sqlite3_column_blob(pStmt, 0), + sqlite3_column_bytes(pStmt, 0)); + }else{ + memset(a, 0, sizeof(u32)*(nStat) ); + } + rc = sqlite3_reset(pStmt); + if( rc!=SQLITE_OK ){ + sqlite3_free(a); + *pRC = rc; + return; + } + if( nChng<0 && a[0]<(u32)(-nChng) ){ + a[0] = 0; + }else{ + a[0] += nChng; + } + for(i=0; inColumn+1; i++){ + u32 x = a[i+1]; + if( x+aSzIns[i] < aSzDel[i] ){ + x = 0; + }else{ + x = x + aSzIns[i] - aSzDel[i]; + } + a[i+1] = x; + } + fts3EncodeIntArray(nStat, a, pBlob, &nBlob); + rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pStmt, 0); + if( rc ){ + sqlite3_free(a); + *pRC = rc; + return; + } + sqlite3_bind_int(pStmt, 1, FTS_STAT_DOCTOTAL); + sqlite3_bind_blob(pStmt, 2, pBlob, nBlob, SQLITE_STATIC); + sqlite3_step(pStmt); + *pRC = sqlite3_reset(pStmt); + sqlite3_bind_null(pStmt, 2); + sqlite3_free(a); +} + +/* +** Merge the entire database so that there is one segment for each +** iIndex/iLangid combination. +*/ +static int fts3DoOptimize(Fts3Table *p, int bReturnDone){ + int bSeenDone = 0; + int rc; + sqlite3_stmt *pAllLangid = 0; + + rc = sqlite3Fts3PendingTermsFlush(p); + if( rc==SQLITE_OK ){ + rc = fts3SqlStmt(p, SQL_SELECT_ALL_LANGID, &pAllLangid, 0); + } + if( rc==SQLITE_OK ){ + int rc2; + sqlite3_bind_int(pAllLangid, 1, p->iPrevLangid); + sqlite3_bind_int(pAllLangid, 2, p->nIndex); + while( sqlite3_step(pAllLangid)==SQLITE_ROW ){ + int i; + int iLangid = sqlite3_column_int(pAllLangid, 0); + for(i=0; rc==SQLITE_OK && inIndex; i++){ + rc = fts3SegmentMerge(p, iLangid, i, FTS3_SEGCURSOR_ALL); + if( rc==SQLITE_DONE ){ + bSeenDone = 1; + rc = SQLITE_OK; + } + } + } + rc2 = sqlite3_reset(pAllLangid); + if( rc==SQLITE_OK ) rc = rc2; + } + + sqlite3Fts3SegmentsClose(p); + + return (rc==SQLITE_OK && bReturnDone && bSeenDone) ? SQLITE_DONE : rc; +} + +/* +** This function is called when the user executes the following statement: +** +** INSERT INTO () VALUES('rebuild'); +** +** The entire FTS index is discarded and rebuilt. If the table is one +** created using the content=xxx option, then the new index is based on +** the current contents of the xxx table. Otherwise, it is rebuilt based +** on the contents of the %_content table. +*/ +static int fts3DoRebuild(Fts3Table *p){ + int rc; /* Return Code */ + + rc = fts3DeleteAll(p, 0); + if( rc==SQLITE_OK ){ + u32 *aSz = 0; + u32 *aSzIns = 0; + u32 *aSzDel = 0; + sqlite3_stmt *pStmt = 0; + int nEntry = 0; + + /* Compose and prepare an SQL statement to loop through the content table */ + char *zSql = sqlite3_mprintf("SELECT %s" , p->zReadExprlist); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); + sqlite3_free(zSql); + } + + if( rc==SQLITE_OK ){ + sqlite3_int64 nByte = sizeof(u32) * ((sqlite3_int64)p->nColumn+1)*3; + aSz = (u32 *)sqlite3_malloc64(nByte); + if( aSz==0 ){ + rc = SQLITE_NOMEM; + }else{ + memset(aSz, 0, nByte); + aSzIns = &aSz[p->nColumn+1]; + aSzDel = &aSzIns[p->nColumn+1]; + } + } + + while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ + int iCol; + int iLangid = langidFromSelect(p, pStmt); + rc = fts3PendingTermsDocid(p, 0, iLangid, sqlite3_column_int64(pStmt, 0)); + memset(aSz, 0, sizeof(aSz[0]) * (p->nColumn+1)); + for(iCol=0; rc==SQLITE_OK && iColnColumn; iCol++){ + if( p->abNotindexed[iCol]==0 ){ + const char *z = (const char *) sqlite3_column_text(pStmt, iCol+1); + rc = fts3PendingTermsAdd(p, iLangid, z, iCol, &aSz[iCol]); + aSz[p->nColumn] += sqlite3_column_bytes(pStmt, iCol+1); + } + } + if( p->bHasDocsize ){ + fts3InsertDocsize(&rc, p, aSz); + } + if( rc!=SQLITE_OK ){ + sqlite3_finalize(pStmt); + pStmt = 0; + }else{ + nEntry++; + for(iCol=0; iCol<=p->nColumn; iCol++){ + aSzIns[iCol] += aSz[iCol]; + } + } + } + if( p->bFts4 ){ + fts3UpdateDocTotals(&rc, p, aSzIns, aSzDel, nEntry); + } + sqlite3_free(aSz); + + if( pStmt ){ + int rc2 = sqlite3_finalize(pStmt); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + } + + return rc; +} + + +/* +** This function opens a cursor used to read the input data for an +** incremental merge operation. Specifically, it opens a cursor to scan +** the oldest nSeg segments (idx=0 through idx=(nSeg-1)) in absolute +** level iAbsLevel. +*/ +static int fts3IncrmergeCsr( + Fts3Table *p, /* FTS3 table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level to open */ + int nSeg, /* Number of segments to merge */ + Fts3MultiSegReader *pCsr /* Cursor object to populate */ +){ + int rc; /* Return Code */ + sqlite3_stmt *pStmt = 0; /* Statement used to read %_segdir entry */ + sqlite3_int64 nByte; /* Bytes allocated at pCsr->apSegment[] */ + + /* Allocate space for the Fts3MultiSegReader.aCsr[] array */ + memset(pCsr, 0, sizeof(*pCsr)); + nByte = sizeof(Fts3SegReader *) * nSeg; + pCsr->apSegment = (Fts3SegReader **)sqlite3_malloc64(nByte); + + if( pCsr->apSegment==0 ){ + rc = SQLITE_NOMEM; + }else{ + memset(pCsr->apSegment, 0, nByte); + rc = fts3SqlStmt(p, SQL_SELECT_LEVEL, &pStmt, 0); + } + if( rc==SQLITE_OK ){ + int i; + int rc2; + sqlite3_bind_int64(pStmt, 1, iAbsLevel); + assert( pCsr->nSegment==0 ); + for(i=0; rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW && iapSegment[i] + ); + pCsr->nSegment++; + } + rc2 = sqlite3_reset(pStmt); + if( rc==SQLITE_OK ) rc = rc2; + } + + return rc; +} + +typedef struct IncrmergeWriter IncrmergeWriter; +typedef struct NodeWriter NodeWriter; +typedef struct Blob Blob; +typedef struct NodeReader NodeReader; + +/* +** An instance of the following structure is used as a dynamic buffer +** to build up nodes or other blobs of data in. +** +** The function blobGrowBuffer() is used to extend the allocation. +*/ +struct Blob { + char *a; /* Pointer to allocation */ + int n; /* Number of valid bytes of data in a[] */ + int nAlloc; /* Allocated size of a[] (nAlloc>=n) */ +}; + +/* +** This structure is used to build up buffers containing segment b-tree +** nodes (blocks). +*/ +struct NodeWriter { + sqlite3_int64 iBlock; /* Current block id */ + Blob key; /* Last key written to the current block */ + Blob block; /* Current block image */ +}; + +/* +** An object of this type contains the state required to create or append +** to an appendable b-tree segment. +*/ +struct IncrmergeWriter { + int nLeafEst; /* Space allocated for leaf blocks */ + int nWork; /* Number of leaf pages flushed */ + sqlite3_int64 iAbsLevel; /* Absolute level of input segments */ + int iIdx; /* Index of *output* segment in iAbsLevel+1 */ + sqlite3_int64 iStart; /* Block number of first allocated block */ + sqlite3_int64 iEnd; /* Block number of last allocated block */ + sqlite3_int64 nLeafData; /* Bytes of leaf page data so far */ + u8 bNoLeafData; /* If true, store 0 for segment size */ + NodeWriter aNodeWriter[FTS_MAX_APPENDABLE_HEIGHT]; +}; + +/* +** An object of the following type is used to read data from a single +** FTS segment node. See the following functions: +** +** nodeReaderInit() +** nodeReaderNext() +** nodeReaderRelease() +*/ +struct NodeReader { + const char *aNode; + int nNode; + int iOff; /* Current offset within aNode[] */ + + /* Output variables. Containing the current node entry. */ + sqlite3_int64 iChild; /* Pointer to child node */ + Blob term; /* Current term */ + const char *aDoclist; /* Pointer to doclist */ + int nDoclist; /* Size of doclist in bytes */ +}; + +/* +** If *pRc is not SQLITE_OK when this function is called, it is a no-op. +** Otherwise, if the allocation at pBlob->a is not already at least nMin +** bytes in size, extend (realloc) it to be so. +** +** If an OOM error occurs, set *pRc to SQLITE_NOMEM and leave pBlob->a +** unmodified. Otherwise, if the allocation succeeds, update pBlob->nAlloc +** to reflect the new size of the pBlob->a[] buffer. +*/ +static void blobGrowBuffer(Blob *pBlob, int nMin, int *pRc){ + if( *pRc==SQLITE_OK && nMin>pBlob->nAlloc ){ + int nAlloc = nMin; + char *a = (char *)sqlite3_realloc(pBlob->a, nAlloc); + if( a ){ + pBlob->nAlloc = nAlloc; + pBlob->a = a; + }else{ + *pRc = SQLITE_NOMEM; + } + } +} + +/* +** Attempt to advance the node-reader object passed as the first argument to +** the next entry on the node. +** +** Return an error code if an error occurs (SQLITE_NOMEM is possible). +** Otherwise return SQLITE_OK. If there is no next entry on the node +** (e.g. because the current entry is the last) set NodeReader->aNode to +** NULL to indicate EOF. Otherwise, populate the NodeReader structure output +** variables for the new entry. +*/ +static int nodeReaderNext(NodeReader *p){ + int bFirst = (p->term.n==0); /* True for first term on the node */ + int nPrefix = 0; /* Bytes to copy from previous term */ + int nSuffix = 0; /* Bytes to append to the prefix */ + int rc = SQLITE_OK; /* Return code */ + + assert( p->aNode ); + if( p->iChild && bFirst==0 ) p->iChild++; + if( p->iOff>=p->nNode ){ + /* EOF */ + p->aNode = 0; + }else{ + if( bFirst==0 ){ + p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &nPrefix); + } + p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &nSuffix); + + if( nPrefix>p->term.n || nSuffix>p->nNode-p->iOff || nSuffix==0 ){ + return FTS_CORRUPT_VTAB; + } + blobGrowBuffer(&p->term, nPrefix+nSuffix, &rc); + if( rc==SQLITE_OK ){ + memcpy(&p->term.a[nPrefix], &p->aNode[p->iOff], nSuffix); + p->term.n = nPrefix+nSuffix; + p->iOff += nSuffix; + if( p->iChild==0 ){ + p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &p->nDoclist); + if( (p->nNode-p->iOff)nDoclist ){ + return FTS_CORRUPT_VTAB; + } + p->aDoclist = &p->aNode[p->iOff]; + p->iOff += p->nDoclist; + } + } + } + + assert_fts3_nc( p->iOff<=p->nNode ); + return rc; +} + +/* +** Release all dynamic resources held by node-reader object *p. +*/ +static void nodeReaderRelease(NodeReader *p){ + sqlite3_free(p->term.a); +} + +/* +** Initialize a node-reader object to read the node in buffer aNode/nNode. +** +** If successful, SQLITE_OK is returned and the NodeReader object set to +** point to the first entry on the node (if any). Otherwise, an SQLite +** error code is returned. +*/ +static int nodeReaderInit(NodeReader *p, const char *aNode, int nNode){ + memset(p, 0, sizeof(NodeReader)); + p->aNode = aNode; + p->nNode = nNode; + + /* Figure out if this is a leaf or an internal node. */ + if( aNode && aNode[0] ){ + /* An internal node. */ + p->iOff = 1 + sqlite3Fts3GetVarint(&p->aNode[1], &p->iChild); + }else{ + p->iOff = 1; + } + + return aNode ? nodeReaderNext(p) : SQLITE_OK; +} + +/* +** This function is called while writing an FTS segment each time a leaf o +** node is finished and written to disk. The key (zTerm/nTerm) is guaranteed +** to be greater than the largest key on the node just written, but smaller +** than or equal to the first key that will be written to the next leaf +** node. +** +** The block id of the leaf node just written to disk may be found in +** (pWriter->aNodeWriter[0].iBlock) when this function is called. +*/ +static int fts3IncrmergePush( + Fts3Table *p, /* Fts3 table handle */ + IncrmergeWriter *pWriter, /* Writer object */ + const char *zTerm, /* Term to write to internal node */ + int nTerm /* Bytes at zTerm */ +){ + sqlite3_int64 iPtr = pWriter->aNodeWriter[0].iBlock; + int iLayer; + + assert( nTerm>0 ); + for(iLayer=1; ALWAYS(iLayeraNodeWriter[iLayer]; + int rc = SQLITE_OK; + int nPrefix; + int nSuffix; + int nSpace; + + /* Figure out how much space the key will consume if it is written to + ** the current node of layer iLayer. Due to the prefix compression, + ** the space required changes depending on which node the key is to + ** be added to. */ + nPrefix = fts3PrefixCompress(pNode->key.a, pNode->key.n, zTerm, nTerm); + nSuffix = nTerm - nPrefix; + if(nSuffix<=0 ) return FTS_CORRUPT_VTAB; + nSpace = sqlite3Fts3VarintLen(nPrefix); + nSpace += sqlite3Fts3VarintLen(nSuffix) + nSuffix; + + if( pNode->key.n==0 || (pNode->block.n + nSpace)<=p->nNodeSize ){ + /* If the current node of layer iLayer contains zero keys, or if adding + ** the key to it will not cause it to grow to larger than nNodeSize + ** bytes in size, write the key here. */ + + Blob *pBlk = &pNode->block; + if( pBlk->n==0 ){ + blobGrowBuffer(pBlk, p->nNodeSize, &rc); + if( rc==SQLITE_OK ){ + pBlk->a[0] = (char)iLayer; + pBlk->n = 1 + sqlite3Fts3PutVarint(&pBlk->a[1], iPtr); + } + } + blobGrowBuffer(pBlk, pBlk->n + nSpace, &rc); + blobGrowBuffer(&pNode->key, nTerm, &rc); + + if( rc==SQLITE_OK ){ + if( pNode->key.n ){ + pBlk->n += sqlite3Fts3PutVarint(&pBlk->a[pBlk->n], nPrefix); + } + pBlk->n += sqlite3Fts3PutVarint(&pBlk->a[pBlk->n], nSuffix); + memcpy(&pBlk->a[pBlk->n], &zTerm[nPrefix], nSuffix); + pBlk->n += nSuffix; + + memcpy(pNode->key.a, zTerm, nTerm); + pNode->key.n = nTerm; + } + }else{ + /* Otherwise, flush the current node of layer iLayer to disk. + ** Then allocate a new, empty sibling node. The key will be written + ** into the parent of this node. */ + rc = fts3WriteSegment(p, pNode->iBlock, pNode->block.a, pNode->block.n); + + assert( pNode->block.nAlloc>=p->nNodeSize ); + pNode->block.a[0] = (char)iLayer; + pNode->block.n = 1 + sqlite3Fts3PutVarint(&pNode->block.a[1], iPtr+1); + + iNextPtr = pNode->iBlock; + pNode->iBlock++; + pNode->key.n = 0; + } + + if( rc!=SQLITE_OK || iNextPtr==0 ) return rc; + iPtr = iNextPtr; + } + + assert( 0 ); + return 0; +} + +/* +** Append a term and (optionally) doclist to the FTS segment node currently +** stored in blob *pNode. The node need not contain any terms, but the +** header must be written before this function is called. +** +** A node header is a single 0x00 byte for a leaf node, or a height varint +** followed by the left-hand-child varint for an internal node. +** +** The term to be appended is passed via arguments zTerm/nTerm. For a +** leaf node, the doclist is passed as aDoclist/nDoclist. For an internal +** node, both aDoclist and nDoclist must be passed 0. +** +** If the size of the value in blob pPrev is zero, then this is the first +** term written to the node. Otherwise, pPrev contains a copy of the +** previous term. Before this function returns, it is updated to contain a +** copy of zTerm/nTerm. +** +** It is assumed that the buffer associated with pNode is already large +** enough to accommodate the new entry. The buffer associated with pPrev +** is extended by this function if requrired. +** +** If an error (i.e. OOM condition) occurs, an SQLite error code is +** returned. Otherwise, SQLITE_OK. +*/ +static int fts3AppendToNode( + Blob *pNode, /* Current node image to append to */ + Blob *pPrev, /* Buffer containing previous term written */ + const char *zTerm, /* New term to write */ + int nTerm, /* Size of zTerm in bytes */ + const char *aDoclist, /* Doclist (or NULL) to write */ + int nDoclist /* Size of aDoclist in bytes */ +){ + int rc = SQLITE_OK; /* Return code */ + int bFirst = (pPrev->n==0); /* True if this is the first term written */ + int nPrefix; /* Size of term prefix in bytes */ + int nSuffix; /* Size of term suffix in bytes */ + + /* Node must have already been started. There must be a doclist for a + ** leaf node, and there must not be a doclist for an internal node. */ + assert( pNode->n>0 ); + assert_fts3_nc( (pNode->a[0]=='\0')==(aDoclist!=0) ); + + blobGrowBuffer(pPrev, nTerm, &rc); + if( rc!=SQLITE_OK ) return rc; + + nPrefix = fts3PrefixCompress(pPrev->a, pPrev->n, zTerm, nTerm); + nSuffix = nTerm - nPrefix; + if( nSuffix<=0 ) return FTS_CORRUPT_VTAB; + memcpy(pPrev->a, zTerm, nTerm); + pPrev->n = nTerm; + + if( bFirst==0 ){ + pNode->n += sqlite3Fts3PutVarint(&pNode->a[pNode->n], nPrefix); + } + pNode->n += sqlite3Fts3PutVarint(&pNode->a[pNode->n], nSuffix); + memcpy(&pNode->a[pNode->n], &zTerm[nPrefix], nSuffix); + pNode->n += nSuffix; + + if( aDoclist ){ + pNode->n += sqlite3Fts3PutVarint(&pNode->a[pNode->n], nDoclist); + memcpy(&pNode->a[pNode->n], aDoclist, nDoclist); + pNode->n += nDoclist; + } + + assert( pNode->n<=pNode->nAlloc ); + + return SQLITE_OK; +} + +/* +** Append the current term and doclist pointed to by cursor pCsr to the +** appendable b-tree segment opened for writing by pWriter. +** +** Return SQLITE_OK if successful, or an SQLite error code otherwise. +*/ +static int fts3IncrmergeAppend( + Fts3Table *p, /* Fts3 table handle */ + IncrmergeWriter *pWriter, /* Writer object */ + Fts3MultiSegReader *pCsr /* Cursor containing term and doclist */ +){ + const char *zTerm = pCsr->zTerm; + int nTerm = pCsr->nTerm; + const char *aDoclist = pCsr->aDoclist; + int nDoclist = pCsr->nDoclist; + int rc = SQLITE_OK; /* Return code */ + int nSpace; /* Total space in bytes required on leaf */ + int nPrefix; /* Size of prefix shared with previous term */ + int nSuffix; /* Size of suffix (nTerm - nPrefix) */ + NodeWriter *pLeaf; /* Object used to write leaf nodes */ + + pLeaf = &pWriter->aNodeWriter[0]; + nPrefix = fts3PrefixCompress(pLeaf->key.a, pLeaf->key.n, zTerm, nTerm); + nSuffix = nTerm - nPrefix; + + nSpace = sqlite3Fts3VarintLen(nPrefix); + nSpace += sqlite3Fts3VarintLen(nSuffix) + nSuffix; + nSpace += sqlite3Fts3VarintLen(nDoclist) + nDoclist; + + /* If the current block is not empty, and if adding this term/doclist + ** to the current block would make it larger than Fts3Table.nNodeSize + ** bytes, write this block out to the database. */ + if( pLeaf->block.n>0 && (pLeaf->block.n + nSpace)>p->nNodeSize ){ + rc = fts3WriteSegment(p, pLeaf->iBlock, pLeaf->block.a, pLeaf->block.n); + pWriter->nWork++; + + /* Add the current term to the parent node. The term added to the + ** parent must: + ** + ** a) be greater than the largest term on the leaf node just written + ** to the database (still available in pLeaf->key), and + ** + ** b) be less than or equal to the term about to be added to the new + ** leaf node (zTerm/nTerm). + ** + ** In other words, it must be the prefix of zTerm 1 byte longer than + ** the common prefix (if any) of zTerm and pWriter->zTerm. + */ + if( rc==SQLITE_OK ){ + rc = fts3IncrmergePush(p, pWriter, zTerm, nPrefix+1); + } + + /* Advance to the next output block */ + pLeaf->iBlock++; + pLeaf->key.n = 0; + pLeaf->block.n = 0; + + nSuffix = nTerm; + nSpace = 1; + nSpace += sqlite3Fts3VarintLen(nSuffix) + nSuffix; + nSpace += sqlite3Fts3VarintLen(nDoclist) + nDoclist; + } + + pWriter->nLeafData += nSpace; + blobGrowBuffer(&pLeaf->block, pLeaf->block.n + nSpace, &rc); + if( rc==SQLITE_OK ){ + if( pLeaf->block.n==0 ){ + pLeaf->block.n = 1; + pLeaf->block.a[0] = '\0'; + } + rc = fts3AppendToNode( + &pLeaf->block, &pLeaf->key, zTerm, nTerm, aDoclist, nDoclist + ); + } + + return rc; +} + +/* +** This function is called to release all dynamic resources held by the +** merge-writer object pWriter, and if no error has occurred, to flush +** all outstanding node buffers held by pWriter to disk. +** +** If *pRc is not SQLITE_OK when this function is called, then no attempt +** is made to write any data to disk. Instead, this function serves only +** to release outstanding resources. +** +** Otherwise, if *pRc is initially SQLITE_OK and an error occurs while +** flushing buffers to disk, *pRc is set to an SQLite error code before +** returning. +*/ +static void fts3IncrmergeRelease( + Fts3Table *p, /* FTS3 table handle */ + IncrmergeWriter *pWriter, /* Merge-writer object */ + int *pRc /* IN/OUT: Error code */ +){ + int i; /* Used to iterate through non-root layers */ + int iRoot; /* Index of root in pWriter->aNodeWriter */ + NodeWriter *pRoot; /* NodeWriter for root node */ + int rc = *pRc; /* Error code */ + + /* Set iRoot to the index in pWriter->aNodeWriter[] of the output segment + ** root node. If the segment fits entirely on a single leaf node, iRoot + ** will be set to 0. If the root node is the parent of the leaves, iRoot + ** will be 1. And so on. */ + for(iRoot=FTS_MAX_APPENDABLE_HEIGHT-1; iRoot>=0; iRoot--){ + NodeWriter *pNode = &pWriter->aNodeWriter[iRoot]; + if( pNode->block.n>0 ) break; + assert( *pRc || pNode->block.nAlloc==0 ); + assert( *pRc || pNode->key.nAlloc==0 ); + sqlite3_free(pNode->block.a); + sqlite3_free(pNode->key.a); + } + + /* Empty output segment. This is a no-op. */ + if( iRoot<0 ) return; + + /* The entire output segment fits on a single node. Normally, this means + ** the node would be stored as a blob in the "root" column of the %_segdir + ** table. However, this is not permitted in this case. The problem is that + ** space has already been reserved in the %_segments table, and so the + ** start_block and end_block fields of the %_segdir table must be populated. + ** And, by design or by accident, released versions of FTS cannot handle + ** segments that fit entirely on the root node with start_block!=0. + ** + ** Instead, create a synthetic root node that contains nothing but a + ** pointer to the single content node. So that the segment consists of a + ** single leaf and a single interior (root) node. + ** + ** Todo: Better might be to defer allocating space in the %_segments + ** table until we are sure it is needed. + */ + if( iRoot==0 ){ + Blob *pBlock = &pWriter->aNodeWriter[1].block; + blobGrowBuffer(pBlock, 1 + FTS3_VARINT_MAX, &rc); + if( rc==SQLITE_OK ){ + pBlock->a[0] = 0x01; + pBlock->n = 1 + sqlite3Fts3PutVarint( + &pBlock->a[1], pWriter->aNodeWriter[0].iBlock + ); + } + iRoot = 1; + } + pRoot = &pWriter->aNodeWriter[iRoot]; + + /* Flush all currently outstanding nodes to disk. */ + for(i=0; iaNodeWriter[i]; + if( pNode->block.n>0 && rc==SQLITE_OK ){ + rc = fts3WriteSegment(p, pNode->iBlock, pNode->block.a, pNode->block.n); + } + sqlite3_free(pNode->block.a); + sqlite3_free(pNode->key.a); + } + + /* Write the %_segdir record. */ + if( rc==SQLITE_OK ){ + rc = fts3WriteSegdir(p, + pWriter->iAbsLevel+1, /* level */ + pWriter->iIdx, /* idx */ + pWriter->iStart, /* start_block */ + pWriter->aNodeWriter[0].iBlock, /* leaves_end_block */ + pWriter->iEnd, /* end_block */ + (pWriter->bNoLeafData==0 ? pWriter->nLeafData : 0), /* end_block */ + pRoot->block.a, pRoot->block.n /* root */ + ); + } + sqlite3_free(pRoot->block.a); + sqlite3_free(pRoot->key.a); + + *pRc = rc; +} + +/* +** Compare the term in buffer zLhs (size in bytes nLhs) with that in +** zRhs (size in bytes nRhs) using memcmp. If one term is a prefix of +** the other, it is considered to be smaller than the other. +** +** Return -ve if zLhs is smaller than zRhs, 0 if it is equal, or +ve +** if it is greater. +*/ +static int fts3TermCmp( + const char *zLhs, int nLhs, /* LHS of comparison */ + const char *zRhs, int nRhs /* RHS of comparison */ +){ + int nCmp = MIN(nLhs, nRhs); + int res; + + res = (nCmp ? memcmp(zLhs, zRhs, nCmp) : 0); + if( res==0 ) res = nLhs - nRhs; + + return res; +} + + +/* +** Query to see if the entry in the %_segments table with blockid iEnd is +** NULL. If no error occurs and the entry is NULL, set *pbRes 1 before +** returning. Otherwise, set *pbRes to 0. +** +** Or, if an error occurs while querying the database, return an SQLite +** error code. The final value of *pbRes is undefined in this case. +** +** This is used to test if a segment is an "appendable" segment. If it +** is, then a NULL entry has been inserted into the %_segments table +** with blockid %_segdir.end_block. +*/ +static int fts3IsAppendable(Fts3Table *p, sqlite3_int64 iEnd, int *pbRes){ + int bRes = 0; /* Result to set *pbRes to */ + sqlite3_stmt *pCheck = 0; /* Statement to query database with */ + int rc; /* Return code */ + + rc = fts3SqlStmt(p, SQL_SEGMENT_IS_APPENDABLE, &pCheck, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pCheck, 1, iEnd); + if( SQLITE_ROW==sqlite3_step(pCheck) ) bRes = 1; + rc = sqlite3_reset(pCheck); + } + + *pbRes = bRes; + return rc; +} + +/* +** This function is called when initializing an incremental-merge operation. +** It checks if the existing segment with index value iIdx at absolute level +** (iAbsLevel+1) can be appended to by the incremental merge. If it can, the +** merge-writer object *pWriter is initialized to write to it. +** +** An existing segment can be appended to by an incremental merge if: +** +** * It was initially created as an appendable segment (with all required +** space pre-allocated), and +** +** * The first key read from the input (arguments zKey and nKey) is +** greater than the largest key currently stored in the potential +** output segment. +*/ +static int fts3IncrmergeLoad( + Fts3Table *p, /* Fts3 table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level of input segments */ + int iIdx, /* Index of candidate output segment */ + const char *zKey, /* First key to write */ + int nKey, /* Number of bytes in nKey */ + IncrmergeWriter *pWriter /* Populate this object */ +){ + int rc; /* Return code */ + sqlite3_stmt *pSelect = 0; /* SELECT to read %_segdir entry */ + + rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR, &pSelect, 0); + if( rc==SQLITE_OK ){ + sqlite3_int64 iStart = 0; /* Value of %_segdir.start_block */ + sqlite3_int64 iLeafEnd = 0; /* Value of %_segdir.leaves_end_block */ + sqlite3_int64 iEnd = 0; /* Value of %_segdir.end_block */ + const char *aRoot = 0; /* Pointer to %_segdir.root buffer */ + int nRoot = 0; /* Size of aRoot[] in bytes */ + int rc2; /* Return code from sqlite3_reset() */ + int bAppendable = 0; /* Set to true if segment is appendable */ + + /* Read the %_segdir entry for index iIdx absolute level (iAbsLevel+1) */ + sqlite3_bind_int64(pSelect, 1, iAbsLevel+1); + sqlite3_bind_int(pSelect, 2, iIdx); + if( sqlite3_step(pSelect)==SQLITE_ROW ){ + iStart = sqlite3_column_int64(pSelect, 1); + iLeafEnd = sqlite3_column_int64(pSelect, 2); + fts3ReadEndBlockField(pSelect, 3, &iEnd, &pWriter->nLeafData); + if( pWriter->nLeafData<0 ){ + pWriter->nLeafData = pWriter->nLeafData * -1; + } + pWriter->bNoLeafData = (pWriter->nLeafData==0); + nRoot = sqlite3_column_bytes(pSelect, 4); + aRoot = sqlite3_column_blob(pSelect, 4); + if( aRoot==0 ){ + sqlite3_reset(pSelect); + return nRoot ? SQLITE_NOMEM : FTS_CORRUPT_VTAB; + } + }else{ + return sqlite3_reset(pSelect); + } + + /* Check for the zero-length marker in the %_segments table */ + rc = fts3IsAppendable(p, iEnd, &bAppendable); + + /* Check that zKey/nKey is larger than the largest key the candidate */ + if( rc==SQLITE_OK && bAppendable ){ + char *aLeaf = 0; + int nLeaf = 0; + + rc = sqlite3Fts3ReadBlock(p, iLeafEnd, &aLeaf, &nLeaf, 0); + if( rc==SQLITE_OK ){ + NodeReader reader; + for(rc = nodeReaderInit(&reader, aLeaf, nLeaf); + rc==SQLITE_OK && reader.aNode; + rc = nodeReaderNext(&reader) + ){ + assert( reader.aNode ); + } + if( fts3TermCmp(zKey, nKey, reader.term.a, reader.term.n)<=0 ){ + bAppendable = 0; + } + nodeReaderRelease(&reader); + } + sqlite3_free(aLeaf); + } + + if( rc==SQLITE_OK && bAppendable ){ + /* It is possible to append to this segment. Set up the IncrmergeWriter + ** object to do so. */ + int i; + int nHeight = (int)aRoot[0]; + NodeWriter *pNode; + if( nHeight<1 || nHeight>=FTS_MAX_APPENDABLE_HEIGHT ){ + sqlite3_reset(pSelect); + return FTS_CORRUPT_VTAB; + } + + pWriter->nLeafEst = (int)((iEnd - iStart) + 1)/FTS_MAX_APPENDABLE_HEIGHT; + pWriter->iStart = iStart; + pWriter->iEnd = iEnd; + pWriter->iAbsLevel = iAbsLevel; + pWriter->iIdx = iIdx; + + for(i=nHeight+1; iaNodeWriter[i].iBlock = pWriter->iStart + i*pWriter->nLeafEst; + } + + pNode = &pWriter->aNodeWriter[nHeight]; + pNode->iBlock = pWriter->iStart + pWriter->nLeafEst*nHeight; + blobGrowBuffer(&pNode->block, + MAX(nRoot, p->nNodeSize)+FTS3_NODE_PADDING, &rc + ); + if( rc==SQLITE_OK ){ + memcpy(pNode->block.a, aRoot, nRoot); + pNode->block.n = nRoot; + memset(&pNode->block.a[nRoot], 0, FTS3_NODE_PADDING); + } + + for(i=nHeight; i>=0 && rc==SQLITE_OK; i--){ + NodeReader reader; + pNode = &pWriter->aNodeWriter[i]; + + if( pNode->block.a){ + rc = nodeReaderInit(&reader, pNode->block.a, pNode->block.n); + while( reader.aNode && rc==SQLITE_OK ) rc = nodeReaderNext(&reader); + blobGrowBuffer(&pNode->key, reader.term.n, &rc); + if( rc==SQLITE_OK ){ + memcpy(pNode->key.a, reader.term.a, reader.term.n); + pNode->key.n = reader.term.n; + if( i>0 ){ + char *aBlock = 0; + int nBlock = 0; + pNode = &pWriter->aNodeWriter[i-1]; + pNode->iBlock = reader.iChild; + rc = sqlite3Fts3ReadBlock(p, reader.iChild, &aBlock, &nBlock, 0); + blobGrowBuffer(&pNode->block, + MAX(nBlock, p->nNodeSize)+FTS3_NODE_PADDING, &rc + ); + if( rc==SQLITE_OK ){ + memcpy(pNode->block.a, aBlock, nBlock); + pNode->block.n = nBlock; + memset(&pNode->block.a[nBlock], 0, FTS3_NODE_PADDING); + } + sqlite3_free(aBlock); + } + } + } + nodeReaderRelease(&reader); + } + } + + rc2 = sqlite3_reset(pSelect); + if( rc==SQLITE_OK ) rc = rc2; + } + + return rc; +} + +/* +** Determine the largest segment index value that exists within absolute +** level iAbsLevel+1. If no error occurs, set *piIdx to this value plus +** one before returning SQLITE_OK. Or, if there are no segments at all +** within level iAbsLevel, set *piIdx to zero. +** +** If an error occurs, return an SQLite error code. The final value of +** *piIdx is undefined in this case. +*/ +static int fts3IncrmergeOutputIdx( + Fts3Table *p, /* FTS Table handle */ + sqlite3_int64 iAbsLevel, /* Absolute index of input segments */ + int *piIdx /* OUT: Next free index at iAbsLevel+1 */ +){ + int rc; + sqlite3_stmt *pOutputIdx = 0; /* SQL used to find output index */ + + rc = fts3SqlStmt(p, SQL_NEXT_SEGMENT_INDEX, &pOutputIdx, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pOutputIdx, 1, iAbsLevel+1); + sqlite3_step(pOutputIdx); + *piIdx = sqlite3_column_int(pOutputIdx, 0); + rc = sqlite3_reset(pOutputIdx); + } + + return rc; +} + +/* +** Allocate an appendable output segment on absolute level iAbsLevel+1 +** with idx value iIdx. +** +** In the %_segdir table, a segment is defined by the values in three +** columns: +** +** start_block +** leaves_end_block +** end_block +** +** When an appendable segment is allocated, it is estimated that the +** maximum number of leaf blocks that may be required is the sum of the +** number of leaf blocks consumed by the input segments, plus the number +** of input segments, multiplied by two. This value is stored in stack +** variable nLeafEst. +** +** A total of 16*nLeafEst blocks are allocated when an appendable segment +** is created ((1 + end_block - start_block)==16*nLeafEst). The contiguous +** array of leaf nodes starts at the first block allocated. The array +** of interior nodes that are parents of the leaf nodes start at block +** (start_block + (1 + end_block - start_block) / 16). And so on. +** +** In the actual code below, the value "16" is replaced with the +** pre-processor macro FTS_MAX_APPENDABLE_HEIGHT. +*/ +static int fts3IncrmergeWriter( + Fts3Table *p, /* Fts3 table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level of input segments */ + int iIdx, /* Index of new output segment */ + Fts3MultiSegReader *pCsr, /* Cursor that data will be read from */ + IncrmergeWriter *pWriter /* Populate this object */ +){ + int rc; /* Return Code */ + int i; /* Iterator variable */ + int nLeafEst = 0; /* Blocks allocated for leaf nodes */ + sqlite3_stmt *pLeafEst = 0; /* SQL used to determine nLeafEst */ + sqlite3_stmt *pFirstBlock = 0; /* SQL used to determine first block */ + + /* Calculate nLeafEst. */ + rc = fts3SqlStmt(p, SQL_MAX_LEAF_NODE_ESTIMATE, &pLeafEst, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pLeafEst, 1, iAbsLevel); + sqlite3_bind_int64(pLeafEst, 2, pCsr->nSegment); + if( SQLITE_ROW==sqlite3_step(pLeafEst) ){ + nLeafEst = sqlite3_column_int(pLeafEst, 0); + } + rc = sqlite3_reset(pLeafEst); + } + if( rc!=SQLITE_OK ) return rc; + + /* Calculate the first block to use in the output segment */ + rc = fts3SqlStmt(p, SQL_NEXT_SEGMENTS_ID, &pFirstBlock, 0); + if( rc==SQLITE_OK ){ + if( SQLITE_ROW==sqlite3_step(pFirstBlock) ){ + pWriter->iStart = sqlite3_column_int64(pFirstBlock, 0); + pWriter->iEnd = pWriter->iStart - 1; + pWriter->iEnd += nLeafEst * FTS_MAX_APPENDABLE_HEIGHT; + } + rc = sqlite3_reset(pFirstBlock); + } + if( rc!=SQLITE_OK ) return rc; + + /* Insert the marker in the %_segments table to make sure nobody tries + ** to steal the space just allocated. This is also used to identify + ** appendable segments. */ + rc = fts3WriteSegment(p, pWriter->iEnd, 0, 0); + if( rc!=SQLITE_OK ) return rc; + + pWriter->iAbsLevel = iAbsLevel; + pWriter->nLeafEst = nLeafEst; + pWriter->iIdx = iIdx; + + /* Set up the array of NodeWriter objects */ + for(i=0; iaNodeWriter[i].iBlock = pWriter->iStart + i*pWriter->nLeafEst; + } + return SQLITE_OK; +} + +/* +** Remove an entry from the %_segdir table. This involves running the +** following two statements: +** +** DELETE FROM %_segdir WHERE level = :iAbsLevel AND idx = :iIdx +** UPDATE %_segdir SET idx = idx - 1 WHERE level = :iAbsLevel AND idx > :iIdx +** +** The DELETE statement removes the specific %_segdir level. The UPDATE +** statement ensures that the remaining segments have contiguously allocated +** idx values. +*/ +static int fts3RemoveSegdirEntry( + Fts3Table *p, /* FTS3 table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level to delete from */ + int iIdx /* Index of %_segdir entry to delete */ +){ + int rc; /* Return code */ + sqlite3_stmt *pDelete = 0; /* DELETE statement */ + + rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_ENTRY, &pDelete, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pDelete, 1, iAbsLevel); + sqlite3_bind_int(pDelete, 2, iIdx); + sqlite3_step(pDelete); + rc = sqlite3_reset(pDelete); + } + + return rc; +} + +/* +** One or more segments have just been removed from absolute level iAbsLevel. +** Update the 'idx' values of the remaining segments in the level so that +** the idx values are a contiguous sequence starting from 0. +*/ +static int fts3RepackSegdirLevel( + Fts3Table *p, /* FTS3 table handle */ + sqlite3_int64 iAbsLevel /* Absolute level to repack */ +){ + int rc; /* Return code */ + int *aIdx = 0; /* Array of remaining idx values */ + int nIdx = 0; /* Valid entries in aIdx[] */ + int nAlloc = 0; /* Allocated size of aIdx[] */ + int i; /* Iterator variable */ + sqlite3_stmt *pSelect = 0; /* Select statement to read idx values */ + sqlite3_stmt *pUpdate = 0; /* Update statement to modify idx values */ + + rc = fts3SqlStmt(p, SQL_SELECT_INDEXES, &pSelect, 0); + if( rc==SQLITE_OK ){ + int rc2; + sqlite3_bind_int64(pSelect, 1, iAbsLevel); + while( SQLITE_ROW==sqlite3_step(pSelect) ){ + if( nIdx>=nAlloc ){ + int *aNew; + nAlloc += 16; + aNew = sqlite3_realloc(aIdx, nAlloc*sizeof(int)); + if( !aNew ){ + rc = SQLITE_NOMEM; + break; + } + aIdx = aNew; + } + aIdx[nIdx++] = sqlite3_column_int(pSelect, 0); + } + rc2 = sqlite3_reset(pSelect); + if( rc==SQLITE_OK ) rc = rc2; + } + + if( rc==SQLITE_OK ){ + rc = fts3SqlStmt(p, SQL_SHIFT_SEGDIR_ENTRY, &pUpdate, 0); + } + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pUpdate, 2, iAbsLevel); + } + + assert( p->bIgnoreSavepoint==0 ); + p->bIgnoreSavepoint = 1; + for(i=0; rc==SQLITE_OK && ibIgnoreSavepoint = 0; + + sqlite3_free(aIdx); + return rc; +} + +static void fts3StartNode(Blob *pNode, int iHeight, sqlite3_int64 iChild){ + pNode->a[0] = (char)iHeight; + if( iChild ){ + assert( pNode->nAlloc>=1+sqlite3Fts3VarintLen(iChild) ); + pNode->n = 1 + sqlite3Fts3PutVarint(&pNode->a[1], iChild); + }else{ + assert( pNode->nAlloc>=1 ); + pNode->n = 1; + } +} + +/* +** The first two arguments are a pointer to and the size of a segment b-tree +** node. The node may be a leaf or an internal node. +** +** This function creates a new node image in blob object *pNew by copying +** all terms that are greater than or equal to zTerm/nTerm (for leaf nodes) +** or greater than zTerm/nTerm (for internal nodes) from aNode/nNode. +*/ +static int fts3TruncateNode( + const char *aNode, /* Current node image */ + int nNode, /* Size of aNode in bytes */ + Blob *pNew, /* OUT: Write new node image here */ + const char *zTerm, /* Omit all terms smaller than this */ + int nTerm, /* Size of zTerm in bytes */ + sqlite3_int64 *piBlock /* OUT: Block number in next layer down */ +){ + NodeReader reader; /* Reader object */ + Blob prev = {0, 0, 0}; /* Previous term written to new node */ + int rc = SQLITE_OK; /* Return code */ + int bLeaf; /* True for a leaf node */ + + if( nNode<1 ) return FTS_CORRUPT_VTAB; + bLeaf = aNode[0]=='\0'; + + /* Allocate required output space */ + blobGrowBuffer(pNew, nNode, &rc); + if( rc!=SQLITE_OK ) return rc; + pNew->n = 0; + + /* Populate new node buffer */ + for(rc = nodeReaderInit(&reader, aNode, nNode); + rc==SQLITE_OK && reader.aNode; + rc = nodeReaderNext(&reader) + ){ + if( pNew->n==0 ){ + int res = fts3TermCmp(reader.term.a, reader.term.n, zTerm, nTerm); + if( res<0 || (bLeaf==0 && res==0) ) continue; + fts3StartNode(pNew, (int)aNode[0], reader.iChild); + *piBlock = reader.iChild; + } + rc = fts3AppendToNode( + pNew, &prev, reader.term.a, reader.term.n, + reader.aDoclist, reader.nDoclist + ); + if( rc!=SQLITE_OK ) break; + } + if( pNew->n==0 ){ + fts3StartNode(pNew, (int)aNode[0], reader.iChild); + *piBlock = reader.iChild; + } + assert( pNew->n<=pNew->nAlloc ); + + nodeReaderRelease(&reader); + sqlite3_free(prev.a); + return rc; +} + +/* +** Remove all terms smaller than zTerm/nTerm from segment iIdx in absolute +** level iAbsLevel. This may involve deleting entries from the %_segments +** table, and modifying existing entries in both the %_segments and %_segdir +** tables. +** +** SQLITE_OK is returned if the segment is updated successfully. Or an +** SQLite error code otherwise. +*/ +static int fts3TruncateSegment( + Fts3Table *p, /* FTS3 table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level of segment to modify */ + int iIdx, /* Index within level of segment to modify */ + const char *zTerm, /* Remove terms smaller than this */ + int nTerm /* Number of bytes in buffer zTerm */ +){ + int rc = SQLITE_OK; /* Return code */ + Blob root = {0,0,0}; /* New root page image */ + Blob block = {0,0,0}; /* Buffer used for any other block */ + sqlite3_int64 iBlock = 0; /* Block id */ + sqlite3_int64 iNewStart = 0; /* New value for iStartBlock */ + sqlite3_int64 iOldStart = 0; /* Old value for iStartBlock */ + sqlite3_stmt *pFetch = 0; /* Statement used to fetch segdir */ + + rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR, &pFetch, 0); + if( rc==SQLITE_OK ){ + int rc2; /* sqlite3_reset() return code */ + sqlite3_bind_int64(pFetch, 1, iAbsLevel); + sqlite3_bind_int(pFetch, 2, iIdx); + if( SQLITE_ROW==sqlite3_step(pFetch) ){ + const char *aRoot = sqlite3_column_blob(pFetch, 4); + int nRoot = sqlite3_column_bytes(pFetch, 4); + iOldStart = sqlite3_column_int64(pFetch, 1); + rc = fts3TruncateNode(aRoot, nRoot, &root, zTerm, nTerm, &iBlock); + } + rc2 = sqlite3_reset(pFetch); + if( rc==SQLITE_OK ) rc = rc2; + } + + while( rc==SQLITE_OK && iBlock ){ + char *aBlock = 0; + int nBlock = 0; + iNewStart = iBlock; + + rc = sqlite3Fts3ReadBlock(p, iBlock, &aBlock, &nBlock, 0); + if( rc==SQLITE_OK ){ + rc = fts3TruncateNode(aBlock, nBlock, &block, zTerm, nTerm, &iBlock); + } + if( rc==SQLITE_OK ){ + rc = fts3WriteSegment(p, iNewStart, block.a, block.n); + } + sqlite3_free(aBlock); + } + + /* Variable iNewStart now contains the first valid leaf node. */ + if( rc==SQLITE_OK && iNewStart ){ + sqlite3_stmt *pDel = 0; + rc = fts3SqlStmt(p, SQL_DELETE_SEGMENTS_RANGE, &pDel, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pDel, 1, iOldStart); + sqlite3_bind_int64(pDel, 2, iNewStart-1); + sqlite3_step(pDel); + rc = sqlite3_reset(pDel); + } + } + + if( rc==SQLITE_OK ){ + sqlite3_stmt *pChomp = 0; + rc = fts3SqlStmt(p, SQL_CHOMP_SEGDIR, &pChomp, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pChomp, 1, iNewStart); + sqlite3_bind_blob(pChomp, 2, root.a, root.n, SQLITE_STATIC); + sqlite3_bind_int64(pChomp, 3, iAbsLevel); + sqlite3_bind_int(pChomp, 4, iIdx); + sqlite3_step(pChomp); + rc = sqlite3_reset(pChomp); + sqlite3_bind_null(pChomp, 2); + } + } + + sqlite3_free(root.a); + sqlite3_free(block.a); + return rc; +} + +/* +** This function is called after an incrmental-merge operation has run to +** merge (or partially merge) two or more segments from absolute level +** iAbsLevel. +** +** Each input segment is either removed from the db completely (if all of +** its data was copied to the output segment by the incrmerge operation) +** or modified in place so that it no longer contains those entries that +** have been duplicated in the output segment. +*/ +static int fts3IncrmergeChomp( + Fts3Table *p, /* FTS table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level containing segments */ + Fts3MultiSegReader *pCsr, /* Chomp all segments opened by this cursor */ + int *pnRem /* Number of segments not deleted */ +){ + int i; + int nRem = 0; + int rc = SQLITE_OK; + + for(i=pCsr->nSegment-1; i>=0 && rc==SQLITE_OK; i--){ + Fts3SegReader *pSeg = 0; + int j; + + /* Find the Fts3SegReader object with Fts3SegReader.iIdx==i. It is hiding + ** somewhere in the pCsr->apSegment[] array. */ + for(j=0; ALWAYS(jnSegment); j++){ + pSeg = pCsr->apSegment[j]; + if( pSeg->iIdx==i ) break; + } + assert( jnSegment && pSeg->iIdx==i ); + + if( pSeg->aNode==0 ){ + /* Seg-reader is at EOF. Remove the entire input segment. */ + rc = fts3DeleteSegment(p, pSeg); + if( rc==SQLITE_OK ){ + rc = fts3RemoveSegdirEntry(p, iAbsLevel, pSeg->iIdx); + } + *pnRem = 0; + }else{ + /* The incremental merge did not copy all the data from this + ** segment to the upper level. The segment is modified in place + ** so that it contains no keys smaller than zTerm/nTerm. */ + const char *zTerm = pSeg->zTerm; + int nTerm = pSeg->nTerm; + rc = fts3TruncateSegment(p, iAbsLevel, pSeg->iIdx, zTerm, nTerm); + nRem++; + } + } + + if( rc==SQLITE_OK && nRem!=pCsr->nSegment ){ + rc = fts3RepackSegdirLevel(p, iAbsLevel); + } + + *pnRem = nRem; + return rc; +} + +/* +** Store an incr-merge hint in the database. +*/ +static int fts3IncrmergeHintStore(Fts3Table *p, Blob *pHint){ + sqlite3_stmt *pReplace = 0; + int rc; /* Return code */ + + rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pReplace, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int(pReplace, 1, FTS_STAT_INCRMERGEHINT); + sqlite3_bind_blob(pReplace, 2, pHint->a, pHint->n, SQLITE_STATIC); + sqlite3_step(pReplace); + rc = sqlite3_reset(pReplace); + sqlite3_bind_null(pReplace, 2); + } + + return rc; +} + +/* +** Load an incr-merge hint from the database. The incr-merge hint, if one +** exists, is stored in the rowid==1 row of the %_stat table. +** +** If successful, populate blob *pHint with the value read from the %_stat +** table and return SQLITE_OK. Otherwise, if an error occurs, return an +** SQLite error code. +*/ +static int fts3IncrmergeHintLoad(Fts3Table *p, Blob *pHint){ + sqlite3_stmt *pSelect = 0; + int rc; + + pHint->n = 0; + rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pSelect, 0); + if( rc==SQLITE_OK ){ + int rc2; + sqlite3_bind_int(pSelect, 1, FTS_STAT_INCRMERGEHINT); + if( SQLITE_ROW==sqlite3_step(pSelect) ){ + const char *aHint = sqlite3_column_blob(pSelect, 0); + int nHint = sqlite3_column_bytes(pSelect, 0); + if( aHint ){ + blobGrowBuffer(pHint, nHint, &rc); + if( rc==SQLITE_OK ){ + memcpy(pHint->a, aHint, nHint); + pHint->n = nHint; + } + } + } + rc2 = sqlite3_reset(pSelect); + if( rc==SQLITE_OK ) rc = rc2; + } + + return rc; +} + +/* +** If *pRc is not SQLITE_OK when this function is called, it is a no-op. +** Otherwise, append an entry to the hint stored in blob *pHint. Each entry +** consists of two varints, the absolute level number of the input segments +** and the number of input segments. +** +** If successful, leave *pRc set to SQLITE_OK and return. If an error occurs, +** set *pRc to an SQLite error code before returning. +*/ +static void fts3IncrmergeHintPush( + Blob *pHint, /* Hint blob to append to */ + i64 iAbsLevel, /* First varint to store in hint */ + int nInput, /* Second varint to store in hint */ + int *pRc /* IN/OUT: Error code */ +){ + blobGrowBuffer(pHint, pHint->n + 2*FTS3_VARINT_MAX, pRc); + if( *pRc==SQLITE_OK ){ + pHint->n += sqlite3Fts3PutVarint(&pHint->a[pHint->n], iAbsLevel); + pHint->n += sqlite3Fts3PutVarint(&pHint->a[pHint->n], (i64)nInput); + } +} + +/* +** Read the last entry (most recently pushed) from the hint blob *pHint +** and then remove the entry. Write the two values read to *piAbsLevel and +** *pnInput before returning. +** +** If no error occurs, return SQLITE_OK. If the hint blob in *pHint does +** not contain at least two valid varints, return SQLITE_CORRUPT_VTAB. +*/ +static int fts3IncrmergeHintPop(Blob *pHint, i64 *piAbsLevel, int *pnInput){ + const int nHint = pHint->n; + int i; + + i = pHint->n-1; + if( (pHint->a[i] & 0x80) ) return FTS_CORRUPT_VTAB; + while( i>0 && (pHint->a[i-1] & 0x80) ) i--; + if( i==0 ) return FTS_CORRUPT_VTAB; + i--; + while( i>0 && (pHint->a[i-1] & 0x80) ) i--; + + pHint->n = i; + i += sqlite3Fts3GetVarint(&pHint->a[i], piAbsLevel); + i += fts3GetVarint32(&pHint->a[i], pnInput); + assert( i<=nHint ); + if( i!=nHint ) return FTS_CORRUPT_VTAB; + + return SQLITE_OK; +} + + +/* +** Attempt an incremental merge that writes nMerge leaf blocks. +** +** Incremental merges happen nMin segments at a time. The segments +** to be merged are the nMin oldest segments (the ones with the smallest +** values for the _segdir.idx field) in the highest level that contains +** at least nMin segments. Multiple merges might occur in an attempt to +** write the quota of nMerge leaf blocks. +*/ +SQLITE_PRIVATE int sqlite3Fts3Incrmerge(Fts3Table *p, int nMerge, int nMin){ + int rc; /* Return code */ + int nRem = nMerge; /* Number of leaf pages yet to be written */ + Fts3MultiSegReader *pCsr; /* Cursor used to read input data */ + Fts3SegFilter *pFilter; /* Filter used with cursor pCsr */ + IncrmergeWriter *pWriter; /* Writer object */ + int nSeg = 0; /* Number of input segments */ + sqlite3_int64 iAbsLevel = 0; /* Absolute level number to work on */ + Blob hint = {0, 0, 0}; /* Hint read from %_stat table */ + int bDirtyHint = 0; /* True if blob 'hint' has been modified */ + + /* Allocate space for the cursor, filter and writer objects */ + const int nAlloc = sizeof(*pCsr) + sizeof(*pFilter) + sizeof(*pWriter); + pWriter = (IncrmergeWriter *)sqlite3_malloc(nAlloc); + if( !pWriter ) return SQLITE_NOMEM; + pFilter = (Fts3SegFilter *)&pWriter[1]; + pCsr = (Fts3MultiSegReader *)&pFilter[1]; + + rc = fts3IncrmergeHintLoad(p, &hint); + while( rc==SQLITE_OK && nRem>0 ){ + const i64 nMod = FTS3_SEGDIR_MAXLEVEL * p->nIndex; + sqlite3_stmt *pFindLevel = 0; /* SQL used to determine iAbsLevel */ + int bUseHint = 0; /* True if attempting to append */ + int iIdx = 0; /* Largest idx in level (iAbsLevel+1) */ + + /* Search the %_segdir table for the absolute level with the smallest + ** relative level number that contains at least nMin segments, if any. + ** If one is found, set iAbsLevel to the absolute level number and + ** nSeg to nMin. If no level with at least nMin segments can be found, + ** set nSeg to -1. + */ + rc = fts3SqlStmt(p, SQL_FIND_MERGE_LEVEL, &pFindLevel, 0); + sqlite3_bind_int(pFindLevel, 1, MAX(2, nMin)); + if( sqlite3_step(pFindLevel)==SQLITE_ROW ){ + iAbsLevel = sqlite3_column_int64(pFindLevel, 0); + nSeg = sqlite3_column_int(pFindLevel, 1); + assert( nSeg>=2 ); + }else{ + nSeg = -1; + } + rc = sqlite3_reset(pFindLevel); + + /* If the hint read from the %_stat table is not empty, check if the + ** last entry in it specifies a relative level smaller than or equal + ** to the level identified by the block above (if any). If so, this + ** iteration of the loop will work on merging at the hinted level. + */ + if( rc==SQLITE_OK && hint.n ){ + int nHint = hint.n; + sqlite3_int64 iHintAbsLevel = 0; /* Hint level */ + int nHintSeg = 0; /* Hint number of segments */ + + rc = fts3IncrmergeHintPop(&hint, &iHintAbsLevel, &nHintSeg); + if( nSeg<0 || (iAbsLevel % nMod) >= (iHintAbsLevel % nMod) ){ + /* Based on the scan in the block above, it is known that there + ** are no levels with a relative level smaller than that of + ** iAbsLevel with more than nSeg segments, or if nSeg is -1, + ** no levels with more than nMin segments. Use this to limit the + ** value of nHintSeg to avoid a large memory allocation in case the + ** merge-hint is corrupt*/ + iAbsLevel = iHintAbsLevel; + nSeg = MIN(MAX(nMin,nSeg), nHintSeg); + bUseHint = 1; + bDirtyHint = 1; + }else{ + /* This undoes the effect of the HintPop() above - so that no entry + ** is removed from the hint blob. */ + hint.n = nHint; + } + } + + /* If nSeg is less that zero, then there is no level with at least + ** nMin segments and no hint in the %_stat table. No work to do. + ** Exit early in this case. */ + if( nSeg<=0 ) break; + + assert( nMod<=0x7FFFFFFF ); + if( iAbsLevel<0 || iAbsLevel>(nMod<<32) ){ + rc = FTS_CORRUPT_VTAB; + break; + } + + /* Open a cursor to iterate through the contents of the oldest nSeg + ** indexes of absolute level iAbsLevel. If this cursor is opened using + ** the 'hint' parameters, it is possible that there are less than nSeg + ** segments available in level iAbsLevel. In this case, no work is + ** done on iAbsLevel - fall through to the next iteration of the loop + ** to start work on some other level. */ + memset(pWriter, 0, nAlloc); + pFilter->flags = FTS3_SEGMENT_REQUIRE_POS; + + if( rc==SQLITE_OK ){ + rc = fts3IncrmergeOutputIdx(p, iAbsLevel, &iIdx); + assert( bUseHint==1 || bUseHint==0 ); + if( iIdx==0 || (bUseHint && iIdx==1) ){ + int bIgnore = 0; + rc = fts3SegmentIsMaxLevel(p, iAbsLevel+1, &bIgnore); + if( bIgnore ){ + pFilter->flags |= FTS3_SEGMENT_IGNORE_EMPTY; + } + } + } + + if( rc==SQLITE_OK ){ + rc = fts3IncrmergeCsr(p, iAbsLevel, nSeg, pCsr); + } + if( SQLITE_OK==rc && pCsr->nSegment==nSeg + && SQLITE_OK==(rc = sqlite3Fts3SegReaderStart(p, pCsr, pFilter)) + ){ + int bEmpty = 0; + rc = sqlite3Fts3SegReaderStep(p, pCsr); + if( rc==SQLITE_OK ){ + bEmpty = 1; + }else if( rc!=SQLITE_ROW ){ + sqlite3Fts3SegReaderFinish(pCsr); + break; + } + if( bUseHint && iIdx>0 ){ + const char *zKey = pCsr->zTerm; + int nKey = pCsr->nTerm; + rc = fts3IncrmergeLoad(p, iAbsLevel, iIdx-1, zKey, nKey, pWriter); + }else{ + rc = fts3IncrmergeWriter(p, iAbsLevel, iIdx, pCsr, pWriter); + } + + if( rc==SQLITE_OK && pWriter->nLeafEst ){ + fts3LogMerge(nSeg, iAbsLevel); + if( bEmpty==0 ){ + do { + rc = fts3IncrmergeAppend(p, pWriter, pCsr); + if( rc==SQLITE_OK ) rc = sqlite3Fts3SegReaderStep(p, pCsr); + if( pWriter->nWork>=nRem && rc==SQLITE_ROW ) rc = SQLITE_OK; + }while( rc==SQLITE_ROW ); + } + + /* Update or delete the input segments */ + if( rc==SQLITE_OK ){ + nRem -= (1 + pWriter->nWork); + rc = fts3IncrmergeChomp(p, iAbsLevel, pCsr, &nSeg); + if( nSeg!=0 ){ + bDirtyHint = 1; + fts3IncrmergeHintPush(&hint, iAbsLevel, nSeg, &rc); + } + } + } + + if( nSeg!=0 ){ + pWriter->nLeafData = pWriter->nLeafData * -1; + } + fts3IncrmergeRelease(p, pWriter, &rc); + if( nSeg==0 && pWriter->bNoLeafData==0 ){ + fts3PromoteSegments(p, iAbsLevel+1, pWriter->nLeafData); + } + } + + sqlite3Fts3SegReaderFinish(pCsr); + } + + /* Write the hint values into the %_stat table for the next incr-merger */ + if( bDirtyHint && rc==SQLITE_OK ){ + rc = fts3IncrmergeHintStore(p, &hint); + } + + sqlite3_free(pWriter); + sqlite3_free(hint.a); + return rc; +} + +/* +** Convert the text beginning at *pz into an integer and return +** its value. Advance *pz to point to the first character past +** the integer. +** +** This function used for parameters to merge= and incrmerge= +** commands. +*/ +static int fts3Getint(const char **pz){ + const char *z = *pz; + int i = 0; + while( (*z)>='0' && (*z)<='9' && i<214748363 ) i = 10*i + *(z++) - '0'; + *pz = z; + return i; +} + +/* +** Process statements of the form: +** +** INSERT INTO table(table) VALUES('merge=A,B'); +** +** A and B are integers that decode to be the number of leaf pages +** written for the merge, and the minimum number of segments on a level +** before it will be selected for a merge, respectively. +*/ +static int fts3DoIncrmerge( + Fts3Table *p, /* FTS3 table handle */ + const char *zParam /* Nul-terminated string containing "A,B" */ +){ + int rc; + int nMin = (MergeCount(p) / 2); + int nMerge = 0; + const char *z = zParam; + + /* Read the first integer value */ + nMerge = fts3Getint(&z); + + /* If the first integer value is followed by a ',', read the second + ** integer value. */ + if( z[0]==',' && z[1]!='\0' ){ + z++; + nMin = fts3Getint(&z); + } + + if( z[0]!='\0' || nMin<2 ){ + rc = SQLITE_ERROR; + }else{ + rc = SQLITE_OK; + if( !p->bHasStat ){ + assert( p->bFts4==0 ); + sqlite3Fts3CreateStatTable(&rc, p); + } + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3Incrmerge(p, nMerge, nMin); + } + sqlite3Fts3SegmentsClose(p); + } + return rc; +} + +/* +** Process statements of the form: +** +** INSERT INTO table(table) VALUES('automerge=X'); +** +** where X is an integer. X==0 means to turn automerge off. X!=0 means +** turn it on. The setting is persistent. +*/ +static int fts3DoAutoincrmerge( + Fts3Table *p, /* FTS3 table handle */ + const char *zParam /* Nul-terminated string containing boolean */ +){ + int rc = SQLITE_OK; + sqlite3_stmt *pStmt = 0; + p->nAutoincrmerge = fts3Getint(&zParam); + if( p->nAutoincrmerge==1 || p->nAutoincrmerge>MergeCount(p) ){ + p->nAutoincrmerge = 8; + } + if( !p->bHasStat ){ + assert( p->bFts4==0 ); + sqlite3Fts3CreateStatTable(&rc, p); + if( rc ) return rc; + } + rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pStmt, 0); + if( rc ) return rc; + sqlite3_bind_int(pStmt, 1, FTS_STAT_AUTOINCRMERGE); + sqlite3_bind_int(pStmt, 2, p->nAutoincrmerge); + sqlite3_step(pStmt); + rc = sqlite3_reset(pStmt); + return rc; +} + +/* +** Return a 64-bit checksum for the FTS index entry specified by the +** arguments to this function. +*/ +static u64 fts3ChecksumEntry( + const char *zTerm, /* Pointer to buffer containing term */ + int nTerm, /* Size of zTerm in bytes */ + int iLangid, /* Language id for current row */ + int iIndex, /* Index (0..Fts3Table.nIndex-1) */ + i64 iDocid, /* Docid for current row. */ + int iCol, /* Column number */ + int iPos /* Position */ +){ + int i; + u64 ret = (u64)iDocid; + + ret += (ret<<3) + iLangid; + ret += (ret<<3) + iIndex; + ret += (ret<<3) + iCol; + ret += (ret<<3) + iPos; + for(i=0; inIndex-1) */ + int *pRc /* OUT: Return code */ +){ + Fts3SegFilter filter; + Fts3MultiSegReader csr; + int rc; + u64 cksum = 0; + + assert( *pRc==SQLITE_OK ); + + memset(&filter, 0, sizeof(filter)); + memset(&csr, 0, sizeof(csr)); + filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY; + filter.flags |= FTS3_SEGMENT_SCAN; + + rc = sqlite3Fts3SegReaderCursor( + p, iLangid, iIndex, FTS3_SEGCURSOR_ALL, 0, 0, 0, 1,&csr + ); + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3SegReaderStart(p, &csr, &filter); + } + + if( rc==SQLITE_OK ){ + while( SQLITE_ROW==(rc = sqlite3Fts3SegReaderStep(p, &csr)) ){ + char *pCsr = csr.aDoclist; + char *pEnd = &pCsr[csr.nDoclist]; + + i64 iDocid = 0; + i64 iCol = 0; + u64 iPos = 0; + + pCsr += sqlite3Fts3GetVarint(pCsr, &iDocid); + while( pCsrbDescIdx ){ + iDocid = (i64)((u64)iDocid - iVal); + }else{ + iDocid = (i64)((u64)iDocid + iVal); + } + } + }else{ + iPos += (iVal - 2); + cksum = cksum ^ fts3ChecksumEntry( + csr.zTerm, csr.nTerm, iLangid, iIndex, iDocid, + (int)iCol, (int)iPos + ); + } + } + } + } + } + sqlite3Fts3SegReaderFinish(&csr); + + *pRc = rc; + return cksum; +} + +/* +** Check if the contents of the FTS index match the current contents of the +** content table. If no error occurs and the contents do match, set *pbOk +** to true and return SQLITE_OK. Or if the contents do not match, set *pbOk +** to false before returning. +** +** If an error occurs (e.g. an OOM or IO error), return an SQLite error +** code. The final value of *pbOk is undefined in this case. +*/ +static int fts3IntegrityCheck(Fts3Table *p, int *pbOk){ + int rc = SQLITE_OK; /* Return code */ + u64 cksum1 = 0; /* Checksum based on FTS index contents */ + u64 cksum2 = 0; /* Checksum based on %_content contents */ + sqlite3_stmt *pAllLangid = 0; /* Statement to return all language-ids */ + + /* This block calculates the checksum according to the FTS index. */ + rc = fts3SqlStmt(p, SQL_SELECT_ALL_LANGID, &pAllLangid, 0); + if( rc==SQLITE_OK ){ + int rc2; + sqlite3_bind_int(pAllLangid, 1, p->iPrevLangid); + sqlite3_bind_int(pAllLangid, 2, p->nIndex); + while( rc==SQLITE_OK && sqlite3_step(pAllLangid)==SQLITE_ROW ){ + int iLangid = sqlite3_column_int(pAllLangid, 0); + int i; + for(i=0; inIndex; i++){ + cksum1 = cksum1 ^ fts3ChecksumIndex(p, iLangid, i, &rc); + } + } + rc2 = sqlite3_reset(pAllLangid); + if( rc==SQLITE_OK ) rc = rc2; + } + + /* This block calculates the checksum according to the %_content table */ + if( rc==SQLITE_OK ){ + sqlite3_tokenizer_module const *pModule = p->pTokenizer->pModule; + sqlite3_stmt *pStmt = 0; + char *zSql; + + zSql = sqlite3_mprintf("SELECT %s" , p->zReadExprlist); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); + sqlite3_free(zSql); + } + + while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ + i64 iDocid = sqlite3_column_int64(pStmt, 0); + int iLang = langidFromSelect(p, pStmt); + int iCol; + + for(iCol=0; rc==SQLITE_OK && iColnColumn; iCol++){ + if( p->abNotindexed[iCol]==0 ){ + const char *zText = (const char *)sqlite3_column_text(pStmt, iCol+1); + sqlite3_tokenizer_cursor *pT = 0; + + rc = sqlite3Fts3OpenTokenizer(p->pTokenizer, iLang, zText, -1, &pT); + while( rc==SQLITE_OK ){ + char const *zToken; /* Buffer containing token */ + int nToken = 0; /* Number of bytes in token */ + int iDum1 = 0, iDum2 = 0; /* Dummy variables */ + int iPos = 0; /* Position of token in zText */ + + rc = pModule->xNext(pT, &zToken, &nToken, &iDum1, &iDum2, &iPos); + if( rc==SQLITE_OK ){ + int i; + cksum2 = cksum2 ^ fts3ChecksumEntry( + zToken, nToken, iLang, 0, iDocid, iCol, iPos + ); + for(i=1; inIndex; i++){ + if( p->aIndex[i].nPrefix<=nToken ){ + cksum2 = cksum2 ^ fts3ChecksumEntry( + zToken, p->aIndex[i].nPrefix, iLang, i, iDocid, iCol, iPos + ); + } + } + } + } + if( pT ) pModule->xClose(pT); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + } + } + } + + sqlite3_finalize(pStmt); + } + + *pbOk = (cksum1==cksum2); + return rc; +} + +/* +** Run the integrity-check. If no error occurs and the current contents of +** the FTS index are correct, return SQLITE_OK. Or, if the contents of the +** FTS index are incorrect, return SQLITE_CORRUPT_VTAB. +** +** Or, if an error (e.g. an OOM or IO error) occurs, return an SQLite +** error code. +** +** The integrity-check works as follows. For each token and indexed token +** prefix in the document set, a 64-bit checksum is calculated (by code +** in fts3ChecksumEntry()) based on the following: +** +** + The index number (0 for the main index, 1 for the first prefix +** index etc.), +** + The token (or token prefix) text itself, +** + The language-id of the row it appears in, +** + The docid of the row it appears in, +** + The column it appears in, and +** + The tokens position within that column. +** +** The checksums for all entries in the index are XORed together to create +** a single checksum for the entire index. +** +** The integrity-check code calculates the same checksum in two ways: +** +** 1. By scanning the contents of the FTS index, and +** 2. By scanning and tokenizing the content table. +** +** If the two checksums are identical, the integrity-check is deemed to have +** passed. +*/ +static int fts3DoIntegrityCheck( + Fts3Table *p /* FTS3 table handle */ +){ + int rc; + int bOk = 0; + rc = fts3IntegrityCheck(p, &bOk); + if( rc==SQLITE_OK && bOk==0 ) rc = FTS_CORRUPT_VTAB; + return rc; +} + +/* +** Handle a 'special' INSERT of the form: +** +** "INSERT INTO tbl(tbl) VALUES()" +** +** Argument pVal contains the result of . Currently the only +** meaningful value to insert is the text 'optimize'. +*/ +static int fts3SpecialInsert(Fts3Table *p, sqlite3_value *pVal){ + int rc = SQLITE_ERROR; /* Return Code */ + const char *zVal = (const char *)sqlite3_value_text(pVal); + int nVal = sqlite3_value_bytes(pVal); + + if( !zVal ){ + return SQLITE_NOMEM; + }else if( nVal==8 && 0==sqlite3_strnicmp(zVal, "optimize", 8) ){ + rc = fts3DoOptimize(p, 0); + }else if( nVal==7 && 0==sqlite3_strnicmp(zVal, "rebuild", 7) ){ + rc = fts3DoRebuild(p); + }else if( nVal==15 && 0==sqlite3_strnicmp(zVal, "integrity-check", 15) ){ + rc = fts3DoIntegrityCheck(p); + }else if( nVal>6 && 0==sqlite3_strnicmp(zVal, "merge=", 6) ){ + rc = fts3DoIncrmerge(p, &zVal[6]); + }else if( nVal>10 && 0==sqlite3_strnicmp(zVal, "automerge=", 10) ){ + rc = fts3DoAutoincrmerge(p, &zVal[10]); +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + }else{ + int v; + if( nVal>9 && 0==sqlite3_strnicmp(zVal, "nodesize=", 9) ){ + v = atoi(&zVal[9]); + if( v>=24 && v<=p->nPgsz-35 ) p->nNodeSize = v; + rc = SQLITE_OK; + }else if( nVal>11 && 0==sqlite3_strnicmp(zVal, "maxpending=", 9) ){ + v = atoi(&zVal[11]); + if( v>=64 && v<=FTS3_MAX_PENDING_DATA ) p->nMaxPendingData = v; + rc = SQLITE_OK; + }else if( nVal>21 && 0==sqlite3_strnicmp(zVal,"test-no-incr-doclist=",21) ){ + p->bNoIncrDoclist = atoi(&zVal[21]); + rc = SQLITE_OK; + }else if( nVal>11 && 0==sqlite3_strnicmp(zVal,"mergecount=",11) ){ + v = atoi(&zVal[11]); + if( v>=4 && v<=FTS3_MERGE_COUNT && (v&1)==0 ) p->nMergeCount = v; + rc = SQLITE_OK; + } +#endif + } + return rc; +} + +#ifndef SQLITE_DISABLE_FTS4_DEFERRED +/* +** Delete all cached deferred doclists. Deferred doclists are cached +** (allocated) by the sqlite3Fts3CacheDeferredDoclists() function. +*/ +SQLITE_PRIVATE void sqlite3Fts3FreeDeferredDoclists(Fts3Cursor *pCsr){ + Fts3DeferredToken *pDef; + for(pDef=pCsr->pDeferred; pDef; pDef=pDef->pNext){ + fts3PendingListDelete(pDef->pList); + pDef->pList = 0; + } +} + +/* +** Free all entries in the pCsr->pDeffered list. Entries are added to +** this list using sqlite3Fts3DeferToken(). +*/ +SQLITE_PRIVATE void sqlite3Fts3FreeDeferredTokens(Fts3Cursor *pCsr){ + Fts3DeferredToken *pDef; + Fts3DeferredToken *pNext; + for(pDef=pCsr->pDeferred; pDef; pDef=pNext){ + pNext = pDef->pNext; + fts3PendingListDelete(pDef->pList); + sqlite3_free(pDef); + } + pCsr->pDeferred = 0; +} + +/* +** Generate deferred-doclists for all tokens in the pCsr->pDeferred list +** based on the row that pCsr currently points to. +** +** A deferred-doclist is like any other doclist with position information +** included, except that it only contains entries for a single row of the +** table, not for all rows. +*/ +SQLITE_PRIVATE int sqlite3Fts3CacheDeferredDoclists(Fts3Cursor *pCsr){ + int rc = SQLITE_OK; /* Return code */ + if( pCsr->pDeferred ){ + int i; /* Used to iterate through table columns */ + sqlite3_int64 iDocid; /* Docid of the row pCsr points to */ + Fts3DeferredToken *pDef; /* Used to iterate through deferred tokens */ + + Fts3Table *p = (Fts3Table *)pCsr->base.pVtab; + sqlite3_tokenizer *pT = p->pTokenizer; + sqlite3_tokenizer_module const *pModule = pT->pModule; + + assert( pCsr->isRequireSeek==0 ); + iDocid = sqlite3_column_int64(pCsr->pStmt, 0); + + for(i=0; inColumn && rc==SQLITE_OK; i++){ + if( p->abNotindexed[i]==0 ){ + const char *zText = (const char *)sqlite3_column_text(pCsr->pStmt, i+1); + sqlite3_tokenizer_cursor *pTC = 0; + + rc = sqlite3Fts3OpenTokenizer(pT, pCsr->iLangid, zText, -1, &pTC); + while( rc==SQLITE_OK ){ + char const *zToken; /* Buffer containing token */ + int nToken = 0; /* Number of bytes in token */ + int iDum1 = 0, iDum2 = 0; /* Dummy variables */ + int iPos = 0; /* Position of token in zText */ + + rc = pModule->xNext(pTC, &zToken, &nToken, &iDum1, &iDum2, &iPos); + for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){ + Fts3PhraseToken *pPT = pDef->pToken; + if( (pDef->iCol>=p->nColumn || pDef->iCol==i) + && (pPT->bFirst==0 || iPos==0) + && (pPT->n==nToken || (pPT->isPrefix && pPT->nz, pPT->n)) + ){ + fts3PendingListAppend(&pDef->pList, iDocid, i, iPos, &rc); + } + } + } + if( pTC ) pModule->xClose(pTC); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + } + } + + for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){ + if( pDef->pList ){ + rc = fts3PendingListAppendVarint(&pDef->pList, 0); + } + } + } + + return rc; +} + +SQLITE_PRIVATE int sqlite3Fts3DeferredTokenList( + Fts3DeferredToken *p, + char **ppData, + int *pnData +){ + char *pRet; + int nSkip; + sqlite3_int64 dummy; + + *ppData = 0; + *pnData = 0; + + if( p->pList==0 ){ + return SQLITE_OK; + } + + pRet = (char *)sqlite3_malloc(p->pList->nData); + if( !pRet ) return SQLITE_NOMEM; + + nSkip = sqlite3Fts3GetVarint(p->pList->aData, &dummy); + *pnData = p->pList->nData - nSkip; + *ppData = pRet; + + memcpy(pRet, &p->pList->aData[nSkip], *pnData); + return SQLITE_OK; +} + +/* +** Add an entry for token pToken to the pCsr->pDeferred list. +*/ +SQLITE_PRIVATE int sqlite3Fts3DeferToken( + Fts3Cursor *pCsr, /* Fts3 table cursor */ + Fts3PhraseToken *pToken, /* Token to defer */ + int iCol /* Column that token must appear in (or -1) */ +){ + Fts3DeferredToken *pDeferred; + pDeferred = sqlite3_malloc(sizeof(*pDeferred)); + if( !pDeferred ){ + return SQLITE_NOMEM; + } + memset(pDeferred, 0, sizeof(*pDeferred)); + pDeferred->pToken = pToken; + pDeferred->pNext = pCsr->pDeferred; + pDeferred->iCol = iCol; + pCsr->pDeferred = pDeferred; + + assert( pToken->pDeferred==0 ); + pToken->pDeferred = pDeferred; + + return SQLITE_OK; +} +#endif + +/* +** SQLite value pRowid contains the rowid of a row that may or may not be +** present in the FTS3 table. If it is, delete it and adjust the contents +** of subsiduary data structures accordingly. +*/ +static int fts3DeleteByRowid( + Fts3Table *p, + sqlite3_value *pRowid, + int *pnChng, /* IN/OUT: Decrement if row is deleted */ + u32 *aSzDel +){ + int rc = SQLITE_OK; /* Return code */ + int bFound = 0; /* True if *pRowid really is in the table */ + + fts3DeleteTerms(&rc, p, pRowid, aSzDel, &bFound); + if( bFound && rc==SQLITE_OK ){ + int isEmpty = 0; /* Deleting *pRowid leaves the table empty */ + rc = fts3IsEmpty(p, pRowid, &isEmpty); + if( rc==SQLITE_OK ){ + if( isEmpty ){ + /* Deleting this row means the whole table is empty. In this case + ** delete the contents of all three tables and throw away any + ** data in the pendingTerms hash table. */ + rc = fts3DeleteAll(p, 1); + *pnChng = 0; + memset(aSzDel, 0, sizeof(u32) * (p->nColumn+1) * 2); + }else{ + *pnChng = *pnChng - 1; + if( p->zContentTbl==0 ){ + fts3SqlExec(&rc, p, SQL_DELETE_CONTENT, &pRowid); + } + if( p->bHasDocsize ){ + fts3SqlExec(&rc, p, SQL_DELETE_DOCSIZE, &pRowid); + } + } + } + } + + return rc; +} + +/* +** This function does the work for the xUpdate method of FTS3 virtual +** tables. The schema of the virtual table being: +** +** CREATE TABLE
    ( +** , +**
    HIDDEN, +** docid HIDDEN, +** HIDDEN +** ); +** +** +*/ +SQLITE_PRIVATE int sqlite3Fts3UpdateMethod( + sqlite3_vtab *pVtab, /* FTS3 vtab object */ + int nArg, /* Size of argument array */ + sqlite3_value **apVal, /* Array of arguments */ + sqlite_int64 *pRowid /* OUT: The affected (or effected) rowid */ +){ + Fts3Table *p = (Fts3Table *)pVtab; + int rc = SQLITE_OK; /* Return Code */ + u32 *aSzIns = 0; /* Sizes of inserted documents */ + u32 *aSzDel = 0; /* Sizes of deleted documents */ + int nChng = 0; /* Net change in number of documents */ + int bInsertDone = 0; + + /* At this point it must be known if the %_stat table exists or not. + ** So bHasStat may not be 2. */ + assert( p->bHasStat==0 || p->bHasStat==1 ); + + assert( p->pSegments==0 ); + assert( + nArg==1 /* DELETE operations */ + || nArg==(2 + p->nColumn + 3) /* INSERT or UPDATE operations */ + ); + + /* Check for a "special" INSERT operation. One of the form: + ** + ** INSERT INTO xyz(xyz) VALUES('command'); + */ + if( nArg>1 + && sqlite3_value_type(apVal[0])==SQLITE_NULL + && sqlite3_value_type(apVal[p->nColumn+2])!=SQLITE_NULL + ){ + rc = fts3SpecialInsert(p, apVal[p->nColumn+2]); + goto update_out; + } + + if( nArg>1 && sqlite3_value_int(apVal[2 + p->nColumn + 2])<0 ){ + rc = SQLITE_CONSTRAINT; + goto update_out; + } + + /* Allocate space to hold the change in document sizes */ + aSzDel = sqlite3_malloc64(sizeof(aSzDel[0])*((sqlite3_int64)p->nColumn+1)*2); + if( aSzDel==0 ){ + rc = SQLITE_NOMEM; + goto update_out; + } + aSzIns = &aSzDel[p->nColumn+1]; + memset(aSzDel, 0, sizeof(aSzDel[0])*(p->nColumn+1)*2); + + rc = fts3Writelock(p); + if( rc!=SQLITE_OK ) goto update_out; + + /* If this is an INSERT operation, or an UPDATE that modifies the rowid + ** value, then this operation requires constraint handling. + ** + ** If the on-conflict mode is REPLACE, this means that the existing row + ** should be deleted from the database before inserting the new row. Or, + ** if the on-conflict mode is other than REPLACE, then this method must + ** detect the conflict and return SQLITE_CONSTRAINT before beginning to + ** modify the database file. + */ + if( nArg>1 && p->zContentTbl==0 ){ + /* Find the value object that holds the new rowid value. */ + sqlite3_value *pNewRowid = apVal[3+p->nColumn]; + if( sqlite3_value_type(pNewRowid)==SQLITE_NULL ){ + pNewRowid = apVal[1]; + } + + if( sqlite3_value_type(pNewRowid)!=SQLITE_NULL && ( + sqlite3_value_type(apVal[0])==SQLITE_NULL + || sqlite3_value_int64(apVal[0])!=sqlite3_value_int64(pNewRowid) + )){ + /* The new rowid is not NULL (in this case the rowid will be + ** automatically assigned and there is no chance of a conflict), and + ** the statement is either an INSERT or an UPDATE that modifies the + ** rowid column. So if the conflict mode is REPLACE, then delete any + ** existing row with rowid=pNewRowid. + ** + ** Or, if the conflict mode is not REPLACE, insert the new record into + ** the %_content table. If we hit the duplicate rowid constraint (or any + ** other error) while doing so, return immediately. + ** + ** This branch may also run if pNewRowid contains a value that cannot + ** be losslessly converted to an integer. In this case, the eventual + ** call to fts3InsertData() (either just below or further on in this + ** function) will return SQLITE_MISMATCH. If fts3DeleteByRowid is + ** invoked, it will delete zero rows (since no row will have + ** docid=$pNewRowid if $pNewRowid is not an integer value). + */ + if( sqlite3_vtab_on_conflict(p->db)==SQLITE_REPLACE ){ + rc = fts3DeleteByRowid(p, pNewRowid, &nChng, aSzDel); + }else{ + rc = fts3InsertData(p, apVal, pRowid); + bInsertDone = 1; + } + } + } + if( rc!=SQLITE_OK ){ + goto update_out; + } + + /* If this is a DELETE or UPDATE operation, remove the old record. */ + if( sqlite3_value_type(apVal[0])!=SQLITE_NULL ){ + assert( sqlite3_value_type(apVal[0])==SQLITE_INTEGER ); + rc = fts3DeleteByRowid(p, apVal[0], &nChng, aSzDel); + } + + /* If this is an INSERT or UPDATE operation, insert the new record. */ + if( nArg>1 && rc==SQLITE_OK ){ + int iLangid = sqlite3_value_int(apVal[2 + p->nColumn + 2]); + if( bInsertDone==0 ){ + rc = fts3InsertData(p, apVal, pRowid); + if( rc==SQLITE_CONSTRAINT && p->zContentTbl==0 ){ + rc = FTS_CORRUPT_VTAB; + } + } + if( rc==SQLITE_OK ){ + rc = fts3PendingTermsDocid(p, 0, iLangid, *pRowid); + } + if( rc==SQLITE_OK ){ + assert( p->iPrevDocid==*pRowid ); + rc = fts3InsertTerms(p, iLangid, apVal, aSzIns); + } + if( p->bHasDocsize ){ + fts3InsertDocsize(&rc, p, aSzIns); + } + nChng++; + } + + if( p->bFts4 ){ + fts3UpdateDocTotals(&rc, p, aSzIns, aSzDel, nChng); + } + + update_out: + sqlite3_free(aSzDel); + sqlite3Fts3SegmentsClose(p); + return rc; +} + +/* +** Flush any data in the pending-terms hash table to disk. If successful, +** merge all segments in the database (including the new segment, if +** there was any data to flush) into a single segment. +*/ +SQLITE_PRIVATE int sqlite3Fts3Optimize(Fts3Table *p){ + int rc; + rc = sqlite3_exec(p->db, "SAVEPOINT fts3", 0, 0, 0); + if( rc==SQLITE_OK ){ + rc = fts3DoOptimize(p, 1); + if( rc==SQLITE_OK || rc==SQLITE_DONE ){ + int rc2 = sqlite3_exec(p->db, "RELEASE fts3", 0, 0, 0); + if( rc2!=SQLITE_OK ) rc = rc2; + }else{ + sqlite3_exec(p->db, "ROLLBACK TO fts3", 0, 0, 0); + sqlite3_exec(p->db, "RELEASE fts3", 0, 0, 0); + } + } + sqlite3Fts3SegmentsClose(p); + return rc; +} + +#endif + +/************** End of fts3_write.c ******************************************/ +/************** Begin file fts3_snippet.c ************************************/ +/* +** 2009 Oct 23 +** +** 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. +** +****************************************************************************** +*/ + +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ + +/* +** Characters that may appear in the second argument to matchinfo(). +*/ +#define FTS3_MATCHINFO_NPHRASE 'p' /* 1 value */ +#define FTS3_MATCHINFO_NCOL 'c' /* 1 value */ +#define FTS3_MATCHINFO_NDOC 'n' /* 1 value */ +#define FTS3_MATCHINFO_AVGLENGTH 'a' /* nCol values */ +#define FTS3_MATCHINFO_LENGTH 'l' /* nCol values */ +#define FTS3_MATCHINFO_LCS 's' /* nCol values */ +#define FTS3_MATCHINFO_HITS 'x' /* 3*nCol*nPhrase values */ +#define FTS3_MATCHINFO_LHITS 'y' /* nCol*nPhrase values */ +#define FTS3_MATCHINFO_LHITS_BM 'b' /* nCol*nPhrase values */ + +/* +** The default value for the second argument to matchinfo(). +*/ +#define FTS3_MATCHINFO_DEFAULT "pcx" + + +/* +** Used as an fts3ExprIterate() context when loading phrase doclists to +** Fts3Expr.aDoclist[]/nDoclist. +*/ +typedef struct LoadDoclistCtx LoadDoclistCtx; +struct LoadDoclistCtx { + Fts3Cursor *pCsr; /* FTS3 Cursor */ + int nPhrase; /* Number of phrases seen so far */ + int nToken; /* Number of tokens seen so far */ +}; + +/* +** The following types are used as part of the implementation of the +** fts3BestSnippet() routine. +*/ +typedef struct SnippetIter SnippetIter; +typedef struct SnippetPhrase SnippetPhrase; +typedef struct SnippetFragment SnippetFragment; + +struct SnippetIter { + Fts3Cursor *pCsr; /* Cursor snippet is being generated from */ + int iCol; /* Extract snippet from this column */ + int nSnippet; /* Requested snippet length (in tokens) */ + int nPhrase; /* Number of phrases in query */ + SnippetPhrase *aPhrase; /* Array of size nPhrase */ + int iCurrent; /* First token of current snippet */ +}; + +struct SnippetPhrase { + int nToken; /* Number of tokens in phrase */ + char *pList; /* Pointer to start of phrase position list */ + int iHead; /* Next value in position list */ + char *pHead; /* Position list data following iHead */ + int iTail; /* Next value in trailing position list */ + char *pTail; /* Position list data following iTail */ +}; + +struct SnippetFragment { + int iCol; /* Column snippet is extracted from */ + int iPos; /* Index of first token in snippet */ + u64 covered; /* Mask of query phrases covered */ + u64 hlmask; /* Mask of snippet terms to highlight */ +}; + +/* +** This type is used as an fts3ExprIterate() context object while +** accumulating the data returned by the matchinfo() function. +*/ +typedef struct MatchInfo MatchInfo; +struct MatchInfo { + Fts3Cursor *pCursor; /* FTS3 Cursor */ + int nCol; /* Number of columns in table */ + int nPhrase; /* Number of matchable phrases in query */ + sqlite3_int64 nDoc; /* Number of docs in database */ + char flag; + u32 *aMatchinfo; /* Pre-allocated buffer */ +}; + +/* +** An instance of this structure is used to manage a pair of buffers, each +** (nElem * sizeof(u32)) bytes in size. See the MatchinfoBuffer code below +** for details. +*/ +struct MatchinfoBuffer { + u8 aRef[3]; + int nElem; + int bGlobal; /* Set if global data is loaded */ + char *zMatchinfo; + u32 aMatchinfo[1]; +}; + + +/* +** The snippet() and offsets() functions both return text values. An instance +** of the following structure is used to accumulate those values while the +** functions are running. See fts3StringAppend() for details. +*/ +typedef struct StrBuffer StrBuffer; +struct StrBuffer { + char *z; /* Pointer to buffer containing string */ + int n; /* Length of z in bytes (excl. nul-term) */ + int nAlloc; /* Allocated size of buffer z in bytes */ +}; + + +/************************************************************************* +** Start of MatchinfoBuffer code. +*/ + +/* +** Allocate a two-slot MatchinfoBuffer object. +*/ +static MatchinfoBuffer *fts3MIBufferNew(size_t nElem, const char *zMatchinfo){ + MatchinfoBuffer *pRet; + sqlite3_int64 nByte = sizeof(u32) * (2*(sqlite3_int64)nElem + 1) + + sizeof(MatchinfoBuffer); + sqlite3_int64 nStr = strlen(zMatchinfo); + + pRet = sqlite3_malloc64(nByte + nStr+1); + if( pRet ){ + memset(pRet, 0, nByte); + pRet->aMatchinfo[0] = (u8*)(&pRet->aMatchinfo[1]) - (u8*)pRet; + pRet->aMatchinfo[1+nElem] = pRet->aMatchinfo[0] + + sizeof(u32)*((int)nElem+1); + pRet->nElem = (int)nElem; + pRet->zMatchinfo = ((char*)pRet) + nByte; + memcpy(pRet->zMatchinfo, zMatchinfo, nStr+1); + pRet->aRef[0] = 1; + } + + return pRet; +} + +static void fts3MIBufferFree(void *p){ + MatchinfoBuffer *pBuf = (MatchinfoBuffer*)((u8*)p - ((u32*)p)[-1]); + + assert( (u32*)p==&pBuf->aMatchinfo[1] + || (u32*)p==&pBuf->aMatchinfo[pBuf->nElem+2] + ); + if( (u32*)p==&pBuf->aMatchinfo[1] ){ + pBuf->aRef[1] = 0; + }else{ + pBuf->aRef[2] = 0; + } + + if( pBuf->aRef[0]==0 && pBuf->aRef[1]==0 && pBuf->aRef[2]==0 ){ + sqlite3_free(pBuf); + } +} + +static void (*fts3MIBufferAlloc(MatchinfoBuffer *p, u32 **paOut))(void*){ + void (*xRet)(void*) = 0; + u32 *aOut = 0; + + if( p->aRef[1]==0 ){ + p->aRef[1] = 1; + aOut = &p->aMatchinfo[1]; + xRet = fts3MIBufferFree; + } + else if( p->aRef[2]==0 ){ + p->aRef[2] = 1; + aOut = &p->aMatchinfo[p->nElem+2]; + xRet = fts3MIBufferFree; + }else{ + aOut = (u32*)sqlite3_malloc64(p->nElem * sizeof(u32)); + if( aOut ){ + xRet = sqlite3_free; + if( p->bGlobal ) memcpy(aOut, &p->aMatchinfo[1], p->nElem*sizeof(u32)); + } + } + + *paOut = aOut; + return xRet; +} + +static void fts3MIBufferSetGlobal(MatchinfoBuffer *p){ + p->bGlobal = 1; + memcpy(&p->aMatchinfo[2+p->nElem], &p->aMatchinfo[1], p->nElem*sizeof(u32)); +} + +/* +** Free a MatchinfoBuffer object allocated using fts3MIBufferNew() +*/ +SQLITE_PRIVATE void sqlite3Fts3MIBufferFree(MatchinfoBuffer *p){ + if( p ){ + assert( p->aRef[0]==1 ); + p->aRef[0] = 0; + if( p->aRef[0]==0 && p->aRef[1]==0 && p->aRef[2]==0 ){ + sqlite3_free(p); + } + } +} + +/* +** End of MatchinfoBuffer code. +*************************************************************************/ + + +/* +** This function is used to help iterate through a position-list. A position +** list is a list of unique integers, sorted from smallest to largest. Each +** element of the list is represented by an FTS3 varint that takes the value +** of the difference between the current element and the previous one plus +** two. For example, to store the position-list: +** +** 4 9 113 +** +** the three varints: +** +** 6 7 106 +** +** are encoded. +** +** When this function is called, *pp points to the start of an element of +** the list. *piPos contains the value of the previous entry in the list. +** After it returns, *piPos contains the value of the next element of the +** list and *pp is advanced to the following varint. +*/ +static void fts3GetDeltaPosition(char **pp, int *piPos){ + int iVal; + *pp += fts3GetVarint32(*pp, &iVal); + *piPos += (iVal-2); +} + +/* +** Helper function for fts3ExprIterate() (see below). +*/ +static int fts3ExprIterate2( + Fts3Expr *pExpr, /* Expression to iterate phrases of */ + int *piPhrase, /* Pointer to phrase counter */ + int (*x)(Fts3Expr*,int,void*), /* Callback function to invoke for phrases */ + void *pCtx /* Second argument to pass to callback */ +){ + int rc; /* Return code */ + int eType = pExpr->eType; /* Type of expression node pExpr */ + + if( eType!=FTSQUERY_PHRASE ){ + assert( pExpr->pLeft && pExpr->pRight ); + rc = fts3ExprIterate2(pExpr->pLeft, piPhrase, x, pCtx); + if( rc==SQLITE_OK && eType!=FTSQUERY_NOT ){ + rc = fts3ExprIterate2(pExpr->pRight, piPhrase, x, pCtx); + } + }else{ + rc = x(pExpr, *piPhrase, pCtx); + (*piPhrase)++; + } + return rc; +} + +/* +** Iterate through all phrase nodes in an FTS3 query, except those that +** are part of a sub-tree that is the right-hand-side of a NOT operator. +** For each phrase node found, the supplied callback function is invoked. +** +** If the callback function returns anything other than SQLITE_OK, +** the iteration is abandoned and the error code returned immediately. +** Otherwise, SQLITE_OK is returned after a callback has been made for +** all eligible phrase nodes. +*/ +static int fts3ExprIterate( + Fts3Expr *pExpr, /* Expression to iterate phrases of */ + int (*x)(Fts3Expr*,int,void*), /* Callback function to invoke for phrases */ + void *pCtx /* Second argument to pass to callback */ +){ + int iPhrase = 0; /* Variable used as the phrase counter */ + return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx); +} + + +/* +** This is an fts3ExprIterate() callback used while loading the doclists +** for each phrase into Fts3Expr.aDoclist[]/nDoclist. See also +** fts3ExprLoadDoclists(). +*/ +static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, int iPhrase, void *ctx){ + int rc = SQLITE_OK; + Fts3Phrase *pPhrase = pExpr->pPhrase; + LoadDoclistCtx *p = (LoadDoclistCtx *)ctx; + + UNUSED_PARAMETER(iPhrase); + + p->nPhrase++; + p->nToken += pPhrase->nToken; + + return rc; +} + +/* +** Load the doclists for each phrase in the query associated with FTS3 cursor +** pCsr. +** +** If pnPhrase is not NULL, then *pnPhrase is set to the number of matchable +** phrases in the expression (all phrases except those directly or +** indirectly descended from the right-hand-side of a NOT operator). If +** pnToken is not NULL, then it is set to the number of tokens in all +** matchable phrases of the expression. +*/ +static int fts3ExprLoadDoclists( + Fts3Cursor *pCsr, /* Fts3 cursor for current query */ + int *pnPhrase, /* OUT: Number of phrases in query */ + int *pnToken /* OUT: Number of tokens in query */ +){ + int rc; /* Return Code */ + LoadDoclistCtx sCtx = {0,0,0}; /* Context for fts3ExprIterate() */ + sCtx.pCsr = pCsr; + rc = fts3ExprIterate(pCsr->pExpr, fts3ExprLoadDoclistsCb, (void *)&sCtx); + if( pnPhrase ) *pnPhrase = sCtx.nPhrase; + if( pnToken ) *pnToken = sCtx.nToken; + return rc; +} + +static int fts3ExprPhraseCountCb(Fts3Expr *pExpr, int iPhrase, void *ctx){ + (*(int *)ctx)++; + pExpr->iPhrase = iPhrase; + return SQLITE_OK; +} +static int fts3ExprPhraseCount(Fts3Expr *pExpr){ + int nPhrase = 0; + (void)fts3ExprIterate(pExpr, fts3ExprPhraseCountCb, (void *)&nPhrase); + return nPhrase; +} + +/* +** Advance the position list iterator specified by the first two +** arguments so that it points to the first element with a value greater +** than or equal to parameter iNext. +*/ +static void fts3SnippetAdvance(char **ppIter, int *piIter, int iNext){ + char *pIter = *ppIter; + if( pIter ){ + int iIter = *piIter; + + while( iIteriCurrent<0 ){ + /* The SnippetIter object has just been initialized. The first snippet + ** candidate always starts at offset 0 (even if this candidate has a + ** score of 0.0). + */ + pIter->iCurrent = 0; + + /* Advance the 'head' iterator of each phrase to the first offset that + ** is greater than or equal to (iNext+nSnippet). + */ + for(i=0; inPhrase; i++){ + SnippetPhrase *pPhrase = &pIter->aPhrase[i]; + fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, pIter->nSnippet); + } + }else{ + int iStart; + int iEnd = 0x7FFFFFFF; + + for(i=0; inPhrase; i++){ + SnippetPhrase *pPhrase = &pIter->aPhrase[i]; + if( pPhrase->pHead && pPhrase->iHeadiHead; + } + } + if( iEnd==0x7FFFFFFF ){ + return 1; + } + + pIter->iCurrent = iStart = iEnd - pIter->nSnippet + 1; + for(i=0; inPhrase; i++){ + SnippetPhrase *pPhrase = &pIter->aPhrase[i]; + fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, iEnd+1); + fts3SnippetAdvance(&pPhrase->pTail, &pPhrase->iTail, iStart); + } + } + + return 0; +} + +/* +** Retrieve information about the current candidate snippet of snippet +** iterator pIter. +*/ +static void fts3SnippetDetails( + SnippetIter *pIter, /* Snippet iterator */ + u64 mCovered, /* Bitmask of phrases already covered */ + int *piToken, /* OUT: First token of proposed snippet */ + int *piScore, /* OUT: "Score" for this snippet */ + u64 *pmCover, /* OUT: Bitmask of phrases covered */ + u64 *pmHighlight /* OUT: Bitmask of terms to highlight */ +){ + int iStart = pIter->iCurrent; /* First token of snippet */ + int iScore = 0; /* Score of this snippet */ + int i; /* Loop counter */ + u64 mCover = 0; /* Mask of phrases covered by this snippet */ + u64 mHighlight = 0; /* Mask of tokens to highlight in snippet */ + + for(i=0; inPhrase; i++){ + SnippetPhrase *pPhrase = &pIter->aPhrase[i]; + if( pPhrase->pTail ){ + char *pCsr = pPhrase->pTail; + int iCsr = pPhrase->iTail; + + while( iCsr<(iStart+pIter->nSnippet) && iCsr>=iStart ){ + int j; + u64 mPhrase = (u64)1 << (i%64); + u64 mPos = (u64)1 << (iCsr - iStart); + assert( iCsr>=iStart && (iCsr - iStart)<=64 ); + assert( i>=0 ); + if( (mCover|mCovered)&mPhrase ){ + iScore++; + }else{ + iScore += 1000; + } + mCover |= mPhrase; + + for(j=0; jnToken; j++){ + mHighlight |= (mPos>>j); + } + + if( 0==(*pCsr & 0x0FE) ) break; + fts3GetDeltaPosition(&pCsr, &iCsr); + } + } + } + + /* Set the output variables before returning. */ + *piToken = iStart; + *piScore = iScore; + *pmCover = mCover; + *pmHighlight = mHighlight; +} + +/* +** This function is an fts3ExprIterate() callback used by fts3BestSnippet(). +** Each invocation populates an element of the SnippetIter.aPhrase[] array. +*/ +static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){ + SnippetIter *p = (SnippetIter *)ctx; + SnippetPhrase *pPhrase = &p->aPhrase[iPhrase]; + char *pCsr; + int rc; + + pPhrase->nToken = pExpr->pPhrase->nToken; + rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr); + assert( rc==SQLITE_OK || pCsr==0 ); + if( pCsr ){ + int iFirst = 0; + pPhrase->pList = pCsr; + fts3GetDeltaPosition(&pCsr, &iFirst); + if( iFirst<0 ){ + rc = FTS_CORRUPT_VTAB; + }else{ + pPhrase->pHead = pCsr; + pPhrase->pTail = pCsr; + pPhrase->iHead = iFirst; + pPhrase->iTail = iFirst; + } + }else{ + assert( rc!=SQLITE_OK || ( + pPhrase->pList==0 && pPhrase->pHead==0 && pPhrase->pTail==0 + )); + } + + return rc; +} + +/* +** Select the fragment of text consisting of nFragment contiguous tokens +** from column iCol that represent the "best" snippet. The best snippet +** is the snippet with the highest score, where scores are calculated +** by adding: +** +** (a) +1 point for each occurrence of a matchable phrase in the snippet. +** +** (b) +1000 points for the first occurrence of each matchable phrase in +** the snippet for which the corresponding mCovered bit is not set. +** +** The selected snippet parameters are stored in structure *pFragment before +** returning. The score of the selected snippet is stored in *piScore +** before returning. +*/ +static int fts3BestSnippet( + int nSnippet, /* Desired snippet length */ + Fts3Cursor *pCsr, /* Cursor to create snippet for */ + int iCol, /* Index of column to create snippet from */ + u64 mCovered, /* Mask of phrases already covered */ + u64 *pmSeen, /* IN/OUT: Mask of phrases seen */ + SnippetFragment *pFragment, /* OUT: Best snippet found */ + int *piScore /* OUT: Score of snippet pFragment */ +){ + int rc; /* Return Code */ + int nList; /* Number of phrases in expression */ + SnippetIter sIter; /* Iterates through snippet candidates */ + sqlite3_int64 nByte; /* Number of bytes of space to allocate */ + int iBestScore = -1; /* Best snippet score found so far */ + int i; /* Loop counter */ + + memset(&sIter, 0, sizeof(sIter)); + + /* Iterate through the phrases in the expression to count them. The same + ** callback makes sure the doclists are loaded for each phrase. + */ + rc = fts3ExprLoadDoclists(pCsr, &nList, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Now that it is known how many phrases there are, allocate and zero + ** the required space using malloc(). + */ + nByte = sizeof(SnippetPhrase) * nList; + sIter.aPhrase = (SnippetPhrase *)sqlite3_malloc64(nByte); + if( !sIter.aPhrase ){ + return SQLITE_NOMEM; + } + memset(sIter.aPhrase, 0, nByte); + + /* Initialize the contents of the SnippetIter object. Then iterate through + ** the set of phrases in the expression to populate the aPhrase[] array. + */ + sIter.pCsr = pCsr; + sIter.iCol = iCol; + sIter.nSnippet = nSnippet; + sIter.nPhrase = nList; + sIter.iCurrent = -1; + rc = fts3ExprIterate(pCsr->pExpr, fts3SnippetFindPositions, (void*)&sIter); + if( rc==SQLITE_OK ){ + + /* Set the *pmSeen output variable. */ + for(i=0; iiCol = iCol; + while( !fts3SnippetNextCandidate(&sIter) ){ + int iPos; + int iScore; + u64 mCover; + u64 mHighlite; + fts3SnippetDetails(&sIter, mCovered, &iPos, &iScore, &mCover,&mHighlite); + assert( iScore>=0 ); + if( iScore>iBestScore ){ + pFragment->iPos = iPos; + pFragment->hlmask = mHighlite; + pFragment->covered = mCover; + iBestScore = iScore; + } + } + + *piScore = iBestScore; + } + sqlite3_free(sIter.aPhrase); + return rc; +} + + +/* +** Append a string to the string-buffer passed as the first argument. +** +** If nAppend is negative, then the length of the string zAppend is +** determined using strlen(). +*/ +static int fts3StringAppend( + StrBuffer *pStr, /* Buffer to append to */ + const char *zAppend, /* Pointer to data to append to buffer */ + int nAppend /* Size of zAppend in bytes (or -1) */ +){ + if( nAppend<0 ){ + nAppend = (int)strlen(zAppend); + } + + /* If there is insufficient space allocated at StrBuffer.z, use realloc() + ** to grow the buffer until so that it is big enough to accomadate the + ** appended data. + */ + if( pStr->n+nAppend+1>=pStr->nAlloc ){ + sqlite3_int64 nAlloc = pStr->nAlloc+(sqlite3_int64)nAppend+100; + char *zNew = sqlite3_realloc64(pStr->z, nAlloc); + if( !zNew ){ + return SQLITE_NOMEM; + } + pStr->z = zNew; + pStr->nAlloc = nAlloc; + } + assert( pStr->z!=0 && (pStr->nAlloc >= pStr->n+nAppend+1) ); + + /* Append the data to the string buffer. */ + memcpy(&pStr->z[pStr->n], zAppend, nAppend); + pStr->n += nAppend; + pStr->z[pStr->n] = '\0'; + + return SQLITE_OK; +} + +/* +** The fts3BestSnippet() function often selects snippets that end with a +** query term. That is, the final term of the snippet is always a term +** that requires highlighting. For example, if 'X' is a highlighted term +** and '.' is a non-highlighted term, BestSnippet() may select: +** +** ........X.....X +** +** This function "shifts" the beginning of the snippet forward in the +** document so that there are approximately the same number of +** non-highlighted terms to the right of the final highlighted term as there +** are to the left of the first highlighted term. For example, to this: +** +** ....X.....X.... +** +** This is done as part of extracting the snippet text, not when selecting +** the snippet. Snippet selection is done based on doclists only, so there +** is no way for fts3BestSnippet() to know whether or not the document +** actually contains terms that follow the final highlighted term. +*/ +static int fts3SnippetShift( + Fts3Table *pTab, /* FTS3 table snippet comes from */ + int iLangid, /* Language id to use in tokenizing */ + int nSnippet, /* Number of tokens desired for snippet */ + const char *zDoc, /* Document text to extract snippet from */ + int nDoc, /* Size of buffer zDoc in bytes */ + int *piPos, /* IN/OUT: First token of snippet */ + u64 *pHlmask /* IN/OUT: Mask of tokens to highlight */ +){ + u64 hlmask = *pHlmask; /* Local copy of initial highlight-mask */ + + if( hlmask ){ + int nLeft; /* Tokens to the left of first highlight */ + int nRight; /* Tokens to the right of last highlight */ + int nDesired; /* Ideal number of tokens to shift forward */ + + for(nLeft=0; !(hlmask & ((u64)1 << nLeft)); nLeft++); + for(nRight=0; !(hlmask & ((u64)1 << (nSnippet-1-nRight))); nRight++); + assert( (nSnippet-1-nRight)<=63 && (nSnippet-1-nRight)>=0 ); + nDesired = (nLeft-nRight)/2; + + /* Ideally, the start of the snippet should be pushed forward in the + ** document nDesired tokens. This block checks if there are actually + ** nDesired tokens to the right of the snippet. If so, *piPos and + ** *pHlMask are updated to shift the snippet nDesired tokens to the + ** right. Otherwise, the snippet is shifted by the number of tokens + ** available. + */ + if( nDesired>0 ){ + int nShift; /* Number of tokens to shift snippet by */ + int iCurrent = 0; /* Token counter */ + int rc; /* Return Code */ + sqlite3_tokenizer_module *pMod; + sqlite3_tokenizer_cursor *pC; + pMod = (sqlite3_tokenizer_module *)pTab->pTokenizer->pModule; + + /* Open a cursor on zDoc/nDoc. Check if there are (nSnippet+nDesired) + ** or more tokens in zDoc/nDoc. + */ + rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC); + if( rc!=SQLITE_OK ){ + return rc; + } + while( rc==SQLITE_OK && iCurrent<(nSnippet+nDesired) ){ + const char *ZDUMMY; int DUMMY1 = 0, DUMMY2 = 0, DUMMY3 = 0; + rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent); + } + pMod->xClose(pC); + if( rc!=SQLITE_OK && rc!=SQLITE_DONE ){ return rc; } + + nShift = (rc==SQLITE_DONE)+iCurrent-nSnippet; + assert( nShift<=nDesired ); + if( nShift>0 ){ + *piPos += nShift; + *pHlmask = hlmask >> nShift; + } + } + } + return SQLITE_OK; +} + +/* +** Extract the snippet text for fragment pFragment from cursor pCsr and +** append it to string buffer pOut. +*/ +static int fts3SnippetText( + Fts3Cursor *pCsr, /* FTS3 Cursor */ + SnippetFragment *pFragment, /* Snippet to extract */ + int iFragment, /* Fragment number */ + int isLast, /* True for final fragment in snippet */ + int nSnippet, /* Number of tokens in extracted snippet */ + const char *zOpen, /* String inserted before highlighted term */ + const char *zClose, /* String inserted after highlighted term */ + const char *zEllipsis, /* String inserted between snippets */ + StrBuffer *pOut /* Write output here */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc; /* Return code */ + const char *zDoc; /* Document text to extract snippet from */ + int nDoc; /* Size of zDoc in bytes */ + int iCurrent = 0; /* Current token number of document */ + int iEnd = 0; /* Byte offset of end of current token */ + int isShiftDone = 0; /* True after snippet is shifted */ + int iPos = pFragment->iPos; /* First token of snippet */ + u64 hlmask = pFragment->hlmask; /* Highlight-mask for snippet */ + int iCol = pFragment->iCol+1; /* Query column to extract text from */ + sqlite3_tokenizer_module *pMod; /* Tokenizer module methods object */ + sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */ + + zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol); + if( zDoc==0 ){ + if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){ + return SQLITE_NOMEM; + } + return SQLITE_OK; + } + nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol); + + /* Open a token cursor on the document. */ + pMod = (sqlite3_tokenizer_module *)pTab->pTokenizer->pModule; + rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC); + if( rc!=SQLITE_OK ){ + return rc; + } + + while( rc==SQLITE_OK ){ + const char *ZDUMMY; /* Dummy argument used with tokenizer */ + int DUMMY1 = -1; /* Dummy argument used with tokenizer */ + int iBegin = 0; /* Offset in zDoc of start of token */ + int iFin = 0; /* Offset in zDoc of end of token */ + int isHighlight = 0; /* True for highlighted terms */ + + /* Variable DUMMY1 is initialized to a negative value above. Elsewhere + ** in the FTS code the variable that the third argument to xNext points to + ** is initialized to zero before the first (*but not necessarily + ** subsequent*) call to xNext(). This is done for a particular application + ** that needs to know whether or not the tokenizer is being used for + ** snippet generation or for some other purpose. + ** + ** Extreme care is required when writing code to depend on this + ** initialization. It is not a documented part of the tokenizer interface. + ** If a tokenizer is used directly by any code outside of FTS, this + ** convention might not be respected. */ + rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_DONE ){ + /* Special case - the last token of the snippet is also the last token + ** of the column. Append any punctuation that occurred between the end + ** of the previous token and the end of the document to the output. + ** Then break out of the loop. */ + rc = fts3StringAppend(pOut, &zDoc[iEnd], -1); + } + break; + } + if( iCurrentiLangid, nSnippet, &zDoc[iBegin], n, &iPos, &hlmask + ); + isShiftDone = 1; + + /* Now that the shift has been done, check if the initial "..." are + ** required. They are required if (a) this is not the first fragment, + ** or (b) this fragment does not begin at position 0 of its column. + */ + if( rc==SQLITE_OK ){ + if( iPos>0 || iFragment>0 ){ + rc = fts3StringAppend(pOut, zEllipsis, -1); + }else if( iBegin ){ + rc = fts3StringAppend(pOut, zDoc, iBegin); + } + } + if( rc!=SQLITE_OK || iCurrent=(iPos+nSnippet) ){ + if( isLast ){ + rc = fts3StringAppend(pOut, zEllipsis, -1); + } + break; + } + + /* Set isHighlight to true if this term should be highlighted. */ + isHighlight = (hlmask & ((u64)1 << (iCurrent-iPos)))!=0; + + if( iCurrent>iPos ) rc = fts3StringAppend(pOut, &zDoc[iEnd], iBegin-iEnd); + if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zOpen, -1); + if( rc==SQLITE_OK ) rc = fts3StringAppend(pOut, &zDoc[iBegin], iFin-iBegin); + if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zClose, -1); + + iEnd = iFin; + } + + pMod->xClose(pC); + return rc; +} + + +/* +** This function is used to count the entries in a column-list (a +** delta-encoded list of term offsets within a single column of a single +** row). When this function is called, *ppCollist should point to the +** beginning of the first varint in the column-list (the varint that +** contains the position of the first matching term in the column data). +** Before returning, *ppCollist is set to point to the first byte after +** the last varint in the column-list (either the 0x00 signifying the end +** of the position-list, or the 0x01 that precedes the column number of +** the next column in the position-list). +** +** The number of elements in the column-list is returned. +*/ +static int fts3ColumnlistCount(char **ppCollist){ + char *pEnd = *ppCollist; + char c = 0; + int nEntry = 0; + + /* A column-list is terminated by either a 0x01 or 0x00. */ + while( 0xFE & (*pEnd | c) ){ + c = *pEnd++ & 0x80; + if( !c ) nEntry++; + } + + *ppCollist = pEnd; + return nEntry; +} + +/* +** This function gathers 'y' or 'b' data for a single phrase. +*/ +static int fts3ExprLHits( + Fts3Expr *pExpr, /* Phrase expression node */ + MatchInfo *p /* Matchinfo context */ +){ + Fts3Table *pTab = (Fts3Table *)p->pCursor->base.pVtab; + int iStart; + Fts3Phrase *pPhrase = pExpr->pPhrase; + char *pIter = pPhrase->doclist.pList; + int iCol = 0; + + assert( p->flag==FTS3_MATCHINFO_LHITS_BM || p->flag==FTS3_MATCHINFO_LHITS ); + if( p->flag==FTS3_MATCHINFO_LHITS ){ + iStart = pExpr->iPhrase * p->nCol; + }else{ + iStart = pExpr->iPhrase * ((p->nCol + 31) / 32); + } + + if( pIter ) while( 1 ){ + int nHit = fts3ColumnlistCount(&pIter); + if( (pPhrase->iColumn>=pTab->nColumn || pPhrase->iColumn==iCol) ){ + if( p->flag==FTS3_MATCHINFO_LHITS ){ + p->aMatchinfo[iStart + iCol] = (u32)nHit; + }else if( nHit ){ + p->aMatchinfo[iStart + (iCol+1)/32] |= (1 << (iCol&0x1F)); + } + } + assert( *pIter==0x00 || *pIter==0x01 ); + if( *pIter!=0x01 ) break; + pIter++; + pIter += fts3GetVarint32(pIter, &iCol); + if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB; + } + return SQLITE_OK; +} + +/* +** Gather the results for matchinfo directives 'y' and 'b'. +*/ +static int fts3ExprLHitGather( + Fts3Expr *pExpr, + MatchInfo *p +){ + int rc = SQLITE_OK; + assert( (pExpr->pLeft==0)==(pExpr->pRight==0) ); + if( pExpr->bEof==0 && pExpr->iDocid==p->pCursor->iPrevId ){ + if( pExpr->pLeft ){ + rc = fts3ExprLHitGather(pExpr->pLeft, p); + if( rc==SQLITE_OK ) rc = fts3ExprLHitGather(pExpr->pRight, p); + }else{ + rc = fts3ExprLHits(pExpr, p); + } + } + return rc; +} + +/* +** fts3ExprIterate() callback used to collect the "global" matchinfo stats +** for a single query. +** +** fts3ExprIterate() callback to load the 'global' elements of a +** FTS3_MATCHINFO_HITS matchinfo array. The global stats are those elements +** of the matchinfo array that are constant for all rows returned by the +** current query. +** +** Argument pCtx is actually a pointer to a struct of type MatchInfo. This +** function populates Matchinfo.aMatchinfo[] as follows: +** +** for(iCol=0; iColpCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol] + ); +} + +/* +** fts3ExprIterate() callback used to collect the "local" part of the +** FTS3_MATCHINFO_HITS array. The local stats are those elements of the +** array that are different for each row returned by the query. +*/ +static int fts3ExprLocalHitsCb( + Fts3Expr *pExpr, /* Phrase expression node */ + int iPhrase, /* Phrase number */ + void *pCtx /* Pointer to MatchInfo structure */ +){ + int rc = SQLITE_OK; + MatchInfo *p = (MatchInfo *)pCtx; + int iStart = iPhrase * p->nCol * 3; + int i; + + for(i=0; inCol && rc==SQLITE_OK; i++){ + char *pCsr; + rc = sqlite3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i, &pCsr); + if( pCsr ){ + p->aMatchinfo[iStart+i*3] = fts3ColumnlistCount(&pCsr); + }else{ + p->aMatchinfo[iStart+i*3] = 0; + } + } + + return rc; +} + +static int fts3MatchinfoCheck( + Fts3Table *pTab, + char cArg, + char **pzErr +){ + if( (cArg==FTS3_MATCHINFO_NPHRASE) + || (cArg==FTS3_MATCHINFO_NCOL) + || (cArg==FTS3_MATCHINFO_NDOC && pTab->bFts4) + || (cArg==FTS3_MATCHINFO_AVGLENGTH && pTab->bFts4) + || (cArg==FTS3_MATCHINFO_LENGTH && pTab->bHasDocsize) + || (cArg==FTS3_MATCHINFO_LCS) + || (cArg==FTS3_MATCHINFO_HITS) + || (cArg==FTS3_MATCHINFO_LHITS) + || (cArg==FTS3_MATCHINFO_LHITS_BM) + ){ + return SQLITE_OK; + } + sqlite3Fts3ErrMsg(pzErr, "unrecognized matchinfo request: %c", cArg); + return SQLITE_ERROR; +} + +static size_t fts3MatchinfoSize(MatchInfo *pInfo, char cArg){ + size_t nVal; /* Number of integers output by cArg */ + + switch( cArg ){ + case FTS3_MATCHINFO_NDOC: + case FTS3_MATCHINFO_NPHRASE: + case FTS3_MATCHINFO_NCOL: + nVal = 1; + break; + + case FTS3_MATCHINFO_AVGLENGTH: + case FTS3_MATCHINFO_LENGTH: + case FTS3_MATCHINFO_LCS: + nVal = pInfo->nCol; + break; + + case FTS3_MATCHINFO_LHITS: + nVal = pInfo->nCol * pInfo->nPhrase; + break; + + case FTS3_MATCHINFO_LHITS_BM: + nVal = pInfo->nPhrase * ((pInfo->nCol + 31) / 32); + break; + + default: + assert( cArg==FTS3_MATCHINFO_HITS ); + nVal = pInfo->nCol * pInfo->nPhrase * 3; + break; + } + + return nVal; +} + +static int fts3MatchinfoSelectDoctotal( + Fts3Table *pTab, + sqlite3_stmt **ppStmt, + sqlite3_int64 *pnDoc, + const char **paLen, + const char **ppEnd +){ + sqlite3_stmt *pStmt; + const char *a; + const char *pEnd; + sqlite3_int64 nDoc; + int n; + + + if( !*ppStmt ){ + int rc = sqlite3Fts3SelectDoctotal(pTab, ppStmt); + if( rc!=SQLITE_OK ) return rc; + } + pStmt = *ppStmt; + assert( sqlite3_data_count(pStmt)==1 ); + + n = sqlite3_column_bytes(pStmt, 0); + a = sqlite3_column_blob(pStmt, 0); + if( a==0 ){ + return FTS_CORRUPT_VTAB; + } + pEnd = a + n; + a += sqlite3Fts3GetVarintBounded(a, pEnd, &nDoc); + if( nDoc<=0 || a>pEnd ){ + return FTS_CORRUPT_VTAB; + } + *pnDoc = nDoc; + + if( paLen ) *paLen = a; + if( ppEnd ) *ppEnd = pEnd; + return SQLITE_OK; +} + +/* +** An instance of the following structure is used to store state while +** iterating through a multi-column position-list corresponding to the +** hits for a single phrase on a single row in order to calculate the +** values for a matchinfo() FTS3_MATCHINFO_LCS request. +*/ +typedef struct LcsIterator LcsIterator; +struct LcsIterator { + Fts3Expr *pExpr; /* Pointer to phrase expression */ + int iPosOffset; /* Tokens count up to end of this phrase */ + char *pRead; /* Cursor used to iterate through aDoclist */ + int iPos; /* Current position */ +}; + +/* +** If LcsIterator.iCol is set to the following value, the iterator has +** finished iterating through all offsets for all columns. +*/ +#define LCS_ITERATOR_FINISHED 0x7FFFFFFF; + +static int fts3MatchinfoLcsCb( + Fts3Expr *pExpr, /* Phrase expression node */ + int iPhrase, /* Phrase number (numbered from zero) */ + void *pCtx /* Pointer to MatchInfo structure */ +){ + LcsIterator *aIter = (LcsIterator *)pCtx; + aIter[iPhrase].pExpr = pExpr; + return SQLITE_OK; +} + +/* +** Advance the iterator passed as an argument to the next position. Return +** 1 if the iterator is at EOF or if it now points to the start of the +** position list for the next column. +*/ +static int fts3LcsIteratorAdvance(LcsIterator *pIter){ + char *pRead = pIter->pRead; + sqlite3_int64 iRead; + int rc = 0; + + pRead += sqlite3Fts3GetVarint(pRead, &iRead); + if( iRead==0 || iRead==1 ){ + pRead = 0; + rc = 1; + }else{ + pIter->iPos += (int)(iRead-2); + } + + pIter->pRead = pRead; + return rc; +} + +/* +** This function implements the FTS3_MATCHINFO_LCS matchinfo() flag. +** +** If the call is successful, the longest-common-substring lengths for each +** column are written into the first nCol elements of the pInfo->aMatchinfo[] +** array before returning. SQLITE_OK is returned in this case. +** +** Otherwise, if an error occurs, an SQLite error code is returned and the +** data written to the first nCol elements of pInfo->aMatchinfo[] is +** undefined. +*/ +static int fts3MatchinfoLcs(Fts3Cursor *pCsr, MatchInfo *pInfo){ + LcsIterator *aIter; + int i; + int iCol; + int nToken = 0; + int rc = SQLITE_OK; + + /* Allocate and populate the array of LcsIterator objects. The array + ** contains one element for each matchable phrase in the query. + **/ + aIter = sqlite3_malloc64(sizeof(LcsIterator) * pCsr->nPhrase); + if( !aIter ) return SQLITE_NOMEM; + memset(aIter, 0, sizeof(LcsIterator) * pCsr->nPhrase); + (void)fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter); + + for(i=0; inPhrase; i++){ + LcsIterator *pIter = &aIter[i]; + nToken -= pIter->pExpr->pPhrase->nToken; + pIter->iPosOffset = nToken; + } + + for(iCol=0; iColnCol; iCol++){ + int nLcs = 0; /* LCS value for this column */ + int nLive = 0; /* Number of iterators in aIter not at EOF */ + + for(i=0; inPhrase; i++){ + LcsIterator *pIt = &aIter[i]; + rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead); + if( rc!=SQLITE_OK ) goto matchinfo_lcs_out; + if( pIt->pRead ){ + pIt->iPos = pIt->iPosOffset; + fts3LcsIteratorAdvance(pIt); + if( pIt->pRead==0 ){ + rc = FTS_CORRUPT_VTAB; + goto matchinfo_lcs_out; + } + nLive++; + } + } + + while( nLive>0 ){ + LcsIterator *pAdv = 0; /* The iterator to advance by one position */ + int nThisLcs = 0; /* LCS for the current iterator positions */ + + for(i=0; inPhrase; i++){ + LcsIterator *pIter = &aIter[i]; + if( pIter->pRead==0 ){ + /* This iterator is already at EOF for this column. */ + nThisLcs = 0; + }else{ + if( pAdv==0 || pIter->iPosiPos ){ + pAdv = pIter; + } + if( nThisLcs==0 || pIter->iPos==pIter[-1].iPos ){ + nThisLcs++; + }else{ + nThisLcs = 1; + } + if( nThisLcs>nLcs ) nLcs = nThisLcs; + } + } + if( fts3LcsIteratorAdvance(pAdv) ) nLive--; + } + + pInfo->aMatchinfo[iCol] = nLcs; + } + + matchinfo_lcs_out: + sqlite3_free(aIter); + return rc; +} + +/* +** Populate the buffer pInfo->aMatchinfo[] with an array of integers to +** be returned by the matchinfo() function. Argument zArg contains the +** format string passed as the second argument to matchinfo (or the +** default value "pcx" if no second argument was specified). The format +** string has already been validated and the pInfo->aMatchinfo[] array +** is guaranteed to be large enough for the output. +** +** If bGlobal is true, then populate all fields of the matchinfo() output. +** If it is false, then assume that those fields that do not change between +** rows (i.e. FTS3_MATCHINFO_NPHRASE, NCOL, NDOC, AVGLENGTH and part of HITS) +** have already been populated. +** +** Return SQLITE_OK if successful, or an SQLite error code if an error +** occurs. If a value other than SQLITE_OK is returned, the state the +** pInfo->aMatchinfo[] buffer is left in is undefined. +*/ +static int fts3MatchinfoValues( + Fts3Cursor *pCsr, /* FTS3 cursor object */ + int bGlobal, /* True to grab the global stats */ + MatchInfo *pInfo, /* Matchinfo context object */ + const char *zArg /* Matchinfo format string */ +){ + int rc = SQLITE_OK; + int i; + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + sqlite3_stmt *pSelect = 0; + + for(i=0; rc==SQLITE_OK && zArg[i]; i++){ + pInfo->flag = zArg[i]; + switch( zArg[i] ){ + case FTS3_MATCHINFO_NPHRASE: + if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nPhrase; + break; + + case FTS3_MATCHINFO_NCOL: + if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol; + break; + + case FTS3_MATCHINFO_NDOC: + if( bGlobal ){ + sqlite3_int64 nDoc = 0; + rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, 0, 0); + pInfo->aMatchinfo[0] = (u32)nDoc; + } + break; + + case FTS3_MATCHINFO_AVGLENGTH: + if( bGlobal ){ + sqlite3_int64 nDoc; /* Number of rows in table */ + const char *a; /* Aggregate column length array */ + const char *pEnd; /* First byte past end of length array */ + + rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, &a, &pEnd); + if( rc==SQLITE_OK ){ + int iCol; + for(iCol=0; iColnCol; iCol++){ + u32 iVal; + sqlite3_int64 nToken; + a += sqlite3Fts3GetVarint(a, &nToken); + if( a>pEnd ){ + rc = SQLITE_CORRUPT_VTAB; + break; + } + iVal = (u32)(((u32)(nToken&0xffffffff)+nDoc/2)/nDoc); + pInfo->aMatchinfo[iCol] = iVal; + } + } + } + break; + + case FTS3_MATCHINFO_LENGTH: { + sqlite3_stmt *pSelectDocsize = 0; + rc = sqlite3Fts3SelectDocsize(pTab, pCsr->iPrevId, &pSelectDocsize); + if( rc==SQLITE_OK ){ + int iCol; + const char *a = sqlite3_column_blob(pSelectDocsize, 0); + const char *pEnd = a + sqlite3_column_bytes(pSelectDocsize, 0); + for(iCol=0; iColnCol; iCol++){ + sqlite3_int64 nToken; + a += sqlite3Fts3GetVarintBounded(a, pEnd, &nToken); + if( a>pEnd ){ + rc = SQLITE_CORRUPT_VTAB; + break; + } + pInfo->aMatchinfo[iCol] = (u32)nToken; + } + } + sqlite3_reset(pSelectDocsize); + break; + } + + case FTS3_MATCHINFO_LCS: + rc = fts3ExprLoadDoclists(pCsr, 0, 0); + if( rc==SQLITE_OK ){ + rc = fts3MatchinfoLcs(pCsr, pInfo); + } + break; + + case FTS3_MATCHINFO_LHITS_BM: + case FTS3_MATCHINFO_LHITS: { + size_t nZero = fts3MatchinfoSize(pInfo, zArg[i]) * sizeof(u32); + memset(pInfo->aMatchinfo, 0, nZero); + rc = fts3ExprLHitGather(pCsr->pExpr, pInfo); + break; + } + + default: { + Fts3Expr *pExpr; + assert( zArg[i]==FTS3_MATCHINFO_HITS ); + pExpr = pCsr->pExpr; + rc = fts3ExprLoadDoclists(pCsr, 0, 0); + if( rc!=SQLITE_OK ) break; + if( bGlobal ){ + if( pCsr->pDeferred ){ + rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &pInfo->nDoc,0,0); + if( rc!=SQLITE_OK ) break; + } + rc = fts3ExprIterate(pExpr, fts3ExprGlobalHitsCb,(void*)pInfo); + sqlite3Fts3EvalTestDeferred(pCsr, &rc); + if( rc!=SQLITE_OK ) break; + } + (void)fts3ExprIterate(pExpr, fts3ExprLocalHitsCb,(void*)pInfo); + break; + } + } + + pInfo->aMatchinfo += fts3MatchinfoSize(pInfo, zArg[i]); + } + + sqlite3_reset(pSelect); + return rc; +} + + +/* +** Populate pCsr->aMatchinfo[] with data for the current row. The +** 'matchinfo' data is an array of 32-bit unsigned integers (C type u32). +*/ +static void fts3GetMatchinfo( + sqlite3_context *pCtx, /* Return results here */ + Fts3Cursor *pCsr, /* FTS3 Cursor object */ + const char *zArg /* Second argument to matchinfo() function */ +){ + MatchInfo sInfo; + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc = SQLITE_OK; + int bGlobal = 0; /* Collect 'global' stats as well as local */ + + u32 *aOut = 0; + void (*xDestroyOut)(void*) = 0; + + memset(&sInfo, 0, sizeof(MatchInfo)); + sInfo.pCursor = pCsr; + sInfo.nCol = pTab->nColumn; + + /* If there is cached matchinfo() data, but the format string for the + ** cache does not match the format string for this request, discard + ** the cached data. */ + if( pCsr->pMIBuffer && strcmp(pCsr->pMIBuffer->zMatchinfo, zArg) ){ + sqlite3Fts3MIBufferFree(pCsr->pMIBuffer); + pCsr->pMIBuffer = 0; + } + + /* If Fts3Cursor.pMIBuffer is NULL, then this is the first time the + ** matchinfo function has been called for this query. In this case + ** allocate the array used to accumulate the matchinfo data and + ** initialize those elements that are constant for every row. + */ + if( pCsr->pMIBuffer==0 ){ + size_t nMatchinfo = 0; /* Number of u32 elements in match-info */ + int i; /* Used to iterate through zArg */ + + /* Determine the number of phrases in the query */ + pCsr->nPhrase = fts3ExprPhraseCount(pCsr->pExpr); + sInfo.nPhrase = pCsr->nPhrase; + + /* Determine the number of integers in the buffer returned by this call. */ + for(i=0; zArg[i]; i++){ + char *zErr = 0; + if( fts3MatchinfoCheck(pTab, zArg[i], &zErr) ){ + sqlite3_result_error(pCtx, zErr, -1); + sqlite3_free(zErr); + return; + } + nMatchinfo += fts3MatchinfoSize(&sInfo, zArg[i]); + } + + /* Allocate space for Fts3Cursor.aMatchinfo[] and Fts3Cursor.zMatchinfo. */ + pCsr->pMIBuffer = fts3MIBufferNew(nMatchinfo, zArg); + if( !pCsr->pMIBuffer ) rc = SQLITE_NOMEM; + + pCsr->isMatchinfoNeeded = 1; + bGlobal = 1; + } + + if( rc==SQLITE_OK ){ + xDestroyOut = fts3MIBufferAlloc(pCsr->pMIBuffer, &aOut); + if( xDestroyOut==0 ){ + rc = SQLITE_NOMEM; + } + } + + if( rc==SQLITE_OK ){ + sInfo.aMatchinfo = aOut; + sInfo.nPhrase = pCsr->nPhrase; + rc = fts3MatchinfoValues(pCsr, bGlobal, &sInfo, zArg); + if( bGlobal ){ + fts3MIBufferSetGlobal(pCsr->pMIBuffer); + } + } + + if( rc!=SQLITE_OK ){ + sqlite3_result_error_code(pCtx, rc); + if( xDestroyOut ) xDestroyOut(aOut); + }else{ + int n = pCsr->pMIBuffer->nElem * sizeof(u32); + sqlite3_result_blob(pCtx, aOut, n, xDestroyOut); + } +} + +/* +** Implementation of snippet() function. +*/ +SQLITE_PRIVATE void sqlite3Fts3Snippet( + sqlite3_context *pCtx, /* SQLite function call context */ + Fts3Cursor *pCsr, /* Cursor object */ + const char *zStart, /* Snippet start text - "" */ + const char *zEnd, /* Snippet end text - "" */ + const char *zEllipsis, /* Snippet ellipsis text - "..." */ + int iCol, /* Extract snippet from this column */ + int nToken /* Approximate number of tokens in snippet */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc = SQLITE_OK; + int i; + StrBuffer res = {0, 0, 0}; + + /* The returned text includes up to four fragments of text extracted from + ** the data in the current row. The first iteration of the for(...) loop + ** below attempts to locate a single fragment of text nToken tokens in + ** size that contains at least one instance of all phrases in the query + ** expression that appear in the current row. If such a fragment of text + ** cannot be found, the second iteration of the loop attempts to locate + ** a pair of fragments, and so on. + */ + int nSnippet = 0; /* Number of fragments in this snippet */ + SnippetFragment aSnippet[4]; /* Maximum of 4 fragments per snippet */ + int nFToken = -1; /* Number of tokens in each fragment */ + + if( !pCsr->pExpr ){ + sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC); + return; + } + + /* Limit the snippet length to 64 tokens. */ + if( nToken<-64 ) nToken = -64; + if( nToken>+64 ) nToken = +64; + + for(nSnippet=1; 1; nSnippet++){ + + int iSnip; /* Loop counter 0..nSnippet-1 */ + u64 mCovered = 0; /* Bitmask of phrases covered by snippet */ + u64 mSeen = 0; /* Bitmask of phrases seen by BestSnippet() */ + + if( nToken>=0 ){ + nFToken = (nToken+nSnippet-1) / nSnippet; + }else{ + nFToken = -1 * nToken; + } + + for(iSnip=0; iSnipnColumn; iRead++){ + SnippetFragment sF = {0, 0, 0, 0}; + int iS = 0; + if( iCol>=0 && iRead!=iCol ) continue; + + /* Find the best snippet of nFToken tokens in column iRead. */ + rc = fts3BestSnippet(nFToken, pCsr, iRead, mCovered, &mSeen, &sF, &iS); + if( rc!=SQLITE_OK ){ + goto snippet_out; + } + if( iS>iBestScore ){ + *pFragment = sF; + iBestScore = iS; + } + } + + mCovered |= pFragment->covered; + } + + /* If all query phrases seen by fts3BestSnippet() are present in at least + ** one of the nSnippet snippet fragments, break out of the loop. + */ + assert( (mCovered&mSeen)==mCovered ); + if( mSeen==mCovered || nSnippet==SizeofArray(aSnippet) ) break; + } + + assert( nFToken>0 ); + + for(i=0; ipCsr, pExpr, p->iCol, &pList); + nTerm = pExpr->pPhrase->nToken; + if( pList ){ + fts3GetDeltaPosition(&pList, &iPos); + assert_fts3_nc( iPos>=0 ); + } + + for(iTerm=0; iTermaTerm[p->iTerm++]; + pT->iOff = nTerm-iTerm-1; + pT->pList = pList; + pT->iPos = iPos; + } + + return rc; +} + +/* +** Implementation of offsets() function. +*/ +SQLITE_PRIVATE void sqlite3Fts3Offsets( + sqlite3_context *pCtx, /* SQLite function call context */ + Fts3Cursor *pCsr /* Cursor object */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + sqlite3_tokenizer_module const *pMod = pTab->pTokenizer->pModule; + int rc; /* Return Code */ + int nToken; /* Number of tokens in query */ + int iCol; /* Column currently being processed */ + StrBuffer res = {0, 0, 0}; /* Result string */ + TermOffsetCtx sCtx; /* Context for fts3ExprTermOffsetInit() */ + + if( !pCsr->pExpr ){ + sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC); + return; + } + + memset(&sCtx, 0, sizeof(sCtx)); + assert( pCsr->isRequireSeek==0 ); + + /* Count the number of terms in the query */ + rc = fts3ExprLoadDoclists(pCsr, 0, &nToken); + if( rc!=SQLITE_OK ) goto offsets_out; + + /* Allocate the array of TermOffset iterators. */ + sCtx.aTerm = (TermOffset *)sqlite3_malloc64(sizeof(TermOffset)*nToken); + if( 0==sCtx.aTerm ){ + rc = SQLITE_NOMEM; + goto offsets_out; + } + sCtx.iDocid = pCsr->iPrevId; + sCtx.pCsr = pCsr; + + /* Loop through the table columns, appending offset information to + ** string-buffer res for each column. + */ + for(iCol=0; iColnColumn; iCol++){ + sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor */ + const char *ZDUMMY; /* Dummy argument used with xNext() */ + int NDUMMY = 0; /* Dummy argument used with xNext() */ + int iStart = 0; + int iEnd = 0; + int iCurrent = 0; + const char *zDoc; + int nDoc; + + /* Initialize the contents of sCtx.aTerm[] for column iCol. There is + ** no way that this operation can fail, so the return code from + ** fts3ExprIterate() can be discarded. + */ + sCtx.iCol = iCol; + sCtx.iTerm = 0; + (void)fts3ExprIterate(pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx); + + /* Retreive the text stored in column iCol. If an SQL NULL is stored + ** in column iCol, jump immediately to the next iteration of the loop. + ** If an OOM occurs while retrieving the data (this can happen if SQLite + ** needs to transform the data from utf-16 to utf-8), return SQLITE_NOMEM + ** to the caller. + */ + zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1); + nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1); + if( zDoc==0 ){ + if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){ + continue; + } + rc = SQLITE_NOMEM; + goto offsets_out; + } + + /* Initialize a tokenizer iterator to iterate through column iCol. */ + rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, + zDoc, nDoc, &pC + ); + if( rc!=SQLITE_OK ) goto offsets_out; + + rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent); + while( rc==SQLITE_OK ){ + int i; /* Used to loop through terms */ + int iMinPos = 0x7FFFFFFF; /* Position of next token */ + TermOffset *pTerm = 0; /* TermOffset associated with next token */ + + for(i=0; ipList && (pT->iPos-pT->iOff)iPos-pT->iOff; + pTerm = pT; + } + } + + if( !pTerm ){ + /* All offsets for this column have been gathered. */ + rc = SQLITE_DONE; + }else{ + assert_fts3_nc( iCurrent<=iMinPos ); + if( 0==(0xFE&*pTerm->pList) ){ + pTerm->pList = 0; + }else{ + fts3GetDeltaPosition(&pTerm->pList, &pTerm->iPos); + } + while( rc==SQLITE_OK && iCurrentxNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent); + } + if( rc==SQLITE_OK ){ + char aBuffer[64]; + sqlite3_snprintf(sizeof(aBuffer), aBuffer, + "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart + ); + rc = fts3StringAppend(&res, aBuffer, -1); + }else if( rc==SQLITE_DONE && pTab->zContentTbl==0 ){ + rc = FTS_CORRUPT_VTAB; + } + } + } + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + } + + pMod->xClose(pC); + if( rc!=SQLITE_OK ) goto offsets_out; + } + + offsets_out: + sqlite3_free(sCtx.aTerm); + assert( rc!=SQLITE_DONE ); + sqlite3Fts3SegmentsClose(pTab); + if( rc!=SQLITE_OK ){ + sqlite3_result_error_code(pCtx, rc); + sqlite3_free(res.z); + }else{ + sqlite3_result_text(pCtx, res.z, res.n-1, sqlite3_free); + } + return; +} + +/* +** Implementation of matchinfo() function. +*/ +SQLITE_PRIVATE void sqlite3Fts3Matchinfo( + sqlite3_context *pContext, /* Function call context */ + Fts3Cursor *pCsr, /* FTS3 table cursor */ + const char *zArg /* Second arg to matchinfo() function */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + const char *zFormat; + + if( zArg ){ + zFormat = zArg; + }else{ + zFormat = FTS3_MATCHINFO_DEFAULT; + } + + if( !pCsr->pExpr ){ + sqlite3_result_blob(pContext, "", 0, SQLITE_STATIC); + return; + }else{ + /* Retrieve matchinfo() data. */ + fts3GetMatchinfo(pContext, pCsr, zFormat); + sqlite3Fts3SegmentsClose(pTab); + } +} + +#endif + +/************** End of fts3_snippet.c ****************************************/ +/************** Begin file fts3_unicode.c ************************************/ +/* +** 2012 May 24 +** +** 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. +** +****************************************************************************** +** +** Implementation of the "unicode" full-text-search tokenizer. +*/ + +#ifndef SQLITE_DISABLE_FTS3_UNICODE + +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ +/* #include */ +/* #include */ + +/* #include "fts3_tokenizer.h" */ + +/* +** The following two macros - READ_UTF8 and WRITE_UTF8 - have been copied +** from the sqlite3 source file utf.c. If this file is compiled as part +** of the amalgamation, they are not required. +*/ +#ifndef SQLITE_AMALGAMATION + +static const unsigned char sqlite3Utf8Trans1[] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00, +}; + +#define READ_UTF8(zIn, zTerm, c) \ + c = *(zIn++); \ + if( c>=0xc0 ){ \ + c = sqlite3Utf8Trans1[c-0xc0]; \ + while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){ \ + c = (c<<6) + (0x3f & *(zIn++)); \ + } \ + if( c<0x80 \ + || (c&0xFFFFF800)==0xD800 \ + || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \ + } + +#define WRITE_UTF8(zOut, c) { \ + if( c<0x00080 ){ \ + *zOut++ = (u8)(c&0xFF); \ + } \ + else if( c<0x00800 ){ \ + *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + } \ + else if( c<0x10000 ){ \ + *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); \ + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + }else{ \ + *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); \ + *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); \ + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + } \ +} + +#endif /* ifndef SQLITE_AMALGAMATION */ + +typedef struct unicode_tokenizer unicode_tokenizer; +typedef struct unicode_cursor unicode_cursor; + +struct unicode_tokenizer { + sqlite3_tokenizer base; + int eRemoveDiacritic; + int nException; + int *aiException; +}; + +struct unicode_cursor { + sqlite3_tokenizer_cursor base; + const unsigned char *aInput; /* Input text being tokenized */ + int nInput; /* Size of aInput[] in bytes */ + int iOff; /* Current offset within aInput[] */ + int iToken; /* Index of next token to be returned */ + char *zToken; /* storage for current token */ + int nAlloc; /* space allocated at zToken */ +}; + + +/* +** Destroy a tokenizer allocated by unicodeCreate(). +*/ +static int unicodeDestroy(sqlite3_tokenizer *pTokenizer){ + if( pTokenizer ){ + unicode_tokenizer *p = (unicode_tokenizer *)pTokenizer; + sqlite3_free(p->aiException); + sqlite3_free(p); + } + return SQLITE_OK; +} + +/* +** As part of a tokenchars= or separators= option, the CREATE VIRTUAL TABLE +** statement has specified that the tokenizer for this table shall consider +** all characters in string zIn/nIn to be separators (if bAlnum==0) or +** token characters (if bAlnum==1). +** +** For each codepoint in the zIn/nIn string, this function checks if the +** sqlite3FtsUnicodeIsalnum() function already returns the desired result. +** If so, no action is taken. Otherwise, the codepoint is added to the +** unicode_tokenizer.aiException[] array. For the purposes of tokenization, +** the return value of sqlite3FtsUnicodeIsalnum() is inverted for all +** codepoints in the aiException[] array. +** +** If a standalone diacritic mark (one that sqlite3FtsUnicodeIsdiacritic() +** identifies as a diacritic) occurs in the zIn/nIn string it is ignored. +** It is not possible to change the behavior of the tokenizer with respect +** to these codepoints. +*/ +static int unicodeAddExceptions( + unicode_tokenizer *p, /* Tokenizer to add exceptions to */ + int bAlnum, /* Replace Isalnum() return value with this */ + const char *zIn, /* Array of characters to make exceptions */ + int nIn /* Length of z in bytes */ +){ + const unsigned char *z = (const unsigned char *)zIn; + const unsigned char *zTerm = &z[nIn]; + unsigned int iCode; + int nEntry = 0; + + assert( bAlnum==0 || bAlnum==1 ); + + while( zaiException,(p->nException+nEntry)*sizeof(int)); + if( aNew==0 ) return SQLITE_NOMEM; + nNew = p->nException; + + z = (const unsigned char *)zIn; + while( zi; j--) aNew[j] = aNew[j-1]; + aNew[i] = (int)iCode; + nNew++; + } + } + p->aiException = aNew; + p->nException = nNew; + } + + return SQLITE_OK; +} + +/* +** Return true if the p->aiException[] array contains the value iCode. +*/ +static int unicodeIsException(unicode_tokenizer *p, int iCode){ + if( p->nException>0 ){ + int *a = p->aiException; + int iLo = 0; + int iHi = p->nException-1; + + while( iHi>=iLo ){ + int iTest = (iHi + iLo) / 2; + if( iCode==a[iTest] ){ + return 1; + }else if( iCode>a[iTest] ){ + iLo = iTest+1; + }else{ + iHi = iTest-1; + } + } + } + + return 0; +} + +/* +** Return true if, for the purposes of tokenization, codepoint iCode is +** considered a token character (not a separator). +*/ +static int unicodeIsAlnum(unicode_tokenizer *p, int iCode){ + assert( (sqlite3FtsUnicodeIsalnum(iCode) & 0xFFFFFFFE)==0 ); + return sqlite3FtsUnicodeIsalnum(iCode) ^ unicodeIsException(p, iCode); +} + +/* +** Create a new tokenizer instance. +*/ +static int unicodeCreate( + int nArg, /* Size of array argv[] */ + const char * const *azArg, /* Tokenizer creation arguments */ + sqlite3_tokenizer **pp /* OUT: New tokenizer handle */ +){ + unicode_tokenizer *pNew; /* New tokenizer object */ + int i; + int rc = SQLITE_OK; + + pNew = (unicode_tokenizer *) sqlite3_malloc(sizeof(unicode_tokenizer)); + if( pNew==NULL ) return SQLITE_NOMEM; + memset(pNew, 0, sizeof(unicode_tokenizer)); + pNew->eRemoveDiacritic = 1; + + for(i=0; rc==SQLITE_OK && ieRemoveDiacritic = 1; + } + else if( n==19 && memcmp("remove_diacritics=0", z, 19)==0 ){ + pNew->eRemoveDiacritic = 0; + } + else if( n==19 && memcmp("remove_diacritics=2", z, 19)==0 ){ + pNew->eRemoveDiacritic = 2; + } + else if( n>=11 && memcmp("tokenchars=", z, 11)==0 ){ + rc = unicodeAddExceptions(pNew, 1, &z[11], n-11); + } + else if( n>=11 && memcmp("separators=", z, 11)==0 ){ + rc = unicodeAddExceptions(pNew, 0, &z[11], n-11); + } + else{ + /* Unrecognized argument */ + rc = SQLITE_ERROR; + } + } + + if( rc!=SQLITE_OK ){ + unicodeDestroy((sqlite3_tokenizer *)pNew); + pNew = 0; + } + *pp = (sqlite3_tokenizer *)pNew; + return rc; +} + +/* +** Prepare to begin tokenizing a particular string. The input +** string to be tokenized is pInput[0..nBytes-1]. A cursor +** used to incrementally tokenize this string is returned in +** *ppCursor. +*/ +static int unicodeOpen( + sqlite3_tokenizer *p, /* The tokenizer */ + const char *aInput, /* Input string */ + int nInput, /* Size of string aInput in bytes */ + sqlite3_tokenizer_cursor **pp /* OUT: New cursor object */ +){ + unicode_cursor *pCsr; + + pCsr = (unicode_cursor *)sqlite3_malloc(sizeof(unicode_cursor)); + if( pCsr==0 ){ + return SQLITE_NOMEM; + } + memset(pCsr, 0, sizeof(unicode_cursor)); + + pCsr->aInput = (const unsigned char *)aInput; + if( aInput==0 ){ + pCsr->nInput = 0; + }else if( nInput<0 ){ + pCsr->nInput = (int)strlen(aInput); + }else{ + pCsr->nInput = nInput; + } + + *pp = &pCsr->base; + UNUSED_PARAMETER(p); + return SQLITE_OK; +} + +/* +** Close a tokenization cursor previously opened by a call to +** simpleOpen() above. +*/ +static int unicodeClose(sqlite3_tokenizer_cursor *pCursor){ + unicode_cursor *pCsr = (unicode_cursor *) pCursor; + sqlite3_free(pCsr->zToken); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +/* +** Extract the next token from a tokenization cursor. The cursor must +** have been opened by a prior call to simpleOpen(). +*/ +static int unicodeNext( + sqlite3_tokenizer_cursor *pC, /* Cursor returned by simpleOpen */ + const char **paToken, /* OUT: Token text */ + int *pnToken, /* OUT: Number of bytes at *paToken */ + int *piStart, /* OUT: Starting offset of token */ + int *piEnd, /* OUT: Ending offset of token */ + int *piPos /* OUT: Position integer of token */ +){ + unicode_cursor *pCsr = (unicode_cursor *)pC; + unicode_tokenizer *p = ((unicode_tokenizer *)pCsr->base.pTokenizer); + unsigned int iCode = 0; + char *zOut; + const unsigned char *z = &pCsr->aInput[pCsr->iOff]; + const unsigned char *zStart = z; + const unsigned char *zEnd; + const unsigned char *zTerm = &pCsr->aInput[pCsr->nInput]; + + /* Scan past any delimiter characters before the start of the next token. + ** Return SQLITE_DONE early if this takes us all the way to the end of + ** the input. */ + while( z=zTerm ) return SQLITE_DONE; + + zOut = pCsr->zToken; + do { + int iOut; + + /* Grow the output buffer if required. */ + if( (zOut-pCsr->zToken)>=(pCsr->nAlloc-4) ){ + char *zNew = sqlite3_realloc64(pCsr->zToken, pCsr->nAlloc+64); + if( !zNew ) return SQLITE_NOMEM; + zOut = &zNew[zOut - pCsr->zToken]; + pCsr->zToken = zNew; + pCsr->nAlloc += 64; + } + + /* Write the folded case of the last character read to the output */ + zEnd = z; + iOut = sqlite3FtsUnicodeFold((int)iCode, p->eRemoveDiacritic); + if( iOut ){ + WRITE_UTF8(zOut, iOut); + } + + /* If the cursor is not at EOF, read the next character */ + if( z>=zTerm ) break; + READ_UTF8(z, zTerm, iCode); + }while( unicodeIsAlnum(p, (int)iCode) + || sqlite3FtsUnicodeIsdiacritic((int)iCode) + ); + + /* Set the output variables and return. */ + pCsr->iOff = (int)(z - pCsr->aInput); + *paToken = pCsr->zToken; + *pnToken = (int)(zOut - pCsr->zToken); + *piStart = (int)(zStart - pCsr->aInput); + *piEnd = (int)(zEnd - pCsr->aInput); + *piPos = pCsr->iToken++; + return SQLITE_OK; +} + +/* +** Set *ppModule to a pointer to the sqlite3_tokenizer_module +** structure for the unicode tokenizer. +*/ +SQLITE_PRIVATE void sqlite3Fts3UnicodeTokenizer(sqlite3_tokenizer_module const **ppModule){ + static const sqlite3_tokenizer_module module = { + 0, + unicodeCreate, + unicodeDestroy, + unicodeOpen, + unicodeClose, + unicodeNext, + 0, + }; + *ppModule = &module; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ +#endif /* ifndef SQLITE_DISABLE_FTS3_UNICODE */ + +/************** End of fts3_unicode.c ****************************************/ +/************** Begin file fts3_unicode2.c ***********************************/ +/* +** 2012-05-25 +** +** 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. +** +****************************************************************************** +*/ + +/* +** DO NOT EDIT THIS MACHINE GENERATED FILE. +*/ + +#ifndef SQLITE_DISABLE_FTS3_UNICODE +#if defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4) + +/* #include */ + +/* +** Return true if the argument corresponds to a unicode codepoint +** classified as either a letter or a number. Otherwise false. +** +** The results are undefined if the value passed to this function +** is less than zero. +*/ +SQLITE_PRIVATE int sqlite3FtsUnicodeIsalnum(int c){ + /* Each unsigned integer in the following array corresponds to a contiguous + ** range of unicode codepoints that are not either letters or numbers (i.e. + ** codepoints for which this function should return 0). + ** + ** The most significant 22 bits in each 32-bit value contain the first + ** codepoint in the range. The least significant 10 bits are used to store + ** the size of the range (always at least 1). In other words, the value + ** ((C<<22) + N) represents a range of N codepoints starting with codepoint + ** C. It is not possible to represent a range larger than 1023 codepoints + ** using this format. + */ + static const unsigned int aEntry[] = { + 0x00000030, 0x0000E807, 0x00016C06, 0x0001EC2F, 0x0002AC07, + 0x0002D001, 0x0002D803, 0x0002EC01, 0x0002FC01, 0x00035C01, + 0x0003DC01, 0x000B0804, 0x000B480E, 0x000B9407, 0x000BB401, + 0x000BBC81, 0x000DD401, 0x000DF801, 0x000E1002, 0x000E1C01, + 0x000FD801, 0x00120808, 0x00156806, 0x00162402, 0x00163C01, + 0x00164437, 0x0017CC02, 0x00180005, 0x00181816, 0x00187802, + 0x00192C15, 0x0019A804, 0x0019C001, 0x001B5001, 0x001B580F, + 0x001B9C07, 0x001BF402, 0x001C000E, 0x001C3C01, 0x001C4401, + 0x001CC01B, 0x001E980B, 0x001FAC09, 0x001FD804, 0x00205804, + 0x00206C09, 0x00209403, 0x0020A405, 0x0020C00F, 0x00216403, + 0x00217801, 0x0023901B, 0x00240004, 0x0024E803, 0x0024F812, + 0x00254407, 0x00258804, 0x0025C001, 0x00260403, 0x0026F001, + 0x0026F807, 0x00271C02, 0x00272C03, 0x00275C01, 0x00278802, + 0x0027C802, 0x0027E802, 0x00280403, 0x0028F001, 0x0028F805, + 0x00291C02, 0x00292C03, 0x00294401, 0x0029C002, 0x0029D401, + 0x002A0403, 0x002AF001, 0x002AF808, 0x002B1C03, 0x002B2C03, + 0x002B8802, 0x002BC002, 0x002C0403, 0x002CF001, 0x002CF807, + 0x002D1C02, 0x002D2C03, 0x002D5802, 0x002D8802, 0x002DC001, + 0x002E0801, 0x002EF805, 0x002F1803, 0x002F2804, 0x002F5C01, + 0x002FCC08, 0x00300403, 0x0030F807, 0x00311803, 0x00312804, + 0x00315402, 0x00318802, 0x0031FC01, 0x00320802, 0x0032F001, + 0x0032F807, 0x00331803, 0x00332804, 0x00335402, 0x00338802, + 0x00340802, 0x0034F807, 0x00351803, 0x00352804, 0x00355C01, + 0x00358802, 0x0035E401, 0x00360802, 0x00372801, 0x00373C06, + 0x00375801, 0x00376008, 0x0037C803, 0x0038C401, 0x0038D007, + 0x0038FC01, 0x00391C09, 0x00396802, 0x003AC401, 0x003AD006, + 0x003AEC02, 0x003B2006, 0x003C041F, 0x003CD00C, 0x003DC417, + 0x003E340B, 0x003E6424, 0x003EF80F, 0x003F380D, 0x0040AC14, + 0x00412806, 0x00415804, 0x00417803, 0x00418803, 0x00419C07, + 0x0041C404, 0x0042080C, 0x00423C01, 0x00426806, 0x0043EC01, + 0x004D740C, 0x004E400A, 0x00500001, 0x0059B402, 0x005A0001, + 0x005A6C02, 0x005BAC03, 0x005C4803, 0x005CC805, 0x005D4802, + 0x005DC802, 0x005ED023, 0x005F6004, 0x005F7401, 0x0060000F, + 0x0062A401, 0x0064800C, 0x0064C00C, 0x00650001, 0x00651002, + 0x0066C011, 0x00672002, 0x00677822, 0x00685C05, 0x00687802, + 0x0069540A, 0x0069801D, 0x0069FC01, 0x006A8007, 0x006AA006, + 0x006C0005, 0x006CD011, 0x006D6823, 0x006E0003, 0x006E840D, + 0x006F980E, 0x006FF004, 0x00709014, 0x0070EC05, 0x0071F802, + 0x00730008, 0x00734019, 0x0073B401, 0x0073C803, 0x00770027, + 0x0077F004, 0x007EF401, 0x007EFC03, 0x007F3403, 0x007F7403, + 0x007FB403, 0x007FF402, 0x00800065, 0x0081A806, 0x0081E805, + 0x00822805, 0x0082801A, 0x00834021, 0x00840002, 0x00840C04, + 0x00842002, 0x00845001, 0x00845803, 0x00847806, 0x00849401, + 0x00849C01, 0x0084A401, 0x0084B801, 0x0084E802, 0x00850005, + 0x00852804, 0x00853C01, 0x00864264, 0x00900027, 0x0091000B, + 0x0092704E, 0x00940200, 0x009C0475, 0x009E53B9, 0x00AD400A, + 0x00B39406, 0x00B3BC03, 0x00B3E404, 0x00B3F802, 0x00B5C001, + 0x00B5FC01, 0x00B7804F, 0x00B8C00C, 0x00BA001A, 0x00BA6C59, + 0x00BC00D6, 0x00BFC00C, 0x00C00005, 0x00C02019, 0x00C0A807, + 0x00C0D802, 0x00C0F403, 0x00C26404, 0x00C28001, 0x00C3EC01, + 0x00C64002, 0x00C6580A, 0x00C70024, 0x00C8001F, 0x00C8A81E, + 0x00C94001, 0x00C98020, 0x00CA2827, 0x00CB003F, 0x00CC0100, + 0x01370040, 0x02924037, 0x0293F802, 0x02983403, 0x0299BC10, + 0x029A7C01, 0x029BC008, 0x029C0017, 0x029C8002, 0x029E2402, + 0x02A00801, 0x02A01801, 0x02A02C01, 0x02A08C09, 0x02A0D804, + 0x02A1D004, 0x02A20002, 0x02A2D011, 0x02A33802, 0x02A38012, + 0x02A3E003, 0x02A4980A, 0x02A51C0D, 0x02A57C01, 0x02A60004, + 0x02A6CC1B, 0x02A77802, 0x02A8A40E, 0x02A90C01, 0x02A93002, + 0x02A97004, 0x02A9DC03, 0x02A9EC01, 0x02AAC001, 0x02AAC803, + 0x02AADC02, 0x02AAF802, 0x02AB0401, 0x02AB7802, 0x02ABAC07, + 0x02ABD402, 0x02AF8C0B, 0x03600001, 0x036DFC02, 0x036FFC02, + 0x037FFC01, 0x03EC7801, 0x03ECA401, 0x03EEC810, 0x03F4F802, + 0x03F7F002, 0x03F8001A, 0x03F88007, 0x03F8C023, 0x03F95013, + 0x03F9A004, 0x03FBFC01, 0x03FC040F, 0x03FC6807, 0x03FCEC06, + 0x03FD6C0B, 0x03FF8007, 0x03FFA007, 0x03FFE405, 0x04040003, + 0x0404DC09, 0x0405E411, 0x0406400C, 0x0407402E, 0x040E7C01, + 0x040F4001, 0x04215C01, 0x04247C01, 0x0424FC01, 0x04280403, + 0x04281402, 0x04283004, 0x0428E003, 0x0428FC01, 0x04294009, + 0x0429FC01, 0x042CE407, 0x04400003, 0x0440E016, 0x04420003, + 0x0442C012, 0x04440003, 0x04449C0E, 0x04450004, 0x04460003, + 0x0446CC0E, 0x04471404, 0x045AAC0D, 0x0491C004, 0x05BD442E, + 0x05BE3C04, 0x074000F6, 0x07440027, 0x0744A4B5, 0x07480046, + 0x074C0057, 0x075B0401, 0x075B6C01, 0x075BEC01, 0x075C5401, + 0x075CD401, 0x075D3C01, 0x075DBC01, 0x075E2401, 0x075EA401, + 0x075F0C01, 0x07BBC002, 0x07C0002C, 0x07C0C064, 0x07C2800F, + 0x07C2C40E, 0x07C3040F, 0x07C3440F, 0x07C4401F, 0x07C4C03C, + 0x07C5C02B, 0x07C7981D, 0x07C8402B, 0x07C90009, 0x07C94002, + 0x07CC0021, 0x07CCC006, 0x07CCDC46, 0x07CE0014, 0x07CE8025, + 0x07CF1805, 0x07CF8011, 0x07D0003F, 0x07D10001, 0x07D108B6, + 0x07D3E404, 0x07D4003E, 0x07D50004, 0x07D54018, 0x07D7EC46, + 0x07D9140B, 0x07DA0046, 0x07DC0074, 0x38000401, 0x38008060, + 0x380400F0, + }; + static const unsigned int aAscii[4] = { + 0xFFFFFFFF, 0xFC00FFFF, 0xF8000001, 0xF8000001, + }; + + if( (unsigned int)c<128 ){ + return ( (aAscii[c >> 5] & ((unsigned int)1 << (c & 0x001F)))==0 ); + }else if( (unsigned int)c<(1<<22) ){ + unsigned int key = (((unsigned int)c)<<10) | 0x000003FF; + int iRes = 0; + int iHi = sizeof(aEntry)/sizeof(aEntry[0]) - 1; + int iLo = 0; + while( iHi>=iLo ){ + int iTest = (iHi + iLo) / 2; + if( key >= aEntry[iTest] ){ + iRes = iTest; + iLo = iTest+1; + }else{ + iHi = iTest-1; + } + } + assert( aEntry[0]=aEntry[iRes] ); + return (((unsigned int)c) >= ((aEntry[iRes]>>10) + (aEntry[iRes]&0x3FF))); + } + return 1; +} + + +/* +** If the argument is a codepoint corresponding to a lowercase letter +** in the ASCII range with a diacritic added, return the codepoint +** of the ASCII letter only. For example, if passed 235 - "LATIN +** SMALL LETTER E WITH DIAERESIS" - return 65 ("LATIN SMALL LETTER +** E"). The resuls of passing a codepoint that corresponds to an +** uppercase letter are undefined. +*/ +static int remove_diacritic(int c, int bComplex){ + unsigned short aDia[] = { + 0, 1797, 1848, 1859, 1891, 1928, 1940, 1995, + 2024, 2040, 2060, 2110, 2168, 2206, 2264, 2286, + 2344, 2383, 2472, 2488, 2516, 2596, 2668, 2732, + 2782, 2842, 2894, 2954, 2984, 3000, 3028, 3336, + 3456, 3696, 3712, 3728, 3744, 3766, 3832, 3896, + 3912, 3928, 3944, 3968, 4008, 4040, 4056, 4106, + 4138, 4170, 4202, 4234, 4266, 4296, 4312, 4344, + 4408, 4424, 4442, 4472, 4488, 4504, 6148, 6198, + 6264, 6280, 6360, 6429, 6505, 6529, 61448, 61468, + 61512, 61534, 61592, 61610, 61642, 61672, 61688, 61704, + 61726, 61784, 61800, 61816, 61836, 61880, 61896, 61914, + 61948, 61998, 62062, 62122, 62154, 62184, 62200, 62218, + 62252, 62302, 62364, 62410, 62442, 62478, 62536, 62554, + 62584, 62604, 62640, 62648, 62656, 62664, 62730, 62766, + 62830, 62890, 62924, 62974, 63032, 63050, 63082, 63118, + 63182, 63242, 63274, 63310, 63368, 63390, + }; +#define HIBIT ((unsigned char)0x80) + unsigned char aChar[] = { + '\0', 'a', 'c', 'e', 'i', 'n', + 'o', 'u', 'y', 'y', 'a', 'c', + 'd', 'e', 'e', 'g', 'h', 'i', + 'j', 'k', 'l', 'n', 'o', 'r', + 's', 't', 'u', 'u', 'w', 'y', + 'z', 'o', 'u', 'a', 'i', 'o', + 'u', 'u'|HIBIT, 'a'|HIBIT, 'g', 'k', 'o', + 'o'|HIBIT, 'j', 'g', 'n', 'a'|HIBIT, 'a', + 'e', 'i', 'o', 'r', 'u', 's', + 't', 'h', 'a', 'e', 'o'|HIBIT, 'o', + 'o'|HIBIT, 'y', '\0', '\0', '\0', '\0', + '\0', '\0', '\0', '\0', 'a', 'b', + 'c'|HIBIT, 'd', 'd', 'e'|HIBIT, 'e', 'e'|HIBIT, + 'f', 'g', 'h', 'h', 'i', 'i'|HIBIT, + 'k', 'l', 'l'|HIBIT, 'l', 'm', 'n', + 'o'|HIBIT, 'p', 'r', 'r'|HIBIT, 'r', 's', + 's'|HIBIT, 't', 'u', 'u'|HIBIT, 'v', 'w', + 'w', 'x', 'y', 'z', 'h', 't', + 'w', 'y', 'a', 'a'|HIBIT, 'a'|HIBIT, 'a'|HIBIT, + 'e', 'e'|HIBIT, 'e'|HIBIT, 'i', 'o', 'o'|HIBIT, + 'o'|HIBIT, 'o'|HIBIT, 'u', 'u'|HIBIT, 'u'|HIBIT, 'y', + }; + + unsigned int key = (((unsigned int)c)<<3) | 0x00000007; + int iRes = 0; + int iHi = sizeof(aDia)/sizeof(aDia[0]) - 1; + int iLo = 0; + while( iHi>=iLo ){ + int iTest = (iHi + iLo) / 2; + if( key >= aDia[iTest] ){ + iRes = iTest; + iLo = iTest+1; + }else{ + iHi = iTest-1; + } + } + assert( key>=aDia[iRes] ); + if( bComplex==0 && (aChar[iRes] & 0x80) ) return c; + return (c > (aDia[iRes]>>3) + (aDia[iRes]&0x07)) ? c : ((int)aChar[iRes] & 0x7F); +} + + +/* +** Return true if the argument interpreted as a unicode codepoint +** is a diacritical modifier character. +*/ +SQLITE_PRIVATE int sqlite3FtsUnicodeIsdiacritic(int c){ + unsigned int mask0 = 0x08029FDF; + unsigned int mask1 = 0x000361F8; + if( c<768 || c>817 ) return 0; + return (c < 768+32) ? + (mask0 & ((unsigned int)1 << (c-768))) : + (mask1 & ((unsigned int)1 << (c-768-32))); +} + + +/* +** Interpret the argument as a unicode codepoint. If the codepoint +** is an upper case character that has a lower case equivalent, +** return the codepoint corresponding to the lower case version. +** Otherwise, return a copy of the argument. +** +** The results are undefined if the value passed to this function +** is less than zero. +*/ +SQLITE_PRIVATE int sqlite3FtsUnicodeFold(int c, int eRemoveDiacritic){ + /* Each entry in the following array defines a rule for folding a range + ** of codepoints to lower case. The rule applies to a range of nRange + ** codepoints starting at codepoint iCode. + ** + ** If the least significant bit in flags is clear, then the rule applies + ** to all nRange codepoints (i.e. all nRange codepoints are upper case and + ** need to be folded). Or, if it is set, then the rule only applies to + ** every second codepoint in the range, starting with codepoint C. + ** + ** The 7 most significant bits in flags are an index into the aiOff[] + ** array. If a specific codepoint C does require folding, then its lower + ** case equivalent is ((C + aiOff[flags>>1]) & 0xFFFF). + ** + ** The contents of this array are generated by parsing the CaseFolding.txt + ** file distributed as part of the "Unicode Character Database". See + ** http://www.unicode.org for details. + */ + static const struct TableEntry { + unsigned short iCode; + unsigned char flags; + unsigned char nRange; + } aEntry[] = { + {65, 14, 26}, {181, 64, 1}, {192, 14, 23}, + {216, 14, 7}, {256, 1, 48}, {306, 1, 6}, + {313, 1, 16}, {330, 1, 46}, {376, 116, 1}, + {377, 1, 6}, {383, 104, 1}, {385, 50, 1}, + {386, 1, 4}, {390, 44, 1}, {391, 0, 1}, + {393, 42, 2}, {395, 0, 1}, {398, 32, 1}, + {399, 38, 1}, {400, 40, 1}, {401, 0, 1}, + {403, 42, 1}, {404, 46, 1}, {406, 52, 1}, + {407, 48, 1}, {408, 0, 1}, {412, 52, 1}, + {413, 54, 1}, {415, 56, 1}, {416, 1, 6}, + {422, 60, 1}, {423, 0, 1}, {425, 60, 1}, + {428, 0, 1}, {430, 60, 1}, {431, 0, 1}, + {433, 58, 2}, {435, 1, 4}, {439, 62, 1}, + {440, 0, 1}, {444, 0, 1}, {452, 2, 1}, + {453, 0, 1}, {455, 2, 1}, {456, 0, 1}, + {458, 2, 1}, {459, 1, 18}, {478, 1, 18}, + {497, 2, 1}, {498, 1, 4}, {502, 122, 1}, + {503, 134, 1}, {504, 1, 40}, {544, 110, 1}, + {546, 1, 18}, {570, 70, 1}, {571, 0, 1}, + {573, 108, 1}, {574, 68, 1}, {577, 0, 1}, + {579, 106, 1}, {580, 28, 1}, {581, 30, 1}, + {582, 1, 10}, {837, 36, 1}, {880, 1, 4}, + {886, 0, 1}, {902, 18, 1}, {904, 16, 3}, + {908, 26, 1}, {910, 24, 2}, {913, 14, 17}, + {931, 14, 9}, {962, 0, 1}, {975, 4, 1}, + {976, 140, 1}, {977, 142, 1}, {981, 146, 1}, + {982, 144, 1}, {984, 1, 24}, {1008, 136, 1}, + {1009, 138, 1}, {1012, 130, 1}, {1013, 128, 1}, + {1015, 0, 1}, {1017, 152, 1}, {1018, 0, 1}, + {1021, 110, 3}, {1024, 34, 16}, {1040, 14, 32}, + {1120, 1, 34}, {1162, 1, 54}, {1216, 6, 1}, + {1217, 1, 14}, {1232, 1, 88}, {1329, 22, 38}, + {4256, 66, 38}, {4295, 66, 1}, {4301, 66, 1}, + {7680, 1, 150}, {7835, 132, 1}, {7838, 96, 1}, + {7840, 1, 96}, {7944, 150, 8}, {7960, 150, 6}, + {7976, 150, 8}, {7992, 150, 8}, {8008, 150, 6}, + {8025, 151, 8}, {8040, 150, 8}, {8072, 150, 8}, + {8088, 150, 8}, {8104, 150, 8}, {8120, 150, 2}, + {8122, 126, 2}, {8124, 148, 1}, {8126, 100, 1}, + {8136, 124, 4}, {8140, 148, 1}, {8152, 150, 2}, + {8154, 120, 2}, {8168, 150, 2}, {8170, 118, 2}, + {8172, 152, 1}, {8184, 112, 2}, {8186, 114, 2}, + {8188, 148, 1}, {8486, 98, 1}, {8490, 92, 1}, + {8491, 94, 1}, {8498, 12, 1}, {8544, 8, 16}, + {8579, 0, 1}, {9398, 10, 26}, {11264, 22, 47}, + {11360, 0, 1}, {11362, 88, 1}, {11363, 102, 1}, + {11364, 90, 1}, {11367, 1, 6}, {11373, 84, 1}, + {11374, 86, 1}, {11375, 80, 1}, {11376, 82, 1}, + {11378, 0, 1}, {11381, 0, 1}, {11390, 78, 2}, + {11392, 1, 100}, {11499, 1, 4}, {11506, 0, 1}, + {42560, 1, 46}, {42624, 1, 24}, {42786, 1, 14}, + {42802, 1, 62}, {42873, 1, 4}, {42877, 76, 1}, + {42878, 1, 10}, {42891, 0, 1}, {42893, 74, 1}, + {42896, 1, 4}, {42912, 1, 10}, {42922, 72, 1}, + {65313, 14, 26}, + }; + static const unsigned short aiOff[] = { + 1, 2, 8, 15, 16, 26, 28, 32, + 37, 38, 40, 48, 63, 64, 69, 71, + 79, 80, 116, 202, 203, 205, 206, 207, + 209, 210, 211, 213, 214, 217, 218, 219, + 775, 7264, 10792, 10795, 23228, 23256, 30204, 54721, + 54753, 54754, 54756, 54787, 54793, 54809, 57153, 57274, + 57921, 58019, 58363, 61722, 65268, 65341, 65373, 65406, + 65408, 65410, 65415, 65424, 65436, 65439, 65450, 65462, + 65472, 65476, 65478, 65480, 65482, 65488, 65506, 65511, + 65514, 65521, 65527, 65528, 65529, + }; + + int ret = c; + + assert( sizeof(unsigned short)==2 && sizeof(unsigned char)==1 ); + + if( c<128 ){ + if( c>='A' && c<='Z' ) ret = c + ('a' - 'A'); + }else if( c<65536 ){ + const struct TableEntry *p; + int iHi = sizeof(aEntry)/sizeof(aEntry[0]) - 1; + int iLo = 0; + int iRes = -1; + + assert( c>aEntry[0].iCode ); + while( iHi>=iLo ){ + int iTest = (iHi + iLo) / 2; + int cmp = (c - aEntry[iTest].iCode); + if( cmp>=0 ){ + iRes = iTest; + iLo = iTest+1; + }else{ + iHi = iTest-1; + } + } + + assert( iRes>=0 && c>=aEntry[iRes].iCode ); + p = &aEntry[iRes]; + if( c<(p->iCode + p->nRange) && 0==(0x01 & p->flags & (p->iCode ^ c)) ){ + ret = (c + (aiOff[p->flags>>1])) & 0x0000FFFF; + assert( ret>0 ); + } + + if( eRemoveDiacritic ){ + ret = remove_diacritic(ret, eRemoveDiacritic==2); + } + } + + else if( c>=66560 && c<66600 ){ + ret = c + 40; + } + + return ret; +} +#endif /* defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4) */ +#endif /* !defined(SQLITE_DISABLE_FTS3_UNICODE) */ + +/************** End of fts3_unicode2.c ***************************************/ +/************** Begin file json1.c *******************************************/ +/* +** 2015-08-12 +** +** 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 SQLite extension implements JSON functions. The interface is +** modeled after MySQL JSON functions: +** +** https://dev.mysql.com/doc/refman/5.7/en/json.html +** +** For the time being, all JSON is stored as pure text. (We might add +** a JSONB type in the future which stores a binary encoding of JSON in +** a BLOB, but there is no support for JSONB in the current implementation. +** This implementation parses JSON text at 250 MB/s, so it is hard to see +** how JSONB might improve on that.) +*/ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_JSON1) +#if !defined(SQLITEINT_H) +/* #include "sqlite3ext.h" */ +#endif +SQLITE_EXTENSION_INIT1 +/* #include */ +/* #include */ +/* #include */ +/* #include */ + +/* Mark a function parameter as unused, to suppress nuisance compiler +** warnings. */ +#ifndef UNUSED_PARAM +# define UNUSED_PARAM(X) (void)(X) +#endif + +#ifndef LARGEST_INT64 +# define LARGEST_INT64 (0xffffffff|(((sqlite3_int64)0x7fffffff)<<32)) +# define SMALLEST_INT64 (((sqlite3_int64)-1) - LARGEST_INT64) +#endif + +#ifndef deliberate_fall_through +# define deliberate_fall_through +#endif + +/* +** Versions of isspace(), isalnum() and isdigit() to which it is safe +** to pass signed char values. +*/ +#ifdef sqlite3Isdigit + /* Use the SQLite core versions if this routine is part of the + ** SQLite amalgamation */ +# define safe_isdigit(x) sqlite3Isdigit(x) +# define safe_isalnum(x) sqlite3Isalnum(x) +# define safe_isxdigit(x) sqlite3Isxdigit(x) +#else + /* Use the standard library for separate compilation */ +#include /* amalgamator: keep */ +# define safe_isdigit(x) isdigit((unsigned char)(x)) +# define safe_isalnum(x) isalnum((unsigned char)(x)) +# define safe_isxdigit(x) isxdigit((unsigned char)(x)) +#endif + +/* +** Growing our own isspace() routine this way is twice as fast as +** the library isspace() function, resulting in a 7% overall performance +** increase for the parser. (Ubuntu14.10 gcc 4.8.4 x64 with -Os). +*/ +static const char jsonIsSpace[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; +#define safe_isspace(x) (jsonIsSpace[(unsigned char)x]) + +#ifndef SQLITE_AMALGAMATION + /* Unsigned integer types. These are already defined in the sqliteInt.h, + ** but the definitions need to be repeated for separate compilation. */ + typedef sqlite3_uint64 u64; + typedef unsigned int u32; + typedef unsigned short int u16; + typedef unsigned char u8; +#endif + +/* Objects */ +typedef struct JsonString JsonString; +typedef struct JsonNode JsonNode; +typedef struct JsonParse JsonParse; + +/* An instance of this object represents a JSON string +** under construction. Really, this is a generic string accumulator +** that can be and is used to create strings other than JSON. +*/ +struct JsonString { + sqlite3_context *pCtx; /* Function context - put error messages here */ + char *zBuf; /* Append JSON content here */ + u64 nAlloc; /* Bytes of storage available in zBuf[] */ + u64 nUsed; /* Bytes of zBuf[] currently used */ + u8 bStatic; /* True if zBuf is static space */ + u8 bErr; /* True if an error has been encountered */ + char zSpace[100]; /* Initial static space */ +}; + +/* JSON type values +*/ +#define JSON_NULL 0 +#define JSON_TRUE 1 +#define JSON_FALSE 2 +#define JSON_INT 3 +#define JSON_REAL 4 +#define JSON_STRING 5 +#define JSON_ARRAY 6 +#define JSON_OBJECT 7 + +/* The "subtype" set for JSON values */ +#define JSON_SUBTYPE 74 /* Ascii for "J" */ + +/* +** Names of the various JSON types: +*/ +static const char * const jsonType[] = { + "null", "true", "false", "integer", "real", "text", "array", "object" +}; + +/* Bit values for the JsonNode.jnFlag field +*/ +#define JNODE_RAW 0x01 /* Content is raw, not JSON encoded */ +#define JNODE_ESCAPE 0x02 /* Content is text with \ escapes */ +#define JNODE_REMOVE 0x04 /* Do not output */ +#define JNODE_REPLACE 0x08 /* Replace with JsonNode.u.iReplace */ +#define JNODE_PATCH 0x10 /* Patch with JsonNode.u.pPatch */ +#define JNODE_APPEND 0x20 /* More ARRAY/OBJECT entries at u.iAppend */ +#define JNODE_LABEL 0x40 /* Is a label of an object */ + + +/* A single node of parsed JSON +*/ +struct JsonNode { + u8 eType; /* One of the JSON_ type values */ + u8 jnFlags; /* JNODE flags */ + u32 n; /* Bytes of content, or number of sub-nodes */ + union { + const char *zJContent; /* Content for INT, REAL, and STRING */ + u32 iAppend; /* More terms for ARRAY and OBJECT */ + u32 iKey; /* Key for ARRAY objects in json_tree() */ + u32 iReplace; /* Replacement content for JNODE_REPLACE */ + JsonNode *pPatch; /* Node chain of patch for JNODE_PATCH */ + } u; +}; + +/* A completely parsed JSON string +*/ +struct JsonParse { + u32 nNode; /* Number of slots of aNode[] used */ + u32 nAlloc; /* Number of slots of aNode[] allocated */ + JsonNode *aNode; /* Array of nodes containing the parse */ + const char *zJson; /* Original JSON string */ + u32 *aUp; /* Index of parent of each node */ + u8 oom; /* Set to true if out of memory */ + u8 nErr; /* Number of errors seen */ + u16 iDepth; /* Nesting depth */ + int nJson; /* Length of the zJson string in bytes */ + u32 iHold; /* Replace cache line with the lowest iHold value */ +}; + +/* +** Maximum nesting depth of JSON for this implementation. +** +** This limit is needed to avoid a stack overflow in the recursive +** descent parser. A depth of 2000 is far deeper than any sane JSON +** should go. +*/ +#define JSON_MAX_DEPTH 2000 + +/************************************************************************** +** Utility routines for dealing with JsonString objects +**************************************************************************/ + +/* Set the JsonString object to an empty string +*/ +static void jsonZero(JsonString *p){ + p->zBuf = p->zSpace; + p->nAlloc = sizeof(p->zSpace); + p->nUsed = 0; + p->bStatic = 1; +} + +/* Initialize the JsonString object +*/ +static void jsonInit(JsonString *p, sqlite3_context *pCtx){ + p->pCtx = pCtx; + p->bErr = 0; + jsonZero(p); +} + + +/* Free all allocated memory and reset the JsonString object back to its +** initial state. +*/ +static void jsonReset(JsonString *p){ + if( !p->bStatic ) sqlite3_free(p->zBuf); + jsonZero(p); +} + + +/* Report an out-of-memory (OOM) condition +*/ +static void jsonOom(JsonString *p){ + p->bErr = 1; + sqlite3_result_error_nomem(p->pCtx); + jsonReset(p); +} + +/* Enlarge pJson->zBuf so that it can hold at least N more bytes. +** Return zero on success. Return non-zero on an OOM error +*/ +static int jsonGrow(JsonString *p, u32 N){ + u64 nTotal = NnAlloc ? p->nAlloc*2 : p->nAlloc+N+10; + char *zNew; + if( p->bStatic ){ + if( p->bErr ) return 1; + zNew = sqlite3_malloc64(nTotal); + if( zNew==0 ){ + jsonOom(p); + return SQLITE_NOMEM; + } + memcpy(zNew, p->zBuf, (size_t)p->nUsed); + p->zBuf = zNew; + p->bStatic = 0; + }else{ + zNew = sqlite3_realloc64(p->zBuf, nTotal); + if( zNew==0 ){ + jsonOom(p); + return SQLITE_NOMEM; + } + p->zBuf = zNew; + } + p->nAlloc = nTotal; + return SQLITE_OK; +} + +/* Append N bytes from zIn onto the end of the JsonString string. +*/ +static void jsonAppendRaw(JsonString *p, const char *zIn, u32 N){ + if( N==0 ) return; + if( (N+p->nUsed >= p->nAlloc) && jsonGrow(p,N)!=0 ) return; + memcpy(p->zBuf+p->nUsed, zIn, N); + p->nUsed += N; +} + +/* Append formatted text (not to exceed N bytes) to the JsonString. +*/ +static void jsonPrintf(int N, JsonString *p, const char *zFormat, ...){ + va_list ap; + if( (p->nUsed + N >= p->nAlloc) && jsonGrow(p, N) ) return; + va_start(ap, zFormat); + sqlite3_vsnprintf(N, p->zBuf+p->nUsed, zFormat, ap); + va_end(ap); + p->nUsed += (int)strlen(p->zBuf+p->nUsed); +} + +/* Append a single character +*/ +static void jsonAppendChar(JsonString *p, char c){ + if( p->nUsed>=p->nAlloc && jsonGrow(p,1)!=0 ) return; + p->zBuf[p->nUsed++] = c; +} + +/* Append a comma separator to the output buffer, if the previous +** character is not '[' or '{'. +*/ +static void jsonAppendSeparator(JsonString *p){ + char c; + if( p->nUsed==0 ) return; + c = p->zBuf[p->nUsed-1]; + if( c!='[' && c!='{' ) jsonAppendChar(p, ','); +} + +/* Append the N-byte string in zIn to the end of the JsonString string +** under construction. Enclose the string in "..." and escape +** any double-quotes or backslash characters contained within the +** string. +*/ +static void jsonAppendString(JsonString *p, const char *zIn, u32 N){ + u32 i; + if( (N+p->nUsed+2 >= p->nAlloc) && jsonGrow(p,N+2)!=0 ) return; + p->zBuf[p->nUsed++] = '"'; + for(i=0; inUsed+N+3-i > p->nAlloc) && jsonGrow(p,N+3-i)!=0 ) return; + p->zBuf[p->nUsed++] = '\\'; + }else if( c<=0x1f ){ + static const char aSpecial[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + assert( sizeof(aSpecial)==32 ); + assert( aSpecial['\b']=='b' ); + assert( aSpecial['\f']=='f' ); + assert( aSpecial['\n']=='n' ); + assert( aSpecial['\r']=='r' ); + assert( aSpecial['\t']=='t' ); + if( aSpecial[c] ){ + c = aSpecial[c]; + goto json_simple_escape; + } + if( (p->nUsed+N+7+i > p->nAlloc) && jsonGrow(p,N+7-i)!=0 ) return; + p->zBuf[p->nUsed++] = '\\'; + p->zBuf[p->nUsed++] = 'u'; + p->zBuf[p->nUsed++] = '0'; + p->zBuf[p->nUsed++] = '0'; + p->zBuf[p->nUsed++] = '0' + (c>>4); + c = "0123456789abcdef"[c&0xf]; + } + p->zBuf[p->nUsed++] = c; + } + p->zBuf[p->nUsed++] = '"'; + assert( p->nUsednAlloc ); +} + +/* +** Append a function parameter value to the JSON string under +** construction. +*/ +static void jsonAppendValue( + JsonString *p, /* Append to this JSON string */ + sqlite3_value *pValue /* Value to append */ +){ + switch( sqlite3_value_type(pValue) ){ + case SQLITE_NULL: { + jsonAppendRaw(p, "null", 4); + break; + } + case SQLITE_INTEGER: + case SQLITE_FLOAT: { + const char *z = (const char*)sqlite3_value_text(pValue); + u32 n = (u32)sqlite3_value_bytes(pValue); + jsonAppendRaw(p, z, n); + break; + } + case SQLITE_TEXT: { + const char *z = (const char*)sqlite3_value_text(pValue); + u32 n = (u32)sqlite3_value_bytes(pValue); + if( sqlite3_value_subtype(pValue)==JSON_SUBTYPE ){ + jsonAppendRaw(p, z, n); + }else{ + jsonAppendString(p, z, n); + } + break; + } + default: { + if( p->bErr==0 ){ + sqlite3_result_error(p->pCtx, "JSON cannot hold BLOB values", -1); + p->bErr = 2; + jsonReset(p); + } + break; + } + } +} + + +/* Make the JSON in p the result of the SQL function. +*/ +static void jsonResult(JsonString *p){ + if( p->bErr==0 ){ + sqlite3_result_text64(p->pCtx, p->zBuf, p->nUsed, + p->bStatic ? SQLITE_TRANSIENT : sqlite3_free, + SQLITE_UTF8); + jsonZero(p); + } + assert( p->bStatic ); +} + +/************************************************************************** +** Utility routines for dealing with JsonNode and JsonParse objects +**************************************************************************/ + +/* +** Return the number of consecutive JsonNode slots need to represent +** the parsed JSON at pNode. The minimum answer is 1. For ARRAY and +** OBJECT types, the number might be larger. +** +** Appended elements are not counted. The value returned is the number +** by which the JsonNode counter should increment in order to go to the +** next peer value. +*/ +static u32 jsonNodeSize(JsonNode *pNode){ + return pNode->eType>=JSON_ARRAY ? pNode->n+1 : 1; +} + +/* +** Reclaim all memory allocated by a JsonParse object. But do not +** delete the JsonParse object itself. +*/ +static void jsonParseReset(JsonParse *pParse){ + sqlite3_free(pParse->aNode); + pParse->aNode = 0; + pParse->nNode = 0; + pParse->nAlloc = 0; + sqlite3_free(pParse->aUp); + pParse->aUp = 0; +} + +/* +** Free a JsonParse object that was obtained from sqlite3_malloc(). +*/ +static void jsonParseFree(JsonParse *pParse){ + jsonParseReset(pParse); + sqlite3_free(pParse); +} + +/* +** Convert the JsonNode pNode into a pure JSON string and +** append to pOut. Subsubstructure is also included. Return +** the number of JsonNode objects that are encoded. +*/ +static void jsonRenderNode( + JsonNode *pNode, /* The node to render */ + JsonString *pOut, /* Write JSON here */ + sqlite3_value **aReplace /* Replacement values */ +){ + if( pNode->jnFlags & (JNODE_REPLACE|JNODE_PATCH) ){ + if( pNode->jnFlags & JNODE_REPLACE ){ + jsonAppendValue(pOut, aReplace[pNode->u.iReplace]); + return; + } + pNode = pNode->u.pPatch; + } + switch( pNode->eType ){ + default: { + assert( pNode->eType==JSON_NULL ); + jsonAppendRaw(pOut, "null", 4); + break; + } + case JSON_TRUE: { + jsonAppendRaw(pOut, "true", 4); + break; + } + case JSON_FALSE: { + jsonAppendRaw(pOut, "false", 5); + break; + } + case JSON_STRING: { + if( pNode->jnFlags & JNODE_RAW ){ + jsonAppendString(pOut, pNode->u.zJContent, pNode->n); + break; + } + /* no break */ deliberate_fall_through + } + case JSON_REAL: + case JSON_INT: { + jsonAppendRaw(pOut, pNode->u.zJContent, pNode->n); + break; + } + case JSON_ARRAY: { + u32 j = 1; + jsonAppendChar(pOut, '['); + for(;;){ + while( j<=pNode->n ){ + if( (pNode[j].jnFlags & JNODE_REMOVE)==0 ){ + jsonAppendSeparator(pOut); + jsonRenderNode(&pNode[j], pOut, aReplace); + } + j += jsonNodeSize(&pNode[j]); + } + if( (pNode->jnFlags & JNODE_APPEND)==0 ) break; + pNode = &pNode[pNode->u.iAppend]; + j = 1; + } + jsonAppendChar(pOut, ']'); + break; + } + case JSON_OBJECT: { + u32 j = 1; + jsonAppendChar(pOut, '{'); + for(;;){ + while( j<=pNode->n ){ + if( (pNode[j+1].jnFlags & JNODE_REMOVE)==0 ){ + jsonAppendSeparator(pOut); + jsonRenderNode(&pNode[j], pOut, aReplace); + jsonAppendChar(pOut, ':'); + jsonRenderNode(&pNode[j+1], pOut, aReplace); + } + j += 1 + jsonNodeSize(&pNode[j+1]); + } + if( (pNode->jnFlags & JNODE_APPEND)==0 ) break; + pNode = &pNode[pNode->u.iAppend]; + j = 1; + } + jsonAppendChar(pOut, '}'); + break; + } + } +} + +/* +** Return a JsonNode and all its descendents as a JSON string. +*/ +static void jsonReturnJson( + JsonNode *pNode, /* Node to return */ + sqlite3_context *pCtx, /* Return value for this function */ + sqlite3_value **aReplace /* Array of replacement values */ +){ + JsonString s; + jsonInit(&s, pCtx); + jsonRenderNode(pNode, &s, aReplace); + jsonResult(&s); + sqlite3_result_subtype(pCtx, JSON_SUBTYPE); +} + +/* +** Translate a single byte of Hex into an integer. +** This routine only works if h really is a valid hexadecimal +** character: 0..9a..fA..F +*/ +static u8 jsonHexToInt(int h){ + assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') ); +#ifdef SQLITE_EBCDIC + h += 9*(1&~(h>>4)); +#else + h += 9*(1&(h>>6)); +#endif + return (u8)(h & 0xf); +} + +/* +** Convert a 4-byte hex string into an integer +*/ +static u32 jsonHexToInt4(const char *z){ + u32 v; + assert( safe_isxdigit(z[0]) ); + assert( safe_isxdigit(z[1]) ); + assert( safe_isxdigit(z[2]) ); + assert( safe_isxdigit(z[3]) ); + v = (jsonHexToInt(z[0])<<12) + + (jsonHexToInt(z[1])<<8) + + (jsonHexToInt(z[2])<<4) + + jsonHexToInt(z[3]); + return v; +} + +/* +** Make the JsonNode the return value of the function. +*/ +static void jsonReturn( + JsonNode *pNode, /* Node to return */ + sqlite3_context *pCtx, /* Return value for this function */ + sqlite3_value **aReplace /* Array of replacement values */ +){ + switch( pNode->eType ){ + default: { + assert( pNode->eType==JSON_NULL ); + sqlite3_result_null(pCtx); + break; + } + case JSON_TRUE: { + sqlite3_result_int(pCtx, 1); + break; + } + case JSON_FALSE: { + sqlite3_result_int(pCtx, 0); + break; + } + case JSON_INT: { + sqlite3_int64 i = 0; + const char *z = pNode->u.zJContent; + if( z[0]=='-' ){ z++; } + while( z[0]>='0' && z[0]<='9' ){ + unsigned v = *(z++) - '0'; + if( i>=LARGEST_INT64/10 ){ + if( i>LARGEST_INT64/10 ) goto int_as_real; + if( z[0]>='0' && z[0]<='9' ) goto int_as_real; + if( v==9 ) goto int_as_real; + if( v==8 ){ + if( pNode->u.zJContent[0]=='-' ){ + sqlite3_result_int64(pCtx, SMALLEST_INT64); + goto int_done; + }else{ + goto int_as_real; + } + } + } + i = i*10 + v; + } + if( pNode->u.zJContent[0]=='-' ){ i = -i; } + sqlite3_result_int64(pCtx, i); + int_done: + break; + int_as_real: i=0; /* no break */ deliberate_fall_through + } + case JSON_REAL: { + double r; +#ifdef SQLITE_AMALGAMATION + const char *z = pNode->u.zJContent; + sqlite3AtoF(z, &r, sqlite3Strlen30(z), SQLITE_UTF8); +#else + r = strtod(pNode->u.zJContent, 0); +#endif + sqlite3_result_double(pCtx, r); + break; + } + case JSON_STRING: { +#if 0 /* Never happens because JNODE_RAW is only set by json_set(), + ** json_insert() and json_replace() and those routines do not + ** call jsonReturn() */ + if( pNode->jnFlags & JNODE_RAW ){ + sqlite3_result_text(pCtx, pNode->u.zJContent, pNode->n, + SQLITE_TRANSIENT); + }else +#endif + assert( (pNode->jnFlags & JNODE_RAW)==0 ); + if( (pNode->jnFlags & JNODE_ESCAPE)==0 ){ + /* JSON formatted without any backslash-escapes */ + sqlite3_result_text(pCtx, pNode->u.zJContent+1, pNode->n-2, + SQLITE_TRANSIENT); + }else{ + /* Translate JSON formatted string into raw text */ + u32 i; + u32 n = pNode->n; + const char *z = pNode->u.zJContent; + char *zOut; + u32 j; + zOut = sqlite3_malloc( n+1 ); + if( zOut==0 ){ + sqlite3_result_error_nomem(pCtx); + break; + } + for(i=1, j=0; i>6)); + zOut[j++] = 0x80 | (v&0x3f); + }else{ + u32 vlo; + if( (v&0xfc00)==0xd800 + && i>18); + zOut[j++] = 0x80 | ((v>>12)&0x3f); + zOut[j++] = 0x80 | ((v>>6)&0x3f); + zOut[j++] = 0x80 | (v&0x3f); + }else{ + zOut[j++] = 0xe0 | (v>>12); + zOut[j++] = 0x80 | ((v>>6)&0x3f); + zOut[j++] = 0x80 | (v&0x3f); + } + } + }else{ + if( c=='b' ){ + c = '\b'; + }else if( c=='f' ){ + c = '\f'; + }else if( c=='n' ){ + c = '\n'; + }else if( c=='r' ){ + c = '\r'; + }else if( c=='t' ){ + c = '\t'; + } + zOut[j++] = c; + } + } + } + zOut[j] = 0; + sqlite3_result_text(pCtx, zOut, j, sqlite3_free); + } + break; + } + case JSON_ARRAY: + case JSON_OBJECT: { + jsonReturnJson(pNode, pCtx, aReplace); + break; + } + } +} + +/* Forward reference */ +static int jsonParseAddNode(JsonParse*,u32,u32,const char*); + +/* +** A macro to hint to the compiler that a function should not be +** inlined. +*/ +#if defined(__GNUC__) +# define JSON_NOINLINE __attribute__((noinline)) +#elif defined(_MSC_VER) && _MSC_VER>=1310 +# define JSON_NOINLINE __declspec(noinline) +#else +# define JSON_NOINLINE +#endif + + +static JSON_NOINLINE int jsonParseAddNodeExpand( + JsonParse *pParse, /* Append the node to this object */ + u32 eType, /* Node type */ + u32 n, /* Content size or sub-node count */ + const char *zContent /* Content */ +){ + u32 nNew; + JsonNode *pNew; + assert( pParse->nNode>=pParse->nAlloc ); + if( pParse->oom ) return -1; + nNew = pParse->nAlloc*2 + 10; + pNew = sqlite3_realloc64(pParse->aNode, sizeof(JsonNode)*nNew); + if( pNew==0 ){ + pParse->oom = 1; + return -1; + } + pParse->nAlloc = nNew; + pParse->aNode = pNew; + assert( pParse->nNodenAlloc ); + return jsonParseAddNode(pParse, eType, n, zContent); +} + +/* +** Create a new JsonNode instance based on the arguments and append that +** instance to the JsonParse. Return the index in pParse->aNode[] of the +** new node, or -1 if a memory allocation fails. +*/ +static int jsonParseAddNode( + JsonParse *pParse, /* Append the node to this object */ + u32 eType, /* Node type */ + u32 n, /* Content size or sub-node count */ + const char *zContent /* Content */ +){ + JsonNode *p; + if( pParse->nNode>=pParse->nAlloc ){ + return jsonParseAddNodeExpand(pParse, eType, n, zContent); + } + p = &pParse->aNode[pParse->nNode]; + p->eType = (u8)eType; + p->jnFlags = 0; + p->n = n; + p->u.zJContent = zContent; + return pParse->nNode++; +} + +/* +** Return true if z[] begins with 4 (or more) hexadecimal digits +*/ +static int jsonIs4Hex(const char *z){ + int i; + for(i=0; i<4; i++) if( !safe_isxdigit(z[i]) ) return 0; + return 1; +} + +/* +** Parse a single JSON value which begins at pParse->zJson[i]. Return the +** index of the first character past the end of the value parsed. +** +** Return negative for a syntax error. Special cases: return -2 if the +** first non-whitespace character is '}' and return -3 if the first +** non-whitespace character is ']'. +*/ +static int jsonParseValue(JsonParse *pParse, u32 i){ + char c; + u32 j; + int iThis; + int x; + JsonNode *pNode; + const char *z = pParse->zJson; + while( safe_isspace(z[i]) ){ i++; } + if( (c = z[i])=='{' ){ + /* Parse object */ + iThis = jsonParseAddNode(pParse, JSON_OBJECT, 0, 0); + if( iThis<0 ) return -1; + for(j=i+1;;j++){ + while( safe_isspace(z[j]) ){ j++; } + if( ++pParse->iDepth > JSON_MAX_DEPTH ) return -1; + x = jsonParseValue(pParse, j); + if( x<0 ){ + pParse->iDepth--; + if( x==(-2) && pParse->nNode==(u32)iThis+1 ) return j+1; + return -1; + } + if( pParse->oom ) return -1; + pNode = &pParse->aNode[pParse->nNode-1]; + if( pNode->eType!=JSON_STRING ) return -1; + pNode->jnFlags |= JNODE_LABEL; + j = x; + while( safe_isspace(z[j]) ){ j++; } + if( z[j]!=':' ) return -1; + j++; + x = jsonParseValue(pParse, j); + pParse->iDepth--; + if( x<0 ) return -1; + j = x; + while( safe_isspace(z[j]) ){ j++; } + c = z[j]; + if( c==',' ) continue; + if( c!='}' ) return -1; + break; + } + pParse->aNode[iThis].n = pParse->nNode - (u32)iThis - 1; + return j+1; + }else if( c=='[' ){ + /* Parse array */ + iThis = jsonParseAddNode(pParse, JSON_ARRAY, 0, 0); + if( iThis<0 ) return -1; + for(j=i+1;;j++){ + while( safe_isspace(z[j]) ){ j++; } + if( ++pParse->iDepth > JSON_MAX_DEPTH ) return -1; + x = jsonParseValue(pParse, j); + pParse->iDepth--; + if( x<0 ){ + if( x==(-3) && pParse->nNode==(u32)iThis+1 ) return j+1; + return -1; + } + j = x; + while( safe_isspace(z[j]) ){ j++; } + c = z[j]; + if( c==',' ) continue; + if( c!=']' ) return -1; + break; + } + pParse->aNode[iThis].n = pParse->nNode - (u32)iThis - 1; + return j+1; + }else if( c=='"' ){ + /* Parse string */ + u8 jnFlags = 0; + j = i+1; + for(;;){ + c = z[j]; + if( (c & ~0x1f)==0 ){ + /* Control characters are not allowed in strings */ + return -1; + } + if( c=='\\' ){ + c = z[++j]; + if( c=='"' || c=='\\' || c=='/' || c=='b' || c=='f' + || c=='n' || c=='r' || c=='t' + || (c=='u' && jsonIs4Hex(z+j+1)) ){ + jnFlags = JNODE_ESCAPE; + }else{ + return -1; + } + }else if( c=='"' ){ + break; + } + j++; + } + jsonParseAddNode(pParse, JSON_STRING, j+1-i, &z[i]); + if( !pParse->oom ) pParse->aNode[pParse->nNode-1].jnFlags = jnFlags; + return j+1; + }else if( c=='n' + && strncmp(z+i,"null",4)==0 + && !safe_isalnum(z[i+4]) ){ + jsonParseAddNode(pParse, JSON_NULL, 0, 0); + return i+4; + }else if( c=='t' + && strncmp(z+i,"true",4)==0 + && !safe_isalnum(z[i+4]) ){ + jsonParseAddNode(pParse, JSON_TRUE, 0, 0); + return i+4; + }else if( c=='f' + && strncmp(z+i,"false",5)==0 + && !safe_isalnum(z[i+5]) ){ + jsonParseAddNode(pParse, JSON_FALSE, 0, 0); + return i+5; + }else if( c=='-' || (c>='0' && c<='9') ){ + /* Parse number */ + u8 seenDP = 0; + u8 seenE = 0; + assert( '-' < '0' ); + if( c<='0' ){ + j = c=='-' ? i+1 : i; + if( z[j]=='0' && z[j+1]>='0' && z[j+1]<='9' ) return -1; + } + j = i+1; + for(;; j++){ + c = z[j]; + if( c>='0' && c<='9' ) continue; + if( c=='.' ){ + if( z[j-1]=='-' ) return -1; + if( seenDP ) return -1; + seenDP = 1; + continue; + } + if( c=='e' || c=='E' ){ + if( z[j-1]<'0' ) return -1; + if( seenE ) return -1; + seenDP = seenE = 1; + c = z[j+1]; + if( c=='+' || c=='-' ){ + j++; + c = z[j+1]; + } + if( c<'0' || c>'9' ) return -1; + continue; + } + break; + } + if( z[j-1]<'0' ) return -1; + jsonParseAddNode(pParse, seenDP ? JSON_REAL : JSON_INT, + j - i, &z[i]); + return j; + }else if( c=='}' ){ + return -2; /* End of {...} */ + }else if( c==']' ){ + return -3; /* End of [...] */ + }else if( c==0 ){ + return 0; /* End of file */ + }else{ + return -1; /* Syntax error */ + } +} + +/* +** Parse a complete JSON string. Return 0 on success or non-zero if there +** are any errors. If an error occurs, free all memory associated with +** pParse. +** +** pParse is uninitialized when this routine is called. +*/ +static int jsonParse( + JsonParse *pParse, /* Initialize and fill this JsonParse object */ + sqlite3_context *pCtx, /* Report errors here */ + const char *zJson /* Input JSON text to be parsed */ +){ + int i; + memset(pParse, 0, sizeof(*pParse)); + if( zJson==0 ) return 1; + pParse->zJson = zJson; + i = jsonParseValue(pParse, 0); + if( pParse->oom ) i = -1; + if( i>0 ){ + assert( pParse->iDepth==0 ); + while( safe_isspace(zJson[i]) ) i++; + if( zJson[i] ) i = -1; + } + if( i<=0 ){ + if( pCtx!=0 ){ + if( pParse->oom ){ + sqlite3_result_error_nomem(pCtx); + }else{ + sqlite3_result_error(pCtx, "malformed JSON", -1); + } + } + jsonParseReset(pParse); + return 1; + } + return 0; +} + +/* Mark node i of pParse as being a child of iParent. Call recursively +** to fill in all the descendants of node i. +*/ +static void jsonParseFillInParentage(JsonParse *pParse, u32 i, u32 iParent){ + JsonNode *pNode = &pParse->aNode[i]; + u32 j; + pParse->aUp[i] = iParent; + switch( pNode->eType ){ + case JSON_ARRAY: { + for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j)){ + jsonParseFillInParentage(pParse, i+j, i); + } + break; + } + case JSON_OBJECT: { + for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j+1)+1){ + pParse->aUp[i+j] = i; + jsonParseFillInParentage(pParse, i+j+1, i); + } + break; + } + default: { + break; + } + } +} + +/* +** Compute the parentage of all nodes in a completed parse. +*/ +static int jsonParseFindParents(JsonParse *pParse){ + u32 *aUp; + assert( pParse->aUp==0 ); + aUp = pParse->aUp = sqlite3_malloc64( sizeof(u32)*pParse->nNode ); + if( aUp==0 ){ + pParse->oom = 1; + return SQLITE_NOMEM; + } + jsonParseFillInParentage(pParse, 0, 0); + return SQLITE_OK; +} + +/* +** Magic number used for the JSON parse cache in sqlite3_get_auxdata() +*/ +#define JSON_CACHE_ID (-429938) /* First cache entry */ +#define JSON_CACHE_SZ 4 /* Max number of cache entries */ + +/* +** Obtain a complete parse of the JSON found in the first argument +** of the argv array. Use the sqlite3_get_auxdata() cache for this +** parse if it is available. If the cache is not available or if it +** is no longer valid, parse the JSON again and return the new parse, +** and also register the new parse so that it will be available for +** future sqlite3_get_auxdata() calls. +*/ +static JsonParse *jsonParseCached( + sqlite3_context *pCtx, + sqlite3_value **argv, + sqlite3_context *pErrCtx +){ + const char *zJson = (const char*)sqlite3_value_text(argv[0]); + int nJson = sqlite3_value_bytes(argv[0]); + JsonParse *p; + JsonParse *pMatch = 0; + int iKey; + int iMinKey = 0; + u32 iMinHold = 0xffffffff; + u32 iMaxHold = 0; + if( zJson==0 ) return 0; + for(iKey=0; iKeynJson==nJson + && memcmp(p->zJson,zJson,nJson)==0 + ){ + p->nErr = 0; + pMatch = p; + }else if( p->iHoldiHold; + iMinKey = iKey; + } + if( p->iHold>iMaxHold ){ + iMaxHold = p->iHold; + } + } + if( pMatch ){ + pMatch->nErr = 0; + pMatch->iHold = iMaxHold+1; + return pMatch; + } + p = sqlite3_malloc64( sizeof(*p) + nJson + 1 ); + if( p==0 ){ + sqlite3_result_error_nomem(pCtx); + return 0; + } + memset(p, 0, sizeof(*p)); + p->zJson = (char*)&p[1]; + memcpy((char*)p->zJson, zJson, nJson+1); + if( jsonParse(p, pErrCtx, p->zJson) ){ + sqlite3_free(p); + return 0; + } + p->nJson = nJson; + p->iHold = iMaxHold+1; + sqlite3_set_auxdata(pCtx, JSON_CACHE_ID+iMinKey, p, + (void(*)(void*))jsonParseFree); + return (JsonParse*)sqlite3_get_auxdata(pCtx, JSON_CACHE_ID+iMinKey); +} + +/* +** Compare the OBJECT label at pNode against zKey,nKey. Return true on +** a match. +*/ +static int jsonLabelCompare(JsonNode *pNode, const char *zKey, u32 nKey){ + if( pNode->jnFlags & JNODE_RAW ){ + if( pNode->n!=nKey ) return 0; + return strncmp(pNode->u.zJContent, zKey, nKey)==0; + }else{ + if( pNode->n!=nKey+2 ) return 0; + return strncmp(pNode->u.zJContent+1, zKey, nKey)==0; + } +} + +/* forward declaration */ +static JsonNode *jsonLookupAppend(JsonParse*,const char*,int*,const char**); + +/* +** Search along zPath to find the node specified. Return a pointer +** to that node, or NULL if zPath is malformed or if there is no such +** node. +** +** If pApnd!=0, then try to append new nodes to complete zPath if it is +** possible to do so and if no existing node corresponds to zPath. If +** new nodes are appended *pApnd is set to 1. +*/ +static JsonNode *jsonLookupStep( + JsonParse *pParse, /* The JSON to search */ + u32 iRoot, /* Begin the search at this node */ + const char *zPath, /* The path to search */ + int *pApnd, /* Append nodes to complete path if not NULL */ + const char **pzErr /* Make *pzErr point to any syntax error in zPath */ +){ + u32 i, j, nKey; + const char *zKey; + JsonNode *pRoot = &pParse->aNode[iRoot]; + if( zPath[0]==0 ) return pRoot; + if( pRoot->jnFlags & JNODE_REPLACE ) return 0; + if( zPath[0]=='.' ){ + if( pRoot->eType!=JSON_OBJECT ) return 0; + zPath++; + if( zPath[0]=='"' ){ + zKey = zPath + 1; + for(i=1; zPath[i] && zPath[i]!='"'; i++){} + nKey = i-1; + if( zPath[i] ){ + i++; + }else{ + *pzErr = zPath; + return 0; + } + }else{ + zKey = zPath; + for(i=0; zPath[i] && zPath[i]!='.' && zPath[i]!='['; i++){} + nKey = i; + } + if( nKey==0 ){ + *pzErr = zPath; + return 0; + } + j = 1; + for(;;){ + while( j<=pRoot->n ){ + if( jsonLabelCompare(pRoot+j, zKey, nKey) ){ + return jsonLookupStep(pParse, iRoot+j+1, &zPath[i], pApnd, pzErr); + } + j++; + j += jsonNodeSize(&pRoot[j]); + } + if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break; + iRoot += pRoot->u.iAppend; + pRoot = &pParse->aNode[iRoot]; + j = 1; + } + if( pApnd ){ + u32 iStart, iLabel; + JsonNode *pNode; + iStart = jsonParseAddNode(pParse, JSON_OBJECT, 2, 0); + iLabel = jsonParseAddNode(pParse, JSON_STRING, nKey, zKey); + zPath += i; + pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr); + if( pParse->oom ) return 0; + if( pNode ){ + pRoot = &pParse->aNode[iRoot]; + pRoot->u.iAppend = iStart - iRoot; + pRoot->jnFlags |= JNODE_APPEND; + pParse->aNode[iLabel].jnFlags |= JNODE_RAW; + } + return pNode; + } + }else if( zPath[0]=='[' ){ + i = 0; + j = 1; + while( safe_isdigit(zPath[j]) ){ + i = i*10 + zPath[j] - '0'; + j++; + } + if( j<2 || zPath[j]!=']' ){ + if( zPath[1]=='#' ){ + JsonNode *pBase = pRoot; + int iBase = iRoot; + if( pRoot->eType!=JSON_ARRAY ) return 0; + for(;;){ + while( j<=pBase->n ){ + if( (pBase[j].jnFlags & JNODE_REMOVE)==0 ) i++; + j += jsonNodeSize(&pBase[j]); + } + if( (pBase->jnFlags & JNODE_APPEND)==0 ) break; + iBase += pBase->u.iAppend; + pBase = &pParse->aNode[iBase]; + j = 1; + } + j = 2; + if( zPath[2]=='-' && safe_isdigit(zPath[3]) ){ + unsigned int x = 0; + j = 3; + do{ + x = x*10 + zPath[j] - '0'; + j++; + }while( safe_isdigit(zPath[j]) ); + if( x>i ) return 0; + i -= x; + } + if( zPath[j]!=']' ){ + *pzErr = zPath; + return 0; + } + }else{ + *pzErr = zPath; + return 0; + } + } + if( pRoot->eType!=JSON_ARRAY ) return 0; + zPath += j + 1; + j = 1; + for(;;){ + while( j<=pRoot->n && (i>0 || (pRoot[j].jnFlags & JNODE_REMOVE)!=0) ){ + if( (pRoot[j].jnFlags & JNODE_REMOVE)==0 ) i--; + j += jsonNodeSize(&pRoot[j]); + } + if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break; + iRoot += pRoot->u.iAppend; + pRoot = &pParse->aNode[iRoot]; + j = 1; + } + if( j<=pRoot->n ){ + return jsonLookupStep(pParse, iRoot+j, zPath, pApnd, pzErr); + } + if( i==0 && pApnd ){ + u32 iStart; + JsonNode *pNode; + iStart = jsonParseAddNode(pParse, JSON_ARRAY, 1, 0); + pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr); + if( pParse->oom ) return 0; + if( pNode ){ + pRoot = &pParse->aNode[iRoot]; + pRoot->u.iAppend = iStart - iRoot; + pRoot->jnFlags |= JNODE_APPEND; + } + return pNode; + } + }else{ + *pzErr = zPath; + } + return 0; +} + +/* +** Append content to pParse that will complete zPath. Return a pointer +** to the inserted node, or return NULL if the append fails. +*/ +static JsonNode *jsonLookupAppend( + JsonParse *pParse, /* Append content to the JSON parse */ + const char *zPath, /* Description of content to append */ + int *pApnd, /* Set this flag to 1 */ + const char **pzErr /* Make this point to any syntax error */ +){ + *pApnd = 1; + if( zPath[0]==0 ){ + jsonParseAddNode(pParse, JSON_NULL, 0, 0); + return pParse->oom ? 0 : &pParse->aNode[pParse->nNode-1]; + } + if( zPath[0]=='.' ){ + jsonParseAddNode(pParse, JSON_OBJECT, 0, 0); + }else if( strncmp(zPath,"[0]",3)==0 ){ + jsonParseAddNode(pParse, JSON_ARRAY, 0, 0); + }else{ + return 0; + } + if( pParse->oom ) return 0; + return jsonLookupStep(pParse, pParse->nNode-1, zPath, pApnd, pzErr); +} + +/* +** Return the text of a syntax error message on a JSON path. Space is +** obtained from sqlite3_malloc(). +*/ +static char *jsonPathSyntaxError(const char *zErr){ + return sqlite3_mprintf("JSON path error near '%q'", zErr); +} + +/* +** Do a node lookup using zPath. Return a pointer to the node on success. +** Return NULL if not found or if there is an error. +** +** On an error, write an error message into pCtx and increment the +** pParse->nErr counter. +** +** If pApnd!=NULL then try to append missing nodes and set *pApnd = 1 if +** nodes are appended. +*/ +static JsonNode *jsonLookup( + JsonParse *pParse, /* The JSON to search */ + const char *zPath, /* The path to search */ + int *pApnd, /* Append nodes to complete path if not NULL */ + sqlite3_context *pCtx /* Report errors here, if not NULL */ +){ + const char *zErr = 0; + JsonNode *pNode = 0; + char *zMsg; + + if( zPath==0 ) return 0; + if( zPath[0]!='$' ){ + zErr = zPath; + goto lookup_err; + } + zPath++; + pNode = jsonLookupStep(pParse, 0, zPath, pApnd, &zErr); + if( zErr==0 ) return pNode; + +lookup_err: + pParse->nErr++; + assert( zErr!=0 && pCtx!=0 ); + zMsg = jsonPathSyntaxError(zErr); + if( zMsg ){ + sqlite3_result_error(pCtx, zMsg, -1); + sqlite3_free(zMsg); + }else{ + sqlite3_result_error_nomem(pCtx); + } + return 0; +} + + +/* +** Report the wrong number of arguments for json_insert(), json_replace() +** or json_set(). +*/ +static void jsonWrongNumArgs( + sqlite3_context *pCtx, + const char *zFuncName +){ + char *zMsg = sqlite3_mprintf("json_%s() needs an odd number of arguments", + zFuncName); + sqlite3_result_error(pCtx, zMsg, -1); + sqlite3_free(zMsg); +} + +/* +** Mark all NULL entries in the Object passed in as JNODE_REMOVE. +*/ +static void jsonRemoveAllNulls(JsonNode *pNode){ + int i, n; + assert( pNode->eType==JSON_OBJECT ); + n = pNode->n; + for(i=2; i<=n; i += jsonNodeSize(&pNode[i])+1){ + switch( pNode[i].eType ){ + case JSON_NULL: + pNode[i].jnFlags |= JNODE_REMOVE; + break; + case JSON_OBJECT: + jsonRemoveAllNulls(&pNode[i]); + break; + } + } +} + + +/**************************************************************************** +** SQL functions used for testing and debugging +****************************************************************************/ + +#ifdef SQLITE_DEBUG +/* +** The json_parse(JSON) function returns a string which describes +** a parse of the JSON provided. Or it returns NULL if JSON is not +** well-formed. +*/ +static void jsonParseFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonString s; /* Output string - not real JSON */ + JsonParse x; /* The parse */ + u32 i; + + assert( argc==1 ); + if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; + jsonParseFindParents(&x); + jsonInit(&s, ctx); + for(i=0; inNode ); + if( argc==2 ){ + const char *zPath = (const char*)sqlite3_value_text(argv[1]); + pNode = jsonLookup(p, zPath, 0, ctx); + }else{ + pNode = p->aNode; + } + if( pNode==0 ){ + return; + } + if( pNode->eType==JSON_ARRAY ){ + assert( (pNode->jnFlags & JNODE_APPEND)==0 ); + for(i=1; i<=pNode->n; n++){ + i += jsonNodeSize(&pNode[i]); + } + } + sqlite3_result_int64(ctx, n); +} + +/* +** json_extract(JSON, PATH, ...) +** +** Return the element described by PATH. Return NULL if there is no +** PATH element. If there are multiple PATHs, then return a JSON array +** with the result from each path. Throw an error if the JSON or any PATH +** is malformed. +*/ +static void jsonExtractFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonParse *p; /* The parse */ + JsonNode *pNode; + const char *zPath; + JsonString jx; + int i; + + if( argc<2 ) return; + p = jsonParseCached(ctx, argv, ctx); + if( p==0 ) return; + jsonInit(&jx, ctx); + jsonAppendChar(&jx, '['); + for(i=1; inErr ) break; + if( argc>2 ){ + jsonAppendSeparator(&jx); + if( pNode ){ + jsonRenderNode(pNode, &jx, 0); + }else{ + jsonAppendRaw(&jx, "null", 4); + } + }else if( pNode ){ + jsonReturn(pNode, ctx, 0); + } + } + if( argc>2 && i==argc ){ + jsonAppendChar(&jx, ']'); + jsonResult(&jx); + sqlite3_result_subtype(ctx, JSON_SUBTYPE); + } + jsonReset(&jx); +} + +/* This is the RFC 7396 MergePatch algorithm. +*/ +static JsonNode *jsonMergePatch( + JsonParse *pParse, /* The JSON parser that contains the TARGET */ + u32 iTarget, /* Node of the TARGET in pParse */ + JsonNode *pPatch /* The PATCH */ +){ + u32 i, j; + u32 iRoot; + JsonNode *pTarget; + if( pPatch->eType!=JSON_OBJECT ){ + return pPatch; + } + assert( iTarget>=0 && iTargetnNode ); + pTarget = &pParse->aNode[iTarget]; + assert( (pPatch->jnFlags & JNODE_APPEND)==0 ); + if( pTarget->eType!=JSON_OBJECT ){ + jsonRemoveAllNulls(pPatch); + return pPatch; + } + iRoot = iTarget; + for(i=1; in; i += jsonNodeSize(&pPatch[i+1])+1){ + u32 nKey; + const char *zKey; + assert( pPatch[i].eType==JSON_STRING ); + assert( pPatch[i].jnFlags & JNODE_LABEL ); + nKey = pPatch[i].n; + zKey = pPatch[i].u.zJContent; + assert( (pPatch[i].jnFlags & JNODE_RAW)==0 ); + for(j=1; jn; j += jsonNodeSize(&pTarget[j+1])+1 ){ + assert( pTarget[j].eType==JSON_STRING ); + assert( pTarget[j].jnFlags & JNODE_LABEL ); + assert( (pPatch[i].jnFlags & JNODE_RAW)==0 ); + if( pTarget[j].n==nKey && strncmp(pTarget[j].u.zJContent,zKey,nKey)==0 ){ + if( pTarget[j+1].jnFlags & (JNODE_REMOVE|JNODE_PATCH) ) break; + if( pPatch[i+1].eType==JSON_NULL ){ + pTarget[j+1].jnFlags |= JNODE_REMOVE; + }else{ + JsonNode *pNew = jsonMergePatch(pParse, iTarget+j+1, &pPatch[i+1]); + if( pNew==0 ) return 0; + pTarget = &pParse->aNode[iTarget]; + if( pNew!=&pTarget[j+1] ){ + pTarget[j+1].u.pPatch = pNew; + pTarget[j+1].jnFlags |= JNODE_PATCH; + } + } + break; + } + } + if( j>=pTarget->n && pPatch[i+1].eType!=JSON_NULL ){ + int iStart, iPatch; + iStart = jsonParseAddNode(pParse, JSON_OBJECT, 2, 0); + jsonParseAddNode(pParse, JSON_STRING, nKey, zKey); + iPatch = jsonParseAddNode(pParse, JSON_TRUE, 0, 0); + if( pParse->oom ) return 0; + jsonRemoveAllNulls(pPatch); + pTarget = &pParse->aNode[iTarget]; + pParse->aNode[iRoot].jnFlags |= JNODE_APPEND; + pParse->aNode[iRoot].u.iAppend = iStart - iRoot; + iRoot = iStart; + pParse->aNode[iPatch].jnFlags |= JNODE_PATCH; + pParse->aNode[iPatch].u.pPatch = &pPatch[i+1]; + } + } + return pTarget; +} + +/* +** Implementation of the json_mergepatch(JSON1,JSON2) function. Return a JSON +** object that is the result of running the RFC 7396 MergePatch() algorithm +** on the two arguments. +*/ +static void jsonPatchFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonParse x; /* The JSON that is being patched */ + JsonParse y; /* The patch */ + JsonNode *pResult; /* The result of the merge */ + + UNUSED_PARAM(argc); + if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; + if( jsonParse(&y, ctx, (const char*)sqlite3_value_text(argv[1])) ){ + jsonParseReset(&x); + return; + } + pResult = jsonMergePatch(&x, 0, y.aNode); + assert( pResult!=0 || x.oom ); + if( pResult ){ + jsonReturnJson(pResult, ctx, 0); + }else{ + sqlite3_result_error_nomem(ctx); + } + jsonParseReset(&x); + jsonParseReset(&y); +} + + +/* +** Implementation of the json_object(NAME,VALUE,...) function. Return a JSON +** object that contains all name/value given in arguments. Or if any name +** is not a string or if any value is a BLOB, throw an error. +*/ +static void jsonObjectFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + int i; + JsonString jx; + const char *z; + u32 n; + + if( argc&1 ){ + sqlite3_result_error(ctx, "json_object() requires an even number " + "of arguments", -1); + return; + } + jsonInit(&jx, ctx); + jsonAppendChar(&jx, '{'); + for(i=0; ijnFlags |= JNODE_REMOVE; + } + if( (x.aNode[0].jnFlags & JNODE_REMOVE)==0 ){ + jsonReturnJson(x.aNode, ctx, 0); + } +remove_done: + jsonParseReset(&x); +} + +/* +** json_replace(JSON, PATH, VALUE, ...) +** +** Replace the value at PATH with VALUE. If PATH does not already exist, +** this routine is a no-op. If JSON or PATH is malformed, throw an error. +*/ +static void jsonReplaceFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonParse x; /* The parse */ + JsonNode *pNode; + const char *zPath; + u32 i; + + if( argc<1 ) return; + if( (argc&1)==0 ) { + jsonWrongNumArgs(ctx, "replace"); + return; + } + if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; + assert( x.nNode ); + for(i=1; i<(u32)argc; i+=2){ + zPath = (const char*)sqlite3_value_text(argv[i]); + pNode = jsonLookup(&x, zPath, 0, ctx); + if( x.nErr ) goto replace_err; + if( pNode ){ + pNode->jnFlags |= (u8)JNODE_REPLACE; + pNode->u.iReplace = i + 1; + } + } + if( x.aNode[0].jnFlags & JNODE_REPLACE ){ + sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]); + }else{ + jsonReturnJson(x.aNode, ctx, argv); + } +replace_err: + jsonParseReset(&x); +} + +/* +** json_set(JSON, PATH, VALUE, ...) +** +** Set the value at PATH to VALUE. Create the PATH if it does not already +** exist. Overwrite existing values that do exist. +** If JSON or PATH is malformed, throw an error. +** +** json_insert(JSON, PATH, VALUE, ...) +** +** Create PATH and initialize it to VALUE. If PATH already exists, this +** routine is a no-op. If JSON or PATH is malformed, throw an error. +*/ +static void jsonSetFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonParse x; /* The parse */ + JsonNode *pNode; + const char *zPath; + u32 i; + int bApnd; + int bIsSet = *(int*)sqlite3_user_data(ctx); + + if( argc<1 ) return; + if( (argc&1)==0 ) { + jsonWrongNumArgs(ctx, bIsSet ? "set" : "insert"); + return; + } + if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; + assert( x.nNode ); + for(i=1; i<(u32)argc; i+=2){ + zPath = (const char*)sqlite3_value_text(argv[i]); + bApnd = 0; + pNode = jsonLookup(&x, zPath, &bApnd, ctx); + if( x.oom ){ + sqlite3_result_error_nomem(ctx); + goto jsonSetDone; + }else if( x.nErr ){ + goto jsonSetDone; + }else if( pNode && (bApnd || bIsSet) ){ + pNode->jnFlags |= (u8)JNODE_REPLACE; + pNode->u.iReplace = i + 1; + } + } + if( x.aNode[0].jnFlags & JNODE_REPLACE ){ + sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]); + }else{ + jsonReturnJson(x.aNode, ctx, argv); + } +jsonSetDone: + jsonParseReset(&x); +} + +/* +** json_type(JSON) +** json_type(JSON, PATH) +** +** Return the top-level "type" of a JSON string. Throw an error if +** either the JSON or PATH inputs are not well-formed. +*/ +static void jsonTypeFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonParse *p; /* The parse */ + const char *zPath; + JsonNode *pNode; + + p = jsonParseCached(ctx, argv, ctx); + if( p==0 ) return; + if( argc==2 ){ + zPath = (const char*)sqlite3_value_text(argv[1]); + pNode = jsonLookup(p, zPath, 0, ctx); + }else{ + pNode = p->aNode; + } + if( pNode ){ + sqlite3_result_text(ctx, jsonType[pNode->eType], -1, SQLITE_STATIC); + } +} + +/* +** json_valid(JSON) +** +** Return 1 if JSON is a well-formed JSON string according to RFC-7159. +** Return 0 otherwise. +*/ +static void jsonValidFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonParse *p; /* The parse */ + UNUSED_PARAM(argc); + p = jsonParseCached(ctx, argv, 0); + sqlite3_result_int(ctx, p!=0); +} + + +/**************************************************************************** +** Aggregate SQL function implementations +****************************************************************************/ +/* +** json_group_array(VALUE) +** +** Return a JSON array composed of all values in the aggregate. +*/ +static void jsonArrayStep( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonString *pStr; + UNUSED_PARAM(argc); + pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr)); + if( pStr ){ + if( pStr->zBuf==0 ){ + jsonInit(pStr, ctx); + jsonAppendChar(pStr, '['); + }else if( pStr->nUsed>1 ){ + jsonAppendChar(pStr, ','); + pStr->pCtx = ctx; + } + jsonAppendValue(pStr, argv[0]); + } +} +static void jsonArrayCompute(sqlite3_context *ctx, int isFinal){ + JsonString *pStr; + pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0); + if( pStr ){ + pStr->pCtx = ctx; + jsonAppendChar(pStr, ']'); + if( pStr->bErr ){ + if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx); + assert( pStr->bStatic ); + }else if( isFinal ){ + sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, + pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free); + pStr->bStatic = 1; + }else{ + sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, SQLITE_TRANSIENT); + pStr->nUsed--; + } + }else{ + sqlite3_result_text(ctx, "[]", 2, SQLITE_STATIC); + } + sqlite3_result_subtype(ctx, JSON_SUBTYPE); +} +static void jsonArrayValue(sqlite3_context *ctx){ + jsonArrayCompute(ctx, 0); +} +static void jsonArrayFinal(sqlite3_context *ctx){ + jsonArrayCompute(ctx, 1); +} + +#ifndef SQLITE_OMIT_WINDOWFUNC +/* +** This method works for both json_group_array() and json_group_object(). +** It works by removing the first element of the group by searching forward +** to the first comma (",") that is not within a string and deleting all +** text through that comma. +*/ +static void jsonGroupInverse( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + unsigned int i; + int inStr = 0; + int nNest = 0; + char *z; + char c; + JsonString *pStr; + UNUSED_PARAM(argc); + UNUSED_PARAM(argv); + pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0); +#ifdef NEVER + /* pStr is always non-NULL since jsonArrayStep() or jsonObjectStep() will + ** always have been called to initalize it */ + if( NEVER(!pStr) ) return; +#endif + z = pStr->zBuf; + for(i=1; (c = z[i])!=',' || inStr || nNest; i++){ + if( i>=pStr->nUsed ){ + pStr->nUsed = 1; + return; + } + if( c=='"' ){ + inStr = !inStr; + }else if( c=='\\' ){ + i++; + }else if( !inStr ){ + if( c=='{' || c=='[' ) nNest++; + if( c=='}' || c==']' ) nNest--; + } + } + pStr->nUsed -= i; + memmove(&z[1], &z[i+1], (size_t)pStr->nUsed-1); +} +#else +# define jsonGroupInverse 0 +#endif + + +/* +** json_group_obj(NAME,VALUE) +** +** Return a JSON object composed of all names and values in the aggregate. +*/ +static void jsonObjectStep( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonString *pStr; + const char *z; + u32 n; + UNUSED_PARAM(argc); + pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr)); + if( pStr ){ + if( pStr->zBuf==0 ){ + jsonInit(pStr, ctx); + jsonAppendChar(pStr, '{'); + }else if( pStr->nUsed>1 ){ + jsonAppendChar(pStr, ','); + pStr->pCtx = ctx; + } + z = (const char*)sqlite3_value_text(argv[0]); + n = (u32)sqlite3_value_bytes(argv[0]); + jsonAppendString(pStr, z, n); + jsonAppendChar(pStr, ':'); + jsonAppendValue(pStr, argv[1]); + } +} +static void jsonObjectCompute(sqlite3_context *ctx, int isFinal){ + JsonString *pStr; + pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0); + if( pStr ){ + jsonAppendChar(pStr, '}'); + if( pStr->bErr ){ + if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx); + assert( pStr->bStatic ); + }else if( isFinal ){ + sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, + pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free); + pStr->bStatic = 1; + }else{ + sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, SQLITE_TRANSIENT); + pStr->nUsed--; + } + }else{ + sqlite3_result_text(ctx, "{}", 2, SQLITE_STATIC); + } + sqlite3_result_subtype(ctx, JSON_SUBTYPE); +} +static void jsonObjectValue(sqlite3_context *ctx){ + jsonObjectCompute(ctx, 0); +} +static void jsonObjectFinal(sqlite3_context *ctx){ + jsonObjectCompute(ctx, 1); +} + + + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/**************************************************************************** +** The json_each virtual table +****************************************************************************/ +typedef struct JsonEachCursor JsonEachCursor; +struct JsonEachCursor { + sqlite3_vtab_cursor base; /* Base class - must be first */ + u32 iRowid; /* The rowid */ + u32 iBegin; /* The first node of the scan */ + u32 i; /* Index in sParse.aNode[] of current row */ + u32 iEnd; /* EOF when i equals or exceeds this value */ + u8 eType; /* Type of top-level element */ + u8 bRecursive; /* True for json_tree(). False for json_each() */ + char *zJson; /* Input JSON */ + char *zRoot; /* Path by which to filter zJson */ + JsonParse sParse; /* Parse of the input JSON */ +}; + +/* Constructor for the json_each virtual table */ +static int jsonEachConnect( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + sqlite3_vtab *pNew; + int rc; + +/* Column numbers */ +#define JEACH_KEY 0 +#define JEACH_VALUE 1 +#define JEACH_TYPE 2 +#define JEACH_ATOM 3 +#define JEACH_ID 4 +#define JEACH_PARENT 5 +#define JEACH_FULLKEY 6 +#define JEACH_PATH 7 +/* The xBestIndex method assumes that the JSON and ROOT columns are +** the last two columns in the table. Should this ever changes, be +** sure to update the xBestIndex method. */ +#define JEACH_JSON 8 +#define JEACH_ROOT 9 + + UNUSED_PARAM(pzErr); + UNUSED_PARAM(argv); + UNUSED_PARAM(argc); + UNUSED_PARAM(pAux); + rc = sqlite3_declare_vtab(db, + "CREATE TABLE x(key,value,type,atom,id,parent,fullkey,path," + "json HIDDEN,root HIDDEN)"); + if( rc==SQLITE_OK ){ + pNew = *ppVtab = sqlite3_malloc( sizeof(*pNew) ); + if( pNew==0 ) return SQLITE_NOMEM; + memset(pNew, 0, sizeof(*pNew)); + sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS); + } + return rc; +} + +/* destructor for json_each virtual table */ +static int jsonEachDisconnect(sqlite3_vtab *pVtab){ + sqlite3_free(pVtab); + return SQLITE_OK; +} + +/* constructor for a JsonEachCursor object for json_each(). */ +static int jsonEachOpenEach(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ + JsonEachCursor *pCur; + + UNUSED_PARAM(p); + pCur = sqlite3_malloc( sizeof(*pCur) ); + if( pCur==0 ) return SQLITE_NOMEM; + memset(pCur, 0, sizeof(*pCur)); + *ppCursor = &pCur->base; + return SQLITE_OK; +} + +/* constructor for a JsonEachCursor object for json_tree(). */ +static int jsonEachOpenTree(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ + int rc = jsonEachOpenEach(p, ppCursor); + if( rc==SQLITE_OK ){ + JsonEachCursor *pCur = (JsonEachCursor*)*ppCursor; + pCur->bRecursive = 1; + } + return rc; +} + +/* Reset a JsonEachCursor back to its original state. Free any memory +** held. */ +static void jsonEachCursorReset(JsonEachCursor *p){ + sqlite3_free(p->zJson); + sqlite3_free(p->zRoot); + jsonParseReset(&p->sParse); + p->iRowid = 0; + p->i = 0; + p->iEnd = 0; + p->eType = 0; + p->zJson = 0; + p->zRoot = 0; +} + +/* Destructor for a jsonEachCursor object */ +static int jsonEachClose(sqlite3_vtab_cursor *cur){ + JsonEachCursor *p = (JsonEachCursor*)cur; + jsonEachCursorReset(p); + sqlite3_free(cur); + return SQLITE_OK; +} + +/* Return TRUE if the jsonEachCursor object has been advanced off the end +** of the JSON object */ +static int jsonEachEof(sqlite3_vtab_cursor *cur){ + JsonEachCursor *p = (JsonEachCursor*)cur; + return p->i >= p->iEnd; +} + +/* Advance the cursor to the next element for json_tree() */ +static int jsonEachNext(sqlite3_vtab_cursor *cur){ + JsonEachCursor *p = (JsonEachCursor*)cur; + if( p->bRecursive ){ + if( p->sParse.aNode[p->i].jnFlags & JNODE_LABEL ) p->i++; + p->i++; + p->iRowid++; + if( p->iiEnd ){ + u32 iUp = p->sParse.aUp[p->i]; + JsonNode *pUp = &p->sParse.aNode[iUp]; + p->eType = pUp->eType; + if( pUp->eType==JSON_ARRAY ){ + if( iUp==p->i-1 ){ + pUp->u.iKey = 0; + }else{ + pUp->u.iKey++; + } + } + } + }else{ + switch( p->eType ){ + case JSON_ARRAY: { + p->i += jsonNodeSize(&p->sParse.aNode[p->i]); + p->iRowid++; + break; + } + case JSON_OBJECT: { + p->i += 1 + jsonNodeSize(&p->sParse.aNode[p->i+1]); + p->iRowid++; + break; + } + default: { + p->i = p->iEnd; + break; + } + } + } + return SQLITE_OK; +} + +/* Append the name of the path for element i to pStr +*/ +static void jsonEachComputePath( + JsonEachCursor *p, /* The cursor */ + JsonString *pStr, /* Write the path here */ + u32 i /* Path to this element */ +){ + JsonNode *pNode, *pUp; + u32 iUp; + if( i==0 ){ + jsonAppendChar(pStr, '$'); + return; + } + iUp = p->sParse.aUp[i]; + jsonEachComputePath(p, pStr, iUp); + pNode = &p->sParse.aNode[i]; + pUp = &p->sParse.aNode[iUp]; + if( pUp->eType==JSON_ARRAY ){ + jsonPrintf(30, pStr, "[%d]", pUp->u.iKey); + }else{ + assert( pUp->eType==JSON_OBJECT ); + if( (pNode->jnFlags & JNODE_LABEL)==0 ) pNode--; + assert( pNode->eType==JSON_STRING ); + assert( pNode->jnFlags & JNODE_LABEL ); + jsonPrintf(pNode->n+1, pStr, ".%.*s", pNode->n-2, pNode->u.zJContent+1); + } +} + +/* Return the value of a column */ +static int jsonEachColumn( + sqlite3_vtab_cursor *cur, /* The cursor */ + sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ + int i /* Which column to return */ +){ + JsonEachCursor *p = (JsonEachCursor*)cur; + JsonNode *pThis = &p->sParse.aNode[p->i]; + switch( i ){ + case JEACH_KEY: { + if( p->i==0 ) break; + if( p->eType==JSON_OBJECT ){ + jsonReturn(pThis, ctx, 0); + }else if( p->eType==JSON_ARRAY ){ + u32 iKey; + if( p->bRecursive ){ + if( p->iRowid==0 ) break; + iKey = p->sParse.aNode[p->sParse.aUp[p->i]].u.iKey; + }else{ + iKey = p->iRowid; + } + sqlite3_result_int64(ctx, (sqlite3_int64)iKey); + } + break; + } + case JEACH_VALUE: { + if( pThis->jnFlags & JNODE_LABEL ) pThis++; + jsonReturn(pThis, ctx, 0); + break; + } + case JEACH_TYPE: { + if( pThis->jnFlags & JNODE_LABEL ) pThis++; + sqlite3_result_text(ctx, jsonType[pThis->eType], -1, SQLITE_STATIC); + break; + } + case JEACH_ATOM: { + if( pThis->jnFlags & JNODE_LABEL ) pThis++; + if( pThis->eType>=JSON_ARRAY ) break; + jsonReturn(pThis, ctx, 0); + break; + } + case JEACH_ID: { + sqlite3_result_int64(ctx, + (sqlite3_int64)p->i + ((pThis->jnFlags & JNODE_LABEL)!=0)); + break; + } + case JEACH_PARENT: { + if( p->i>p->iBegin && p->bRecursive ){ + sqlite3_result_int64(ctx, (sqlite3_int64)p->sParse.aUp[p->i]); + } + break; + } + case JEACH_FULLKEY: { + JsonString x; + jsonInit(&x, ctx); + if( p->bRecursive ){ + jsonEachComputePath(p, &x, p->i); + }else{ + if( p->zRoot ){ + jsonAppendRaw(&x, p->zRoot, (int)strlen(p->zRoot)); + }else{ + jsonAppendChar(&x, '$'); + } + if( p->eType==JSON_ARRAY ){ + jsonPrintf(30, &x, "[%d]", p->iRowid); + }else if( p->eType==JSON_OBJECT ){ + jsonPrintf(pThis->n, &x, ".%.*s", pThis->n-2, pThis->u.zJContent+1); + } + } + jsonResult(&x); + break; + } + case JEACH_PATH: { + if( p->bRecursive ){ + JsonString x; + jsonInit(&x, ctx); + jsonEachComputePath(p, &x, p->sParse.aUp[p->i]); + jsonResult(&x); + break; + } + /* For json_each() path and root are the same so fall through + ** into the root case */ + /* no break */ deliberate_fall_through + } + default: { + const char *zRoot = p->zRoot; + if( zRoot==0 ) zRoot = "$"; + sqlite3_result_text(ctx, zRoot, -1, SQLITE_STATIC); + break; + } + case JEACH_JSON: { + assert( i==JEACH_JSON ); + sqlite3_result_text(ctx, p->sParse.zJson, -1, SQLITE_STATIC); + break; + } + } + return SQLITE_OK; +} + +/* Return the current rowid value */ +static int jsonEachRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ + JsonEachCursor *p = (JsonEachCursor*)cur; + *pRowid = p->iRowid; + return SQLITE_OK; +} + +/* The query strategy is to look for an equality constraint on the json +** column. Without such a constraint, the table cannot operate. idxNum is +** 1 if the constraint is found, 3 if the constraint and zRoot are found, +** and 0 otherwise. +*/ +static int jsonEachBestIndex( + sqlite3_vtab *tab, + sqlite3_index_info *pIdxInfo +){ + int i; /* Loop counter or computed array index */ + int aIdx[2]; /* Index of constraints for JSON and ROOT */ + int unusableMask = 0; /* Mask of unusable JSON and ROOT constraints */ + int idxMask = 0; /* Mask of usable == constraints JSON and ROOT */ + const struct sqlite3_index_constraint *pConstraint; + + /* This implementation assumes that JSON and ROOT are the last two + ** columns in the table */ + assert( JEACH_ROOT == JEACH_JSON+1 ); + UNUSED_PARAM(tab); + aIdx[0] = aIdx[1] = -1; + pConstraint = pIdxInfo->aConstraint; + for(i=0; inConstraint; i++, pConstraint++){ + int iCol; + int iMask; + if( pConstraint->iColumn < JEACH_JSON ) continue; + iCol = pConstraint->iColumn - JEACH_JSON; + assert( iCol==0 || iCol==1 ); + iMask = 1 << iCol; + if( pConstraint->usable==0 ){ + unusableMask |= iMask; + }else if( pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ ){ + aIdx[iCol] = i; + idxMask |= iMask; + } + } + if( (unusableMask & ~idxMask)!=0 ){ + /* If there are any unusable constraints on JSON or ROOT, then reject + ** this entire plan */ + return SQLITE_CONSTRAINT; + } + if( aIdx[0]<0 ){ + /* No JSON input. Leave estimatedCost at the huge value that it was + ** initialized to to discourage the query planner from selecting this + ** plan. */ + pIdxInfo->idxNum = 0; + }else{ + pIdxInfo->estimatedCost = 1.0; + i = aIdx[0]; + pIdxInfo->aConstraintUsage[i].argvIndex = 1; + pIdxInfo->aConstraintUsage[i].omit = 1; + if( aIdx[1]<0 ){ + pIdxInfo->idxNum = 1; /* Only JSON supplied. Plan 1 */ + }else{ + i = aIdx[1]; + pIdxInfo->aConstraintUsage[i].argvIndex = 2; + pIdxInfo->aConstraintUsage[i].omit = 1; + pIdxInfo->idxNum = 3; /* Both JSON and ROOT are supplied. Plan 3 */ + } + } + return SQLITE_OK; +} + +/* Start a search on a new JSON string */ +static int jsonEachFilter( + sqlite3_vtab_cursor *cur, + int idxNum, const char *idxStr, + int argc, sqlite3_value **argv +){ + JsonEachCursor *p = (JsonEachCursor*)cur; + const char *z; + const char *zRoot = 0; + sqlite3_int64 n; + + UNUSED_PARAM(idxStr); + UNUSED_PARAM(argc); + jsonEachCursorReset(p); + if( idxNum==0 ) return SQLITE_OK; + z = (const char*)sqlite3_value_text(argv[0]); + if( z==0 ) return SQLITE_OK; + n = sqlite3_value_bytes(argv[0]); + p->zJson = sqlite3_malloc64( n+1 ); + if( p->zJson==0 ) return SQLITE_NOMEM; + memcpy(p->zJson, z, (size_t)n+1); + if( jsonParse(&p->sParse, 0, p->zJson) ){ + int rc = SQLITE_NOMEM; + if( p->sParse.oom==0 ){ + sqlite3_free(cur->pVtab->zErrMsg); + cur->pVtab->zErrMsg = sqlite3_mprintf("malformed JSON"); + if( cur->pVtab->zErrMsg ) rc = SQLITE_ERROR; + } + jsonEachCursorReset(p); + return rc; + }else if( p->bRecursive && jsonParseFindParents(&p->sParse) ){ + jsonEachCursorReset(p); + return SQLITE_NOMEM; + }else{ + JsonNode *pNode = 0; + if( idxNum==3 ){ + const char *zErr = 0; + zRoot = (const char*)sqlite3_value_text(argv[1]); + if( zRoot==0 ) return SQLITE_OK; + n = sqlite3_value_bytes(argv[1]); + p->zRoot = sqlite3_malloc64( n+1 ); + if( p->zRoot==0 ) return SQLITE_NOMEM; + memcpy(p->zRoot, zRoot, (size_t)n+1); + if( zRoot[0]!='$' ){ + zErr = zRoot; + }else{ + pNode = jsonLookupStep(&p->sParse, 0, p->zRoot+1, 0, &zErr); + } + if( zErr ){ + sqlite3_free(cur->pVtab->zErrMsg); + cur->pVtab->zErrMsg = jsonPathSyntaxError(zErr); + jsonEachCursorReset(p); + return cur->pVtab->zErrMsg ? SQLITE_ERROR : SQLITE_NOMEM; + }else if( pNode==0 ){ + return SQLITE_OK; + } + }else{ + pNode = p->sParse.aNode; + } + p->iBegin = p->i = (int)(pNode - p->sParse.aNode); + p->eType = pNode->eType; + if( p->eType>=JSON_ARRAY ){ + pNode->u.iKey = 0; + p->iEnd = p->i + pNode->n + 1; + if( p->bRecursive ){ + p->eType = p->sParse.aNode[p->sParse.aUp[p->i]].eType; + if( p->i>0 && (p->sParse.aNode[p->i-1].jnFlags & JNODE_LABEL)!=0 ){ + p->i--; + } + }else{ + p->i++; + } + }else{ + p->iEnd = p->i+1; + } + } + return SQLITE_OK; +} + +/* The methods of the json_each virtual table */ +static sqlite3_module jsonEachModule = { + 0, /* iVersion */ + 0, /* xCreate */ + jsonEachConnect, /* xConnect */ + jsonEachBestIndex, /* xBestIndex */ + jsonEachDisconnect, /* xDisconnect */ + 0, /* xDestroy */ + jsonEachOpenEach, /* xOpen - open a cursor */ + jsonEachClose, /* xClose - close a cursor */ + jsonEachFilter, /* xFilter - configure scan constraints */ + jsonEachNext, /* xNext - advance a cursor */ + jsonEachEof, /* xEof - check for end of scan */ + jsonEachColumn, /* xColumn - read data */ + jsonEachRowid, /* xRowid - read data */ + 0, /* xUpdate */ + 0, /* xBegin */ + 0, /* xSync */ + 0, /* xCommit */ + 0, /* xRollback */ + 0, /* xFindMethod */ + 0, /* xRename */ + 0, /* xSavepoint */ + 0, /* xRelease */ + 0, /* xRollbackTo */ + 0 /* xShadowName */ +}; + +/* The methods of the json_tree virtual table. */ +static sqlite3_module jsonTreeModule = { + 0, /* iVersion */ + 0, /* xCreate */ + jsonEachConnect, /* xConnect */ + jsonEachBestIndex, /* xBestIndex */ + jsonEachDisconnect, /* xDisconnect */ + 0, /* xDestroy */ + jsonEachOpenTree, /* xOpen - open a cursor */ + jsonEachClose, /* xClose - close a cursor */ + jsonEachFilter, /* xFilter - configure scan constraints */ + jsonEachNext, /* xNext - advance a cursor */ + jsonEachEof, /* xEof - check for end of scan */ + jsonEachColumn, /* xColumn - read data */ + jsonEachRowid, /* xRowid - read data */ + 0, /* xUpdate */ + 0, /* xBegin */ + 0, /* xSync */ + 0, /* xCommit */ + 0, /* xRollback */ + 0, /* xFindMethod */ + 0, /* xRename */ + 0, /* xSavepoint */ + 0, /* xRelease */ + 0, /* xRollbackTo */ + 0 /* xShadowName */ +}; +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +/**************************************************************************** +** The following routines are the only publically visible identifiers in this +** file. Call the following routines in order to register the various SQL +** functions and the virtual table implemented by this file. +****************************************************************************/ + +SQLITE_PRIVATE int sqlite3Json1Init(sqlite3 *db){ + int rc = SQLITE_OK; + unsigned int i; + static const struct { + const char *zName; + int nArg; + int flag; + void (*xFunc)(sqlite3_context*,int,sqlite3_value**); + } aFunc[] = { + { "json", 1, 0, jsonRemoveFunc }, + { "json_array", -1, 0, jsonArrayFunc }, + { "json_array_length", 1, 0, jsonArrayLengthFunc }, + { "json_array_length", 2, 0, jsonArrayLengthFunc }, + { "json_extract", -1, 0, jsonExtractFunc }, + { "json_insert", -1, 0, jsonSetFunc }, + { "json_object", -1, 0, jsonObjectFunc }, + { "json_patch", 2, 0, jsonPatchFunc }, + { "json_quote", 1, 0, jsonQuoteFunc }, + { "json_remove", -1, 0, jsonRemoveFunc }, + { "json_replace", -1, 0, jsonReplaceFunc }, + { "json_set", -1, 1, jsonSetFunc }, + { "json_type", 1, 0, jsonTypeFunc }, + { "json_type", 2, 0, jsonTypeFunc }, + { "json_valid", 1, 0, jsonValidFunc }, + +#if SQLITE_DEBUG + /* DEBUG and TESTING functions */ + { "json_parse", 1, 0, jsonParseFunc }, + { "json_test1", 1, 0, jsonTest1Func }, +#endif + }; + static const struct { + const char *zName; + int nArg; + void (*xStep)(sqlite3_context*,int,sqlite3_value**); + void (*xFinal)(sqlite3_context*); + void (*xValue)(sqlite3_context*); + } aAgg[] = { + { "json_group_array", 1, + jsonArrayStep, jsonArrayFinal, jsonArrayValue }, + { "json_group_object", 2, + jsonObjectStep, jsonObjectFinal, jsonObjectValue }, + }; +#ifndef SQLITE_OMIT_VIRTUALTABLE + static const struct { + const char *zName; + sqlite3_module *pModule; + } aMod[] = { + { "json_each", &jsonEachModule }, + { "json_tree", &jsonTreeModule }, + }; +#endif + static const int enc = + SQLITE_UTF8 | + SQLITE_DETERMINISTIC | + SQLITE_INNOCUOUS; + for(i=0; i */ +/* #include */ +/* #include */ +/* #include */ + +/* The following macro is used to suppress compiler warnings. +*/ +#ifndef UNUSED_PARAMETER +# define UNUSED_PARAMETER(x) (void)(x) +#endif + +typedef struct Rtree Rtree; +typedef struct RtreeCursor RtreeCursor; +typedef struct RtreeNode RtreeNode; +typedef struct RtreeCell RtreeCell; +typedef struct RtreeConstraint RtreeConstraint; +typedef struct RtreeMatchArg RtreeMatchArg; +typedef struct RtreeGeomCallback RtreeGeomCallback; +typedef union RtreeCoord RtreeCoord; +typedef struct RtreeSearchPoint RtreeSearchPoint; + +/* The rtree may have between 1 and RTREE_MAX_DIMENSIONS dimensions. */ +#define RTREE_MAX_DIMENSIONS 5 + +/* Maximum number of auxiliary columns */ +#define RTREE_MAX_AUX_COLUMN 100 + +/* Size of hash table Rtree.aHash. This hash table is not expected to +** ever contain very many entries, so a fixed number of buckets is +** used. +*/ +#define HASHSIZE 97 + +/* The xBestIndex method of this virtual table requires an estimate of +** the number of rows in the virtual table to calculate the costs of +** various strategies. If possible, this estimate is loaded from the +** sqlite_stat1 table (with RTREE_MIN_ROWEST as a hard-coded minimum). +** Otherwise, if no sqlite_stat1 entry is available, use +** RTREE_DEFAULT_ROWEST. +*/ +#define RTREE_DEFAULT_ROWEST 1048576 +#define RTREE_MIN_ROWEST 100 + +/* +** An rtree virtual-table object. +*/ +struct Rtree { + sqlite3_vtab base; /* Base class. Must be first */ + sqlite3 *db; /* Host database connection */ + int iNodeSize; /* Size in bytes of each node in the node table */ + u8 nDim; /* Number of dimensions */ + u8 nDim2; /* Twice the number of dimensions */ + u8 eCoordType; /* RTREE_COORD_REAL32 or RTREE_COORD_INT32 */ + u8 nBytesPerCell; /* Bytes consumed per cell */ + u8 inWrTrans; /* True if inside write transaction */ + u8 nAux; /* # of auxiliary columns in %_rowid */ + u8 nAuxNotNull; /* Number of initial not-null aux columns */ +#ifdef SQLITE_DEBUG + u8 bCorrupt; /* Shadow table corruption detected */ +#endif + int iDepth; /* Current depth of the r-tree structure */ + char *zDb; /* Name of database containing r-tree table */ + char *zName; /* Name of r-tree table */ + u32 nBusy; /* Current number of users of this structure */ + i64 nRowEst; /* Estimated number of rows in this table */ + u32 nCursor; /* Number of open cursors */ + u32 nNodeRef; /* Number RtreeNodes with positive nRef */ + char *zReadAuxSql; /* SQL for statement to read aux data */ + + /* List of nodes removed during a CondenseTree operation. List is + ** linked together via the pointer normally used for hash chains - + ** RtreeNode.pNext. RtreeNode.iNode stores the depth of the sub-tree + ** headed by the node (leaf nodes have RtreeNode.iNode==0). + */ + RtreeNode *pDeleted; + int iReinsertHeight; /* Height of sub-trees Reinsert() has run on */ + + /* Blob I/O on xxx_node */ + sqlite3_blob *pNodeBlob; + + /* Statements to read/write/delete a record from xxx_node */ + sqlite3_stmt *pWriteNode; + sqlite3_stmt *pDeleteNode; + + /* Statements to read/write/delete a record from xxx_rowid */ + sqlite3_stmt *pReadRowid; + sqlite3_stmt *pWriteRowid; + sqlite3_stmt *pDeleteRowid; + + /* Statements to read/write/delete a record from xxx_parent */ + sqlite3_stmt *pReadParent; + sqlite3_stmt *pWriteParent; + sqlite3_stmt *pDeleteParent; + + /* Statement for writing to the "aux:" fields, if there are any */ + sqlite3_stmt *pWriteAux; + + RtreeNode *aHash[HASHSIZE]; /* Hash table of in-memory nodes. */ +}; + +/* Possible values for Rtree.eCoordType: */ +#define RTREE_COORD_REAL32 0 +#define RTREE_COORD_INT32 1 + +/* +** If SQLITE_RTREE_INT_ONLY is defined, then this virtual table will +** only deal with integer coordinates. No floating point operations +** will be done. +*/ +#ifdef SQLITE_RTREE_INT_ONLY + typedef sqlite3_int64 RtreeDValue; /* High accuracy coordinate */ + typedef int RtreeValue; /* Low accuracy coordinate */ +# define RTREE_ZERO 0 +#else + typedef double RtreeDValue; /* High accuracy coordinate */ + typedef float RtreeValue; /* Low accuracy coordinate */ +# define RTREE_ZERO 0.0 +#endif + +/* +** Set the Rtree.bCorrupt flag +*/ +#ifdef SQLITE_DEBUG +# define RTREE_IS_CORRUPT(X) ((X)->bCorrupt = 1) +#else +# define RTREE_IS_CORRUPT(X) +#endif + +/* +** When doing a search of an r-tree, instances of the following structure +** record intermediate results from the tree walk. +** +** The id is always a node-id. For iLevel>=1 the id is the node-id of +** the node that the RtreeSearchPoint represents. When iLevel==0, however, +** the id is of the parent node and the cell that RtreeSearchPoint +** represents is the iCell-th entry in the parent node. +*/ +struct RtreeSearchPoint { + RtreeDValue rScore; /* The score for this node. Smallest goes first. */ + sqlite3_int64 id; /* Node ID */ + u8 iLevel; /* 0=entries. 1=leaf node. 2+ for higher */ + u8 eWithin; /* PARTLY_WITHIN or FULLY_WITHIN */ + u8 iCell; /* Cell index within the node */ +}; + +/* +** The minimum number of cells allowed for a node is a third of the +** maximum. In Gutman's notation: +** +** m = M/3 +** +** If an R*-tree "Reinsert" operation is required, the same number of +** cells are removed from the overfull node and reinserted into the tree. +*/ +#define RTREE_MINCELLS(p) ((((p)->iNodeSize-4)/(p)->nBytesPerCell)/3) +#define RTREE_REINSERT(p) RTREE_MINCELLS(p) +#define RTREE_MAXCELLS 51 + +/* +** The smallest possible node-size is (512-64)==448 bytes. And the largest +** supported cell size is 48 bytes (8 byte rowid + ten 4 byte coordinates). +** Therefore all non-root nodes must contain at least 3 entries. Since +** 3^40 is greater than 2^64, an r-tree structure always has a depth of +** 40 or less. +*/ +#define RTREE_MAX_DEPTH 40 + + +/* +** Number of entries in the cursor RtreeNode cache. The first entry is +** used to cache the RtreeNode for RtreeCursor.sPoint. The remaining +** entries cache the RtreeNode for the first elements of the priority queue. +*/ +#define RTREE_CACHE_SZ 5 + +/* +** An rtree cursor object. +*/ +struct RtreeCursor { + sqlite3_vtab_cursor base; /* Base class. Must be first */ + u8 atEOF; /* True if at end of search */ + u8 bPoint; /* True if sPoint is valid */ + u8 bAuxValid; /* True if pReadAux is valid */ + int iStrategy; /* Copy of idxNum search parameter */ + int nConstraint; /* Number of entries in aConstraint */ + RtreeConstraint *aConstraint; /* Search constraints. */ + int nPointAlloc; /* Number of slots allocated for aPoint[] */ + int nPoint; /* Number of slots used in aPoint[] */ + int mxLevel; /* iLevel value for root of the tree */ + RtreeSearchPoint *aPoint; /* Priority queue for search points */ + sqlite3_stmt *pReadAux; /* Statement to read aux-data */ + RtreeSearchPoint sPoint; /* Cached next search point */ + RtreeNode *aNode[RTREE_CACHE_SZ]; /* Rtree node cache */ + u32 anQueue[RTREE_MAX_DEPTH+1]; /* Number of queued entries by iLevel */ +}; + +/* Return the Rtree of a RtreeCursor */ +#define RTREE_OF_CURSOR(X) ((Rtree*)((X)->base.pVtab)) + +/* +** A coordinate can be either a floating point number or a integer. All +** coordinates within a single R-Tree are always of the same time. +*/ +union RtreeCoord { + RtreeValue f; /* Floating point value */ + int i; /* Integer value */ + u32 u; /* Unsigned for byte-order conversions */ +}; + +/* +** The argument is an RtreeCoord. Return the value stored within the RtreeCoord +** formatted as a RtreeDValue (double or int64). This macro assumes that local +** variable pRtree points to the Rtree structure associated with the +** RtreeCoord. +*/ +#ifdef SQLITE_RTREE_INT_ONLY +# define DCOORD(coord) ((RtreeDValue)coord.i) +#else +# define DCOORD(coord) ( \ + (pRtree->eCoordType==RTREE_COORD_REAL32) ? \ + ((double)coord.f) : \ + ((double)coord.i) \ + ) +#endif + +/* +** A search constraint. +*/ +struct RtreeConstraint { + int iCoord; /* Index of constrained coordinate */ + int op; /* Constraining operation */ + union { + RtreeDValue rValue; /* Constraint value. */ + int (*xGeom)(sqlite3_rtree_geometry*,int,RtreeDValue*,int*); + int (*xQueryFunc)(sqlite3_rtree_query_info*); + } u; + sqlite3_rtree_query_info *pInfo; /* xGeom and xQueryFunc argument */ +}; + +/* Possible values for RtreeConstraint.op */ +#define RTREE_EQ 0x41 /* A */ +#define RTREE_LE 0x42 /* B */ +#define RTREE_LT 0x43 /* C */ +#define RTREE_GE 0x44 /* D */ +#define RTREE_GT 0x45 /* E */ +#define RTREE_MATCH 0x46 /* F: Old-style sqlite3_rtree_geometry_callback() */ +#define RTREE_QUERY 0x47 /* G: New-style sqlite3_rtree_query_callback() */ + +/* Special operators available only on cursors. Needs to be consecutive +** with the normal values above, but must be less than RTREE_MATCH. These +** are used in the cursor for contraints such as x=NULL (RTREE_FALSE) or +** x<'xyz' (RTREE_TRUE) */ +#define RTREE_TRUE 0x3f /* ? */ +#define RTREE_FALSE 0x40 /* @ */ + +/* +** An rtree structure node. +*/ +struct RtreeNode { + RtreeNode *pParent; /* Parent node */ + i64 iNode; /* The node number */ + int nRef; /* Number of references to this node */ + int isDirty; /* True if the node needs to be written to disk */ + u8 *zData; /* Content of the node, as should be on disk */ + RtreeNode *pNext; /* Next node in this hash collision chain */ +}; + +/* Return the number of cells in a node */ +#define NCELL(pNode) readInt16(&(pNode)->zData[2]) + +/* +** A single cell from a node, deserialized +*/ +struct RtreeCell { + i64 iRowid; /* Node or entry ID */ + RtreeCoord aCoord[RTREE_MAX_DIMENSIONS*2]; /* Bounding box coordinates */ +}; + + +/* +** This object becomes the sqlite3_user_data() for the SQL functions +** that are created by sqlite3_rtree_geometry_callback() and +** sqlite3_rtree_query_callback() and which appear on the right of MATCH +** operators in order to constrain a search. +** +** xGeom and xQueryFunc are the callback functions. Exactly one of +** xGeom and xQueryFunc fields is non-NULL, depending on whether the +** SQL function was created using sqlite3_rtree_geometry_callback() or +** sqlite3_rtree_query_callback(). +** +** This object is deleted automatically by the destructor mechanism in +** sqlite3_create_function_v2(). +*/ +struct RtreeGeomCallback { + int (*xGeom)(sqlite3_rtree_geometry*, int, RtreeDValue*, int*); + int (*xQueryFunc)(sqlite3_rtree_query_info*); + void (*xDestructor)(void*); + void *pContext; +}; + +/* +** An instance of this structure (in the form of a BLOB) is returned by +** the SQL functions that sqlite3_rtree_geometry_callback() and +** sqlite3_rtree_query_callback() create, and is read as the right-hand +** operand to the MATCH operator of an R-Tree. +*/ +struct RtreeMatchArg { + u32 iSize; /* Size of this object */ + RtreeGeomCallback cb; /* Info about the callback functions */ + int nParam; /* Number of parameters to the SQL function */ + sqlite3_value **apSqlParam; /* Original SQL parameter values */ + RtreeDValue aParam[1]; /* Values for parameters to the SQL function */ +}; + +#ifndef MAX +# define MAX(x,y) ((x) < (y) ? (y) : (x)) +#endif +#ifndef MIN +# define MIN(x,y) ((x) > (y) ? (y) : (x)) +#endif + +/* What version of GCC is being used. 0 means GCC is not being used . +** Note that the GCC_VERSION macro will also be set correctly when using +** clang, since clang works hard to be gcc compatible. So the gcc +** optimizations will also work when compiling with clang. +*/ +#ifndef GCC_VERSION +#if defined(__GNUC__) && !defined(SQLITE_DISABLE_INTRINSIC) +# define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__) +#else +# define GCC_VERSION 0 +#endif +#endif + +/* The testcase() macro should already be defined in the amalgamation. If +** it is not, make it a no-op. +*/ +#ifndef SQLITE_AMALGAMATION +# define testcase(X) +#endif + +/* +** Make sure that the compiler intrinsics we desire are enabled when +** compiling with an appropriate version of MSVC unless prevented by +** the SQLITE_DISABLE_INTRINSIC define. +*/ +#if !defined(SQLITE_DISABLE_INTRINSIC) +# if defined(_MSC_VER) && _MSC_VER>=1400 +# if !defined(_WIN32_WCE) +/* # include */ +# pragma intrinsic(_byteswap_ulong) +# pragma intrinsic(_byteswap_uint64) +# else +/* # include */ +# endif +# endif +#endif + +/* +** Macros to determine whether the machine is big or little endian, +** and whether or not that determination is run-time or compile-time. +** +** For best performance, an attempt is made to guess at the byte-order +** using C-preprocessor macros. If that is unsuccessful, or if +** -DSQLITE_RUNTIME_BYTEORDER=1 is set, then byte-order is determined +** at run-time. +*/ +#ifndef SQLITE_BYTEORDER +#if defined(i386) || defined(__i386__) || defined(_M_IX86) || \ + defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \ + defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \ + defined(__arm__) +# define SQLITE_BYTEORDER 1234 +#elif defined(sparc) || defined(__ppc__) +# define SQLITE_BYTEORDER 4321 +#else +# define SQLITE_BYTEORDER 0 /* 0 means "unknown at compile-time" */ +#endif +#endif + + +/* What version of MSVC is being used. 0 means MSVC is not being used */ +#ifndef MSVC_VERSION +#if defined(_MSC_VER) && !defined(SQLITE_DISABLE_INTRINSIC) +# define MSVC_VERSION _MSC_VER +#else +# define MSVC_VERSION 0 +#endif +#endif + +/* +** Functions to deserialize a 16 bit integer, 32 bit real number and +** 64 bit integer. The deserialized value is returned. +*/ +static int readInt16(u8 *p){ + return (p[0]<<8) + p[1]; +} +static void readCoord(u8 *p, RtreeCoord *pCoord){ + assert( ((((char*)p) - (char*)0)&3)==0 ); /* p is always 4-byte aligned */ +#if SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 + pCoord->u = _byteswap_ulong(*(u32*)p); +#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 + pCoord->u = __builtin_bswap32(*(u32*)p); +#elif SQLITE_BYTEORDER==4321 + pCoord->u = *(u32*)p; +#else + pCoord->u = ( + (((u32)p[0]) << 24) + + (((u32)p[1]) << 16) + + (((u32)p[2]) << 8) + + (((u32)p[3]) << 0) + ); +#endif +} +static i64 readInt64(u8 *p){ +#if SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 + u64 x; + memcpy(&x, p, 8); + return (i64)_byteswap_uint64(x); +#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 + u64 x; + memcpy(&x, p, 8); + return (i64)__builtin_bswap64(x); +#elif SQLITE_BYTEORDER==4321 + i64 x; + memcpy(&x, p, 8); + return x; +#else + return (i64)( + (((u64)p[0]) << 56) + + (((u64)p[1]) << 48) + + (((u64)p[2]) << 40) + + (((u64)p[3]) << 32) + + (((u64)p[4]) << 24) + + (((u64)p[5]) << 16) + + (((u64)p[6]) << 8) + + (((u64)p[7]) << 0) + ); +#endif +} + +/* +** Functions to serialize a 16 bit integer, 32 bit real number and +** 64 bit integer. The value returned is the number of bytes written +** to the argument buffer (always 2, 4 and 8 respectively). +*/ +static void writeInt16(u8 *p, int i){ + p[0] = (i>> 8)&0xFF; + p[1] = (i>> 0)&0xFF; +} +static int writeCoord(u8 *p, RtreeCoord *pCoord){ + u32 i; + assert( ((((char*)p) - (char*)0)&3)==0 ); /* p is always 4-byte aligned */ + assert( sizeof(RtreeCoord)==4 ); + assert( sizeof(u32)==4 ); +#if SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 + i = __builtin_bswap32(pCoord->u); + memcpy(p, &i, 4); +#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 + i = _byteswap_ulong(pCoord->u); + memcpy(p, &i, 4); +#elif SQLITE_BYTEORDER==4321 + i = pCoord->u; + memcpy(p, &i, 4); +#else + i = pCoord->u; + p[0] = (i>>24)&0xFF; + p[1] = (i>>16)&0xFF; + p[2] = (i>> 8)&0xFF; + p[3] = (i>> 0)&0xFF; +#endif + return 4; +} +static int writeInt64(u8 *p, i64 i){ +#if SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 + i = (i64)__builtin_bswap64((u64)i); + memcpy(p, &i, 8); +#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 + i = (i64)_byteswap_uint64((u64)i); + memcpy(p, &i, 8); +#elif SQLITE_BYTEORDER==4321 + memcpy(p, &i, 8); +#else + p[0] = (i>>56)&0xFF; + p[1] = (i>>48)&0xFF; + p[2] = (i>>40)&0xFF; + p[3] = (i>>32)&0xFF; + p[4] = (i>>24)&0xFF; + p[5] = (i>>16)&0xFF; + p[6] = (i>> 8)&0xFF; + p[7] = (i>> 0)&0xFF; +#endif + return 8; +} + +/* +** Increment the reference count of node p. +*/ +static void nodeReference(RtreeNode *p){ + if( p ){ + assert( p->nRef>0 ); + p->nRef++; + } +} + +/* +** Clear the content of node p (set all bytes to 0x00). +*/ +static void nodeZero(Rtree *pRtree, RtreeNode *p){ + memset(&p->zData[2], 0, pRtree->iNodeSize-2); + p->isDirty = 1; +} + +/* +** Given a node number iNode, return the corresponding key to use +** in the Rtree.aHash table. +*/ +static unsigned int nodeHash(i64 iNode){ + return ((unsigned)iNode) % HASHSIZE; +} + +/* +** Search the node hash table for node iNode. If found, return a pointer +** to it. Otherwise, return 0. +*/ +static RtreeNode *nodeHashLookup(Rtree *pRtree, i64 iNode){ + RtreeNode *p; + for(p=pRtree->aHash[nodeHash(iNode)]; p && p->iNode!=iNode; p=p->pNext); + return p; +} + +/* +** Add node pNode to the node hash table. +*/ +static void nodeHashInsert(Rtree *pRtree, RtreeNode *pNode){ + int iHash; + assert( pNode->pNext==0 ); + iHash = nodeHash(pNode->iNode); + pNode->pNext = pRtree->aHash[iHash]; + pRtree->aHash[iHash] = pNode; +} + +/* +** Remove node pNode from the node hash table. +*/ +static void nodeHashDelete(Rtree *pRtree, RtreeNode *pNode){ + RtreeNode **pp; + if( pNode->iNode!=0 ){ + pp = &pRtree->aHash[nodeHash(pNode->iNode)]; + for( ; (*pp)!=pNode; pp = &(*pp)->pNext){ assert(*pp); } + *pp = pNode->pNext; + pNode->pNext = 0; + } +} + +/* +** Allocate and return new r-tree node. Initially, (RtreeNode.iNode==0), +** indicating that node has not yet been assigned a node number. It is +** assigned a node number when nodeWrite() is called to write the +** node contents out to the database. +*/ +static RtreeNode *nodeNew(Rtree *pRtree, RtreeNode *pParent){ + RtreeNode *pNode; + pNode = (RtreeNode *)sqlite3_malloc64(sizeof(RtreeNode) + pRtree->iNodeSize); + if( pNode ){ + memset(pNode, 0, sizeof(RtreeNode) + pRtree->iNodeSize); + pNode->zData = (u8 *)&pNode[1]; + pNode->nRef = 1; + pRtree->nNodeRef++; + pNode->pParent = pParent; + pNode->isDirty = 1; + nodeReference(pParent); + } + return pNode; +} + +/* +** Clear the Rtree.pNodeBlob object +*/ +static void nodeBlobReset(Rtree *pRtree){ + if( pRtree->pNodeBlob && pRtree->inWrTrans==0 && pRtree->nCursor==0 ){ + sqlite3_blob *pBlob = pRtree->pNodeBlob; + pRtree->pNodeBlob = 0; + sqlite3_blob_close(pBlob); + } +} + +/* +** Check to see if pNode is the same as pParent or any of the parents +** of pParent. +*/ +static int nodeInParentChain(const RtreeNode *pNode, const RtreeNode *pParent){ + do{ + if( pNode==pParent ) return 1; + pParent = pParent->pParent; + }while( pParent ); + return 0; +} + +/* +** Obtain a reference to an r-tree node. +*/ +static int nodeAcquire( + Rtree *pRtree, /* R-tree structure */ + i64 iNode, /* Node number to load */ + RtreeNode *pParent, /* Either the parent node or NULL */ + RtreeNode **ppNode /* OUT: Acquired node */ +){ + int rc = SQLITE_OK; + RtreeNode *pNode = 0; + + /* Check if the requested node is already in the hash table. If so, + ** increase its reference count and return it. + */ + if( (pNode = nodeHashLookup(pRtree, iNode))!=0 ){ + if( pParent && !pNode->pParent ){ + if( nodeInParentChain(pNode, pParent) ){ + RTREE_IS_CORRUPT(pRtree); + return SQLITE_CORRUPT_VTAB; + } + pParent->nRef++; + pNode->pParent = pParent; + }else if( pParent && pNode->pParent && pParent!=pNode->pParent ){ + RTREE_IS_CORRUPT(pRtree); + return SQLITE_CORRUPT_VTAB; + } + pNode->nRef++; + *ppNode = pNode; + return SQLITE_OK; + } + + if( pRtree->pNodeBlob ){ + sqlite3_blob *pBlob = pRtree->pNodeBlob; + pRtree->pNodeBlob = 0; + rc = sqlite3_blob_reopen(pBlob, iNode); + pRtree->pNodeBlob = pBlob; + if( rc ){ + nodeBlobReset(pRtree); + if( rc==SQLITE_NOMEM ) return SQLITE_NOMEM; + } + } + if( pRtree->pNodeBlob==0 ){ + char *zTab = sqlite3_mprintf("%s_node", pRtree->zName); + if( zTab==0 ) return SQLITE_NOMEM; + rc = sqlite3_blob_open(pRtree->db, pRtree->zDb, zTab, "data", iNode, 0, + &pRtree->pNodeBlob); + sqlite3_free(zTab); + } + if( rc ){ + nodeBlobReset(pRtree); + *ppNode = 0; + /* If unable to open an sqlite3_blob on the desired row, that can only + ** be because the shadow tables hold erroneous data. */ + if( rc==SQLITE_ERROR ){ + rc = SQLITE_CORRUPT_VTAB; + RTREE_IS_CORRUPT(pRtree); + } + }else if( pRtree->iNodeSize==sqlite3_blob_bytes(pRtree->pNodeBlob) ){ + pNode = (RtreeNode *)sqlite3_malloc64(sizeof(RtreeNode)+pRtree->iNodeSize); + if( !pNode ){ + rc = SQLITE_NOMEM; + }else{ + pNode->pParent = pParent; + pNode->zData = (u8 *)&pNode[1]; + pNode->nRef = 1; + pRtree->nNodeRef++; + pNode->iNode = iNode; + pNode->isDirty = 0; + pNode->pNext = 0; + rc = sqlite3_blob_read(pRtree->pNodeBlob, pNode->zData, + pRtree->iNodeSize, 0); + } + } + + /* If the root node was just loaded, set pRtree->iDepth to the height + ** of the r-tree structure. A height of zero means all data is stored on + ** the root node. A height of one means the children of the root node + ** are the leaves, and so on. If the depth as specified on the root node + ** is greater than RTREE_MAX_DEPTH, the r-tree structure must be corrupt. + */ + if( pNode && rc==SQLITE_OK && iNode==1 ){ + pRtree->iDepth = readInt16(pNode->zData); + if( pRtree->iDepth>RTREE_MAX_DEPTH ){ + rc = SQLITE_CORRUPT_VTAB; + RTREE_IS_CORRUPT(pRtree); + } + } + + /* If no error has occurred so far, check if the "number of entries" + ** field on the node is too large. If so, set the return code to + ** SQLITE_CORRUPT_VTAB. + */ + if( pNode && rc==SQLITE_OK ){ + if( NCELL(pNode)>((pRtree->iNodeSize-4)/pRtree->nBytesPerCell) ){ + rc = SQLITE_CORRUPT_VTAB; + RTREE_IS_CORRUPT(pRtree); + } + } + + if( rc==SQLITE_OK ){ + if( pNode!=0 ){ + nodeReference(pParent); + nodeHashInsert(pRtree, pNode); + }else{ + rc = SQLITE_CORRUPT_VTAB; + RTREE_IS_CORRUPT(pRtree); + } + *ppNode = pNode; + }else{ + if( pNode ){ + pRtree->nNodeRef--; + sqlite3_free(pNode); + } + *ppNode = 0; + } + + return rc; +} + +/* +** Overwrite cell iCell of node pNode with the contents of pCell. +*/ +static void nodeOverwriteCell( + Rtree *pRtree, /* The overall R-Tree */ + RtreeNode *pNode, /* The node into which the cell is to be written */ + RtreeCell *pCell, /* The cell to write */ + int iCell /* Index into pNode into which pCell is written */ +){ + int ii; + u8 *p = &pNode->zData[4 + pRtree->nBytesPerCell*iCell]; + p += writeInt64(p, pCell->iRowid); + for(ii=0; iinDim2; ii++){ + p += writeCoord(p, &pCell->aCoord[ii]); + } + pNode->isDirty = 1; +} + +/* +** Remove the cell with index iCell from node pNode. +*/ +static void nodeDeleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell){ + u8 *pDst = &pNode->zData[4 + pRtree->nBytesPerCell*iCell]; + u8 *pSrc = &pDst[pRtree->nBytesPerCell]; + int nByte = (NCELL(pNode) - iCell - 1) * pRtree->nBytesPerCell; + memmove(pDst, pSrc, nByte); + writeInt16(&pNode->zData[2], NCELL(pNode)-1); + pNode->isDirty = 1; +} + +/* +** Insert the contents of cell pCell into node pNode. If the insert +** is successful, return SQLITE_OK. +** +** If there is not enough free space in pNode, return SQLITE_FULL. +*/ +static int nodeInsertCell( + Rtree *pRtree, /* The overall R-Tree */ + RtreeNode *pNode, /* Write new cell into this node */ + RtreeCell *pCell /* The cell to be inserted */ +){ + int nCell; /* Current number of cells in pNode */ + int nMaxCell; /* Maximum number of cells for pNode */ + + nMaxCell = (pRtree->iNodeSize-4)/pRtree->nBytesPerCell; + nCell = NCELL(pNode); + + assert( nCell<=nMaxCell ); + if( nCellzData[2], nCell+1); + pNode->isDirty = 1; + } + + return (nCell==nMaxCell); +} + +/* +** If the node is dirty, write it out to the database. +*/ +static int nodeWrite(Rtree *pRtree, RtreeNode *pNode){ + int rc = SQLITE_OK; + if( pNode->isDirty ){ + sqlite3_stmt *p = pRtree->pWriteNode; + if( pNode->iNode ){ + sqlite3_bind_int64(p, 1, pNode->iNode); + }else{ + sqlite3_bind_null(p, 1); + } + sqlite3_bind_blob(p, 2, pNode->zData, pRtree->iNodeSize, SQLITE_STATIC); + sqlite3_step(p); + pNode->isDirty = 0; + rc = sqlite3_reset(p); + sqlite3_bind_null(p, 2); + if( pNode->iNode==0 && rc==SQLITE_OK ){ + pNode->iNode = sqlite3_last_insert_rowid(pRtree->db); + nodeHashInsert(pRtree, pNode); + } + } + return rc; +} + +/* +** Release a reference to a node. If the node is dirty and the reference +** count drops to zero, the node data is written to the database. +*/ +static int nodeRelease(Rtree *pRtree, RtreeNode *pNode){ + int rc = SQLITE_OK; + if( pNode ){ + assert( pNode->nRef>0 ); + assert( pRtree->nNodeRef>0 ); + pNode->nRef--; + if( pNode->nRef==0 ){ + pRtree->nNodeRef--; + if( pNode->iNode==1 ){ + pRtree->iDepth = -1; + } + if( pNode->pParent ){ + rc = nodeRelease(pRtree, pNode->pParent); + } + if( rc==SQLITE_OK ){ + rc = nodeWrite(pRtree, pNode); + } + nodeHashDelete(pRtree, pNode); + sqlite3_free(pNode); + } + } + return rc; +} + +/* +** Return the 64-bit integer value associated with cell iCell of +** node pNode. If pNode is a leaf node, this is a rowid. If it is +** an internal node, then the 64-bit integer is a child page number. +*/ +static i64 nodeGetRowid( + Rtree *pRtree, /* The overall R-Tree */ + RtreeNode *pNode, /* The node from which to extract the ID */ + int iCell /* The cell index from which to extract the ID */ +){ + assert( iCellzData[4 + pRtree->nBytesPerCell*iCell]); +} + +/* +** Return coordinate iCoord from cell iCell in node pNode. +*/ +static void nodeGetCoord( + Rtree *pRtree, /* The overall R-Tree */ + RtreeNode *pNode, /* The node from which to extract a coordinate */ + int iCell, /* The index of the cell within the node */ + int iCoord, /* Which coordinate to extract */ + RtreeCoord *pCoord /* OUT: Space to write result to */ +){ + readCoord(&pNode->zData[12 + pRtree->nBytesPerCell*iCell + 4*iCoord], pCoord); +} + +/* +** Deserialize cell iCell of node pNode. Populate the structure pointed +** to by pCell with the results. +*/ +static void nodeGetCell( + Rtree *pRtree, /* The overall R-Tree */ + RtreeNode *pNode, /* The node containing the cell to be read */ + int iCell, /* Index of the cell within the node */ + RtreeCell *pCell /* OUT: Write the cell contents here */ +){ + u8 *pData; + RtreeCoord *pCoord; + int ii = 0; + pCell->iRowid = nodeGetRowid(pRtree, pNode, iCell); + pData = pNode->zData + (12 + pRtree->nBytesPerCell*iCell); + pCoord = pCell->aCoord; + do{ + readCoord(pData, &pCoord[ii]); + readCoord(pData+4, &pCoord[ii+1]); + pData += 8; + ii += 2; + }while( iinDim2 ); +} + + +/* Forward declaration for the function that does the work of +** the virtual table module xCreate() and xConnect() methods. +*/ +static int rtreeInit( + sqlite3 *, void *, int, const char *const*, sqlite3_vtab **, char **, int +); + +/* +** Rtree virtual table module xCreate method. +*/ +static int rtreeCreate( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + return rtreeInit(db, pAux, argc, argv, ppVtab, pzErr, 1); +} + +/* +** Rtree virtual table module xConnect method. +*/ +static int rtreeConnect( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + return rtreeInit(db, pAux, argc, argv, ppVtab, pzErr, 0); +} + +/* +** Increment the r-tree reference count. +*/ +static void rtreeReference(Rtree *pRtree){ + pRtree->nBusy++; +} + +/* +** Decrement the r-tree reference count. When the reference count reaches +** zero the structure is deleted. +*/ +static void rtreeRelease(Rtree *pRtree){ + pRtree->nBusy--; + if( pRtree->nBusy==0 ){ + pRtree->inWrTrans = 0; + assert( pRtree->nCursor==0 ); + nodeBlobReset(pRtree); + assert( pRtree->nNodeRef==0 || pRtree->bCorrupt ); + sqlite3_finalize(pRtree->pWriteNode); + sqlite3_finalize(pRtree->pDeleteNode); + sqlite3_finalize(pRtree->pReadRowid); + sqlite3_finalize(pRtree->pWriteRowid); + sqlite3_finalize(pRtree->pDeleteRowid); + sqlite3_finalize(pRtree->pReadParent); + sqlite3_finalize(pRtree->pWriteParent); + sqlite3_finalize(pRtree->pDeleteParent); + sqlite3_finalize(pRtree->pWriteAux); + sqlite3_free(pRtree->zReadAuxSql); + sqlite3_free(pRtree); + } +} + +/* +** Rtree virtual table module xDisconnect method. +*/ +static int rtreeDisconnect(sqlite3_vtab *pVtab){ + rtreeRelease((Rtree *)pVtab); + return SQLITE_OK; +} + +/* +** Rtree virtual table module xDestroy method. +*/ +static int rtreeDestroy(sqlite3_vtab *pVtab){ + Rtree *pRtree = (Rtree *)pVtab; + int rc; + char *zCreate = sqlite3_mprintf( + "DROP TABLE '%q'.'%q_node';" + "DROP TABLE '%q'.'%q_rowid';" + "DROP TABLE '%q'.'%q_parent';", + pRtree->zDb, pRtree->zName, + pRtree->zDb, pRtree->zName, + pRtree->zDb, pRtree->zName + ); + if( !zCreate ){ + rc = SQLITE_NOMEM; + }else{ + nodeBlobReset(pRtree); + rc = sqlite3_exec(pRtree->db, zCreate, 0, 0, 0); + sqlite3_free(zCreate); + } + if( rc==SQLITE_OK ){ + rtreeRelease(pRtree); + } + + return rc; +} + +/* +** Rtree virtual table module xOpen method. +*/ +static int rtreeOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){ + int rc = SQLITE_NOMEM; + Rtree *pRtree = (Rtree *)pVTab; + RtreeCursor *pCsr; + + pCsr = (RtreeCursor *)sqlite3_malloc64(sizeof(RtreeCursor)); + if( pCsr ){ + memset(pCsr, 0, sizeof(RtreeCursor)); + pCsr->base.pVtab = pVTab; + rc = SQLITE_OK; + pRtree->nCursor++; + } + *ppCursor = (sqlite3_vtab_cursor *)pCsr; + + return rc; +} + + +/* +** Reset a cursor back to its initial state. +*/ +static void resetCursor(RtreeCursor *pCsr){ + Rtree *pRtree = (Rtree *)(pCsr->base.pVtab); + int ii; + sqlite3_stmt *pStmt; + if( pCsr->aConstraint ){ + int i; /* Used to iterate through constraint array */ + for(i=0; inConstraint; i++){ + sqlite3_rtree_query_info *pInfo = pCsr->aConstraint[i].pInfo; + if( pInfo ){ + if( pInfo->xDelUser ) pInfo->xDelUser(pInfo->pUser); + sqlite3_free(pInfo); + } + } + sqlite3_free(pCsr->aConstraint); + pCsr->aConstraint = 0; + } + for(ii=0; iiaNode[ii]); + sqlite3_free(pCsr->aPoint); + pStmt = pCsr->pReadAux; + memset(pCsr, 0, sizeof(RtreeCursor)); + pCsr->base.pVtab = (sqlite3_vtab*)pRtree; + pCsr->pReadAux = pStmt; + +} + +/* +** Rtree virtual table module xClose method. +*/ +static int rtreeClose(sqlite3_vtab_cursor *cur){ + Rtree *pRtree = (Rtree *)(cur->pVtab); + RtreeCursor *pCsr = (RtreeCursor *)cur; + assert( pRtree->nCursor>0 ); + resetCursor(pCsr); + sqlite3_finalize(pCsr->pReadAux); + sqlite3_free(pCsr); + pRtree->nCursor--; + nodeBlobReset(pRtree); + return SQLITE_OK; +} + +/* +** Rtree virtual table module xEof method. +** +** Return non-zero if the cursor does not currently point to a valid +** record (i.e if the scan has finished), or zero otherwise. +*/ +static int rtreeEof(sqlite3_vtab_cursor *cur){ + RtreeCursor *pCsr = (RtreeCursor *)cur; + return pCsr->atEOF; +} + +/* +** Convert raw bits from the on-disk RTree record into a coordinate value. +** The on-disk format is big-endian and needs to be converted for little- +** endian platforms. The on-disk record stores integer coordinates if +** eInt is true and it stores 32-bit floating point records if eInt is +** false. a[] is the four bytes of the on-disk record to be decoded. +** Store the results in "r". +** +** There are five versions of this macro. The last one is generic. The +** other four are various architectures-specific optimizations. +*/ +#if SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 +#define RTREE_DECODE_COORD(eInt, a, r) { \ + RtreeCoord c; /* Coordinate decoded */ \ + c.u = _byteswap_ulong(*(u32*)a); \ + r = eInt ? (sqlite3_rtree_dbl)c.i : (sqlite3_rtree_dbl)c.f; \ +} +#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 +#define RTREE_DECODE_COORD(eInt, a, r) { \ + RtreeCoord c; /* Coordinate decoded */ \ + c.u = __builtin_bswap32(*(u32*)a); \ + r = eInt ? (sqlite3_rtree_dbl)c.i : (sqlite3_rtree_dbl)c.f; \ +} +#elif SQLITE_BYTEORDER==1234 +#define RTREE_DECODE_COORD(eInt, a, r) { \ + RtreeCoord c; /* Coordinate decoded */ \ + memcpy(&c.u,a,4); \ + c.u = ((c.u>>24)&0xff)|((c.u>>8)&0xff00)| \ + ((c.u&0xff)<<24)|((c.u&0xff00)<<8); \ + r = eInt ? (sqlite3_rtree_dbl)c.i : (sqlite3_rtree_dbl)c.f; \ +} +#elif SQLITE_BYTEORDER==4321 +#define RTREE_DECODE_COORD(eInt, a, r) { \ + RtreeCoord c; /* Coordinate decoded */ \ + memcpy(&c.u,a,4); \ + r = eInt ? (sqlite3_rtree_dbl)c.i : (sqlite3_rtree_dbl)c.f; \ +} +#else +#define RTREE_DECODE_COORD(eInt, a, r) { \ + RtreeCoord c; /* Coordinate decoded */ \ + c.u = ((u32)a[0]<<24) + ((u32)a[1]<<16) \ + +((u32)a[2]<<8) + a[3]; \ + r = eInt ? (sqlite3_rtree_dbl)c.i : (sqlite3_rtree_dbl)c.f; \ +} +#endif + +/* +** Check the RTree node or entry given by pCellData and p against the MATCH +** constraint pConstraint. +*/ +static int rtreeCallbackConstraint( + RtreeConstraint *pConstraint, /* The constraint to test */ + int eInt, /* True if RTree holding integer coordinates */ + u8 *pCellData, /* Raw cell content */ + RtreeSearchPoint *pSearch, /* Container of this cell */ + sqlite3_rtree_dbl *prScore, /* OUT: score for the cell */ + int *peWithin /* OUT: visibility of the cell */ +){ + sqlite3_rtree_query_info *pInfo = pConstraint->pInfo; /* Callback info */ + int nCoord = pInfo->nCoord; /* No. of coordinates */ + int rc; /* Callback return code */ + RtreeCoord c; /* Translator union */ + sqlite3_rtree_dbl aCoord[RTREE_MAX_DIMENSIONS*2]; /* Decoded coordinates */ + + assert( pConstraint->op==RTREE_MATCH || pConstraint->op==RTREE_QUERY ); + assert( nCoord==2 || nCoord==4 || nCoord==6 || nCoord==8 || nCoord==10 ); + + if( pConstraint->op==RTREE_QUERY && pSearch->iLevel==1 ){ + pInfo->iRowid = readInt64(pCellData); + } + pCellData += 8; +#ifndef SQLITE_RTREE_INT_ONLY + if( eInt==0 ){ + switch( nCoord ){ + case 10: readCoord(pCellData+36, &c); aCoord[9] = c.f; + readCoord(pCellData+32, &c); aCoord[8] = c.f; + case 8: readCoord(pCellData+28, &c); aCoord[7] = c.f; + readCoord(pCellData+24, &c); aCoord[6] = c.f; + case 6: readCoord(pCellData+20, &c); aCoord[5] = c.f; + readCoord(pCellData+16, &c); aCoord[4] = c.f; + case 4: readCoord(pCellData+12, &c); aCoord[3] = c.f; + readCoord(pCellData+8, &c); aCoord[2] = c.f; + default: readCoord(pCellData+4, &c); aCoord[1] = c.f; + readCoord(pCellData, &c); aCoord[0] = c.f; + } + }else +#endif + { + switch( nCoord ){ + case 10: readCoord(pCellData+36, &c); aCoord[9] = c.i; + readCoord(pCellData+32, &c); aCoord[8] = c.i; + case 8: readCoord(pCellData+28, &c); aCoord[7] = c.i; + readCoord(pCellData+24, &c); aCoord[6] = c.i; + case 6: readCoord(pCellData+20, &c); aCoord[5] = c.i; + readCoord(pCellData+16, &c); aCoord[4] = c.i; + case 4: readCoord(pCellData+12, &c); aCoord[3] = c.i; + readCoord(pCellData+8, &c); aCoord[2] = c.i; + default: readCoord(pCellData+4, &c); aCoord[1] = c.i; + readCoord(pCellData, &c); aCoord[0] = c.i; + } + } + if( pConstraint->op==RTREE_MATCH ){ + int eWithin = 0; + rc = pConstraint->u.xGeom((sqlite3_rtree_geometry*)pInfo, + nCoord, aCoord, &eWithin); + if( eWithin==0 ) *peWithin = NOT_WITHIN; + *prScore = RTREE_ZERO; + }else{ + pInfo->aCoord = aCoord; + pInfo->iLevel = pSearch->iLevel - 1; + pInfo->rScore = pInfo->rParentScore = pSearch->rScore; + pInfo->eWithin = pInfo->eParentWithin = pSearch->eWithin; + rc = pConstraint->u.xQueryFunc(pInfo); + if( pInfo->eWithin<*peWithin ) *peWithin = pInfo->eWithin; + if( pInfo->rScore<*prScore || *prScorerScore; + } + } + return rc; +} + +/* +** Check the internal RTree node given by pCellData against constraint p. +** If this constraint cannot be satisfied by any child within the node, +** set *peWithin to NOT_WITHIN. +*/ +static void rtreeNonleafConstraint( + RtreeConstraint *p, /* The constraint to test */ + int eInt, /* True if RTree holds integer coordinates */ + u8 *pCellData, /* Raw cell content as appears on disk */ + int *peWithin /* Adjust downward, as appropriate */ +){ + sqlite3_rtree_dbl val; /* Coordinate value convert to a double */ + + /* p->iCoord might point to either a lower or upper bound coordinate + ** in a coordinate pair. But make pCellData point to the lower bound. + */ + pCellData += 8 + 4*(p->iCoord&0xfe); + + assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE + || p->op==RTREE_GT || p->op==RTREE_EQ || p->op==RTREE_TRUE + || p->op==RTREE_FALSE ); + assert( ((((char*)pCellData) - (char*)0)&3)==0 ); /* 4-byte aligned */ + switch( p->op ){ + case RTREE_TRUE: return; /* Always satisfied */ + case RTREE_FALSE: break; /* Never satisfied */ + case RTREE_LE: + case RTREE_LT: + case RTREE_EQ: + RTREE_DECODE_COORD(eInt, pCellData, val); + /* val now holds the lower bound of the coordinate pair */ + if( p->u.rValue>=val ) return; + if( p->op!=RTREE_EQ ) break; /* RTREE_LE and RTREE_LT end here */ + /* Fall through for the RTREE_EQ case */ + + default: /* RTREE_GT or RTREE_GE, or fallthrough of RTREE_EQ */ + pCellData += 4; + RTREE_DECODE_COORD(eInt, pCellData, val); + /* val now holds the upper bound of the coordinate pair */ + if( p->u.rValue<=val ) return; + } + *peWithin = NOT_WITHIN; +} + +/* +** Check the leaf RTree cell given by pCellData against constraint p. +** If this constraint is not satisfied, set *peWithin to NOT_WITHIN. +** If the constraint is satisfied, leave *peWithin unchanged. +** +** The constraint is of the form: xN op $val +** +** The op is given by p->op. The xN is p->iCoord-th coordinate in +** pCellData. $val is given by p->u.rValue. +*/ +static void rtreeLeafConstraint( + RtreeConstraint *p, /* The constraint to test */ + int eInt, /* True if RTree holds integer coordinates */ + u8 *pCellData, /* Raw cell content as appears on disk */ + int *peWithin /* Adjust downward, as appropriate */ +){ + RtreeDValue xN; /* Coordinate value converted to a double */ + + assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE + || p->op==RTREE_GT || p->op==RTREE_EQ || p->op==RTREE_TRUE + || p->op==RTREE_FALSE ); + pCellData += 8 + p->iCoord*4; + assert( ((((char*)pCellData) - (char*)0)&3)==0 ); /* 4-byte aligned */ + RTREE_DECODE_COORD(eInt, pCellData, xN); + switch( p->op ){ + case RTREE_TRUE: return; /* Always satisfied */ + case RTREE_FALSE: break; /* Never satisfied */ + case RTREE_LE: if( xN <= p->u.rValue ) return; break; + case RTREE_LT: if( xN < p->u.rValue ) return; break; + case RTREE_GE: if( xN >= p->u.rValue ) return; break; + case RTREE_GT: if( xN > p->u.rValue ) return; break; + default: if( xN == p->u.rValue ) return; break; + } + *peWithin = NOT_WITHIN; +} + +/* +** One of the cells in node pNode is guaranteed to have a 64-bit +** integer value equal to iRowid. Return the index of this cell. +*/ +static int nodeRowidIndex( + Rtree *pRtree, + RtreeNode *pNode, + i64 iRowid, + int *piIndex +){ + int ii; + int nCell = NCELL(pNode); + assert( nCell<200 ); + for(ii=0; iipParent; + if( pParent ){ + return nodeRowidIndex(pRtree, pParent, pNode->iNode, piIndex); + } + *piIndex = -1; + return SQLITE_OK; +} + +/* +** Compare two search points. Return negative, zero, or positive if the first +** is less than, equal to, or greater than the second. +** +** The rScore is the primary key. Smaller rScore values come first. +** If the rScore is a tie, then use iLevel as the tie breaker with smaller +** iLevel values coming first. In this way, if rScore is the same for all +** SearchPoints, then iLevel becomes the deciding factor and the result +** is a depth-first search, which is the desired default behavior. +*/ +static int rtreeSearchPointCompare( + const RtreeSearchPoint *pA, + const RtreeSearchPoint *pB +){ + if( pA->rScorerScore ) return -1; + if( pA->rScore>pB->rScore ) return +1; + if( pA->iLeveliLevel ) return -1; + if( pA->iLevel>pB->iLevel ) return +1; + return 0; +} + +/* +** Interchange two search points in a cursor. +*/ +static void rtreeSearchPointSwap(RtreeCursor *p, int i, int j){ + RtreeSearchPoint t = p->aPoint[i]; + assert( iaPoint[i] = p->aPoint[j]; + p->aPoint[j] = t; + i++; j++; + if( i=RTREE_CACHE_SZ ){ + nodeRelease(RTREE_OF_CURSOR(p), p->aNode[i]); + p->aNode[i] = 0; + }else{ + RtreeNode *pTemp = p->aNode[i]; + p->aNode[i] = p->aNode[j]; + p->aNode[j] = pTemp; + } + } +} + +/* +** Return the search point with the lowest current score. +*/ +static RtreeSearchPoint *rtreeSearchPointFirst(RtreeCursor *pCur){ + return pCur->bPoint ? &pCur->sPoint : pCur->nPoint ? pCur->aPoint : 0; +} + +/* +** Get the RtreeNode for the search point with the lowest score. +*/ +static RtreeNode *rtreeNodeOfFirstSearchPoint(RtreeCursor *pCur, int *pRC){ + sqlite3_int64 id; + int ii = 1 - pCur->bPoint; + assert( ii==0 || ii==1 ); + assert( pCur->bPoint || pCur->nPoint ); + if( pCur->aNode[ii]==0 ){ + assert( pRC!=0 ); + id = ii ? pCur->aPoint[0].id : pCur->sPoint.id; + *pRC = nodeAcquire(RTREE_OF_CURSOR(pCur), id, 0, &pCur->aNode[ii]); + } + return pCur->aNode[ii]; +} + +/* +** Push a new element onto the priority queue +*/ +static RtreeSearchPoint *rtreeEnqueue( + RtreeCursor *pCur, /* The cursor */ + RtreeDValue rScore, /* Score for the new search point */ + u8 iLevel /* Level for the new search point */ +){ + int i, j; + RtreeSearchPoint *pNew; + if( pCur->nPoint>=pCur->nPointAlloc ){ + int nNew = pCur->nPointAlloc*2 + 8; + pNew = sqlite3_realloc64(pCur->aPoint, nNew*sizeof(pCur->aPoint[0])); + if( pNew==0 ) return 0; + pCur->aPoint = pNew; + pCur->nPointAlloc = nNew; + } + i = pCur->nPoint++; + pNew = pCur->aPoint + i; + pNew->rScore = rScore; + pNew->iLevel = iLevel; + assert( iLevel<=RTREE_MAX_DEPTH ); + while( i>0 ){ + RtreeSearchPoint *pParent; + j = (i-1)/2; + pParent = pCur->aPoint + j; + if( rtreeSearchPointCompare(pNew, pParent)>=0 ) break; + rtreeSearchPointSwap(pCur, j, i); + i = j; + pNew = pParent; + } + return pNew; +} + +/* +** Allocate a new RtreeSearchPoint and return a pointer to it. Return +** NULL if malloc fails. +*/ +static RtreeSearchPoint *rtreeSearchPointNew( + RtreeCursor *pCur, /* The cursor */ + RtreeDValue rScore, /* Score for the new search point */ + u8 iLevel /* Level for the new search point */ +){ + RtreeSearchPoint *pNew, *pFirst; + pFirst = rtreeSearchPointFirst(pCur); + pCur->anQueue[iLevel]++; + if( pFirst==0 + || pFirst->rScore>rScore + || (pFirst->rScore==rScore && pFirst->iLevel>iLevel) + ){ + if( pCur->bPoint ){ + int ii; + pNew = rtreeEnqueue(pCur, rScore, iLevel); + if( pNew==0 ) return 0; + ii = (int)(pNew - pCur->aPoint) + 1; + if( iiaNode[ii]==0 ); + pCur->aNode[ii] = pCur->aNode[0]; + }else{ + nodeRelease(RTREE_OF_CURSOR(pCur), pCur->aNode[0]); + } + pCur->aNode[0] = 0; + *pNew = pCur->sPoint; + } + pCur->sPoint.rScore = rScore; + pCur->sPoint.iLevel = iLevel; + pCur->bPoint = 1; + return &pCur->sPoint; + }else{ + return rtreeEnqueue(pCur, rScore, iLevel); + } +} + +#if 0 +/* Tracing routines for the RtreeSearchPoint queue */ +static void tracePoint(RtreeSearchPoint *p, int idx, RtreeCursor *pCur){ + if( idx<0 ){ printf(" s"); }else{ printf("%2d", idx); } + printf(" %d.%05lld.%02d %g %d", + p->iLevel, p->id, p->iCell, p->rScore, p->eWithin + ); + idx++; + if( idxaNode[idx]); + }else{ + printf("\n"); + } +} +static void traceQueue(RtreeCursor *pCur, const char *zPrefix){ + int ii; + printf("=== %9s ", zPrefix); + if( pCur->bPoint ){ + tracePoint(&pCur->sPoint, -1, pCur); + } + for(ii=0; iinPoint; ii++){ + if( ii>0 || pCur->bPoint ) printf(" "); + tracePoint(&pCur->aPoint[ii], ii, pCur); + } +} +# define RTREE_QUEUE_TRACE(A,B) traceQueue(A,B) +#else +# define RTREE_QUEUE_TRACE(A,B) /* no-op */ +#endif + +/* Remove the search point with the lowest current score. +*/ +static void rtreeSearchPointPop(RtreeCursor *p){ + int i, j, k, n; + i = 1 - p->bPoint; + assert( i==0 || i==1 ); + if( p->aNode[i] ){ + nodeRelease(RTREE_OF_CURSOR(p), p->aNode[i]); + p->aNode[i] = 0; + } + if( p->bPoint ){ + p->anQueue[p->sPoint.iLevel]--; + p->bPoint = 0; + }else if( p->nPoint ){ + p->anQueue[p->aPoint[0].iLevel]--; + n = --p->nPoint; + p->aPoint[0] = p->aPoint[n]; + if( naNode[1] = p->aNode[n+1]; + p->aNode[n+1] = 0; + } + i = 0; + while( (j = i*2+1)aPoint[k], &p->aPoint[j])<0 ){ + if( rtreeSearchPointCompare(&p->aPoint[k], &p->aPoint[i])<0 ){ + rtreeSearchPointSwap(p, i, k); + i = k; + }else{ + break; + } + }else{ + if( rtreeSearchPointCompare(&p->aPoint[j], &p->aPoint[i])<0 ){ + rtreeSearchPointSwap(p, i, j); + i = j; + }else{ + break; + } + } + } + } +} + + +/* +** Continue the search on cursor pCur until the front of the queue +** contains an entry suitable for returning as a result-set row, +** or until the RtreeSearchPoint queue is empty, indicating that the +** query has completed. +*/ +static int rtreeStepToLeaf(RtreeCursor *pCur){ + RtreeSearchPoint *p; + Rtree *pRtree = RTREE_OF_CURSOR(pCur); + RtreeNode *pNode; + int eWithin; + int rc = SQLITE_OK; + int nCell; + int nConstraint = pCur->nConstraint; + int ii; + int eInt; + RtreeSearchPoint x; + + eInt = pRtree->eCoordType==RTREE_COORD_INT32; + while( (p = rtreeSearchPointFirst(pCur))!=0 && p->iLevel>0 ){ + u8 *pCellData; + pNode = rtreeNodeOfFirstSearchPoint(pCur, &rc); + if( rc ) return rc; + nCell = NCELL(pNode); + assert( nCell<200 ); + pCellData = pNode->zData + (4+pRtree->nBytesPerCell*p->iCell); + while( p->iCellaConstraint + ii; + if( pConstraint->op>=RTREE_MATCH ){ + rc = rtreeCallbackConstraint(pConstraint, eInt, pCellData, p, + &rScore, &eWithin); + if( rc ) return rc; + }else if( p->iLevel==1 ){ + rtreeLeafConstraint(pConstraint, eInt, pCellData, &eWithin); + }else{ + rtreeNonleafConstraint(pConstraint, eInt, pCellData, &eWithin); + } + if( eWithin==NOT_WITHIN ){ + p->iCell++; + pCellData += pRtree->nBytesPerCell; + break; + } + } + if( eWithin==NOT_WITHIN ) continue; + p->iCell++; + x.iLevel = p->iLevel - 1; + if( x.iLevel ){ + x.id = readInt64(pCellData); + for(ii=0; iinPoint; ii++){ + if( pCur->aPoint[ii].id==x.id ){ + RTREE_IS_CORRUPT(pRtree); + return SQLITE_CORRUPT_VTAB; + } + } + x.iCell = 0; + }else{ + x.id = p->id; + x.iCell = p->iCell - 1; + } + if( p->iCell>=nCell ){ + RTREE_QUEUE_TRACE(pCur, "POP-S:"); + rtreeSearchPointPop(pCur); + } + if( rScoreeWithin = (u8)eWithin; + p->id = x.id; + p->iCell = x.iCell; + RTREE_QUEUE_TRACE(pCur, "PUSH-S:"); + break; + } + if( p->iCell>=nCell ){ + RTREE_QUEUE_TRACE(pCur, "POP-Se:"); + rtreeSearchPointPop(pCur); + } + } + pCur->atEOF = p==0; + return SQLITE_OK; +} + +/* +** Rtree virtual table module xNext method. +*/ +static int rtreeNext(sqlite3_vtab_cursor *pVtabCursor){ + RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor; + int rc = SQLITE_OK; + + /* Move to the next entry that matches the configured constraints. */ + RTREE_QUEUE_TRACE(pCsr, "POP-Nx:"); + if( pCsr->bAuxValid ){ + pCsr->bAuxValid = 0; + sqlite3_reset(pCsr->pReadAux); + } + rtreeSearchPointPop(pCsr); + rc = rtreeStepToLeaf(pCsr); + return rc; +} + +/* +** Rtree virtual table module xRowid method. +*/ +static int rtreeRowid(sqlite3_vtab_cursor *pVtabCursor, sqlite_int64 *pRowid){ + RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor; + RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr); + int rc = SQLITE_OK; + RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc); + if( rc==SQLITE_OK && p ){ + *pRowid = nodeGetRowid(RTREE_OF_CURSOR(pCsr), pNode, p->iCell); + } + return rc; +} + +/* +** Rtree virtual table module xColumn method. +*/ +static int rtreeColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){ + Rtree *pRtree = (Rtree *)cur->pVtab; + RtreeCursor *pCsr = (RtreeCursor *)cur; + RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr); + RtreeCoord c; + int rc = SQLITE_OK; + RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc); + + if( rc ) return rc; + if( p==0 ) return SQLITE_OK; + if( i==0 ){ + sqlite3_result_int64(ctx, nodeGetRowid(pRtree, pNode, p->iCell)); + }else if( i<=pRtree->nDim2 ){ + nodeGetCoord(pRtree, pNode, p->iCell, i-1, &c); +#ifndef SQLITE_RTREE_INT_ONLY + if( pRtree->eCoordType==RTREE_COORD_REAL32 ){ + sqlite3_result_double(ctx, c.f); + }else +#endif + { + assert( pRtree->eCoordType==RTREE_COORD_INT32 ); + sqlite3_result_int(ctx, c.i); + } + }else{ + if( !pCsr->bAuxValid ){ + if( pCsr->pReadAux==0 ){ + rc = sqlite3_prepare_v3(pRtree->db, pRtree->zReadAuxSql, -1, 0, + &pCsr->pReadAux, 0); + if( rc ) return rc; + } + sqlite3_bind_int64(pCsr->pReadAux, 1, + nodeGetRowid(pRtree, pNode, p->iCell)); + rc = sqlite3_step(pCsr->pReadAux); + if( rc==SQLITE_ROW ){ + pCsr->bAuxValid = 1; + }else{ + sqlite3_reset(pCsr->pReadAux); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + return rc; + } + } + sqlite3_result_value(ctx, + sqlite3_column_value(pCsr->pReadAux, i - pRtree->nDim2 + 1)); + } + return SQLITE_OK; +} + +/* +** Use nodeAcquire() to obtain the leaf node containing the record with +** rowid iRowid. If successful, set *ppLeaf to point to the node and +** return SQLITE_OK. If there is no such record in the table, set +** *ppLeaf to 0 and return SQLITE_OK. If an error occurs, set *ppLeaf +** to zero and return an SQLite error code. +*/ +static int findLeafNode( + Rtree *pRtree, /* RTree to search */ + i64 iRowid, /* The rowid searching for */ + RtreeNode **ppLeaf, /* Write the node here */ + sqlite3_int64 *piNode /* Write the node-id here */ +){ + int rc; + *ppLeaf = 0; + sqlite3_bind_int64(pRtree->pReadRowid, 1, iRowid); + if( sqlite3_step(pRtree->pReadRowid)==SQLITE_ROW ){ + i64 iNode = sqlite3_column_int64(pRtree->pReadRowid, 0); + if( piNode ) *piNode = iNode; + rc = nodeAcquire(pRtree, iNode, 0, ppLeaf); + sqlite3_reset(pRtree->pReadRowid); + }else{ + rc = sqlite3_reset(pRtree->pReadRowid); + } + return rc; +} + +/* +** This function is called to configure the RtreeConstraint object passed +** as the second argument for a MATCH constraint. The value passed as the +** first argument to this function is the right-hand operand to the MATCH +** operator. +*/ +static int deserializeGeometry(sqlite3_value *pValue, RtreeConstraint *pCons){ + RtreeMatchArg *pBlob, *pSrc; /* BLOB returned by geometry function */ + sqlite3_rtree_query_info *pInfo; /* Callback information */ + + pSrc = sqlite3_value_pointer(pValue, "RtreeMatchArg"); + if( pSrc==0 ) return SQLITE_ERROR; + pInfo = (sqlite3_rtree_query_info*) + sqlite3_malloc64( sizeof(*pInfo)+pSrc->iSize ); + if( !pInfo ) return SQLITE_NOMEM; + memset(pInfo, 0, sizeof(*pInfo)); + pBlob = (RtreeMatchArg*)&pInfo[1]; + memcpy(pBlob, pSrc, pSrc->iSize); + pInfo->pContext = pBlob->cb.pContext; + pInfo->nParam = pBlob->nParam; + pInfo->aParam = pBlob->aParam; + pInfo->apSqlParam = pBlob->apSqlParam; + + if( pBlob->cb.xGeom ){ + pCons->u.xGeom = pBlob->cb.xGeom; + }else{ + pCons->op = RTREE_QUERY; + pCons->u.xQueryFunc = pBlob->cb.xQueryFunc; + } + pCons->pInfo = pInfo; + return SQLITE_OK; +} + +/* +** Rtree virtual table module xFilter method. +*/ +static int rtreeFilter( + sqlite3_vtab_cursor *pVtabCursor, + int idxNum, const char *idxStr, + int argc, sqlite3_value **argv +){ + Rtree *pRtree = (Rtree *)pVtabCursor->pVtab; + RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor; + RtreeNode *pRoot = 0; + int ii; + int rc = SQLITE_OK; + int iCell = 0; + + rtreeReference(pRtree); + + /* Reset the cursor to the same state as rtreeOpen() leaves it in. */ + resetCursor(pCsr); + + pCsr->iStrategy = idxNum; + if( idxNum==1 ){ + /* Special case - lookup by rowid. */ + RtreeNode *pLeaf; /* Leaf on which the required cell resides */ + RtreeSearchPoint *p; /* Search point for the leaf */ + i64 iRowid = sqlite3_value_int64(argv[0]); + i64 iNode = 0; + int eType = sqlite3_value_numeric_type(argv[0]); + if( eType==SQLITE_INTEGER + || (eType==SQLITE_FLOAT && sqlite3_value_double(argv[0])==iRowid) + ){ + rc = findLeafNode(pRtree, iRowid, &pLeaf, &iNode); + }else{ + rc = SQLITE_OK; + pLeaf = 0; + } + if( rc==SQLITE_OK && pLeaf!=0 ){ + p = rtreeSearchPointNew(pCsr, RTREE_ZERO, 0); + assert( p!=0 ); /* Always returns pCsr->sPoint */ + pCsr->aNode[0] = pLeaf; + p->id = iNode; + p->eWithin = PARTLY_WITHIN; + rc = nodeRowidIndex(pRtree, pLeaf, iRowid, &iCell); + p->iCell = (u8)iCell; + RTREE_QUEUE_TRACE(pCsr, "PUSH-F1:"); + }else{ + pCsr->atEOF = 1; + } + }else{ + /* Normal case - r-tree scan. Set up the RtreeCursor.aConstraint array + ** with the configured constraints. + */ + rc = nodeAcquire(pRtree, 1, 0, &pRoot); + if( rc==SQLITE_OK && argc>0 ){ + pCsr->aConstraint = sqlite3_malloc64(sizeof(RtreeConstraint)*argc); + pCsr->nConstraint = argc; + if( !pCsr->aConstraint ){ + rc = SQLITE_NOMEM; + }else{ + memset(pCsr->aConstraint, 0, sizeof(RtreeConstraint)*argc); + memset(pCsr->anQueue, 0, sizeof(u32)*(pRtree->iDepth + 1)); + assert( (idxStr==0 && argc==0) + || (idxStr && (int)strlen(idxStr)==argc*2) ); + for(ii=0; iiaConstraint[ii]; + int eType = sqlite3_value_numeric_type(argv[ii]); + p->op = idxStr[ii*2]; + p->iCoord = idxStr[ii*2+1]-'0'; + if( p->op>=RTREE_MATCH ){ + /* A MATCH operator. The right-hand-side must be a blob that + ** can be cast into an RtreeMatchArg object. One created using + ** an sqlite3_rtree_geometry_callback() SQL user function. + */ + rc = deserializeGeometry(argv[ii], p); + if( rc!=SQLITE_OK ){ + break; + } + p->pInfo->nCoord = pRtree->nDim2; + p->pInfo->anQueue = pCsr->anQueue; + p->pInfo->mxLevel = pRtree->iDepth + 1; + }else if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){ +#ifdef SQLITE_RTREE_INT_ONLY + p->u.rValue = sqlite3_value_int64(argv[ii]); +#else + p->u.rValue = sqlite3_value_double(argv[ii]); +#endif + }else{ + p->u.rValue = RTREE_ZERO; + if( eType==SQLITE_NULL ){ + p->op = RTREE_FALSE; + }else if( p->op==RTREE_LT || p->op==RTREE_LE ){ + p->op = RTREE_TRUE; + }else{ + p->op = RTREE_FALSE; + } + } + } + } + } + if( rc==SQLITE_OK ){ + RtreeSearchPoint *pNew; + pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1)); + if( pNew==0 ) return SQLITE_NOMEM; + pNew->id = 1; + pNew->iCell = 0; + pNew->eWithin = PARTLY_WITHIN; + assert( pCsr->bPoint==1 ); + pCsr->aNode[0] = pRoot; + pRoot = 0; + RTREE_QUEUE_TRACE(pCsr, "PUSH-Fm:"); + rc = rtreeStepToLeaf(pCsr); + } + } + + nodeRelease(pRtree, pRoot); + rtreeRelease(pRtree); + return rc; +} + +/* +** Rtree virtual table module xBestIndex method. There are three +** table scan strategies to choose from (in order from most to +** least desirable): +** +** idxNum idxStr Strategy +** ------------------------------------------------ +** 1 Unused Direct lookup by rowid. +** 2 See below R-tree query or full-table scan. +** ------------------------------------------------ +** +** If strategy 1 is used, then idxStr is not meaningful. If strategy +** 2 is used, idxStr is formatted to contain 2 bytes for each +** constraint used. The first two bytes of idxStr correspond to +** the constraint in sqlite3_index_info.aConstraintUsage[] with +** (argvIndex==1) etc. +** +** The first of each pair of bytes in idxStr identifies the constraint +** operator as follows: +** +** Operator Byte Value +** ---------------------- +** = 0x41 ('A') +** <= 0x42 ('B') +** < 0x43 ('C') +** >= 0x44 ('D') +** > 0x45 ('E') +** MATCH 0x46 ('F') +** ---------------------- +** +** The second of each pair of bytes identifies the coordinate column +** to which the constraint applies. The leftmost coordinate column +** is 'a', the second from the left 'b' etc. +*/ +static int rtreeBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){ + Rtree *pRtree = (Rtree*)tab; + int rc = SQLITE_OK; + int ii; + int bMatch = 0; /* True if there exists a MATCH constraint */ + i64 nRow; /* Estimated rows returned by this scan */ + + int iIdx = 0; + char zIdxStr[RTREE_MAX_DIMENSIONS*8+1]; + memset(zIdxStr, 0, sizeof(zIdxStr)); + + /* Check if there exists a MATCH constraint - even an unusable one. If there + ** is, do not consider the lookup-by-rowid plan as using such a plan would + ** require the VDBE to evaluate the MATCH constraint, which is not currently + ** possible. */ + for(ii=0; iinConstraint; ii++){ + if( pIdxInfo->aConstraint[ii].op==SQLITE_INDEX_CONSTRAINT_MATCH ){ + bMatch = 1; + } + } + + assert( pIdxInfo->idxStr==0 ); + for(ii=0; iinConstraint && iIdx<(int)(sizeof(zIdxStr)-1); ii++){ + struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[ii]; + + if( bMatch==0 && p->usable + && p->iColumn==0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ + ){ + /* We have an equality constraint on the rowid. Use strategy 1. */ + int jj; + for(jj=0; jjaConstraintUsage[jj].argvIndex = 0; + pIdxInfo->aConstraintUsage[jj].omit = 0; + } + pIdxInfo->idxNum = 1; + pIdxInfo->aConstraintUsage[ii].argvIndex = 1; + pIdxInfo->aConstraintUsage[jj].omit = 1; + + /* This strategy involves a two rowid lookups on an B-Tree structures + ** and then a linear search of an R-Tree node. This should be + ** considered almost as quick as a direct rowid lookup (for which + ** sqlite uses an internal cost of 0.0). It is expected to return + ** a single row. + */ + pIdxInfo->estimatedCost = 30.0; + pIdxInfo->estimatedRows = 1; + pIdxInfo->idxFlags = SQLITE_INDEX_SCAN_UNIQUE; + return SQLITE_OK; + } + + if( p->usable + && ((p->iColumn>0 && p->iColumn<=pRtree->nDim2) + || p->op==SQLITE_INDEX_CONSTRAINT_MATCH) + ){ + u8 op; + switch( p->op ){ + case SQLITE_INDEX_CONSTRAINT_EQ: op = RTREE_EQ; break; + case SQLITE_INDEX_CONSTRAINT_GT: op = RTREE_GT; break; + case SQLITE_INDEX_CONSTRAINT_LE: op = RTREE_LE; break; + case SQLITE_INDEX_CONSTRAINT_LT: op = RTREE_LT; break; + case SQLITE_INDEX_CONSTRAINT_GE: op = RTREE_GE; break; + case SQLITE_INDEX_CONSTRAINT_MATCH: op = RTREE_MATCH; break; + default: op = 0; break; + } + if( op ){ + zIdxStr[iIdx++] = op; + zIdxStr[iIdx++] = (char)(p->iColumn - 1 + '0'); + pIdxInfo->aConstraintUsage[ii].argvIndex = (iIdx/2); + pIdxInfo->aConstraintUsage[ii].omit = 1; + } + } + } + + pIdxInfo->idxNum = 2; + pIdxInfo->needToFreeIdxStr = 1; + if( iIdx>0 && 0==(pIdxInfo->idxStr = sqlite3_mprintf("%s", zIdxStr)) ){ + return SQLITE_NOMEM; + } + + nRow = pRtree->nRowEst >> (iIdx/2); + pIdxInfo->estimatedCost = (double)6.0 * (double)nRow; + pIdxInfo->estimatedRows = nRow; + + return rc; +} + +/* +** Return the N-dimensional volumn of the cell stored in *p. +*/ +static RtreeDValue cellArea(Rtree *pRtree, RtreeCell *p){ + RtreeDValue area = (RtreeDValue)1; + assert( pRtree->nDim>=1 && pRtree->nDim<=5 ); +#ifndef SQLITE_RTREE_INT_ONLY + if( pRtree->eCoordType==RTREE_COORD_REAL32 ){ + switch( pRtree->nDim ){ + case 5: area = p->aCoord[9].f - p->aCoord[8].f; + case 4: area *= p->aCoord[7].f - p->aCoord[6].f; + case 3: area *= p->aCoord[5].f - p->aCoord[4].f; + case 2: area *= p->aCoord[3].f - p->aCoord[2].f; + default: area *= p->aCoord[1].f - p->aCoord[0].f; + } + }else +#endif + { + switch( pRtree->nDim ){ + case 5: area = (i64)p->aCoord[9].i - (i64)p->aCoord[8].i; + case 4: area *= (i64)p->aCoord[7].i - (i64)p->aCoord[6].i; + case 3: area *= (i64)p->aCoord[5].i - (i64)p->aCoord[4].i; + case 2: area *= (i64)p->aCoord[3].i - (i64)p->aCoord[2].i; + default: area *= (i64)p->aCoord[1].i - (i64)p->aCoord[0].i; + } + } + return area; +} + +/* +** Return the margin length of cell p. The margin length is the sum +** of the objects size in each dimension. +*/ +static RtreeDValue cellMargin(Rtree *pRtree, RtreeCell *p){ + RtreeDValue margin = 0; + int ii = pRtree->nDim2 - 2; + do{ + margin += (DCOORD(p->aCoord[ii+1]) - DCOORD(p->aCoord[ii])); + ii -= 2; + }while( ii>=0 ); + return margin; +} + +/* +** Store the union of cells p1 and p2 in p1. +*/ +static void cellUnion(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){ + int ii = 0; + if( pRtree->eCoordType==RTREE_COORD_REAL32 ){ + do{ + p1->aCoord[ii].f = MIN(p1->aCoord[ii].f, p2->aCoord[ii].f); + p1->aCoord[ii+1].f = MAX(p1->aCoord[ii+1].f, p2->aCoord[ii+1].f); + ii += 2; + }while( iinDim2 ); + }else{ + do{ + p1->aCoord[ii].i = MIN(p1->aCoord[ii].i, p2->aCoord[ii].i); + p1->aCoord[ii+1].i = MAX(p1->aCoord[ii+1].i, p2->aCoord[ii+1].i); + ii += 2; + }while( iinDim2 ); + } +} + +/* +** Return true if the area covered by p2 is a subset of the area covered +** by p1. False otherwise. +*/ +static int cellContains(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){ + int ii; + int isInt = (pRtree->eCoordType==RTREE_COORD_INT32); + for(ii=0; iinDim2; ii+=2){ + RtreeCoord *a1 = &p1->aCoord[ii]; + RtreeCoord *a2 = &p2->aCoord[ii]; + if( (!isInt && (a2[0].fa1[1].f)) + || ( isInt && (a2[0].ia1[1].i)) + ){ + return 0; + } + } + return 1; +} + +/* +** Return the amount cell p would grow by if it were unioned with pCell. +*/ +static RtreeDValue cellGrowth(Rtree *pRtree, RtreeCell *p, RtreeCell *pCell){ + RtreeDValue area; + RtreeCell cell; + memcpy(&cell, p, sizeof(RtreeCell)); + area = cellArea(pRtree, &cell); + cellUnion(pRtree, &cell, pCell); + return (cellArea(pRtree, &cell)-area); +} + +static RtreeDValue cellOverlap( + Rtree *pRtree, + RtreeCell *p, + RtreeCell *aCell, + int nCell +){ + int ii; + RtreeDValue overlap = RTREE_ZERO; + for(ii=0; iinDim2; jj+=2){ + RtreeDValue x1, x2; + x1 = MAX(DCOORD(p->aCoord[jj]), DCOORD(aCell[ii].aCoord[jj])); + x2 = MIN(DCOORD(p->aCoord[jj+1]), DCOORD(aCell[ii].aCoord[jj+1])); + if( x2iDepth-iHeight); ii++){ + int iCell; + sqlite3_int64 iBest = 0; + + RtreeDValue fMinGrowth = RTREE_ZERO; + RtreeDValue fMinArea = RTREE_ZERO; + + int nCell = NCELL(pNode); + RtreeCell cell; + RtreeNode *pChild; + + RtreeCell *aCell = 0; + + /* Select the child node which will be enlarged the least if pCell + ** is inserted into it. Resolve ties by choosing the entry with + ** the smallest area. + */ + for(iCell=0; iCellpParent ){ + RtreeNode *pParent = p->pParent; + RtreeCell cell; + int iCell; + + if( (++cnt)>1000 || nodeParentIndex(pRtree, p, &iCell) ){ + RTREE_IS_CORRUPT(pRtree); + return SQLITE_CORRUPT_VTAB; + } + + nodeGetCell(pRtree, pParent, iCell, &cell); + if( !cellContains(pRtree, &cell, pCell) ){ + cellUnion(pRtree, &cell, pCell); + nodeOverwriteCell(pRtree, pParent, &cell, iCell); + } + + p = pParent; + } + return SQLITE_OK; +} + +/* +** Write mapping (iRowid->iNode) to the _rowid table. +*/ +static int rowidWrite(Rtree *pRtree, sqlite3_int64 iRowid, sqlite3_int64 iNode){ + sqlite3_bind_int64(pRtree->pWriteRowid, 1, iRowid); + sqlite3_bind_int64(pRtree->pWriteRowid, 2, iNode); + sqlite3_step(pRtree->pWriteRowid); + return sqlite3_reset(pRtree->pWriteRowid); +} + +/* +** Write mapping (iNode->iPar) to the _parent table. +*/ +static int parentWrite(Rtree *pRtree, sqlite3_int64 iNode, sqlite3_int64 iPar){ + sqlite3_bind_int64(pRtree->pWriteParent, 1, iNode); + sqlite3_bind_int64(pRtree->pWriteParent, 2, iPar); + sqlite3_step(pRtree->pWriteParent); + return sqlite3_reset(pRtree->pWriteParent); +} + +static int rtreeInsertCell(Rtree *, RtreeNode *, RtreeCell *, int); + + +/* +** Arguments aIdx, aDistance and aSpare all point to arrays of size +** nIdx. The aIdx array contains the set of integers from 0 to +** (nIdx-1) in no particular order. This function sorts the values +** in aIdx according to the indexed values in aDistance. For +** example, assuming the inputs: +** +** aIdx = { 0, 1, 2, 3 } +** aDistance = { 5.0, 2.0, 7.0, 6.0 } +** +** this function sets the aIdx array to contain: +** +** aIdx = { 0, 1, 2, 3 } +** +** The aSpare array is used as temporary working space by the +** sorting algorithm. +*/ +static void SortByDistance( + int *aIdx, + int nIdx, + RtreeDValue *aDistance, + int *aSpare +){ + if( nIdx>1 ){ + int iLeft = 0; + int iRight = 0; + + int nLeft = nIdx/2; + int nRight = nIdx-nLeft; + int *aLeft = aIdx; + int *aRight = &aIdx[nLeft]; + + SortByDistance(aLeft, nLeft, aDistance, aSpare); + SortByDistance(aRight, nRight, aDistance, aSpare); + + memcpy(aSpare, aLeft, sizeof(int)*nLeft); + aLeft = aSpare; + + while( iLeft1 ){ + + int iLeft = 0; + int iRight = 0; + + int nLeft = nIdx/2; + int nRight = nIdx-nLeft; + int *aLeft = aIdx; + int *aRight = &aIdx[nLeft]; + + SortByDimension(pRtree, aLeft, nLeft, iDim, aCell, aSpare); + SortByDimension(pRtree, aRight, nRight, iDim, aCell, aSpare); + + memcpy(aSpare, aLeft, sizeof(int)*nLeft); + aLeft = aSpare; + while( iLeftnDim+1)*(sizeof(int*)+nCell*sizeof(int)); + + aaSorted = (int **)sqlite3_malloc64(nByte); + if( !aaSorted ){ + return SQLITE_NOMEM; + } + + aSpare = &((int *)&aaSorted[pRtree->nDim])[pRtree->nDim*nCell]; + memset(aaSorted, 0, nByte); + for(ii=0; iinDim; ii++){ + int jj; + aaSorted[ii] = &((int *)&aaSorted[pRtree->nDim])[ii*nCell]; + for(jj=0; jjnDim; ii++){ + RtreeDValue margin = RTREE_ZERO; + RtreeDValue fBestOverlap = RTREE_ZERO; + RtreeDValue fBestArea = RTREE_ZERO; + int iBestLeft = 0; + int nLeft; + + for( + nLeft=RTREE_MINCELLS(pRtree); + nLeft<=(nCell-RTREE_MINCELLS(pRtree)); + nLeft++ + ){ + RtreeCell left; + RtreeCell right; + int kk; + RtreeDValue overlap; + RtreeDValue area; + + memcpy(&left, &aCell[aaSorted[ii][0]], sizeof(RtreeCell)); + memcpy(&right, &aCell[aaSorted[ii][nCell-1]], sizeof(RtreeCell)); + for(kk=1; kk<(nCell-1); kk++){ + if( kk0 ){ + RtreeNode *pChild = nodeHashLookup(pRtree, iRowid); + if( pChild ){ + nodeRelease(pRtree, pChild->pParent); + nodeReference(pNode); + pChild->pParent = pNode; + } + } + return xSetMapping(pRtree, iRowid, pNode->iNode); +} + +static int SplitNode( + Rtree *pRtree, + RtreeNode *pNode, + RtreeCell *pCell, + int iHeight +){ + int i; + int newCellIsRight = 0; + + int rc = SQLITE_OK; + int nCell = NCELL(pNode); + RtreeCell *aCell; + int *aiUsed; + + RtreeNode *pLeft = 0; + RtreeNode *pRight = 0; + + RtreeCell leftbbox; + RtreeCell rightbbox; + + /* Allocate an array and populate it with a copy of pCell and + ** all cells from node pLeft. Then zero the original node. + */ + aCell = sqlite3_malloc64((sizeof(RtreeCell)+sizeof(int))*(nCell+1)); + if( !aCell ){ + rc = SQLITE_NOMEM; + goto splitnode_out; + } + aiUsed = (int *)&aCell[nCell+1]; + memset(aiUsed, 0, sizeof(int)*(nCell+1)); + for(i=0; iiNode==1 ){ + pRight = nodeNew(pRtree, pNode); + pLeft = nodeNew(pRtree, pNode); + pRtree->iDepth++; + pNode->isDirty = 1; + writeInt16(pNode->zData, pRtree->iDepth); + }else{ + pLeft = pNode; + pRight = nodeNew(pRtree, pLeft->pParent); + pLeft->nRef++; + } + + if( !pLeft || !pRight ){ + rc = SQLITE_NOMEM; + goto splitnode_out; + } + + memset(pLeft->zData, 0, pRtree->iNodeSize); + memset(pRight->zData, 0, pRtree->iNodeSize); + + rc = splitNodeStartree(pRtree, aCell, nCell, pLeft, pRight, + &leftbbox, &rightbbox); + if( rc!=SQLITE_OK ){ + goto splitnode_out; + } + + /* Ensure both child nodes have node numbers assigned to them by calling + ** nodeWrite(). Node pRight always needs a node number, as it was created + ** by nodeNew() above. But node pLeft sometimes already has a node number. + ** In this case avoid the all to nodeWrite(). + */ + if( SQLITE_OK!=(rc = nodeWrite(pRtree, pRight)) + || (0==pLeft->iNode && SQLITE_OK!=(rc = nodeWrite(pRtree, pLeft))) + ){ + goto splitnode_out; + } + + rightbbox.iRowid = pRight->iNode; + leftbbox.iRowid = pLeft->iNode; + + if( pNode->iNode==1 ){ + rc = rtreeInsertCell(pRtree, pLeft->pParent, &leftbbox, iHeight+1); + if( rc!=SQLITE_OK ){ + goto splitnode_out; + } + }else{ + RtreeNode *pParent = pLeft->pParent; + int iCell; + rc = nodeParentIndex(pRtree, pLeft, &iCell); + if( rc==SQLITE_OK ){ + nodeOverwriteCell(pRtree, pParent, &leftbbox, iCell); + rc = AdjustTree(pRtree, pParent, &leftbbox); + } + if( rc!=SQLITE_OK ){ + goto splitnode_out; + } + } + if( (rc = rtreeInsertCell(pRtree, pRight->pParent, &rightbbox, iHeight+1)) ){ + goto splitnode_out; + } + + for(i=0; iiRowid ){ + newCellIsRight = 1; + } + if( rc!=SQLITE_OK ){ + goto splitnode_out; + } + } + if( pNode->iNode==1 ){ + for(i=0; iiRowid, pLeft, iHeight); + } + + if( rc==SQLITE_OK ){ + rc = nodeRelease(pRtree, pRight); + pRight = 0; + } + if( rc==SQLITE_OK ){ + rc = nodeRelease(pRtree, pLeft); + pLeft = 0; + } + +splitnode_out: + nodeRelease(pRtree, pRight); + nodeRelease(pRtree, pLeft); + sqlite3_free(aCell); + return rc; +} + +/* +** If node pLeaf is not the root of the r-tree and its pParent pointer is +** still NULL, load all ancestor nodes of pLeaf into memory and populate +** the pLeaf->pParent chain all the way up to the root node. +** +** This operation is required when a row is deleted (or updated - an update +** is implemented as a delete followed by an insert). SQLite provides the +** rowid of the row to delete, which can be used to find the leaf on which +** the entry resides (argument pLeaf). Once the leaf is located, this +** function is called to determine its ancestry. +*/ +static int fixLeafParent(Rtree *pRtree, RtreeNode *pLeaf){ + int rc = SQLITE_OK; + RtreeNode *pChild = pLeaf; + while( rc==SQLITE_OK && pChild->iNode!=1 && pChild->pParent==0 ){ + int rc2 = SQLITE_OK; /* sqlite3_reset() return code */ + sqlite3_bind_int64(pRtree->pReadParent, 1, pChild->iNode); + rc = sqlite3_step(pRtree->pReadParent); + if( rc==SQLITE_ROW ){ + RtreeNode *pTest; /* Used to test for reference loops */ + i64 iNode; /* Node number of parent node */ + + /* Before setting pChild->pParent, test that we are not creating a + ** loop of references (as we would if, say, pChild==pParent). We don't + ** want to do this as it leads to a memory leak when trying to delete + ** the referenced counted node structures. + */ + iNode = sqlite3_column_int64(pRtree->pReadParent, 0); + for(pTest=pLeaf; pTest && pTest->iNode!=iNode; pTest=pTest->pParent); + if( !pTest ){ + rc2 = nodeAcquire(pRtree, iNode, 0, &pChild->pParent); + } + } + rc = sqlite3_reset(pRtree->pReadParent); + if( rc==SQLITE_OK ) rc = rc2; + if( rc==SQLITE_OK && !pChild->pParent ){ + RTREE_IS_CORRUPT(pRtree); + rc = SQLITE_CORRUPT_VTAB; + } + pChild = pChild->pParent; + } + return rc; +} + +static int deleteCell(Rtree *, RtreeNode *, int, int); + +static int removeNode(Rtree *pRtree, RtreeNode *pNode, int iHeight){ + int rc; + int rc2; + RtreeNode *pParent = 0; + int iCell; + + assert( pNode->nRef==1 ); + + /* Remove the entry in the parent cell. */ + rc = nodeParentIndex(pRtree, pNode, &iCell); + if( rc==SQLITE_OK ){ + pParent = pNode->pParent; + pNode->pParent = 0; + rc = deleteCell(pRtree, pParent, iCell, iHeight+1); + } + rc2 = nodeRelease(pRtree, pParent); + if( rc==SQLITE_OK ){ + rc = rc2; + } + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Remove the xxx_node entry. */ + sqlite3_bind_int64(pRtree->pDeleteNode, 1, pNode->iNode); + sqlite3_step(pRtree->pDeleteNode); + if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteNode)) ){ + return rc; + } + + /* Remove the xxx_parent entry. */ + sqlite3_bind_int64(pRtree->pDeleteParent, 1, pNode->iNode); + sqlite3_step(pRtree->pDeleteParent); + if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteParent)) ){ + return rc; + } + + /* Remove the node from the in-memory hash table and link it into + ** the Rtree.pDeleted list. Its contents will be re-inserted later on. + */ + nodeHashDelete(pRtree, pNode); + pNode->iNode = iHeight; + pNode->pNext = pRtree->pDeleted; + pNode->nRef++; + pRtree->pDeleted = pNode; + + return SQLITE_OK; +} + +static int fixBoundingBox(Rtree *pRtree, RtreeNode *pNode){ + RtreeNode *pParent = pNode->pParent; + int rc = SQLITE_OK; + if( pParent ){ + int ii; + int nCell = NCELL(pNode); + RtreeCell box; /* Bounding box for pNode */ + nodeGetCell(pRtree, pNode, 0, &box); + for(ii=1; iiiNode; + rc = nodeParentIndex(pRtree, pNode, &ii); + if( rc==SQLITE_OK ){ + nodeOverwriteCell(pRtree, pParent, &box, ii); + rc = fixBoundingBox(pRtree, pParent); + } + } + return rc; +} + +/* +** Delete the cell at index iCell of node pNode. After removing the +** cell, adjust the r-tree data structure if required. +*/ +static int deleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell, int iHeight){ + RtreeNode *pParent; + int rc; + + if( SQLITE_OK!=(rc = fixLeafParent(pRtree, pNode)) ){ + return rc; + } + + /* Remove the cell from the node. This call just moves bytes around + ** the in-memory node image, so it cannot fail. + */ + nodeDeleteCell(pRtree, pNode, iCell); + + /* If the node is not the tree root and now has less than the minimum + ** number of cells, remove it from the tree. Otherwise, update the + ** cell in the parent node so that it tightly contains the updated + ** node. + */ + pParent = pNode->pParent; + assert( pParent || pNode->iNode==1 ); + if( pParent ){ + if( NCELL(pNode)nDim; iDim++){ + aCenterCoord[iDim] += DCOORD(aCell[ii].aCoord[iDim*2]); + aCenterCoord[iDim] += DCOORD(aCell[ii].aCoord[iDim*2+1]); + } + } + for(iDim=0; iDimnDim; iDim++){ + aCenterCoord[iDim] = (aCenterCoord[iDim]/(nCell*(RtreeDValue)2)); + } + + for(ii=0; iinDim; iDim++){ + RtreeDValue coord = (DCOORD(aCell[ii].aCoord[iDim*2+1]) - + DCOORD(aCell[ii].aCoord[iDim*2])); + aDistance[ii] += (coord-aCenterCoord[iDim])*(coord-aCenterCoord[iDim]); + } + } + + SortByDistance(aOrder, nCell, aDistance, aSpare); + nodeZero(pRtree, pNode); + + for(ii=0; rc==SQLITE_OK && ii<(nCell-(RTREE_MINCELLS(pRtree)+1)); ii++){ + RtreeCell *p = &aCell[aOrder[ii]]; + nodeInsertCell(pRtree, pNode, p); + if( p->iRowid==pCell->iRowid ){ + if( iHeight==0 ){ + rc = rowidWrite(pRtree, p->iRowid, pNode->iNode); + }else{ + rc = parentWrite(pRtree, p->iRowid, pNode->iNode); + } + } + } + if( rc==SQLITE_OK ){ + rc = fixBoundingBox(pRtree, pNode); + } + for(; rc==SQLITE_OK && iiiNode currently contains + ** the height of the sub-tree headed by the cell. + */ + RtreeNode *pInsert; + RtreeCell *p = &aCell[aOrder[ii]]; + rc = ChooseLeaf(pRtree, p, iHeight, &pInsert); + if( rc==SQLITE_OK ){ + int rc2; + rc = rtreeInsertCell(pRtree, pInsert, p, iHeight); + rc2 = nodeRelease(pRtree, pInsert); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + } + + sqlite3_free(aCell); + return rc; +} + +/* +** Insert cell pCell into node pNode. Node pNode is the head of a +** subtree iHeight high (leaf nodes have iHeight==0). +*/ +static int rtreeInsertCell( + Rtree *pRtree, + RtreeNode *pNode, + RtreeCell *pCell, + int iHeight +){ + int rc = SQLITE_OK; + if( iHeight>0 ){ + RtreeNode *pChild = nodeHashLookup(pRtree, pCell->iRowid); + if( pChild ){ + nodeRelease(pRtree, pChild->pParent); + nodeReference(pNode); + pChild->pParent = pNode; + } + } + if( nodeInsertCell(pRtree, pNode, pCell) ){ + if( iHeight<=pRtree->iReinsertHeight || pNode->iNode==1){ + rc = SplitNode(pRtree, pNode, pCell, iHeight); + }else{ + pRtree->iReinsertHeight = iHeight; + rc = Reinsert(pRtree, pNode, pCell, iHeight); + } + }else{ + rc = AdjustTree(pRtree, pNode, pCell); + if( rc==SQLITE_OK ){ + if( iHeight==0 ){ + rc = rowidWrite(pRtree, pCell->iRowid, pNode->iNode); + }else{ + rc = parentWrite(pRtree, pCell->iRowid, pNode->iNode); + } + } + } + return rc; +} + +static int reinsertNodeContent(Rtree *pRtree, RtreeNode *pNode){ + int ii; + int rc = SQLITE_OK; + int nCell = NCELL(pNode); + + for(ii=0; rc==SQLITE_OK && iiiNode currently contains + ** the height of the sub-tree headed by the cell. + */ + rc = ChooseLeaf(pRtree, &cell, (int)pNode->iNode, &pInsert); + if( rc==SQLITE_OK ){ + int rc2; + rc = rtreeInsertCell(pRtree, pInsert, &cell, (int)pNode->iNode); + rc2 = nodeRelease(pRtree, pInsert); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + } + return rc; +} + +/* +** Select a currently unused rowid for a new r-tree record. +*/ +static int rtreeNewRowid(Rtree *pRtree, i64 *piRowid){ + int rc; + sqlite3_bind_null(pRtree->pWriteRowid, 1); + sqlite3_bind_null(pRtree->pWriteRowid, 2); + sqlite3_step(pRtree->pWriteRowid); + rc = sqlite3_reset(pRtree->pWriteRowid); + *piRowid = sqlite3_last_insert_rowid(pRtree->db); + return rc; +} + +/* +** Remove the entry with rowid=iDelete from the r-tree structure. +*/ +static int rtreeDeleteRowid(Rtree *pRtree, sqlite3_int64 iDelete){ + int rc; /* Return code */ + RtreeNode *pLeaf = 0; /* Leaf node containing record iDelete */ + int iCell; /* Index of iDelete cell in pLeaf */ + RtreeNode *pRoot = 0; /* Root node of rtree structure */ + + + /* Obtain a reference to the root node to initialize Rtree.iDepth */ + rc = nodeAcquire(pRtree, 1, 0, &pRoot); + + /* Obtain a reference to the leaf node that contains the entry + ** about to be deleted. + */ + if( rc==SQLITE_OK ){ + rc = findLeafNode(pRtree, iDelete, &pLeaf, 0); + } + +#ifdef CORRUPT_DB + assert( pLeaf!=0 || rc!=SQLITE_OK || CORRUPT_DB ); +#endif + + /* Delete the cell in question from the leaf node. */ + if( rc==SQLITE_OK && pLeaf ){ + int rc2; + rc = nodeRowidIndex(pRtree, pLeaf, iDelete, &iCell); + if( rc==SQLITE_OK ){ + rc = deleteCell(pRtree, pLeaf, iCell, 0); + } + rc2 = nodeRelease(pRtree, pLeaf); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + + /* Delete the corresponding entry in the _rowid table. */ + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pRtree->pDeleteRowid, 1, iDelete); + sqlite3_step(pRtree->pDeleteRowid); + rc = sqlite3_reset(pRtree->pDeleteRowid); + } + + /* Check if the root node now has exactly one child. If so, remove + ** it, schedule the contents of the child for reinsertion and + ** reduce the tree height by one. + ** + ** This is equivalent to copying the contents of the child into + ** the root node (the operation that Gutman's paper says to perform + ** in this scenario). + */ + if( rc==SQLITE_OK && pRtree->iDepth>0 && NCELL(pRoot)==1 ){ + int rc2; + RtreeNode *pChild = 0; + i64 iChild = nodeGetRowid(pRtree, pRoot, 0); + rc = nodeAcquire(pRtree, iChild, pRoot, &pChild); + if( rc==SQLITE_OK ){ + rc = removeNode(pRtree, pChild, pRtree->iDepth-1); + } + rc2 = nodeRelease(pRtree, pChild); + if( rc==SQLITE_OK ) rc = rc2; + if( rc==SQLITE_OK ){ + pRtree->iDepth--; + writeInt16(pRoot->zData, pRtree->iDepth); + pRoot->isDirty = 1; + } + } + + /* Re-insert the contents of any underfull nodes removed from the tree. */ + for(pLeaf=pRtree->pDeleted; pLeaf; pLeaf=pRtree->pDeleted){ + if( rc==SQLITE_OK ){ + rc = reinsertNodeContent(pRtree, pLeaf); + } + pRtree->pDeleted = pLeaf->pNext; + pRtree->nNodeRef--; + sqlite3_free(pLeaf); + } + + /* Release the reference to the root node. */ + if( rc==SQLITE_OK ){ + rc = nodeRelease(pRtree, pRoot); + }else{ + nodeRelease(pRtree, pRoot); + } + + return rc; +} + +/* +** Rounding constants for float->double conversion. +*/ +#define RNDTOWARDS (1.0 - 1.0/8388608.0) /* Round towards zero */ +#define RNDAWAY (1.0 + 1.0/8388608.0) /* Round away from zero */ + +#if !defined(SQLITE_RTREE_INT_ONLY) +/* +** Convert an sqlite3_value into an RtreeValue (presumably a float) +** while taking care to round toward negative or positive, respectively. +*/ +static RtreeValue rtreeValueDown(sqlite3_value *v){ + double d = sqlite3_value_double(v); + float f = (float)d; + if( f>d ){ + f = (float)(d*(d<0 ? RNDAWAY : RNDTOWARDS)); + } + return f; +} +static RtreeValue rtreeValueUp(sqlite3_value *v){ + double d = sqlite3_value_double(v); + float f = (float)d; + if( fbase.zErrMsg) to an appropriate value and returns +** SQLITE_CONSTRAINT. +** +** Parameter iCol is the index of the leftmost column involved in the +** constraint failure. If it is 0, then the constraint that failed is +** the unique constraint on the id column. Otherwise, it is the rtree +** (c1<=c2) constraint on columns iCol and iCol+1 that has failed. +** +** If an OOM occurs, SQLITE_NOMEM is returned instead of SQLITE_CONSTRAINT. +*/ +static int rtreeConstraintError(Rtree *pRtree, int iCol){ + sqlite3_stmt *pStmt = 0; + char *zSql; + int rc; + + assert( iCol==0 || iCol%2 ); + zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q", pRtree->zDb, pRtree->zName); + if( zSql ){ + rc = sqlite3_prepare_v2(pRtree->db, zSql, -1, &pStmt, 0); + }else{ + rc = SQLITE_NOMEM; + } + sqlite3_free(zSql); + + if( rc==SQLITE_OK ){ + if( iCol==0 ){ + const char *zCol = sqlite3_column_name(pStmt, 0); + pRtree->base.zErrMsg = sqlite3_mprintf( + "UNIQUE constraint failed: %s.%s", pRtree->zName, zCol + ); + }else{ + const char *zCol1 = sqlite3_column_name(pStmt, iCol); + const char *zCol2 = sqlite3_column_name(pStmt, iCol+1); + pRtree->base.zErrMsg = sqlite3_mprintf( + "rtree constraint failed: %s.(%s<=%s)", pRtree->zName, zCol1, zCol2 + ); + } + } + + sqlite3_finalize(pStmt); + return (rc==SQLITE_OK ? SQLITE_CONSTRAINT : rc); +} + + + +/* +** The xUpdate method for rtree module virtual tables. +*/ +static int rtreeUpdate( + sqlite3_vtab *pVtab, + int nData, + sqlite3_value **aData, + sqlite_int64 *pRowid +){ + Rtree *pRtree = (Rtree *)pVtab; + int rc = SQLITE_OK; + RtreeCell cell; /* New cell to insert if nData>1 */ + int bHaveRowid = 0; /* Set to 1 after new rowid is determined */ + + if( pRtree->nNodeRef ){ + /* Unable to write to the btree while another cursor is reading from it, + ** since the write might do a rebalance which would disrupt the read + ** cursor. */ + return SQLITE_LOCKED_VTAB; + } + rtreeReference(pRtree); + assert(nData>=1); + + cell.iRowid = 0; /* Used only to suppress a compiler warning */ + + /* Constraint handling. A write operation on an r-tree table may return + ** SQLITE_CONSTRAINT for two reasons: + ** + ** 1. A duplicate rowid value, or + ** 2. The supplied data violates the "x2>=x1" constraint. + ** + ** In the first case, if the conflict-handling mode is REPLACE, then + ** the conflicting row can be removed before proceeding. In the second + ** case, SQLITE_CONSTRAINT must be returned regardless of the + ** conflict-handling mode specified by the user. + */ + if( nData>1 ){ + int ii; + int nn = nData - 4; + + if( nn > pRtree->nDim2 ) nn = pRtree->nDim2; + /* Populate the cell.aCoord[] array. The first coordinate is aData[3]. + ** + ** NB: nData can only be less than nDim*2+3 if the rtree is mis-declared + ** with "column" that are interpreted as table constraints. + ** Example: CREATE VIRTUAL TABLE bad USING rtree(x,y,CHECK(y>5)); + ** This problem was discovered after years of use, so we silently ignore + ** these kinds of misdeclared tables to avoid breaking any legacy. + */ + +#ifndef SQLITE_RTREE_INT_ONLY + if( pRtree->eCoordType==RTREE_COORD_REAL32 ){ + for(ii=0; iicell.aCoord[ii+1].f ){ + rc = rtreeConstraintError(pRtree, ii+1); + goto constraint; + } + } + }else +#endif + { + for(ii=0; iicell.aCoord[ii+1].i ){ + rc = rtreeConstraintError(pRtree, ii+1); + goto constraint; + } + } + } + + /* If a rowid value was supplied, check if it is already present in + ** the table. If so, the constraint has failed. */ + if( sqlite3_value_type(aData[2])!=SQLITE_NULL ){ + cell.iRowid = sqlite3_value_int64(aData[2]); + if( sqlite3_value_type(aData[0])==SQLITE_NULL + || sqlite3_value_int64(aData[0])!=cell.iRowid + ){ + int steprc; + sqlite3_bind_int64(pRtree->pReadRowid, 1, cell.iRowid); + steprc = sqlite3_step(pRtree->pReadRowid); + rc = sqlite3_reset(pRtree->pReadRowid); + if( SQLITE_ROW==steprc ){ + if( sqlite3_vtab_on_conflict(pRtree->db)==SQLITE_REPLACE ){ + rc = rtreeDeleteRowid(pRtree, cell.iRowid); + }else{ + rc = rtreeConstraintError(pRtree, 0); + goto constraint; + } + } + } + bHaveRowid = 1; + } + } + + /* If aData[0] is not an SQL NULL value, it is the rowid of a + ** record to delete from the r-tree table. The following block does + ** just that. + */ + if( sqlite3_value_type(aData[0])!=SQLITE_NULL ){ + rc = rtreeDeleteRowid(pRtree, sqlite3_value_int64(aData[0])); + } + + /* If the aData[] array contains more than one element, elements + ** (aData[2]..aData[argc-1]) contain a new record to insert into + ** the r-tree structure. + */ + if( rc==SQLITE_OK && nData>1 ){ + /* Insert the new record into the r-tree */ + RtreeNode *pLeaf = 0; + + /* Figure out the rowid of the new row. */ + if( bHaveRowid==0 ){ + rc = rtreeNewRowid(pRtree, &cell.iRowid); + } + *pRowid = cell.iRowid; + + if( rc==SQLITE_OK ){ + rc = ChooseLeaf(pRtree, &cell, 0, &pLeaf); + } + if( rc==SQLITE_OK ){ + int rc2; + pRtree->iReinsertHeight = -1; + rc = rtreeInsertCell(pRtree, pLeaf, &cell, 0); + rc2 = nodeRelease(pRtree, pLeaf); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + if( rc==SQLITE_OK && pRtree->nAux ){ + sqlite3_stmt *pUp = pRtree->pWriteAux; + int jj; + sqlite3_bind_int64(pUp, 1, *pRowid); + for(jj=0; jjnAux; jj++){ + sqlite3_bind_value(pUp, jj+2, aData[pRtree->nDim2+3+jj]); + } + sqlite3_step(pUp); + rc = sqlite3_reset(pUp); + } + } + +constraint: + rtreeRelease(pRtree); + return rc; +} + +/* +** Called when a transaction starts. +*/ +static int rtreeBeginTransaction(sqlite3_vtab *pVtab){ + Rtree *pRtree = (Rtree *)pVtab; + assert( pRtree->inWrTrans==0 ); + pRtree->inWrTrans++; + return SQLITE_OK; +} + +/* +** Called when a transaction completes (either by COMMIT or ROLLBACK). +** The sqlite3_blob object should be released at this point. +*/ +static int rtreeEndTransaction(sqlite3_vtab *pVtab){ + Rtree *pRtree = (Rtree *)pVtab; + pRtree->inWrTrans = 0; + nodeBlobReset(pRtree); + return SQLITE_OK; +} + +/* +** The xRename method for rtree module virtual tables. +*/ +static int rtreeRename(sqlite3_vtab *pVtab, const char *zNewName){ + Rtree *pRtree = (Rtree *)pVtab; + int rc = SQLITE_NOMEM; + char *zSql = sqlite3_mprintf( + "ALTER TABLE %Q.'%q_node' RENAME TO \"%w_node\";" + "ALTER TABLE %Q.'%q_parent' RENAME TO \"%w_parent\";" + "ALTER TABLE %Q.'%q_rowid' RENAME TO \"%w_rowid\";" + , pRtree->zDb, pRtree->zName, zNewName + , pRtree->zDb, pRtree->zName, zNewName + , pRtree->zDb, pRtree->zName, zNewName + ); + if( zSql ){ + nodeBlobReset(pRtree); + rc = sqlite3_exec(pRtree->db, zSql, 0, 0, 0); + sqlite3_free(zSql); + } + return rc; +} + +/* +** The xSavepoint method. +** +** This module does not need to do anything to support savepoints. However, +** it uses this hook to close any open blob handle. This is done because a +** DROP TABLE command - which fortunately always opens a savepoint - cannot +** succeed if there are any open blob handles. i.e. if the blob handle were +** not closed here, the following would fail: +** +** BEGIN; +** INSERT INTO rtree... +** DROP TABLE ; -- Would fail with SQLITE_LOCKED +** COMMIT; +*/ +static int rtreeSavepoint(sqlite3_vtab *pVtab, int iSavepoint){ + Rtree *pRtree = (Rtree *)pVtab; + u8 iwt = pRtree->inWrTrans; + UNUSED_PARAMETER(iSavepoint); + pRtree->inWrTrans = 0; + nodeBlobReset(pRtree); + pRtree->inWrTrans = iwt; + return SQLITE_OK; +} + +/* +** This function populates the pRtree->nRowEst variable with an estimate +** of the number of rows in the virtual table. If possible, this is based +** on sqlite_stat1 data. Otherwise, use RTREE_DEFAULT_ROWEST. +*/ +static int rtreeQueryStat1(sqlite3 *db, Rtree *pRtree){ + const char *zFmt = "SELECT stat FROM %Q.sqlite_stat1 WHERE tbl = '%q_rowid'"; + char *zSql; + sqlite3_stmt *p; + int rc; + i64 nRow = 0; + + rc = sqlite3_table_column_metadata( + db, pRtree->zDb, "sqlite_stat1",0,0,0,0,0,0 + ); + if( rc!=SQLITE_OK ){ + pRtree->nRowEst = RTREE_DEFAULT_ROWEST; + return rc==SQLITE_ERROR ? SQLITE_OK : rc; + } + zSql = sqlite3_mprintf(zFmt, pRtree->zDb, pRtree->zName); + if( zSql==0 ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v2(db, zSql, -1, &p, 0); + if( rc==SQLITE_OK ){ + if( sqlite3_step(p)==SQLITE_ROW ) nRow = sqlite3_column_int64(p, 0); + rc = sqlite3_finalize(p); + }else if( rc!=SQLITE_NOMEM ){ + rc = SQLITE_OK; + } + + if( rc==SQLITE_OK ){ + if( nRow==0 ){ + pRtree->nRowEst = RTREE_DEFAULT_ROWEST; + }else{ + pRtree->nRowEst = MAX(nRow, RTREE_MIN_ROWEST); + } + } + sqlite3_free(zSql); + } + + return rc; +} + + +/* +** Return true if zName is the extension on one of the shadow tables used +** by this module. +*/ +static int rtreeShadowName(const char *zName){ + static const char *azName[] = { + "node", "parent", "rowid" + }; + unsigned int i; + for(i=0; idb = db; + + if( isCreate ){ + char *zCreate; + sqlite3_str *p = sqlite3_str_new(db); + int ii; + sqlite3_str_appendf(p, + "CREATE TABLE \"%w\".\"%w_rowid\"(rowid INTEGER PRIMARY KEY,nodeno", + zDb, zPrefix); + for(ii=0; iinAux; ii++){ + sqlite3_str_appendf(p,",a%d",ii); + } + sqlite3_str_appendf(p, + ");CREATE TABLE \"%w\".\"%w_node\"(nodeno INTEGER PRIMARY KEY,data);", + zDb, zPrefix); + sqlite3_str_appendf(p, + "CREATE TABLE \"%w\".\"%w_parent\"(nodeno INTEGER PRIMARY KEY,parentnode);", + zDb, zPrefix); + sqlite3_str_appendf(p, + "INSERT INTO \"%w\".\"%w_node\"VALUES(1,zeroblob(%d))", + zDb, zPrefix, pRtree->iNodeSize); + zCreate = sqlite3_str_finish(p); + if( !zCreate ){ + return SQLITE_NOMEM; + } + rc = sqlite3_exec(db, zCreate, 0, 0, 0); + sqlite3_free(zCreate); + if( rc!=SQLITE_OK ){ + return rc; + } + } + + appStmt[0] = &pRtree->pWriteNode; + appStmt[1] = &pRtree->pDeleteNode; + appStmt[2] = &pRtree->pReadRowid; + appStmt[3] = &pRtree->pWriteRowid; + appStmt[4] = &pRtree->pDeleteRowid; + appStmt[5] = &pRtree->pReadParent; + appStmt[6] = &pRtree->pWriteParent; + appStmt[7] = &pRtree->pDeleteParent; + + rc = rtreeQueryStat1(db, pRtree); + for(i=0; inAux==0 ){ + zFormat = azSql[i]; + }else { + /* An UPSERT is very slightly slower than REPLACE, but it is needed + ** if there are auxiliary columns */ + zFormat = "INSERT INTO\"%w\".\"%w_rowid\"(rowid,nodeno)VALUES(?1,?2)" + "ON CONFLICT(rowid)DO UPDATE SET nodeno=excluded.nodeno"; + } + zSql = sqlite3_mprintf(zFormat, zDb, zPrefix); + if( zSql ){ + rc = sqlite3_prepare_v3(db, zSql, -1, f, appStmt[i], 0); + }else{ + rc = SQLITE_NOMEM; + } + sqlite3_free(zSql); + } + if( pRtree->nAux ){ + pRtree->zReadAuxSql = sqlite3_mprintf( + "SELECT * FROM \"%w\".\"%w_rowid\" WHERE rowid=?1", + zDb, zPrefix); + if( pRtree->zReadAuxSql==0 ){ + rc = SQLITE_NOMEM; + }else{ + sqlite3_str *p = sqlite3_str_new(db); + int ii; + char *zSql; + sqlite3_str_appendf(p, "UPDATE \"%w\".\"%w_rowid\"SET ", zDb, zPrefix); + for(ii=0; iinAux; ii++){ + if( ii ) sqlite3_str_append(p, ",", 1); + if( iinAuxNotNull ){ + sqlite3_str_appendf(p,"a%d=coalesce(?%d,a%d)",ii,ii+2,ii); + }else{ + sqlite3_str_appendf(p,"a%d=?%d",ii,ii+2); + } + } + sqlite3_str_appendf(p, " WHERE rowid=?1"); + zSql = sqlite3_str_finish(p); + if( zSql==0 ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v3(db, zSql, -1, f, &pRtree->pWriteAux, 0); + sqlite3_free(zSql); + } + } + } + + return rc; +} + +/* +** The second argument to this function contains the text of an SQL statement +** that returns a single integer value. The statement is compiled and executed +** using database connection db. If successful, the integer value returned +** is written to *piVal and SQLITE_OK returned. Otherwise, an SQLite error +** code is returned and the value of *piVal after returning is not defined. +*/ +static int getIntFromStmt(sqlite3 *db, const char *zSql, int *piVal){ + int rc = SQLITE_NOMEM; + if( zSql ){ + sqlite3_stmt *pStmt = 0; + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); + if( rc==SQLITE_OK ){ + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + *piVal = sqlite3_column_int(pStmt, 0); + } + rc = sqlite3_finalize(pStmt); + } + } + return rc; +} + +/* +** This function is called from within the xConnect() or xCreate() method to +** determine the node-size used by the rtree table being created or connected +** to. If successful, pRtree->iNodeSize is populated and SQLITE_OK returned. +** Otherwise, an SQLite error code is returned. +** +** If this function is being called as part of an xConnect(), then the rtree +** table already exists. In this case the node-size is determined by inspecting +** the root node of the tree. +** +** Otherwise, for an xCreate(), use 64 bytes less than the database page-size. +** This ensures that each node is stored on a single database page. If the +** database page-size is so large that more than RTREE_MAXCELLS entries +** would fit in a single node, use a smaller node-size. +*/ +static int getNodeSize( + sqlite3 *db, /* Database handle */ + Rtree *pRtree, /* Rtree handle */ + int isCreate, /* True for xCreate, false for xConnect */ + char **pzErr /* OUT: Error message, if any */ +){ + int rc; + char *zSql; + if( isCreate ){ + int iPageSize = 0; + zSql = sqlite3_mprintf("PRAGMA %Q.page_size", pRtree->zDb); + rc = getIntFromStmt(db, zSql, &iPageSize); + if( rc==SQLITE_OK ){ + pRtree->iNodeSize = iPageSize-64; + if( (4+pRtree->nBytesPerCell*RTREE_MAXCELLS)iNodeSize ){ + pRtree->iNodeSize = 4+pRtree->nBytesPerCell*RTREE_MAXCELLS; + } + }else{ + *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + } + }else{ + zSql = sqlite3_mprintf( + "SELECT length(data) FROM '%q'.'%q_node' WHERE nodeno = 1", + pRtree->zDb, pRtree->zName + ); + rc = getIntFromStmt(db, zSql, &pRtree->iNodeSize); + if( rc!=SQLITE_OK ){ + *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + }else if( pRtree->iNodeSize<(512-64) ){ + rc = SQLITE_CORRUPT_VTAB; + RTREE_IS_CORRUPT(pRtree); + *pzErr = sqlite3_mprintf("undersize RTree blobs in \"%q_node\"", + pRtree->zName); + } + } + + sqlite3_free(zSql); + return rc; +} + +/* +** Return the length of a token +*/ +static int rtreeTokenLength(const char *z){ + int dummy = 0; + return sqlite3GetToken((const unsigned char*)z,&dummy); +} + +/* +** This function is the implementation of both the xConnect and xCreate +** methods of the r-tree virtual table. +** +** argv[0] -> module name +** argv[1] -> database name +** argv[2] -> table name +** argv[...] -> column names... +*/ +static int rtreeInit( + sqlite3 *db, /* Database connection */ + void *pAux, /* One of the RTREE_COORD_* constants */ + int argc, const char *const*argv, /* Parameters to CREATE TABLE statement */ + sqlite3_vtab **ppVtab, /* OUT: New virtual table */ + char **pzErr, /* OUT: Error message, if any */ + int isCreate /* True for xCreate, false for xConnect */ +){ + int rc = SQLITE_OK; + Rtree *pRtree; + int nDb; /* Length of string argv[1] */ + int nName; /* Length of string argv[2] */ + int eCoordType = (pAux ? RTREE_COORD_INT32 : RTREE_COORD_REAL32); + sqlite3_str *pSql; + char *zSql; + int ii = 4; + int iErr; + + const char *aErrMsg[] = { + 0, /* 0 */ + "Wrong number of columns for an rtree table", /* 1 */ + "Too few columns for an rtree table", /* 2 */ + "Too many columns for an rtree table", /* 3 */ + "Auxiliary rtree columns must be last" /* 4 */ + }; + + assert( RTREE_MAX_AUX_COLUMN<256 ); /* Aux columns counted by a u8 */ + if( argc<6 || argc>RTREE_MAX_AUX_COLUMN+3 ){ + *pzErr = sqlite3_mprintf("%s", aErrMsg[2 + (argc>=6)]); + return SQLITE_ERROR; + } + + sqlite3_vtab_config(db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1); + + /* Allocate the sqlite3_vtab structure */ + nDb = (int)strlen(argv[1]); + nName = (int)strlen(argv[2]); + pRtree = (Rtree *)sqlite3_malloc64(sizeof(Rtree)+nDb+nName+2); + if( !pRtree ){ + return SQLITE_NOMEM; + } + memset(pRtree, 0, sizeof(Rtree)+nDb+nName+2); + pRtree->nBusy = 1; + pRtree->base.pModule = &rtreeModule; + pRtree->zDb = (char *)&pRtree[1]; + pRtree->zName = &pRtree->zDb[nDb+1]; + pRtree->eCoordType = (u8)eCoordType; + memcpy(pRtree->zDb, argv[1], nDb); + memcpy(pRtree->zName, argv[2], nName); + + + /* Create/Connect to the underlying relational database schema. If + ** that is successful, call sqlite3_declare_vtab() to configure + ** the r-tree table schema. + */ + pSql = sqlite3_str_new(db); + sqlite3_str_appendf(pSql, "CREATE TABLE x(%.*s INT", + rtreeTokenLength(argv[3]), argv[3]); + for(ii=4; iinAux++; + sqlite3_str_appendf(pSql, ",%.*s", rtreeTokenLength(zArg+1), zArg+1); + }else if( pRtree->nAux>0 ){ + break; + }else{ + static const char *azFormat[] = {",%.*s REAL", ",%.*s INT"}; + pRtree->nDim2++; + sqlite3_str_appendf(pSql, azFormat[eCoordType], + rtreeTokenLength(zArg), zArg); + } + } + sqlite3_str_appendf(pSql, ");"); + zSql = sqlite3_str_finish(pSql); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else if( iinDim = pRtree->nDim2/2; + if( pRtree->nDim<1 ){ + iErr = 2; + }else if( pRtree->nDim2>RTREE_MAX_DIMENSIONS*2 ){ + iErr = 3; + }else if( pRtree->nDim2 % 2 ){ + iErr = 1; + }else{ + iErr = 0; + } + if( iErr ){ + *pzErr = sqlite3_mprintf("%s", aErrMsg[iErr]); + goto rtreeInit_fail; + } + pRtree->nBytesPerCell = 8 + pRtree->nDim2*4; + + /* Figure out the node size to use. */ + rc = getNodeSize(db, pRtree, isCreate, pzErr); + if( rc ) goto rtreeInit_fail; + rc = rtreeSqlInit(pRtree, db, argv[1], argv[2], isCreate); + if( rc ){ + *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + goto rtreeInit_fail; + } + + *ppVtab = (sqlite3_vtab *)pRtree; + return SQLITE_OK; + +rtreeInit_fail: + if( rc==SQLITE_OK ) rc = SQLITE_ERROR; + assert( *ppVtab==0 ); + assert( pRtree->nBusy==1 ); + rtreeRelease(pRtree); + return rc; +} + + +/* +** Implementation of a scalar function that decodes r-tree nodes to +** human readable strings. This can be used for debugging and analysis. +** +** The scalar function takes two arguments: (1) the number of dimensions +** to the rtree (between 1 and 5, inclusive) and (2) a blob of data containing +** an r-tree node. For a two-dimensional r-tree structure called "rt", to +** deserialize all nodes, a statement like: +** +** SELECT rtreenode(2, data) FROM rt_node; +** +** The human readable string takes the form of a Tcl list with one +** entry for each cell in the r-tree node. Each entry is itself a +** list, containing the 8-byte rowid/pageno followed by the +** *2 coordinates. +*/ +static void rtreenode(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){ + RtreeNode node; + Rtree tree; + int ii; + int nData; + int errCode; + sqlite3_str *pOut; + + UNUSED_PARAMETER(nArg); + memset(&node, 0, sizeof(RtreeNode)); + memset(&tree, 0, sizeof(Rtree)); + tree.nDim = (u8)sqlite3_value_int(apArg[0]); + if( tree.nDim<1 || tree.nDim>5 ) return; + tree.nDim2 = tree.nDim*2; + tree.nBytesPerCell = 8 + 8 * tree.nDim; + node.zData = (u8 *)sqlite3_value_blob(apArg[1]); + nData = sqlite3_value_bytes(apArg[1]); + if( nData<4 ) return; + if( nData0 ) sqlite3_str_append(pOut, " ", 1); + sqlite3_str_appendf(pOut, "{%lld", cell.iRowid); + for(jj=0; jjrc==SQLITE_OK ) pCheck->rc = rc; +} + +/* +** The second and subsequent arguments to this function are a format string +** and printf style arguments. This function formats the string and attempts +** to compile it as an SQL statement. +** +** If successful, a pointer to the new SQL statement is returned. Otherwise, +** NULL is returned and an error code left in RtreeCheck.rc. +*/ +static sqlite3_stmt *rtreeCheckPrepare( + RtreeCheck *pCheck, /* RtreeCheck object */ + const char *zFmt, ... /* Format string and trailing args */ +){ + va_list ap; + char *z; + sqlite3_stmt *pRet = 0; + + va_start(ap, zFmt); + z = sqlite3_vmprintf(zFmt, ap); + + if( pCheck->rc==SQLITE_OK ){ + if( z==0 ){ + pCheck->rc = SQLITE_NOMEM; + }else{ + pCheck->rc = sqlite3_prepare_v2(pCheck->db, z, -1, &pRet, 0); + } + } + + sqlite3_free(z); + va_end(ap); + return pRet; +} + +/* +** The second and subsequent arguments to this function are a printf() +** style format string and arguments. This function formats the string and +** appends it to the report being accumuated in pCheck. +*/ +static void rtreeCheckAppendMsg(RtreeCheck *pCheck, const char *zFmt, ...){ + va_list ap; + va_start(ap, zFmt); + if( pCheck->rc==SQLITE_OK && pCheck->nErrrc = SQLITE_NOMEM; + }else{ + pCheck->zReport = sqlite3_mprintf("%z%s%z", + pCheck->zReport, (pCheck->zReport ? "\n" : ""), z + ); + if( pCheck->zReport==0 ){ + pCheck->rc = SQLITE_NOMEM; + } + } + pCheck->nErr++; + } + va_end(ap); +} + +/* +** This function is a no-op if there is already an error code stored +** in the RtreeCheck object indicated by the first argument. NULL is +** returned in this case. +** +** Otherwise, the contents of rtree table node iNode are loaded from +** the database and copied into a buffer obtained from sqlite3_malloc(). +** If no error occurs, a pointer to the buffer is returned and (*pnNode) +** is set to the size of the buffer in bytes. +** +** Or, if an error does occur, NULL is returned and an error code left +** in the RtreeCheck object. The final value of *pnNode is undefined in +** this case. +*/ +static u8 *rtreeCheckGetNode(RtreeCheck *pCheck, i64 iNode, int *pnNode){ + u8 *pRet = 0; /* Return value */ + + if( pCheck->rc==SQLITE_OK && pCheck->pGetNode==0 ){ + pCheck->pGetNode = rtreeCheckPrepare(pCheck, + "SELECT data FROM %Q.'%q_node' WHERE nodeno=?", + pCheck->zDb, pCheck->zTab + ); + } + + if( pCheck->rc==SQLITE_OK ){ + sqlite3_bind_int64(pCheck->pGetNode, 1, iNode); + if( sqlite3_step(pCheck->pGetNode)==SQLITE_ROW ){ + int nNode = sqlite3_column_bytes(pCheck->pGetNode, 0); + const u8 *pNode = (const u8*)sqlite3_column_blob(pCheck->pGetNode, 0); + pRet = sqlite3_malloc64(nNode); + if( pRet==0 ){ + pCheck->rc = SQLITE_NOMEM; + }else{ + memcpy(pRet, pNode, nNode); + *pnNode = nNode; + } + } + rtreeCheckReset(pCheck, pCheck->pGetNode); + if( pCheck->rc==SQLITE_OK && pRet==0 ){ + rtreeCheckAppendMsg(pCheck, "Node %lld missing from database", iNode); + } + } + + return pRet; +} + +/* +** This function is used to check that the %_parent (if bLeaf==0) or %_rowid +** (if bLeaf==1) table contains a specified entry. The schemas of the +** two tables are: +** +** CREATE TABLE %_parent(nodeno INTEGER PRIMARY KEY, parentnode INTEGER) +** CREATE TABLE %_rowid(rowid INTEGER PRIMARY KEY, nodeno INTEGER, ...) +** +** In both cases, this function checks that there exists an entry with +** IPK value iKey and the second column set to iVal. +** +*/ +static void rtreeCheckMapping( + RtreeCheck *pCheck, /* RtreeCheck object */ + int bLeaf, /* True for a leaf cell, false for interior */ + i64 iKey, /* Key for mapping */ + i64 iVal /* Expected value for mapping */ +){ + int rc; + sqlite3_stmt *pStmt; + const char *azSql[2] = { + "SELECT parentnode FROM %Q.'%q_parent' WHERE nodeno=?1", + "SELECT nodeno FROM %Q.'%q_rowid' WHERE rowid=?1" + }; + + assert( bLeaf==0 || bLeaf==1 ); + if( pCheck->aCheckMapping[bLeaf]==0 ){ + pCheck->aCheckMapping[bLeaf] = rtreeCheckPrepare(pCheck, + azSql[bLeaf], pCheck->zDb, pCheck->zTab + ); + } + if( pCheck->rc!=SQLITE_OK ) return; + + pStmt = pCheck->aCheckMapping[bLeaf]; + sqlite3_bind_int64(pStmt, 1, iKey); + rc = sqlite3_step(pStmt); + if( rc==SQLITE_DONE ){ + rtreeCheckAppendMsg(pCheck, "Mapping (%lld -> %lld) missing from %s table", + iKey, iVal, (bLeaf ? "%_rowid" : "%_parent") + ); + }else if( rc==SQLITE_ROW ){ + i64 ii = sqlite3_column_int64(pStmt, 0); + if( ii!=iVal ){ + rtreeCheckAppendMsg(pCheck, + "Found (%lld -> %lld) in %s table, expected (%lld -> %lld)", + iKey, ii, (bLeaf ? "%_rowid" : "%_parent"), iKey, iVal + ); + } + } + rtreeCheckReset(pCheck, pStmt); +} + +/* +** Argument pCell points to an array of coordinates stored on an rtree page. +** This function checks that the coordinates are internally consistent (no +** x1>x2 conditions) and adds an error message to the RtreeCheck object +** if they are not. +** +** Additionally, if pParent is not NULL, then it is assumed to point to +** the array of coordinates on the parent page that bound the page +** containing pCell. In this case it is also verified that the two +** sets of coordinates are mutually consistent and an error message added +** to the RtreeCheck object if they are not. +*/ +static void rtreeCheckCellCoord( + RtreeCheck *pCheck, + i64 iNode, /* Node id to use in error messages */ + int iCell, /* Cell number to use in error messages */ + u8 *pCell, /* Pointer to cell coordinates */ + u8 *pParent /* Pointer to parent coordinates */ +){ + RtreeCoord c1, c2; + RtreeCoord p1, p2; + int i; + + for(i=0; inDim; i++){ + readCoord(&pCell[4*2*i], &c1); + readCoord(&pCell[4*(2*i + 1)], &c2); + + /* printf("%e, %e\n", c1.u.f, c2.u.f); */ + if( pCheck->bInt ? c1.i>c2.i : c1.f>c2.f ){ + rtreeCheckAppendMsg(pCheck, + "Dimension %d of cell %d on node %lld is corrupt", i, iCell, iNode + ); + } + + if( pParent ){ + readCoord(&pParent[4*2*i], &p1); + readCoord(&pParent[4*(2*i + 1)], &p2); + + if( (pCheck->bInt ? c1.ibInt ? c2.i>p2.i : c2.f>p2.f) + ){ + rtreeCheckAppendMsg(pCheck, + "Dimension %d of cell %d on node %lld is corrupt relative to parent" + , i, iCell, iNode + ); + } + } + } +} + +/* +** Run rtreecheck() checks on node iNode, which is at depth iDepth within +** the r-tree structure. Argument aParent points to the array of coordinates +** that bound node iNode on the parent node. +** +** If any problems are discovered, an error message is appended to the +** report accumulated in the RtreeCheck object. +*/ +static void rtreeCheckNode( + RtreeCheck *pCheck, + int iDepth, /* Depth of iNode (0==leaf) */ + u8 *aParent, /* Buffer containing parent coords */ + i64 iNode /* Node to check */ +){ + u8 *aNode = 0; + int nNode = 0; + + assert( iNode==1 || aParent!=0 ); + assert( pCheck->nDim>0 ); + + aNode = rtreeCheckGetNode(pCheck, iNode, &nNode); + if( aNode ){ + if( nNode<4 ){ + rtreeCheckAppendMsg(pCheck, + "Node %lld is too small (%d bytes)", iNode, nNode + ); + }else{ + int nCell; /* Number of cells on page */ + int i; /* Used to iterate through cells */ + if( aParent==0 ){ + iDepth = readInt16(aNode); + if( iDepth>RTREE_MAX_DEPTH ){ + rtreeCheckAppendMsg(pCheck, "Rtree depth out of range (%d)", iDepth); + sqlite3_free(aNode); + return; + } + } + nCell = readInt16(&aNode[2]); + if( (4 + nCell*(8 + pCheck->nDim*2*4))>nNode ){ + rtreeCheckAppendMsg(pCheck, + "Node %lld is too small for cell count of %d (%d bytes)", + iNode, nCell, nNode + ); + }else{ + for(i=0; inDim*2*4)]; + i64 iVal = readInt64(pCell); + rtreeCheckCellCoord(pCheck, iNode, i, &pCell[8], aParent); + + if( iDepth>0 ){ + rtreeCheckMapping(pCheck, 0, iVal, iNode); + rtreeCheckNode(pCheck, iDepth-1, &pCell[8], iVal); + pCheck->nNonLeaf++; + }else{ + rtreeCheckMapping(pCheck, 1, iVal, iNode); + pCheck->nLeaf++; + } + } + } + } + sqlite3_free(aNode); + } +} + +/* +** The second argument to this function must be either "_rowid" or +** "_parent". This function checks that the number of entries in the +** %_rowid or %_parent table is exactly nExpect. If not, it adds +** an error message to the report in the RtreeCheck object indicated +** by the first argument. +*/ +static void rtreeCheckCount(RtreeCheck *pCheck, const char *zTbl, i64 nExpect){ + if( pCheck->rc==SQLITE_OK ){ + sqlite3_stmt *pCount; + pCount = rtreeCheckPrepare(pCheck, "SELECT count(*) FROM %Q.'%q%s'", + pCheck->zDb, pCheck->zTab, zTbl + ); + if( pCount ){ + if( sqlite3_step(pCount)==SQLITE_ROW ){ + i64 nActual = sqlite3_column_int64(pCount, 0); + if( nActual!=nExpect ){ + rtreeCheckAppendMsg(pCheck, "Wrong number of entries in %%%s table" + " - expected %lld, actual %lld" , zTbl, nExpect, nActual + ); + } + } + pCheck->rc = sqlite3_finalize(pCount); + } + } +} + +/* +** This function does the bulk of the work for the rtree integrity-check. +** It is called by rtreecheck(), which is the SQL function implementation. +*/ +static int rtreeCheckTable( + sqlite3 *db, /* Database handle to access db through */ + const char *zDb, /* Name of db ("main", "temp" etc.) */ + const char *zTab, /* Name of rtree table to check */ + char **pzReport /* OUT: sqlite3_malloc'd report text */ +){ + RtreeCheck check; /* Common context for various routines */ + sqlite3_stmt *pStmt = 0; /* Used to find column count of rtree table */ + int bEnd = 0; /* True if transaction should be closed */ + int nAux = 0; /* Number of extra columns. */ + + /* Initialize the context object */ + memset(&check, 0, sizeof(check)); + check.db = db; + check.zDb = zDb; + check.zTab = zTab; + + /* If there is not already an open transaction, open one now. This is + ** to ensure that the queries run as part of this integrity-check operate + ** on a consistent snapshot. */ + if( sqlite3_get_autocommit(db) ){ + check.rc = sqlite3_exec(db, "BEGIN", 0, 0, 0); + bEnd = 1; + } + + /* Find the number of auxiliary columns */ + if( check.rc==SQLITE_OK ){ + pStmt = rtreeCheckPrepare(&check, "SELECT * FROM %Q.'%q_rowid'", zDb, zTab); + if( pStmt ){ + nAux = sqlite3_column_count(pStmt) - 2; + sqlite3_finalize(pStmt); + } + check.rc = SQLITE_OK; + } + + /* Find number of dimensions in the rtree table. */ + pStmt = rtreeCheckPrepare(&check, "SELECT * FROM %Q.%Q", zDb, zTab); + if( pStmt ){ + int rc; + check.nDim = (sqlite3_column_count(pStmt) - 1 - nAux) / 2; + if( check.nDim<1 ){ + rtreeCheckAppendMsg(&check, "Schema corrupt or not an rtree"); + }else if( SQLITE_ROW==sqlite3_step(pStmt) ){ + check.bInt = (sqlite3_column_type(pStmt, 1)==SQLITE_INTEGER); + } + rc = sqlite3_finalize(pStmt); + if( rc!=SQLITE_CORRUPT ) check.rc = rc; + } + + /* Do the actual integrity-check */ + if( check.nDim>=1 ){ + if( check.rc==SQLITE_OK ){ + rtreeCheckNode(&check, 0, 0, 1); + } + rtreeCheckCount(&check, "_rowid", check.nLeaf); + rtreeCheckCount(&check, "_parent", check.nNonLeaf); + } + + /* Finalize SQL statements used by the integrity-check */ + sqlite3_finalize(check.pGetNode); + sqlite3_finalize(check.aCheckMapping[0]); + sqlite3_finalize(check.aCheckMapping[1]); + + /* If one was opened, close the transaction */ + if( bEnd ){ + int rc = sqlite3_exec(db, "END", 0, 0, 0); + if( check.rc==SQLITE_OK ) check.rc = rc; + } + *pzReport = check.zReport; + return check.rc; +} + +/* +** Usage: +** +** rtreecheck(); +** rtreecheck(, ); +** +** Invoking this SQL function runs an integrity-check on the named rtree +** table. The integrity-check verifies the following: +** +** 1. For each cell in the r-tree structure (%_node table), that: +** +** a) for each dimension, (coord1 <= coord2). +** +** b) unless the cell is on the root node, that the cell is bounded +** by the parent cell on the parent node. +** +** c) for leaf nodes, that there is an entry in the %_rowid +** table corresponding to the cell's rowid value that +** points to the correct node. +** +** d) for cells on non-leaf nodes, that there is an entry in the +** %_parent table mapping from the cell's child node to the +** node that it resides on. +** +** 2. That there are the same number of entries in the %_rowid table +** as there are leaf cells in the r-tree structure, and that there +** is a leaf cell that corresponds to each entry in the %_rowid table. +** +** 3. That there are the same number of entries in the %_parent table +** as there are non-leaf cells in the r-tree structure, and that +** there is a non-leaf cell that corresponds to each entry in the +** %_parent table. +*/ +static void rtreecheck( + sqlite3_context *ctx, + int nArg, + sqlite3_value **apArg +){ + if( nArg!=1 && nArg!=2 ){ + sqlite3_result_error(ctx, + "wrong number of arguments to function rtreecheck()", -1 + ); + }else{ + int rc; + char *zReport = 0; + const char *zDb = (const char*)sqlite3_value_text(apArg[0]); + const char *zTab; + if( nArg==1 ){ + zTab = zDb; + zDb = "main"; + }else{ + zTab = (const char*)sqlite3_value_text(apArg[1]); + } + rc = rtreeCheckTable(sqlite3_context_db_handle(ctx), zDb, zTab, &zReport); + if( rc==SQLITE_OK ){ + sqlite3_result_text(ctx, zReport ? zReport : "ok", -1, SQLITE_TRANSIENT); + }else{ + sqlite3_result_error_code(ctx, rc); + } + sqlite3_free(zReport); + } +} + +/* Conditionally include the geopoly code */ +#ifdef SQLITE_ENABLE_GEOPOLY +/************** Include geopoly.c in the middle of rtree.c *******************/ +/************** Begin file geopoly.c *****************************************/ +/* +** 2018-05-25 +** +** 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 an alternative R-Tree virtual table that +** uses polygons to express the boundaries of 2-dimensional objects. +** +** This file is #include-ed onto the end of "rtree.c" so that it has +** access to all of the R-Tree internals. +*/ +/* #include */ + +/* Enable -DGEOPOLY_ENABLE_DEBUG for debugging facilities */ +#ifdef GEOPOLY_ENABLE_DEBUG + static int geo_debug = 0; +# define GEODEBUG(X) if(geo_debug)printf X +#else +# define GEODEBUG(X) +#endif + +#ifndef JSON_NULL /* The following stuff repeats things found in json1 */ +/* +** Versions of isspace(), isalnum() and isdigit() to which it is safe +** to pass signed char values. +*/ +#ifdef sqlite3Isdigit + /* Use the SQLite core versions if this routine is part of the + ** SQLite amalgamation */ +# define safe_isdigit(x) sqlite3Isdigit(x) +# define safe_isalnum(x) sqlite3Isalnum(x) +# define safe_isxdigit(x) sqlite3Isxdigit(x) +#else + /* Use the standard library for separate compilation */ +#include /* amalgamator: keep */ +# define safe_isdigit(x) isdigit((unsigned char)(x)) +# define safe_isalnum(x) isalnum((unsigned char)(x)) +# define safe_isxdigit(x) isxdigit((unsigned char)(x)) +#endif + +/* +** Growing our own isspace() routine this way is twice as fast as +** the library isspace() function. +*/ +static const char geopolyIsSpace[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; +#define safe_isspace(x) (geopolyIsSpace[(unsigned char)x]) +#endif /* JSON NULL - back to original code */ + +/* Compiler and version */ +#ifndef GCC_VERSION +#if defined(__GNUC__) && !defined(SQLITE_DISABLE_INTRINSIC) +# define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__) +#else +# define GCC_VERSION 0 +#endif +#endif +#ifndef MSVC_VERSION +#if defined(_MSC_VER) && !defined(SQLITE_DISABLE_INTRINSIC) +# define MSVC_VERSION _MSC_VER +#else +# define MSVC_VERSION 0 +#endif +#endif + +/* Datatype for coordinates +*/ +typedef float GeoCoord; + +/* +** Internal representation of a polygon. +** +** The polygon consists of a sequence of vertexes. There is a line +** segment between each pair of vertexes, and one final segment from +** the last vertex back to the first. (This differs from the GeoJSON +** standard in which the final vertex is a repeat of the first.) +** +** The polygon follows the right-hand rule. The area to the right of +** each segment is "outside" and the area to the left is "inside". +** +** The on-disk representation consists of a 4-byte header followed by +** the values. The 4-byte header is: +** +** encoding (1 byte) 0=big-endian, 1=little-endian +** nvertex (3 bytes) Number of vertexes as a big-endian integer +** +** Enough space is allocated for 4 coordinates, to work around over-zealous +** warnings coming from some compiler (notably, clang). In reality, the size +** of each GeoPoly memory allocate is adjusted as necessary so that the +** GeoPoly.a[] array at the end is the appropriate size. +*/ +typedef struct GeoPoly GeoPoly; +struct GeoPoly { + int nVertex; /* Number of vertexes */ + unsigned char hdr[4]; /* Header for on-disk representation */ + GeoCoord a[8]; /* 2*nVertex values. X (longitude) first, then Y */ +}; + +/* The size of a memory allocation needed for a GeoPoly object sufficient +** to hold N coordinate pairs. +*/ +#define GEOPOLY_SZ(N) (sizeof(GeoPoly) + sizeof(GeoCoord)*2*((N)-4)) + +/* Macros to access coordinates of a GeoPoly. +** We have to use these macros, rather than just say p->a[i] in order +** to silence (incorrect) UBSAN warnings if the array index is too large. +*/ +#define GeoX(P,I) (((GeoCoord*)(P)->a)[(I)*2]) +#define GeoY(P,I) (((GeoCoord*)(P)->a)[(I)*2+1]) + + +/* +** State of a parse of a GeoJSON input. +*/ +typedef struct GeoParse GeoParse; +struct GeoParse { + const unsigned char *z; /* Unparsed input */ + int nVertex; /* Number of vertexes in a[] */ + int nAlloc; /* Space allocated to a[] */ + int nErr; /* Number of errors encountered */ + GeoCoord *a; /* Array of vertexes. From sqlite3_malloc64() */ +}; + +/* Do a 4-byte byte swap */ +static void geopolySwab32(unsigned char *a){ + unsigned char t = a[0]; + a[0] = a[3]; + a[3] = t; + t = a[1]; + a[1] = a[2]; + a[2] = t; +} + +/* Skip whitespace. Return the next non-whitespace character. */ +static char geopolySkipSpace(GeoParse *p){ + while( safe_isspace(p->z[0]) ) p->z++; + return p->z[0]; +} + +/* Parse out a number. Write the value into *pVal if pVal!=0. +** return non-zero on success and zero if the next token is not a number. +*/ +static int geopolyParseNumber(GeoParse *p, GeoCoord *pVal){ + char c = geopolySkipSpace(p); + const unsigned char *z = p->z; + int j = 0; + int seenDP = 0; + int seenE = 0; + if( c=='-' ){ + j = 1; + c = z[j]; + } + if( c=='0' && z[j+1]>='0' && z[j+1]<='9' ) return 0; + for(;; j++){ + c = z[j]; + if( safe_isdigit(c) ) continue; + if( c=='.' ){ + if( z[j-1]=='-' ) return 0; + if( seenDP ) return 0; + seenDP = 1; + continue; + } + if( c=='e' || c=='E' ){ + if( z[j-1]<'0' ) return 0; + if( seenE ) return -1; + seenDP = seenE = 1; + c = z[j+1]; + if( c=='+' || c=='-' ){ + j++; + c = z[j+1]; + } + if( c<'0' || c>'9' ) return 0; + continue; + } + break; + } + if( z[j-1]<'0' ) return 0; + if( pVal ){ +#ifdef SQLITE_AMALGAMATION + /* The sqlite3AtoF() routine is much much faster than atof(), if it + ** is available */ + double r; + (void)sqlite3AtoF((const char*)p->z, &r, j, SQLITE_UTF8); + *pVal = r; +#else + *pVal = (GeoCoord)atof((const char*)p->z); +#endif + } + p->z += j; + return 1; +} + +/* +** If the input is a well-formed JSON array of coordinates with at least +** four coordinates and where each coordinate is itself a two-value array, +** then convert the JSON into a GeoPoly object and return a pointer to +** that object. +** +** If any error occurs, return NULL. +*/ +static GeoPoly *geopolyParseJson(const unsigned char *z, int *pRc){ + GeoParse s; + int rc = SQLITE_OK; + memset(&s, 0, sizeof(s)); + s.z = z; + if( geopolySkipSpace(&s)=='[' ){ + s.z++; + while( geopolySkipSpace(&s)=='[' ){ + int ii = 0; + char c; + s.z++; + if( s.nVertex>=s.nAlloc ){ + GeoCoord *aNew; + s.nAlloc = s.nAlloc*2 + 16; + aNew = sqlite3_realloc64(s.a, s.nAlloc*sizeof(GeoCoord)*2 ); + if( aNew==0 ){ + rc = SQLITE_NOMEM; + s.nErr++; + break; + } + s.a = aNew; + } + while( geopolyParseNumber(&s, ii<=1 ? &s.a[s.nVertex*2+ii] : 0) ){ + ii++; + if( ii==2 ) s.nVertex++; + c = geopolySkipSpace(&s); + s.z++; + if( c==',' ) continue; + if( c==']' && ii>=2 ) break; + s.nErr++; + rc = SQLITE_ERROR; + goto parse_json_err; + } + if( geopolySkipSpace(&s)==',' ){ + s.z++; + continue; + } + break; + } + if( geopolySkipSpace(&s)==']' + && s.nVertex>=4 + && s.a[0]==s.a[s.nVertex*2-2] + && s.a[1]==s.a[s.nVertex*2-1] + && (s.z++, geopolySkipSpace(&s)==0) + ){ + GeoPoly *pOut; + int x = 1; + s.nVertex--; /* Remove the redundant vertex at the end */ + pOut = sqlite3_malloc64( GEOPOLY_SZ((sqlite3_int64)s.nVertex) ); + x = 1; + if( pOut==0 ) goto parse_json_err; + pOut->nVertex = s.nVertex; + memcpy(pOut->a, s.a, s.nVertex*2*sizeof(GeoCoord)); + pOut->hdr[0] = *(unsigned char*)&x; + pOut->hdr[1] = (s.nVertex>>16)&0xff; + pOut->hdr[2] = (s.nVertex>>8)&0xff; + pOut->hdr[3] = s.nVertex&0xff; + sqlite3_free(s.a); + if( pRc ) *pRc = SQLITE_OK; + return pOut; + }else{ + s.nErr++; + rc = SQLITE_ERROR; + } + } +parse_json_err: + if( pRc ) *pRc = rc; + sqlite3_free(s.a); + return 0; +} + +/* +** Given a function parameter, try to interpret it as a polygon, either +** in the binary format or JSON text. Compute a GeoPoly object and +** return a pointer to that object. Or if the input is not a well-formed +** polygon, put an error message in sqlite3_context and return NULL. +*/ +static GeoPoly *geopolyFuncParam( + sqlite3_context *pCtx, /* Context for error messages */ + sqlite3_value *pVal, /* The value to decode */ + int *pRc /* Write error here */ +){ + GeoPoly *p = 0; + int nByte; + if( sqlite3_value_type(pVal)==SQLITE_BLOB + && (nByte = sqlite3_value_bytes(pVal))>=(4+6*sizeof(GeoCoord)) + ){ + const unsigned char *a = sqlite3_value_blob(pVal); + int nVertex; + nVertex = (a[1]<<16) + (a[2]<<8) + a[3]; + if( (a[0]==0 || a[0]==1) + && (nVertex*2*sizeof(GeoCoord) + 4)==(unsigned int)nByte + ){ + p = sqlite3_malloc64( sizeof(*p) + (nVertex-1)*2*sizeof(GeoCoord) ); + if( p==0 ){ + if( pRc ) *pRc = SQLITE_NOMEM; + if( pCtx ) sqlite3_result_error_nomem(pCtx); + }else{ + int x = 1; + p->nVertex = nVertex; + memcpy(p->hdr, a, nByte); + if( a[0] != *(unsigned char*)&x ){ + int ii; + for(ii=0; iihdr[0] ^= 1; + } + } + } + if( pRc ) *pRc = SQLITE_OK; + return p; + }else if( sqlite3_value_type(pVal)==SQLITE_TEXT ){ + const unsigned char *zJson = sqlite3_value_text(pVal); + if( zJson==0 ){ + if( pRc ) *pRc = SQLITE_NOMEM; + return 0; + } + return geopolyParseJson(zJson, pRc); + }else{ + if( pRc ) *pRc = SQLITE_ERROR; + return 0; + } +} + +/* +** Implementation of the geopoly_blob(X) function. +** +** If the input is a well-formed Geopoly BLOB or JSON string +** then return the BLOB representation of the polygon. Otherwise +** return NULL. +*/ +static void geopolyBlobFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p = geopolyFuncParam(context, argv[0], 0); + if( p ){ + sqlite3_result_blob(context, p->hdr, + 4+8*p->nVertex, SQLITE_TRANSIENT); + sqlite3_free(p); + } +} + +/* +** SQL function: geopoly_json(X) +** +** Interpret X as a polygon and render it as a JSON array +** of coordinates. Or, if X is not a valid polygon, return NULL. +*/ +static void geopolyJsonFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p = geopolyFuncParam(context, argv[0], 0); + if( p ){ + sqlite3 *db = sqlite3_context_db_handle(context); + sqlite3_str *x = sqlite3_str_new(db); + int i; + sqlite3_str_append(x, "[", 1); + for(i=0; inVertex; i++){ + sqlite3_str_appendf(x, "[%!g,%!g],", GeoX(p,i), GeoY(p,i)); + } + sqlite3_str_appendf(x, "[%!g,%!g]]", GeoX(p,0), GeoY(p,0)); + sqlite3_result_text(context, sqlite3_str_finish(x), -1, sqlite3_free); + sqlite3_free(p); + } +} + +/* +** SQL function: geopoly_svg(X, ....) +** +** Interpret X as a polygon and render it as a SVG . +** Additional arguments are added as attributes to the . +*/ +static void geopolySvgFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p; + if( argc<1 ) return; + p = geopolyFuncParam(context, argv[0], 0); + if( p ){ + sqlite3 *db = sqlite3_context_db_handle(context); + sqlite3_str *x = sqlite3_str_new(db); + int i; + char cSep = '\''; + sqlite3_str_appendf(x, ""); + sqlite3_result_text(context, sqlite3_str_finish(x), -1, sqlite3_free); + sqlite3_free(p); + } +} + +/* +** SQL Function: geopoly_xform(poly, A, B, C, D, E, F) +** +** Transform and/or translate a polygon as follows: +** +** x1 = A*x0 + B*y0 + E +** y1 = C*x0 + D*y0 + F +** +** For a translation: +** +** geopoly_xform(poly, 1, 0, 0, 1, x-offset, y-offset) +** +** Rotate by R around the point (0,0): +** +** geopoly_xform(poly, cos(R), sin(R), -sin(R), cos(R), 0, 0) +*/ +static void geopolyXformFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p = geopolyFuncParam(context, argv[0], 0); + double A = sqlite3_value_double(argv[1]); + double B = sqlite3_value_double(argv[2]); + double C = sqlite3_value_double(argv[3]); + double D = sqlite3_value_double(argv[4]); + double E = sqlite3_value_double(argv[5]); + double F = sqlite3_value_double(argv[6]); + GeoCoord x1, y1, x0, y0; + int ii; + if( p ){ + for(ii=0; iinVertex; ii++){ + x0 = GeoX(p,ii); + y0 = GeoY(p,ii); + x1 = (GeoCoord)(A*x0 + B*y0 + E); + y1 = (GeoCoord)(C*x0 + D*y0 + F); + GeoX(p,ii) = x1; + GeoY(p,ii) = y1; + } + sqlite3_result_blob(context, p->hdr, + 4+8*p->nVertex, SQLITE_TRANSIENT); + sqlite3_free(p); + } +} + +/* +** Compute the area enclosed by the polygon. +** +** This routine can also be used to detect polygons that rotate in +** the wrong direction. Polygons are suppose to be counter-clockwise (CCW). +** This routine returns a negative value for clockwise (CW) polygons. +*/ +static double geopolyArea(GeoPoly *p){ + double rArea = 0.0; + int ii; + for(ii=0; iinVertex-1; ii++){ + rArea += (GeoX(p,ii) - GeoX(p,ii+1)) /* (x0 - x1) */ + * (GeoY(p,ii) + GeoY(p,ii+1)) /* (y0 + y1) */ + * 0.5; + } + rArea += (GeoX(p,ii) - GeoX(p,0)) /* (xN - x0) */ + * (GeoY(p,ii) + GeoY(p,0)) /* (yN + y0) */ + * 0.5; + return rArea; +} + +/* +** Implementation of the geopoly_area(X) function. +** +** If the input is a well-formed Geopoly BLOB then return the area +** enclosed by the polygon. If the polygon circulates clockwise instead +** of counterclockwise (as it should) then return the negative of the +** enclosed area. Otherwise return NULL. +*/ +static void geopolyAreaFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p = geopolyFuncParam(context, argv[0], 0); + if( p ){ + sqlite3_result_double(context, geopolyArea(p)); + sqlite3_free(p); + } +} + +/* +** Implementation of the geopoly_ccw(X) function. +** +** If the rotation of polygon X is clockwise (incorrect) instead of +** counter-clockwise (the correct winding order according to RFC7946) +** then reverse the order of the vertexes in polygon X. +** +** In other words, this routine returns a CCW polygon regardless of the +** winding order of its input. +** +** Use this routine to sanitize historical inputs that that sometimes +** contain polygons that wind in the wrong direction. +*/ +static void geopolyCcwFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p = geopolyFuncParam(context, argv[0], 0); + if( p ){ + if( geopolyArea(p)<0.0 ){ + int ii, jj; + for(ii=1, jj=p->nVertex-1; iihdr, + 4+8*p->nVertex, SQLITE_TRANSIENT); + sqlite3_free(p); + } +} + +#define GEOPOLY_PI 3.1415926535897932385 + +/* Fast approximation for sine(X) for X between -0.5*pi and 2*pi +*/ +static double geopolySine(double r){ + assert( r>=-0.5*GEOPOLY_PI && r<=2.0*GEOPOLY_PI ); + if( r>=1.5*GEOPOLY_PI ){ + r -= 2.0*GEOPOLY_PI; + } + if( r>=0.5*GEOPOLY_PI ){ + return -geopolySine(r-GEOPOLY_PI); + }else{ + double r2 = r*r; + double r3 = r2*r; + double r5 = r3*r2; + return 0.9996949*r - 0.1656700*r3 + 0.0075134*r5; + } +} + +/* +** Function: geopoly_regular(X,Y,R,N) +** +** Construct a simple, convex, regular polygon centered at X, Y +** with circumradius R and with N sides. +*/ +static void geopolyRegularFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + double x = sqlite3_value_double(argv[0]); + double y = sqlite3_value_double(argv[1]); + double r = sqlite3_value_double(argv[2]); + int n = sqlite3_value_int(argv[3]); + int i; + GeoPoly *p; + + if( n<3 || r<=0.0 ) return; + if( n>1000 ) n = 1000; + p = sqlite3_malloc64( sizeof(*p) + (n-1)*2*sizeof(GeoCoord) ); + if( p==0 ){ + sqlite3_result_error_nomem(context); + return; + } + i = 1; + p->hdr[0] = *(unsigned char*)&i; + p->hdr[1] = 0; + p->hdr[2] = (n>>8)&0xff; + p->hdr[3] = n&0xff; + for(i=0; ihdr, 4+8*n, SQLITE_TRANSIENT); + sqlite3_free(p); +} + +/* +** If pPoly is a polygon, compute its bounding box. Then: +** +** (1) if aCoord!=0 store the bounding box in aCoord, returning NULL +** (2) otherwise, compute a GeoPoly for the bounding box and return the +** new GeoPoly +** +** If pPoly is NULL but aCoord is not NULL, then compute a new GeoPoly from +** the bounding box in aCoord and return a pointer to that GeoPoly. +*/ +static GeoPoly *geopolyBBox( + sqlite3_context *context, /* For recording the error */ + sqlite3_value *pPoly, /* The polygon */ + RtreeCoord *aCoord, /* Results here */ + int *pRc /* Error code here */ +){ + GeoPoly *pOut = 0; + GeoPoly *p; + float mnX, mxX, mnY, mxY; + if( pPoly==0 && aCoord!=0 ){ + p = 0; + mnX = aCoord[0].f; + mxX = aCoord[1].f; + mnY = aCoord[2].f; + mxY = aCoord[3].f; + goto geopolyBboxFill; + }else{ + p = geopolyFuncParam(context, pPoly, pRc); + } + if( p ){ + int ii; + mnX = mxX = GeoX(p,0); + mnY = mxY = GeoY(p,0); + for(ii=1; iinVertex; ii++){ + double r = GeoX(p,ii); + if( rmxX ) mxX = (float)r; + r = GeoY(p,ii); + if( rmxY ) mxY = (float)r; + } + if( pRc ) *pRc = SQLITE_OK; + if( aCoord==0 ){ + geopolyBboxFill: + pOut = sqlite3_realloc64(p, GEOPOLY_SZ(4)); + if( pOut==0 ){ + sqlite3_free(p); + if( context ) sqlite3_result_error_nomem(context); + if( pRc ) *pRc = SQLITE_NOMEM; + return 0; + } + pOut->nVertex = 4; + ii = 1; + pOut->hdr[0] = *(unsigned char*)ⅈ + pOut->hdr[1] = 0; + pOut->hdr[2] = 0; + pOut->hdr[3] = 4; + GeoX(pOut,0) = mnX; + GeoY(pOut,0) = mnY; + GeoX(pOut,1) = mxX; + GeoY(pOut,1) = mnY; + GeoX(pOut,2) = mxX; + GeoY(pOut,2) = mxY; + GeoX(pOut,3) = mnX; + GeoY(pOut,3) = mxY; + }else{ + sqlite3_free(p); + aCoord[0].f = mnX; + aCoord[1].f = mxX; + aCoord[2].f = mnY; + aCoord[3].f = mxY; + } + }else{ + memset(aCoord, 0, sizeof(RtreeCoord)*4); + } + return pOut; +} + +/* +** Implementation of the geopoly_bbox(X) SQL function. +*/ +static void geopolyBBoxFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p = geopolyBBox(context, argv[0], 0, 0); + if( p ){ + sqlite3_result_blob(context, p->hdr, + 4+8*p->nVertex, SQLITE_TRANSIENT); + sqlite3_free(p); + } +} + +/* +** State vector for the geopoly_group_bbox() aggregate function. +*/ +typedef struct GeoBBox GeoBBox; +struct GeoBBox { + int isInit; + RtreeCoord a[4]; +}; + + +/* +** Implementation of the geopoly_group_bbox(X) aggregate SQL function. +*/ +static void geopolyBBoxStep( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + RtreeCoord a[4]; + int rc = SQLITE_OK; + (void)geopolyBBox(context, argv[0], a, &rc); + if( rc==SQLITE_OK ){ + GeoBBox *pBBox; + pBBox = (GeoBBox*)sqlite3_aggregate_context(context, sizeof(*pBBox)); + if( pBBox==0 ) return; + if( pBBox->isInit==0 ){ + pBBox->isInit = 1; + memcpy(pBBox->a, a, sizeof(RtreeCoord)*4); + }else{ + if( a[0].f < pBBox->a[0].f ) pBBox->a[0] = a[0]; + if( a[1].f > pBBox->a[1].f ) pBBox->a[1] = a[1]; + if( a[2].f < pBBox->a[2].f ) pBBox->a[2] = a[2]; + if( a[3].f > pBBox->a[3].f ) pBBox->a[3] = a[3]; + } + } +} +static void geopolyBBoxFinal( + sqlite3_context *context +){ + GeoPoly *p; + GeoBBox *pBBox; + pBBox = (GeoBBox*)sqlite3_aggregate_context(context, 0); + if( pBBox==0 ) return; + p = geopolyBBox(context, 0, pBBox->a, 0); + if( p ){ + sqlite3_result_blob(context, p->hdr, + 4+8*p->nVertex, SQLITE_TRANSIENT); + sqlite3_free(p); + } +} + + +/* +** Determine if point (x0,y0) is beneath line segment (x1,y1)->(x2,y2). +** Returns: +** +** +2 x0,y0 is on the line segement +** +** +1 x0,y0 is beneath line segment +** +** 0 x0,y0 is not on or beneath the line segment or the line segment +** is vertical and x0,y0 is not on the line segment +** +** The left-most coordinate min(x1,x2) is not considered to be part of +** the line segment for the purposes of this analysis. +*/ +static int pointBeneathLine( + double x0, double y0, + double x1, double y1, + double x2, double y2 +){ + double y; + if( x0==x1 && y0==y1 ) return 2; + if( x1x2 ) return 0; + }else if( x1>x2 ){ + if( x0<=x2 || x0>x1 ) return 0; + }else{ + /* Vertical line segment */ + if( x0!=x1 ) return 0; + if( y0y1 && y0>y2 ) return 0; + return 2; + } + y = y1 + (y2-y1)*(x0-x1)/(x2-x1); + if( y0==y ) return 2; + if( y0nVertex-1; ii++){ + v = pointBeneathLine(x0,y0,GeoX(p1,ii), GeoY(p1,ii), + GeoX(p1,ii+1),GeoY(p1,ii+1)); + if( v==2 ) break; + cnt += v; + } + if( v!=2 ){ + v = pointBeneathLine(x0,y0,GeoX(p1,ii), GeoY(p1,ii), + GeoX(p1,0), GeoY(p1,0)); + } + if( v==2 ){ + sqlite3_result_int(context, 1); + }else if( ((v+cnt)&1)==0 ){ + sqlite3_result_int(context, 0); + }else{ + sqlite3_result_int(context, 2); + } + sqlite3_free(p1); +} + +/* Forward declaration */ +static int geopolyOverlap(GeoPoly *p1, GeoPoly *p2); + +/* +** SQL function: geopoly_within(P1,P2) +** +** Return +2 if P1 and P2 are the same polygon +** Return +1 if P2 is contained within P1 +** Return 0 if any part of P2 is on the outside of P1 +** +*/ +static void geopolyWithinFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p1 = geopolyFuncParam(context, argv[0], 0); + GeoPoly *p2 = geopolyFuncParam(context, argv[1], 0); + if( p1 && p2 ){ + int x = geopolyOverlap(p1, p2); + if( x<0 ){ + sqlite3_result_error_nomem(context); + }else{ + sqlite3_result_int(context, x==2 ? 1 : x==4 ? 2 : 0); + } + } + sqlite3_free(p1); + sqlite3_free(p2); +} + +/* Objects used by the overlap algorihm. */ +typedef struct GeoEvent GeoEvent; +typedef struct GeoSegment GeoSegment; +typedef struct GeoOverlap GeoOverlap; +struct GeoEvent { + double x; /* X coordinate at which event occurs */ + int eType; /* 0 for ADD, 1 for REMOVE */ + GeoSegment *pSeg; /* The segment to be added or removed */ + GeoEvent *pNext; /* Next event in the sorted list */ +}; +struct GeoSegment { + double C, B; /* y = C*x + B */ + double y; /* Current y value */ + float y0; /* Initial y value */ + unsigned char side; /* 1 for p1, 2 for p2 */ + unsigned int idx; /* Which segment within the side */ + GeoSegment *pNext; /* Next segment in a list sorted by y */ +}; +struct GeoOverlap { + GeoEvent *aEvent; /* Array of all events */ + GeoSegment *aSegment; /* Array of all segments */ + int nEvent; /* Number of events */ + int nSegment; /* Number of segments */ +}; + +/* +** Add a single segment and its associated events. +*/ +static void geopolyAddOneSegment( + GeoOverlap *p, + GeoCoord x0, + GeoCoord y0, + GeoCoord x1, + GeoCoord y1, + unsigned char side, + unsigned int idx +){ + GeoSegment *pSeg; + GeoEvent *pEvent; + if( x0==x1 ) return; /* Ignore vertical segments */ + if( x0>x1 ){ + GeoCoord t = x0; + x0 = x1; + x1 = t; + t = y0; + y0 = y1; + y1 = t; + } + pSeg = p->aSegment + p->nSegment; + p->nSegment++; + pSeg->C = (y1-y0)/(x1-x0); + pSeg->B = y1 - x1*pSeg->C; + pSeg->y0 = y0; + pSeg->side = side; + pSeg->idx = idx; + pEvent = p->aEvent + p->nEvent; + p->nEvent++; + pEvent->x = x0; + pEvent->eType = 0; + pEvent->pSeg = pSeg; + pEvent = p->aEvent + p->nEvent; + p->nEvent++; + pEvent->x = x1; + pEvent->eType = 1; + pEvent->pSeg = pSeg; +} + + + +/* +** Insert all segments and events for polygon pPoly. +*/ +static void geopolyAddSegments( + GeoOverlap *p, /* Add segments to this Overlap object */ + GeoPoly *pPoly, /* Take all segments from this polygon */ + unsigned char side /* The side of pPoly */ +){ + unsigned int i; + GeoCoord *x; + for(i=0; i<(unsigned)pPoly->nVertex-1; i++){ + x = &GeoX(pPoly,i); + geopolyAddOneSegment(p, x[0], x[1], x[2], x[3], side, i); + } + x = &GeoX(pPoly,i); + geopolyAddOneSegment(p, x[0], x[1], pPoly->a[0], pPoly->a[1], side, i); +} + +/* +** Merge two lists of sorted events by X coordinate +*/ +static GeoEvent *geopolyEventMerge(GeoEvent *pLeft, GeoEvent *pRight){ + GeoEvent head, *pLast; + head.pNext = 0; + pLast = &head; + while( pRight && pLeft ){ + if( pRight->x <= pLeft->x ){ + pLast->pNext = pRight; + pLast = pRight; + pRight = pRight->pNext; + }else{ + pLast->pNext = pLeft; + pLast = pLeft; + pLeft = pLeft->pNext; + } + } + pLast->pNext = pRight ? pRight : pLeft; + return head.pNext; +} + +/* +** Sort an array of nEvent event objects into a list. +*/ +static GeoEvent *geopolySortEventsByX(GeoEvent *aEvent, int nEvent){ + int mx = 0; + int i, j; + GeoEvent *p; + GeoEvent *a[50]; + for(i=0; ipNext = 0; + for(j=0; j=mx ) mx = j+1; + } + p = 0; + for(i=0; iy - pLeft->y; + if( r==0.0 ) r = pRight->C - pLeft->C; + if( r<0.0 ){ + pLast->pNext = pRight; + pLast = pRight; + pRight = pRight->pNext; + }else{ + pLast->pNext = pLeft; + pLast = pLeft; + pLeft = pLeft->pNext; + } + } + pLast->pNext = pRight ? pRight : pLeft; + return head.pNext; +} + +/* +** Sort a list of GeoSegments in order of increasing Y and in the event of +** a tie, increasing C (slope). +*/ +static GeoSegment *geopolySortSegmentsByYAndC(GeoSegment *pList){ + int mx = 0; + int i; + GeoSegment *p; + GeoSegment *a[50]; + while( pList ){ + p = pList; + pList = pList->pNext; + p->pNext = 0; + for(i=0; i=mx ) mx = i+1; + } + p = 0; + for(i=0; inVertex + p2->nVertex + 2; + GeoOverlap *p; + sqlite3_int64 nByte; + GeoEvent *pThisEvent; + double rX; + int rc = 0; + int needSort = 0; + GeoSegment *pActive = 0; + GeoSegment *pSeg; + unsigned char aOverlap[4]; + + nByte = sizeof(GeoEvent)*nVertex*2 + + sizeof(GeoSegment)*nVertex + + sizeof(GeoOverlap); + p = sqlite3_malloc64( nByte ); + if( p==0 ) return -1; + p->aEvent = (GeoEvent*)&p[1]; + p->aSegment = (GeoSegment*)&p->aEvent[nVertex*2]; + p->nEvent = p->nSegment = 0; + geopolyAddSegments(p, p1, 1); + geopolyAddSegments(p, p2, 2); + pThisEvent = geopolySortEventsByX(p->aEvent, p->nEvent); + rX = pThisEvent && pThisEvent->x==0.0 ? -1.0 : 0.0; + memset(aOverlap, 0, sizeof(aOverlap)); + while( pThisEvent ){ + if( pThisEvent->x!=rX ){ + GeoSegment *pPrev = 0; + int iMask = 0; + GEODEBUG(("Distinct X: %g\n", pThisEvent->x)); + rX = pThisEvent->x; + if( needSort ){ + GEODEBUG(("SORT\n")); + pActive = geopolySortSegmentsByYAndC(pActive); + needSort = 0; + } + for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){ + if( pPrev ){ + if( pPrev->y!=pSeg->y ){ + GEODEBUG(("MASK: %d\n", iMask)); + aOverlap[iMask] = 1; + } + } + iMask ^= pSeg->side; + pPrev = pSeg; + } + pPrev = 0; + for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){ + double y = pSeg->C*rX + pSeg->B; + GEODEBUG(("Segment %d.%d %g->%g\n", pSeg->side, pSeg->idx, pSeg->y, y)); + pSeg->y = y; + if( pPrev ){ + if( pPrev->y>pSeg->y && pPrev->side!=pSeg->side ){ + rc = 1; + GEODEBUG(("Crossing: %d.%d and %d.%d\n", + pPrev->side, pPrev->idx, + pSeg->side, pSeg->idx)); + goto geopolyOverlapDone; + }else if( pPrev->y!=pSeg->y ){ + GEODEBUG(("MASK: %d\n", iMask)); + aOverlap[iMask] = 1; + } + } + iMask ^= pSeg->side; + pPrev = pSeg; + } + } + GEODEBUG(("%s %d.%d C=%g B=%g\n", + pThisEvent->eType ? "RM " : "ADD", + pThisEvent->pSeg->side, pThisEvent->pSeg->idx, + pThisEvent->pSeg->C, + pThisEvent->pSeg->B)); + if( pThisEvent->eType==0 ){ + /* Add a segment */ + pSeg = pThisEvent->pSeg; + pSeg->y = pSeg->y0; + pSeg->pNext = pActive; + pActive = pSeg; + needSort = 1; + }else{ + /* Remove a segment */ + if( pActive==pThisEvent->pSeg ){ + pActive = pActive->pNext; + }else{ + for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){ + if( pSeg->pNext==pThisEvent->pSeg ){ + pSeg->pNext = pSeg->pNext->pNext; + break; + } + } + } + } + pThisEvent = pThisEvent->pNext; + } + if( aOverlap[3]==0 ){ + rc = 0; + }else if( aOverlap[1]!=0 && aOverlap[2]==0 ){ + rc = 3; + }else if( aOverlap[1]==0 && aOverlap[2]!=0 ){ + rc = 2; + }else if( aOverlap[1]==0 && aOverlap[2]==0 ){ + rc = 4; + }else{ + rc = 1; + } + +geopolyOverlapDone: + sqlite3_free(p); + return rc; +} + +/* +** SQL function: geopoly_overlap(P1,P2) +** +** Determine whether or not P1 and P2 overlap. Return value: +** +** 0 The two polygons are disjoint +** 1 They overlap +** 2 P1 is completely contained within P2 +** 3 P2 is completely contained within P1 +** 4 P1 and P2 are the same polygon +** NULL Either P1 or P2 or both are not valid polygons +*/ +static void geopolyOverlapFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p1 = geopolyFuncParam(context, argv[0], 0); + GeoPoly *p2 = geopolyFuncParam(context, argv[1], 0); + if( p1 && p2 ){ + int x = geopolyOverlap(p1, p2); + if( x<0 ){ + sqlite3_result_error_nomem(context); + }else{ + sqlite3_result_int(context, x); + } + } + sqlite3_free(p1); + sqlite3_free(p2); +} + +/* +** Enable or disable debugging output +*/ +static void geopolyDebugFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ +#ifdef GEOPOLY_ENABLE_DEBUG + geo_debug = sqlite3_value_int(argv[0]); +#endif +} + +/* +** This function is the implementation of both the xConnect and xCreate +** methods of the geopoly virtual table. +** +** argv[0] -> module name +** argv[1] -> database name +** argv[2] -> table name +** argv[...] -> column names... +*/ +static int geopolyInit( + sqlite3 *db, /* Database connection */ + void *pAux, /* One of the RTREE_COORD_* constants */ + int argc, const char *const*argv, /* Parameters to CREATE TABLE statement */ + sqlite3_vtab **ppVtab, /* OUT: New virtual table */ + char **pzErr, /* OUT: Error message, if any */ + int isCreate /* True for xCreate, false for xConnect */ +){ + int rc = SQLITE_OK; + Rtree *pRtree; + sqlite3_int64 nDb; /* Length of string argv[1] */ + sqlite3_int64 nName; /* Length of string argv[2] */ + sqlite3_str *pSql; + char *zSql; + int ii; + + sqlite3_vtab_config(db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1); + + /* Allocate the sqlite3_vtab structure */ + nDb = strlen(argv[1]); + nName = strlen(argv[2]); + pRtree = (Rtree *)sqlite3_malloc64(sizeof(Rtree)+nDb+nName+2); + if( !pRtree ){ + return SQLITE_NOMEM; + } + memset(pRtree, 0, sizeof(Rtree)+nDb+nName+2); + pRtree->nBusy = 1; + pRtree->base.pModule = &rtreeModule; + pRtree->zDb = (char *)&pRtree[1]; + pRtree->zName = &pRtree->zDb[nDb+1]; + pRtree->eCoordType = RTREE_COORD_REAL32; + pRtree->nDim = 2; + pRtree->nDim2 = 4; + memcpy(pRtree->zDb, argv[1], nDb); + memcpy(pRtree->zName, argv[2], nName); + + + /* Create/Connect to the underlying relational database schema. If + ** that is successful, call sqlite3_declare_vtab() to configure + ** the r-tree table schema. + */ + pSql = sqlite3_str_new(db); + sqlite3_str_appendf(pSql, "CREATE TABLE x(_shape"); + pRtree->nAux = 1; /* Add one for _shape */ + pRtree->nAuxNotNull = 1; /* The _shape column is always not-null */ + for(ii=3; iinAux++; + sqlite3_str_appendf(pSql, ",%s", argv[ii]); + } + sqlite3_str_appendf(pSql, ");"); + zSql = sqlite3_str_finish(pSql); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){ + *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + } + sqlite3_free(zSql); + if( rc ) goto geopolyInit_fail; + pRtree->nBytesPerCell = 8 + pRtree->nDim2*4; + + /* Figure out the node size to use. */ + rc = getNodeSize(db, pRtree, isCreate, pzErr); + if( rc ) goto geopolyInit_fail; + rc = rtreeSqlInit(pRtree, db, argv[1], argv[2], isCreate); + if( rc ){ + *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + goto geopolyInit_fail; + } + + *ppVtab = (sqlite3_vtab *)pRtree; + return SQLITE_OK; + +geopolyInit_fail: + if( rc==SQLITE_OK ) rc = SQLITE_ERROR; + assert( *ppVtab==0 ); + assert( pRtree->nBusy==1 ); + rtreeRelease(pRtree); + return rc; +} + + +/* +** GEOPOLY virtual table module xCreate method. +*/ +static int geopolyCreate( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + return geopolyInit(db, pAux, argc, argv, ppVtab, pzErr, 1); +} + +/* +** GEOPOLY virtual table module xConnect method. +*/ +static int geopolyConnect( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + return geopolyInit(db, pAux, argc, argv, ppVtab, pzErr, 0); +} + + +/* +** GEOPOLY virtual table module xFilter method. +** +** Query plans: +** +** 1 rowid lookup +** 2 search for objects overlapping the same bounding box +** that contains polygon argv[0] +** 3 search for objects overlapping the same bounding box +** that contains polygon argv[0] +** 4 full table scan +*/ +static int geopolyFilter( + sqlite3_vtab_cursor *pVtabCursor, /* The cursor to initialize */ + int idxNum, /* Query plan */ + const char *idxStr, /* Not Used */ + int argc, sqlite3_value **argv /* Parameters to the query plan */ +){ + Rtree *pRtree = (Rtree *)pVtabCursor->pVtab; + RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor; + RtreeNode *pRoot = 0; + int rc = SQLITE_OK; + int iCell = 0; + + rtreeReference(pRtree); + + /* Reset the cursor to the same state as rtreeOpen() leaves it in. */ + resetCursor(pCsr); + + pCsr->iStrategy = idxNum; + if( idxNum==1 ){ + /* Special case - lookup by rowid. */ + RtreeNode *pLeaf; /* Leaf on which the required cell resides */ + RtreeSearchPoint *p; /* Search point for the leaf */ + i64 iRowid = sqlite3_value_int64(argv[0]); + i64 iNode = 0; + rc = findLeafNode(pRtree, iRowid, &pLeaf, &iNode); + if( rc==SQLITE_OK && pLeaf!=0 ){ + p = rtreeSearchPointNew(pCsr, RTREE_ZERO, 0); + assert( p!=0 ); /* Always returns pCsr->sPoint */ + pCsr->aNode[0] = pLeaf; + p->id = iNode; + p->eWithin = PARTLY_WITHIN; + rc = nodeRowidIndex(pRtree, pLeaf, iRowid, &iCell); + p->iCell = (u8)iCell; + RTREE_QUEUE_TRACE(pCsr, "PUSH-F1:"); + }else{ + pCsr->atEOF = 1; + } + }else{ + /* Normal case - r-tree scan. Set up the RtreeCursor.aConstraint array + ** with the configured constraints. + */ + rc = nodeAcquire(pRtree, 1, 0, &pRoot); + if( rc==SQLITE_OK && idxNum<=3 ){ + RtreeCoord bbox[4]; + RtreeConstraint *p; + assert( argc==1 ); + geopolyBBox(0, argv[0], bbox, &rc); + if( rc ){ + goto geopoly_filter_end; + } + pCsr->aConstraint = p = sqlite3_malloc(sizeof(RtreeConstraint)*4); + pCsr->nConstraint = 4; + if( p==0 ){ + rc = SQLITE_NOMEM; + }else{ + memset(pCsr->aConstraint, 0, sizeof(RtreeConstraint)*4); + memset(pCsr->anQueue, 0, sizeof(u32)*(pRtree->iDepth + 1)); + if( idxNum==2 ){ + /* Overlap query */ + p->op = 'B'; + p->iCoord = 0; + p->u.rValue = bbox[1].f; + p++; + p->op = 'D'; + p->iCoord = 1; + p->u.rValue = bbox[0].f; + p++; + p->op = 'B'; + p->iCoord = 2; + p->u.rValue = bbox[3].f; + p++; + p->op = 'D'; + p->iCoord = 3; + p->u.rValue = bbox[2].f; + }else{ + /* Within query */ + p->op = 'D'; + p->iCoord = 0; + p->u.rValue = bbox[0].f; + p++; + p->op = 'B'; + p->iCoord = 1; + p->u.rValue = bbox[1].f; + p++; + p->op = 'D'; + p->iCoord = 2; + p->u.rValue = bbox[2].f; + p++; + p->op = 'B'; + p->iCoord = 3; + p->u.rValue = bbox[3].f; + } + } + } + if( rc==SQLITE_OK ){ + RtreeSearchPoint *pNew; + pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1)); + if( pNew==0 ){ + rc = SQLITE_NOMEM; + goto geopoly_filter_end; + } + pNew->id = 1; + pNew->iCell = 0; + pNew->eWithin = PARTLY_WITHIN; + assert( pCsr->bPoint==1 ); + pCsr->aNode[0] = pRoot; + pRoot = 0; + RTREE_QUEUE_TRACE(pCsr, "PUSH-Fm:"); + rc = rtreeStepToLeaf(pCsr); + } + } + +geopoly_filter_end: + nodeRelease(pRtree, pRoot); + rtreeRelease(pRtree); + return rc; +} + +/* +** Rtree virtual table module xBestIndex method. There are three +** table scan strategies to choose from (in order from most to +** least desirable): +** +** idxNum idxStr Strategy +** ------------------------------------------------ +** 1 "rowid" Direct lookup by rowid. +** 2 "rtree" R-tree overlap query using geopoly_overlap() +** 3 "rtree" R-tree within query using geopoly_within() +** 4 "fullscan" full-table scan. +** ------------------------------------------------ +*/ +static int geopolyBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){ + int ii; + int iRowidTerm = -1; + int iFuncTerm = -1; + int idxNum = 0; + + for(ii=0; iinConstraint; ii++){ + struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[ii]; + if( !p->usable ) continue; + if( p->iColumn<0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ ){ + iRowidTerm = ii; + break; + } + if( p->iColumn==0 && p->op>=SQLITE_INDEX_CONSTRAINT_FUNCTION ){ + /* p->op==SQLITE_INDEX_CONSTRAINT_FUNCTION for geopoly_overlap() + ** p->op==(SQLITE_INDEX_CONTRAINT_FUNCTION+1) for geopoly_within(). + ** See geopolyFindFunction() */ + iFuncTerm = ii; + idxNum = p->op - SQLITE_INDEX_CONSTRAINT_FUNCTION + 2; + } + } + + if( iRowidTerm>=0 ){ + pIdxInfo->idxNum = 1; + pIdxInfo->idxStr = "rowid"; + pIdxInfo->aConstraintUsage[iRowidTerm].argvIndex = 1; + pIdxInfo->aConstraintUsage[iRowidTerm].omit = 1; + pIdxInfo->estimatedCost = 30.0; + pIdxInfo->estimatedRows = 1; + pIdxInfo->idxFlags = SQLITE_INDEX_SCAN_UNIQUE; + return SQLITE_OK; + } + if( iFuncTerm>=0 ){ + pIdxInfo->idxNum = idxNum; + pIdxInfo->idxStr = "rtree"; + pIdxInfo->aConstraintUsage[iFuncTerm].argvIndex = 1; + pIdxInfo->aConstraintUsage[iFuncTerm].omit = 0; + pIdxInfo->estimatedCost = 300.0; + pIdxInfo->estimatedRows = 10; + return SQLITE_OK; + } + pIdxInfo->idxNum = 4; + pIdxInfo->idxStr = "fullscan"; + pIdxInfo->estimatedCost = 3000000.0; + pIdxInfo->estimatedRows = 100000; + return SQLITE_OK; +} + + +/* +** GEOPOLY virtual table module xColumn method. +*/ +static int geopolyColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){ + Rtree *pRtree = (Rtree *)cur->pVtab; + RtreeCursor *pCsr = (RtreeCursor *)cur; + RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr); + int rc = SQLITE_OK; + RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc); + + if( rc ) return rc; + if( p==0 ) return SQLITE_OK; + if( i==0 && sqlite3_vtab_nochange(ctx) ) return SQLITE_OK; + if( i<=pRtree->nAux ){ + if( !pCsr->bAuxValid ){ + if( pCsr->pReadAux==0 ){ + rc = sqlite3_prepare_v3(pRtree->db, pRtree->zReadAuxSql, -1, 0, + &pCsr->pReadAux, 0); + if( rc ) return rc; + } + sqlite3_bind_int64(pCsr->pReadAux, 1, + nodeGetRowid(pRtree, pNode, p->iCell)); + rc = sqlite3_step(pCsr->pReadAux); + if( rc==SQLITE_ROW ){ + pCsr->bAuxValid = 1; + }else{ + sqlite3_reset(pCsr->pReadAux); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + return rc; + } + } + sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pReadAux, i+2)); + } + return SQLITE_OK; +} + + +/* +** The xUpdate method for GEOPOLY module virtual tables. +** +** For DELETE: +** +** argv[0] = the rowid to be deleted +** +** For INSERT: +** +** argv[0] = SQL NULL +** argv[1] = rowid to insert, or an SQL NULL to select automatically +** argv[2] = _shape column +** argv[3] = first application-defined column.... +** +** For UPDATE: +** +** argv[0] = rowid to modify. Never NULL +** argv[1] = rowid after the change. Never NULL +** argv[2] = new value for _shape +** argv[3] = new value for first application-defined column.... +*/ +static int geopolyUpdate( + sqlite3_vtab *pVtab, + int nData, + sqlite3_value **aData, + sqlite_int64 *pRowid +){ + Rtree *pRtree = (Rtree *)pVtab; + int rc = SQLITE_OK; + RtreeCell cell; /* New cell to insert if nData>1 */ + i64 oldRowid; /* The old rowid */ + int oldRowidValid; /* True if oldRowid is valid */ + i64 newRowid; /* The new rowid */ + int newRowidValid; /* True if newRowid is valid */ + int coordChange = 0; /* Change in coordinates */ + + if( pRtree->nNodeRef ){ + /* Unable to write to the btree while another cursor is reading from it, + ** since the write might do a rebalance which would disrupt the read + ** cursor. */ + return SQLITE_LOCKED_VTAB; + } + rtreeReference(pRtree); + assert(nData>=1); + + oldRowidValid = sqlite3_value_type(aData[0])!=SQLITE_NULL;; + oldRowid = oldRowidValid ? sqlite3_value_int64(aData[0]) : 0; + newRowidValid = nData>1 && sqlite3_value_type(aData[1])!=SQLITE_NULL; + newRowid = newRowidValid ? sqlite3_value_int64(aData[1]) : 0; + cell.iRowid = newRowid; + + if( nData>1 /* not a DELETE */ + && (!oldRowidValid /* INSERT */ + || !sqlite3_value_nochange(aData[2]) /* UPDATE _shape */ + || oldRowid!=newRowid) /* Rowid change */ + ){ + geopolyBBox(0, aData[2], cell.aCoord, &rc); + if( rc ){ + if( rc==SQLITE_ERROR ){ + pVtab->zErrMsg = + sqlite3_mprintf("_shape does not contain a valid polygon"); + } + goto geopoly_update_end; + } + coordChange = 1; + + /* If a rowid value was supplied, check if it is already present in + ** the table. If so, the constraint has failed. */ + if( newRowidValid && (!oldRowidValid || oldRowid!=newRowid) ){ + int steprc; + sqlite3_bind_int64(pRtree->pReadRowid, 1, cell.iRowid); + steprc = sqlite3_step(pRtree->pReadRowid); + rc = sqlite3_reset(pRtree->pReadRowid); + if( SQLITE_ROW==steprc ){ + if( sqlite3_vtab_on_conflict(pRtree->db)==SQLITE_REPLACE ){ + rc = rtreeDeleteRowid(pRtree, cell.iRowid); + }else{ + rc = rtreeConstraintError(pRtree, 0); + } + } + } + } + + /* If aData[0] is not an SQL NULL value, it is the rowid of a + ** record to delete from the r-tree table. The following block does + ** just that. + */ + if( rc==SQLITE_OK && (nData==1 || (coordChange && oldRowidValid)) ){ + rc = rtreeDeleteRowid(pRtree, oldRowid); + } + + /* If the aData[] array contains more than one element, elements + ** (aData[2]..aData[argc-1]) contain a new record to insert into + ** the r-tree structure. + */ + if( rc==SQLITE_OK && nData>1 && coordChange ){ + /* Insert the new record into the r-tree */ + RtreeNode *pLeaf = 0; + if( !newRowidValid ){ + rc = rtreeNewRowid(pRtree, &cell.iRowid); + } + *pRowid = cell.iRowid; + if( rc==SQLITE_OK ){ + rc = ChooseLeaf(pRtree, &cell, 0, &pLeaf); + } + if( rc==SQLITE_OK ){ + int rc2; + pRtree->iReinsertHeight = -1; + rc = rtreeInsertCell(pRtree, pLeaf, &cell, 0); + rc2 = nodeRelease(pRtree, pLeaf); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + } + + /* Change the data */ + if( rc==SQLITE_OK && nData>1 ){ + sqlite3_stmt *pUp = pRtree->pWriteAux; + int jj; + int nChange = 0; + sqlite3_bind_int64(pUp, 1, cell.iRowid); + assert( pRtree->nAux>=1 ); + if( sqlite3_value_nochange(aData[2]) ){ + sqlite3_bind_null(pUp, 2); + }else{ + GeoPoly *p = 0; + if( sqlite3_value_type(aData[2])==SQLITE_TEXT + && (p = geopolyFuncParam(0, aData[2], &rc))!=0 + && rc==SQLITE_OK + ){ + sqlite3_bind_blob(pUp, 2, p->hdr, 4+8*p->nVertex, SQLITE_TRANSIENT); + }else{ + sqlite3_bind_value(pUp, 2, aData[2]); + } + sqlite3_free(p); + nChange = 1; + } + for(jj=1; jjnAux; jj++){ + nChange++; + sqlite3_bind_value(pUp, jj+2, aData[jj+2]); + } + if( nChange ){ + sqlite3_step(pUp); + rc = sqlite3_reset(pUp); + } + } + +geopoly_update_end: + rtreeRelease(pRtree); + return rc; +} + +/* +** Report that geopoly_overlap() is an overloaded function suitable +** for use in xBestIndex. +*/ +static int geopolyFindFunction( + sqlite3_vtab *pVtab, + int nArg, + const char *zName, + void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), + void **ppArg +){ + if( sqlite3_stricmp(zName, "geopoly_overlap")==0 ){ + *pxFunc = geopolyOverlapFunc; + *ppArg = 0; + return SQLITE_INDEX_CONSTRAINT_FUNCTION; + } + if( sqlite3_stricmp(zName, "geopoly_within")==0 ){ + *pxFunc = geopolyWithinFunc; + *ppArg = 0; + return SQLITE_INDEX_CONSTRAINT_FUNCTION+1; + } + return 0; +} + + +static sqlite3_module geopolyModule = { + 3, /* iVersion */ + geopolyCreate, /* xCreate - create a table */ + geopolyConnect, /* xConnect - connect to an existing table */ + geopolyBestIndex, /* xBestIndex - Determine search strategy */ + rtreeDisconnect, /* xDisconnect - Disconnect from a table */ + rtreeDestroy, /* xDestroy - Drop a table */ + rtreeOpen, /* xOpen - open a cursor */ + rtreeClose, /* xClose - close a cursor */ + geopolyFilter, /* xFilter - configure scan constraints */ + rtreeNext, /* xNext - advance a cursor */ + rtreeEof, /* xEof */ + geopolyColumn, /* xColumn - read data */ + rtreeRowid, /* xRowid - read data */ + geopolyUpdate, /* xUpdate - write data */ + rtreeBeginTransaction, /* xBegin - begin transaction */ + rtreeEndTransaction, /* xSync - sync transaction */ + rtreeEndTransaction, /* xCommit - commit transaction */ + rtreeEndTransaction, /* xRollback - rollback transaction */ + geopolyFindFunction, /* xFindFunction - function overloading */ + rtreeRename, /* xRename - rename the table */ + rtreeSavepoint, /* xSavepoint */ + 0, /* xRelease */ + 0, /* xRollbackTo */ + rtreeShadowName /* xShadowName */ +}; + +static int sqlite3_geopoly_init(sqlite3 *db){ + int rc = SQLITE_OK; + static const struct { + void (*xFunc)(sqlite3_context*,int,sqlite3_value**); + signed char nArg; + unsigned char bPure; + const char *zName; + } aFunc[] = { + { geopolyAreaFunc, 1, 1, "geopoly_area" }, + { geopolyBlobFunc, 1, 1, "geopoly_blob" }, + { geopolyJsonFunc, 1, 1, "geopoly_json" }, + { geopolySvgFunc, -1, 1, "geopoly_svg" }, + { geopolyWithinFunc, 2, 1, "geopoly_within" }, + { geopolyContainsPointFunc, 3, 1, "geopoly_contains_point" }, + { geopolyOverlapFunc, 2, 1, "geopoly_overlap" }, + { geopolyDebugFunc, 1, 0, "geopoly_debug" }, + { geopolyBBoxFunc, 1, 1, "geopoly_bbox" }, + { geopolyXformFunc, 7, 1, "geopoly_xform" }, + { geopolyRegularFunc, 4, 1, "geopoly_regular" }, + { geopolyCcwFunc, 1, 1, "geopoly_ccw" }, + }; + static const struct { + void (*xStep)(sqlite3_context*,int,sqlite3_value**); + void (*xFinal)(sqlite3_context*); + const char *zName; + } aAgg[] = { + { geopolyBBoxStep, geopolyBBoxFinal, "geopoly_group_bbox" }, + }; + int i; + for(i=0; ixDestructor ) pInfo->xDestructor(pInfo->pContext); + sqlite3_free(p); +} + +/* +** This routine frees the BLOB that is returned by geomCallback(). +*/ +static void rtreeMatchArgFree(void *pArg){ + int i; + RtreeMatchArg *p = (RtreeMatchArg*)pArg; + for(i=0; inParam; i++){ + sqlite3_value_free(p->apSqlParam[i]); + } + sqlite3_free(p); +} + +/* +** Each call to sqlite3_rtree_geometry_callback() or +** sqlite3_rtree_query_callback() creates an ordinary SQLite +** scalar function that is implemented by this routine. +** +** All this function does is construct an RtreeMatchArg object that +** contains the geometry-checking callback routines and a list of +** parameters to this function, then return that RtreeMatchArg object +** as a BLOB. +** +** The R-Tree MATCH operator will read the returned BLOB, deserialize +** the RtreeMatchArg object, and use the RtreeMatchArg object to figure +** out which elements of the R-Tree should be returned by the query. +*/ +static void geomCallback(sqlite3_context *ctx, int nArg, sqlite3_value **aArg){ + RtreeGeomCallback *pGeomCtx = (RtreeGeomCallback *)sqlite3_user_data(ctx); + RtreeMatchArg *pBlob; + sqlite3_int64 nBlob; + int memErr = 0; + + nBlob = sizeof(RtreeMatchArg) + (nArg-1)*sizeof(RtreeDValue) + + nArg*sizeof(sqlite3_value*); + pBlob = (RtreeMatchArg *)sqlite3_malloc64(nBlob); + if( !pBlob ){ + sqlite3_result_error_nomem(ctx); + }else{ + int i; + pBlob->iSize = nBlob; + pBlob->cb = pGeomCtx[0]; + pBlob->apSqlParam = (sqlite3_value**)&pBlob->aParam[nArg]; + pBlob->nParam = nArg; + for(i=0; iapSqlParam[i] = sqlite3_value_dup(aArg[i]); + if( pBlob->apSqlParam[i]==0 ) memErr = 1; +#ifdef SQLITE_RTREE_INT_ONLY + pBlob->aParam[i] = sqlite3_value_int64(aArg[i]); +#else + pBlob->aParam[i] = sqlite3_value_double(aArg[i]); +#endif + } + if( memErr ){ + sqlite3_result_error_nomem(ctx); + rtreeMatchArgFree(pBlob); + }else{ + sqlite3_result_pointer(ctx, pBlob, "RtreeMatchArg", rtreeMatchArgFree); + } + } +} + +/* +** Register a new geometry function for use with the r-tree MATCH operator. +*/ +SQLITE_API int sqlite3_rtree_geometry_callback( + sqlite3 *db, /* Register SQL function on this connection */ + const char *zGeom, /* Name of the new SQL function */ + int (*xGeom)(sqlite3_rtree_geometry*,int,RtreeDValue*,int*), /* Callback */ + void *pContext /* Extra data associated with the callback */ +){ + RtreeGeomCallback *pGeomCtx; /* Context object for new user-function */ + + /* Allocate and populate the context object. */ + pGeomCtx = (RtreeGeomCallback *)sqlite3_malloc(sizeof(RtreeGeomCallback)); + if( !pGeomCtx ) return SQLITE_NOMEM; + pGeomCtx->xGeom = xGeom; + pGeomCtx->xQueryFunc = 0; + pGeomCtx->xDestructor = 0; + pGeomCtx->pContext = pContext; + return sqlite3_create_function_v2(db, zGeom, -1, SQLITE_ANY, + (void *)pGeomCtx, geomCallback, 0, 0, rtreeFreeCallback + ); +} + +/* +** Register a new 2nd-generation geometry function for use with the +** r-tree MATCH operator. +*/ +SQLITE_API int sqlite3_rtree_query_callback( + sqlite3 *db, /* Register SQL function on this connection */ + const char *zQueryFunc, /* Name of new SQL function */ + int (*xQueryFunc)(sqlite3_rtree_query_info*), /* Callback */ + void *pContext, /* Extra data passed into the callback */ + void (*xDestructor)(void*) /* Destructor for the extra data */ +){ + RtreeGeomCallback *pGeomCtx; /* Context object for new user-function */ + + /* Allocate and populate the context object. */ + pGeomCtx = (RtreeGeomCallback *)sqlite3_malloc(sizeof(RtreeGeomCallback)); + if( !pGeomCtx ) return SQLITE_NOMEM; + pGeomCtx->xGeom = 0; + pGeomCtx->xQueryFunc = xQueryFunc; + pGeomCtx->xDestructor = xDestructor; + pGeomCtx->pContext = pContext; + return sqlite3_create_function_v2(db, zQueryFunc, -1, SQLITE_ANY, + (void *)pGeomCtx, geomCallback, 0, 0, rtreeFreeCallback + ); +} + +#if !SQLITE_CORE +#ifdef _WIN32 +__declspec(dllexport) +#endif +SQLITE_API int sqlite3_rtree_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi +){ + SQLITE_EXTENSION_INIT2(pApi) + return sqlite3RtreeInit(db); +} +#endif + +#endif + +/************** End of rtree.c ***********************************************/ +/************** Begin file icu.c *********************************************/ +/* +** 2007 May 6 +** +** 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. +** +************************************************************************* +** $Id: icu.c,v 1.7 2007/12/13 21:54:11 drh Exp $ +** +** This file implements an integration between the ICU library +** ("International Components for Unicode", an open-source library +** for handling unicode data) and SQLite. The integration uses +** ICU to provide the following to SQLite: +** +** * An implementation of the SQL regexp() function (and hence REGEXP +** operator) using the ICU uregex_XX() APIs. +** +** * Implementations of the SQL scalar upper() and lower() functions +** for case mapping. +** +** * Integration of ICU and SQLite collation sequences. +** +** * An implementation of the LIKE operator that uses ICU to +** provide case-independent matching. +*/ + +#if !defined(SQLITE_CORE) \ + || defined(SQLITE_ENABLE_ICU) \ + || defined(SQLITE_ENABLE_ICU_COLLATIONS) + +/* Include ICU headers */ +#include +#include +#include +#include + +/* #include */ + +#ifndef SQLITE_CORE +/* #include "sqlite3ext.h" */ + SQLITE_EXTENSION_INIT1 +#else +/* #include "sqlite3.h" */ +#endif + +/* +** This function is called when an ICU function called from within +** the implementation of an SQL scalar function returns an error. +** +** The scalar function context passed as the first argument is +** loaded with an error message based on the following two args. +*/ +static void icuFunctionError( + sqlite3_context *pCtx, /* SQLite scalar function context */ + const char *zName, /* Name of ICU function that failed */ + UErrorCode e /* Error code returned by ICU function */ +){ + char zBuf[128]; + sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e)); + zBuf[127] = '\0'; + sqlite3_result_error(pCtx, zBuf, -1); +} + +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ICU) + +/* +** Maximum length (in bytes) of the pattern in a LIKE or GLOB +** operator. +*/ +#ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH +# define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000 +#endif + +/* +** Version of sqlite3_free() that is always a function, never a macro. +*/ +static void xFree(void *p){ + sqlite3_free(p); +} + +/* +** This lookup table is used to help decode the first byte of +** a multi-byte UTF8 character. It is copied here from SQLite source +** code file utf8.c. +*/ +static const unsigned char icuUtf8Trans1[] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00, +}; + +#define SQLITE_ICU_READ_UTF8(zIn, c) \ + c = *(zIn++); \ + if( c>=0xc0 ){ \ + c = icuUtf8Trans1[c-0xc0]; \ + while( (*zIn & 0xc0)==0x80 ){ \ + c = (c<<6) + (0x3f & *(zIn++)); \ + } \ + } + +#define SQLITE_ICU_SKIP_UTF8(zIn) \ + assert( *zIn ); \ + if( *(zIn++)>=0xc0 ){ \ + while( (*zIn & 0xc0)==0x80 ){zIn++;} \ + } + + +/* +** Compare two UTF-8 strings for equality where the first string is +** a "LIKE" expression. Return true (1) if they are the same and +** false (0) if they are different. +*/ +static int icuLikeCompare( + const uint8_t *zPattern, /* LIKE pattern */ + const uint8_t *zString, /* The UTF-8 string to compare against */ + const UChar32 uEsc /* The escape character */ +){ + static const uint32_t MATCH_ONE = (uint32_t)'_'; + static const uint32_t MATCH_ALL = (uint32_t)'%'; + + int prevEscape = 0; /* True if the previous character was uEsc */ + + while( 1 ){ + + /* Read (and consume) the next character from the input pattern. */ + uint32_t uPattern; + SQLITE_ICU_READ_UTF8(zPattern, uPattern); + if( uPattern==0 ) break; + + /* There are now 4 possibilities: + ** + ** 1. uPattern is an unescaped match-all character "%", + ** 2. uPattern is an unescaped match-one character "_", + ** 3. uPattern is an unescaped escape character, or + ** 4. uPattern is to be handled as an ordinary character + */ + if( uPattern==MATCH_ALL && !prevEscape && uPattern!=(uint32_t)uEsc ){ + /* Case 1. */ + uint8_t c; + + /* Skip any MATCH_ALL or MATCH_ONE characters that follow a + ** MATCH_ALL. For each MATCH_ONE, skip one character in the + ** test string. + */ + while( (c=*zPattern) == MATCH_ALL || c == MATCH_ONE ){ + if( c==MATCH_ONE ){ + if( *zString==0 ) return 0; + SQLITE_ICU_SKIP_UTF8(zString); + } + zPattern++; + } + + if( *zPattern==0 ) return 1; + + while( *zString ){ + if( icuLikeCompare(zPattern, zString, uEsc) ){ + return 1; + } + SQLITE_ICU_SKIP_UTF8(zString); + } + return 0; + + }else if( uPattern==MATCH_ONE && !prevEscape && uPattern!=(uint32_t)uEsc ){ + /* Case 2. */ + if( *zString==0 ) return 0; + SQLITE_ICU_SKIP_UTF8(zString); + + }else if( uPattern==(uint32_t)uEsc && !prevEscape ){ + /* Case 3. */ + prevEscape = 1; + + }else{ + /* Case 4. */ + uint32_t uString; + SQLITE_ICU_READ_UTF8(zString, uString); + uString = (uint32_t)u_foldCase((UChar32)uString, U_FOLD_CASE_DEFAULT); + uPattern = (uint32_t)u_foldCase((UChar32)uPattern, U_FOLD_CASE_DEFAULT); + if( uString!=uPattern ){ + return 0; + } + prevEscape = 0; + } + } + + return *zString==0; +} + +/* +** Implementation of the like() SQL function. This function implements +** the build-in LIKE operator. The first argument to the function is the +** pattern and the second argument is the string. So, the SQL statements: +** +** A LIKE B +** +** is implemented as like(B, A). If there is an escape character E, +** +** A LIKE B ESCAPE E +** +** is mapped to like(B, A, E). +*/ +static void icuLikeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zA = sqlite3_value_text(argv[0]); + const unsigned char *zB = sqlite3_value_text(argv[1]); + UChar32 uEsc = 0; + + /* Limit the length of the LIKE or GLOB pattern to avoid problems + ** of deep recursion and N*N behavior in patternCompare(). + */ + if( sqlite3_value_bytes(argv[0])>SQLITE_MAX_LIKE_PATTERN_LENGTH ){ + sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1); + return; + } + + + if( argc==3 ){ + /* The escape character string must consist of a single UTF-8 character. + ** Otherwise, return an error. + */ + int nE= sqlite3_value_bytes(argv[2]); + const unsigned char *zE = sqlite3_value_text(argv[2]); + int i = 0; + if( zE==0 ) return; + U8_NEXT(zE, i, nE, uEsc); + if( i!=nE){ + sqlite3_result_error(context, + "ESCAPE expression must be a single character", -1); + return; + } + } + + if( zA && zB ){ + sqlite3_result_int(context, icuLikeCompare(zA, zB, uEsc)); + } +} + +/* +** Function to delete compiled regexp objects. Registered as +** a destructor function with sqlite3_set_auxdata(). +*/ +static void icuRegexpDelete(void *p){ + URegularExpression *pExpr = (URegularExpression *)p; + uregex_close(pExpr); +} + +/* +** Implementation of SQLite REGEXP operator. This scalar function takes +** two arguments. The first is a regular expression pattern to compile +** the second is a string to match against that pattern. If either +** argument is an SQL NULL, then NULL Is returned. Otherwise, the result +** is 1 if the string matches the pattern, or 0 otherwise. +** +** SQLite maps the regexp() function to the regexp() operator such +** that the following two are equivalent: +** +** zString REGEXP zPattern +** regexp(zPattern, zString) +** +** Uses the following ICU regexp APIs: +** +** uregex_open() +** uregex_matches() +** uregex_close() +*/ +static void icuRegexpFunc(sqlite3_context *p, int nArg, sqlite3_value **apArg){ + UErrorCode status = U_ZERO_ERROR; + URegularExpression *pExpr; + UBool res; + const UChar *zString = sqlite3_value_text16(apArg[1]); + + (void)nArg; /* Unused parameter */ + + /* If the left hand side of the regexp operator is NULL, + ** then the result is also NULL. + */ + if( !zString ){ + return; + } + + pExpr = sqlite3_get_auxdata(p, 0); + if( !pExpr ){ + const UChar *zPattern = sqlite3_value_text16(apArg[0]); + if( !zPattern ){ + return; + } + pExpr = uregex_open(zPattern, -1, 0, 0, &status); + + if( U_SUCCESS(status) ){ + sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete); + }else{ + assert(!pExpr); + icuFunctionError(p, "uregex_open", status); + return; + } + } + + /* Configure the text that the regular expression operates on. */ + uregex_setText(pExpr, zString, -1, &status); + if( !U_SUCCESS(status) ){ + icuFunctionError(p, "uregex_setText", status); + return; + } + + /* Attempt the match */ + res = uregex_matches(pExpr, 0, &status); + if( !U_SUCCESS(status) ){ + icuFunctionError(p, "uregex_matches", status); + return; + } + + /* Set the text that the regular expression operates on to a NULL + ** pointer. This is not really necessary, but it is tidier than + ** leaving the regular expression object configured with an invalid + ** pointer after this function returns. + */ + uregex_setText(pExpr, 0, 0, &status); + + /* Return 1 or 0. */ + sqlite3_result_int(p, res ? 1 : 0); +} + +/* +** Implementations of scalar functions for case mapping - upper() and +** lower(). Function upper() converts its input to upper-case (ABC). +** Function lower() converts to lower-case (abc). +** +** ICU provides two types of case mapping, "general" case mapping and +** "language specific". Refer to ICU documentation for the differences +** between the two. +** +** To utilise "general" case mapping, the upper() or lower() scalar +** functions are invoked with one argument: +** +** upper('ABC') -> 'abc' +** lower('abc') -> 'ABC' +** +** To access ICU "language specific" case mapping, upper() or lower() +** should be invoked with two arguments. The second argument is the name +** of the locale to use. Passing an empty string ("") or SQL NULL value +** as the second argument is the same as invoking the 1 argument version +** of upper() or lower(). +** +** lower('I', 'en_us') -> 'i' +** lower('I', 'tr_tr') -> '\u131' (small dotless i) +** +** http://www.icu-project.org/userguide/posix.html#case_mappings +*/ +static void icuCaseFunc16(sqlite3_context *p, int nArg, sqlite3_value **apArg){ + const UChar *zInput; /* Pointer to input string */ + UChar *zOutput = 0; /* Pointer to output buffer */ + int nInput; /* Size of utf-16 input string in bytes */ + int nOut; /* Size of output buffer in bytes */ + int cnt; + int bToUpper; /* True for toupper(), false for tolower() */ + UErrorCode status; + const char *zLocale = 0; + + assert(nArg==1 || nArg==2); + bToUpper = (sqlite3_user_data(p)!=0); + if( nArg==2 ){ + zLocale = (const char *)sqlite3_value_text(apArg[1]); + } + + zInput = sqlite3_value_text16(apArg[0]); + if( !zInput ){ + return; + } + nOut = nInput = sqlite3_value_bytes16(apArg[0]); + if( nOut==0 ){ + sqlite3_result_text16(p, "", 0, SQLITE_STATIC); + return; + } + + for(cnt=0; cnt<2; cnt++){ + UChar *zNew = sqlite3_realloc(zOutput, nOut); + if( zNew==0 ){ + sqlite3_free(zOutput); + sqlite3_result_error_nomem(p); + return; + } + zOutput = zNew; + status = U_ZERO_ERROR; + if( bToUpper ){ + nOut = 2*u_strToUpper(zOutput,nOut/2,zInput,nInput/2,zLocale,&status); + }else{ + nOut = 2*u_strToLower(zOutput,nOut/2,zInput,nInput/2,zLocale,&status); + } + + if( U_SUCCESS(status) ){ + sqlite3_result_text16(p, zOutput, nOut, xFree); + }else if( status==U_BUFFER_OVERFLOW_ERROR ){ + assert( cnt==0 ); + continue; + }else{ + icuFunctionError(p, bToUpper ? "u_strToUpper" : "u_strToLower", status); + } + return; + } + assert( 0 ); /* Unreachable */ +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ICU) */ + +/* +** Collation sequence destructor function. The pCtx argument points to +** a UCollator structure previously allocated using ucol_open(). +*/ +static void icuCollationDel(void *pCtx){ + UCollator *p = (UCollator *)pCtx; + ucol_close(p); +} + +/* +** Collation sequence comparison function. The pCtx argument points to +** a UCollator structure previously allocated using ucol_open(). +*/ +static int icuCollationColl( + void *pCtx, + int nLeft, + const void *zLeft, + int nRight, + const void *zRight +){ + UCollationResult res; + UCollator *p = (UCollator *)pCtx; + res = ucol_strcoll(p, (UChar *)zLeft, nLeft/2, (UChar *)zRight, nRight/2); + switch( res ){ + case UCOL_LESS: return -1; + case UCOL_GREATER: return +1; + case UCOL_EQUAL: return 0; + } + assert(!"Unexpected return value from ucol_strcoll()"); + return 0; +} + +/* +** Implementation of the scalar function icu_load_collation(). +** +** This scalar function is used to add ICU collation based collation +** types to an SQLite database connection. It is intended to be called +** as follows: +** +** SELECT icu_load_collation(, ); +** +** Where is a string containing an ICU locale identifier (i.e. +** "en_AU", "tr_TR" etc.) and is the name of the +** collation sequence to create. +*/ +static void icuLoadCollation( + sqlite3_context *p, + int nArg, + sqlite3_value **apArg +){ + sqlite3 *db = (sqlite3 *)sqlite3_user_data(p); + UErrorCode status = U_ZERO_ERROR; + const char *zLocale; /* Locale identifier - (eg. "jp_JP") */ + const char *zName; /* SQL Collation sequence name (eg. "japanese") */ + UCollator *pUCollator; /* ICU library collation object */ + int rc; /* Return code from sqlite3_create_collation_x() */ + + assert(nArg==2); + (void)nArg; /* Unused parameter */ + zLocale = (const char *)sqlite3_value_text(apArg[0]); + zName = (const char *)sqlite3_value_text(apArg[1]); + + if( !zLocale || !zName ){ + return; + } + + pUCollator = ucol_open(zLocale, &status); + if( !U_SUCCESS(status) ){ + icuFunctionError(p, "ucol_open", status); + return; + } + assert(p); + + rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator, + icuCollationColl, icuCollationDel + ); + if( rc!=SQLITE_OK ){ + ucol_close(pUCollator); + sqlite3_result_error(p, "Error registering collation function", -1); + } +} + +/* +** Register the ICU extension functions with database db. +*/ +SQLITE_PRIVATE int sqlite3IcuInit(sqlite3 *db){ +# define SQLITEICU_EXTRAFLAGS (SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS) + static const struct IcuScalar { + const char *zName; /* Function name */ + unsigned char nArg; /* Number of arguments */ + unsigned int enc; /* Optimal text encoding */ + unsigned char iContext; /* sqlite3_user_data() context */ + void (*xFunc)(sqlite3_context*,int,sqlite3_value**); + } scalars[] = { + {"icu_load_collation",2,SQLITE_UTF8|SQLITE_DIRECTONLY,1, icuLoadCollation}, +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ICU) + {"regexp", 2, SQLITE_ANY|SQLITEICU_EXTRAFLAGS, 0, icuRegexpFunc}, + {"lower", 1, SQLITE_UTF16|SQLITEICU_EXTRAFLAGS, 0, icuCaseFunc16}, + {"lower", 2, SQLITE_UTF16|SQLITEICU_EXTRAFLAGS, 0, icuCaseFunc16}, + {"upper", 1, SQLITE_UTF16|SQLITEICU_EXTRAFLAGS, 1, icuCaseFunc16}, + {"upper", 2, SQLITE_UTF16|SQLITEICU_EXTRAFLAGS, 1, icuCaseFunc16}, + {"lower", 1, SQLITE_UTF8|SQLITEICU_EXTRAFLAGS, 0, icuCaseFunc16}, + {"lower", 2, SQLITE_UTF8|SQLITEICU_EXTRAFLAGS, 0, icuCaseFunc16}, + {"upper", 1, SQLITE_UTF8|SQLITEICU_EXTRAFLAGS, 1, icuCaseFunc16}, + {"upper", 2, SQLITE_UTF8|SQLITEICU_EXTRAFLAGS, 1, icuCaseFunc16}, + {"like", 2, SQLITE_UTF8|SQLITEICU_EXTRAFLAGS, 0, icuLikeFunc}, + {"like", 3, SQLITE_UTF8|SQLITEICU_EXTRAFLAGS, 0, icuLikeFunc}, +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ICU) */ + }; + int rc = SQLITE_OK; + int i; + + for(i=0; rc==SQLITE_OK && i<(int)(sizeof(scalars)/sizeof(scalars[0])); i++){ + const struct IcuScalar *p = &scalars[i]; + rc = sqlite3_create_function( + db, p->zName, p->nArg, p->enc, + p->iContext ? (void*)db : (void*)0, + p->xFunc, 0, 0 + ); + } + + return rc; +} + +#if !SQLITE_CORE +#ifdef _WIN32 +__declspec(dllexport) +#endif +SQLITE_API int sqlite3_icu_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi +){ + SQLITE_EXTENSION_INIT2(pApi) + return sqlite3IcuInit(db); +} +#endif + +#endif + +/************** End of icu.c *************************************************/ +/************** Begin file fts3_icu.c ****************************************/ +/* +** 2007 June 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file implements a tokenizer for fts3 based on the ICU library. +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) +#ifdef SQLITE_ENABLE_ICU + +/* #include */ +/* #include */ +/* #include "fts3_tokenizer.h" */ + +#include +/* #include */ +/* #include */ +#include + +typedef struct IcuTokenizer IcuTokenizer; +typedef struct IcuCursor IcuCursor; + +struct IcuTokenizer { + sqlite3_tokenizer base; + char *zLocale; +}; + +struct IcuCursor { + sqlite3_tokenizer_cursor base; + + UBreakIterator *pIter; /* ICU break-iterator object */ + int nChar; /* Number of UChar elements in pInput */ + UChar *aChar; /* Copy of input using utf-16 encoding */ + int *aOffset; /* Offsets of each character in utf-8 input */ + + int nBuffer; + char *zBuffer; + + int iToken; +}; + +/* +** Create a new tokenizer instance. +*/ +static int icuCreate( + int argc, /* Number of entries in argv[] */ + const char * const *argv, /* Tokenizer creation arguments */ + sqlite3_tokenizer **ppTokenizer /* OUT: Created tokenizer */ +){ + IcuTokenizer *p; + int n = 0; + + if( argc>0 ){ + n = strlen(argv[0])+1; + } + p = (IcuTokenizer *)sqlite3_malloc64(sizeof(IcuTokenizer)+n); + if( !p ){ + return SQLITE_NOMEM; + } + memset(p, 0, sizeof(IcuTokenizer)); + + if( n ){ + p->zLocale = (char *)&p[1]; + memcpy(p->zLocale, argv[0], n); + } + + *ppTokenizer = (sqlite3_tokenizer *)p; + + return SQLITE_OK; +} + +/* +** Destroy a tokenizer +*/ +static int icuDestroy(sqlite3_tokenizer *pTokenizer){ + IcuTokenizer *p = (IcuTokenizer *)pTokenizer; + sqlite3_free(p); + return SQLITE_OK; +} + +/* +** Prepare to begin tokenizing a particular string. The input +** string to be tokenized is pInput[0..nBytes-1]. A cursor +** used to incrementally tokenize this string is returned in +** *ppCursor. +*/ +static int icuOpen( + sqlite3_tokenizer *pTokenizer, /* The tokenizer */ + const char *zInput, /* Input string */ + int nInput, /* Length of zInput in bytes */ + sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */ +){ + IcuTokenizer *p = (IcuTokenizer *)pTokenizer; + IcuCursor *pCsr; + + const int32_t opt = U_FOLD_CASE_DEFAULT; + UErrorCode status = U_ZERO_ERROR; + int nChar; + + UChar32 c; + int iInput = 0; + int iOut = 0; + + *ppCursor = 0; + + if( zInput==0 ){ + nInput = 0; + zInput = ""; + }else if( nInput<0 ){ + nInput = strlen(zInput); + } + nChar = nInput+1; + pCsr = (IcuCursor *)sqlite3_malloc64( + sizeof(IcuCursor) + /* IcuCursor */ + ((nChar+3)&~3) * sizeof(UChar) + /* IcuCursor.aChar[] */ + (nChar+1) * sizeof(int) /* IcuCursor.aOffset[] */ + ); + if( !pCsr ){ + return SQLITE_NOMEM; + } + memset(pCsr, 0, sizeof(IcuCursor)); + pCsr->aChar = (UChar *)&pCsr[1]; + pCsr->aOffset = (int *)&pCsr->aChar[(nChar+3)&~3]; + + pCsr->aOffset[iOut] = iInput; + U8_NEXT(zInput, iInput, nInput, c); + while( c>0 ){ + int isError = 0; + c = u_foldCase(c, opt); + U16_APPEND(pCsr->aChar, iOut, nChar, c, isError); + if( isError ){ + sqlite3_free(pCsr); + return SQLITE_ERROR; + } + pCsr->aOffset[iOut] = iInput; + + if( iInputpIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status); + if( !U_SUCCESS(status) ){ + sqlite3_free(pCsr); + return SQLITE_ERROR; + } + pCsr->nChar = iOut; + + ubrk_first(pCsr->pIter); + *ppCursor = (sqlite3_tokenizer_cursor *)pCsr; + return SQLITE_OK; +} + +/* +** Close a tokenization cursor previously opened by a call to icuOpen(). +*/ +static int icuClose(sqlite3_tokenizer_cursor *pCursor){ + IcuCursor *pCsr = (IcuCursor *)pCursor; + ubrk_close(pCsr->pIter); + sqlite3_free(pCsr->zBuffer); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +/* +** Extract the next token from a tokenization cursor. +*/ +static int icuNext( + sqlite3_tokenizer_cursor *pCursor, /* Cursor returned by simpleOpen */ + const char **ppToken, /* OUT: *ppToken is the token text */ + int *pnBytes, /* OUT: Number of bytes in token */ + int *piStartOffset, /* OUT: Starting offset of token */ + int *piEndOffset, /* OUT: Ending offset of token */ + int *piPosition /* OUT: Position integer of token */ +){ + IcuCursor *pCsr = (IcuCursor *)pCursor; + + int iStart = 0; + int iEnd = 0; + int nByte = 0; + + while( iStart==iEnd ){ + UChar32 c; + + iStart = ubrk_current(pCsr->pIter); + iEnd = ubrk_next(pCsr->pIter); + if( iEnd==UBRK_DONE ){ + return SQLITE_DONE; + } + + while( iStartaChar, iWhite, pCsr->nChar, c); + if( u_isspace(c) ){ + iStart = iWhite; + }else{ + break; + } + } + assert(iStart<=iEnd); + } + + do { + UErrorCode status = U_ZERO_ERROR; + if( nByte ){ + char *zNew = sqlite3_realloc(pCsr->zBuffer, nByte); + if( !zNew ){ + return SQLITE_NOMEM; + } + pCsr->zBuffer = zNew; + pCsr->nBuffer = nByte; + } + + u_strToUTF8( + pCsr->zBuffer, pCsr->nBuffer, &nByte, /* Output vars */ + &pCsr->aChar[iStart], iEnd-iStart, /* Input vars */ + &status /* Output success/failure */ + ); + } while( nByte>pCsr->nBuffer ); + + *ppToken = pCsr->zBuffer; + *pnBytes = nByte; + *piStartOffset = pCsr->aOffset[iStart]; + *piEndOffset = pCsr->aOffset[iEnd]; + *piPosition = pCsr->iToken++; + + return SQLITE_OK; +} + +/* +** The set of routines that implement the simple tokenizer +*/ +static const sqlite3_tokenizer_module icuTokenizerModule = { + 0, /* iVersion */ + icuCreate, /* xCreate */ + icuDestroy, /* xCreate */ + icuOpen, /* xOpen */ + icuClose, /* xClose */ + icuNext, /* xNext */ + 0, /* xLanguageid */ +}; + +/* +** Set *ppModule to point at the implementation of the ICU tokenizer. +*/ +SQLITE_PRIVATE void sqlite3Fts3IcuTokenizerModule( + sqlite3_tokenizer_module const**ppModule +){ + *ppModule = &icuTokenizerModule; +} + +#endif /* defined(SQLITE_ENABLE_ICU) */ +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_icu.c ********************************************/ +/************** Begin file sqlite3rbu.c **************************************/ +/* +** 2014 August 30 +** +** 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. +** +************************************************************************* +** +** +** OVERVIEW +** +** The RBU extension requires that the RBU update be packaged as an +** SQLite database. The tables it expects to find are described in +** sqlite3rbu.h. Essentially, for each table xyz in the target database +** that the user wishes to write to, a corresponding data_xyz table is +** created in the RBU database and populated with one row for each row to +** update, insert or delete from the target table. +** +** The update proceeds in three stages: +** +** 1) The database is updated. The modified database pages are written +** to a *-oal file. A *-oal file is just like a *-wal file, except +** that it is named "-oal" instead of "-wal". +** Because regular SQLite clients do not look for file named +** "-oal", they go on using the original database in +** rollback mode while the *-oal file is being generated. +** +** During this stage RBU does not update the database by writing +** directly to the target tables. Instead it creates "imposter" +** tables using the SQLITE_TESTCTRL_IMPOSTER interface that it uses +** to update each b-tree individually. All updates required by each +** b-tree are completed before moving on to the next, and all +** updates are done in sorted key order. +** +** 2) The "-oal" file is moved to the equivalent "-wal" +** location using a call to rename(2). Before doing this the RBU +** module takes an EXCLUSIVE lock on the database file, ensuring +** that there are no other active readers. +** +** Once the EXCLUSIVE lock is released, any other database readers +** detect the new *-wal file and read the database in wal mode. At +** this point they see the new version of the database - including +** the updates made as part of the RBU update. +** +** 3) The new *-wal file is checkpointed. This proceeds in the same way +** as a regular database checkpoint, except that a single frame is +** checkpointed each time sqlite3rbu_step() is called. If the RBU +** handle is closed before the entire *-wal file is checkpointed, +** the checkpoint progress is saved in the RBU database and the +** checkpoint can be resumed by another RBU client at some point in +** the future. +** +** POTENTIAL PROBLEMS +** +** The rename() call might not be portable. And RBU is not currently +** syncing the directory after renaming the file. +** +** When state is saved, any commit to the *-oal file and the commit to +** the RBU update database are not atomic. So if the power fails at the +** wrong moment they might get out of sync. As the main database will be +** committed before the RBU update database this will likely either just +** pass unnoticed, or result in SQLITE_CONSTRAINT errors (due to UNIQUE +** constraint violations). +** +** If some client does modify the target database mid RBU update, or some +** other error occurs, the RBU extension will keep throwing errors. It's +** not really clear how to get out of this state. The system could just +** by delete the RBU update database and *-oal file and have the device +** download the update again and start over. +** +** At present, for an UPDATE, both the new.* and old.* records are +** collected in the rbu_xyz table. And for both UPDATEs and DELETEs all +** fields are collected. This means we're probably writing a lot more +** data to disk when saving the state of an ongoing update to the RBU +** update database than is strictly necessary. +** +*/ + +/* #include */ +/* #include */ +/* #include */ + +/* #include "sqlite3.h" */ + +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU) +/************** Include sqlite3rbu.h in the middle of sqlite3rbu.c ***********/ +/************** Begin file sqlite3rbu.h **************************************/ +/* +** 2014 August 30 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains the public interface for the RBU extension. +*/ + +/* +** SUMMARY +** +** Writing a transaction containing a large number of operations on +** b-tree indexes that are collectively larger than the available cache +** memory can be very inefficient. +** +** The problem is that in order to update a b-tree, the leaf page (at least) +** containing the entry being inserted or deleted must be modified. If the +** working set of leaves is larger than the available cache memory, then a +** single leaf that is modified more than once as part of the transaction +** may be loaded from or written to the persistent media multiple times. +** Additionally, because the index updates are likely to be applied in +** random order, access to pages within the database is also likely to be in +** random order, which is itself quite inefficient. +** +** One way to improve the situation is to sort the operations on each index +** by index key before applying them to the b-tree. This leads to an IO +** pattern that resembles a single linear scan through the index b-tree, +** and all but guarantees each modified leaf page is loaded and stored +** exactly once. SQLite uses this trick to improve the performance of +** CREATE INDEX commands. This extension allows it to be used to improve +** the performance of large transactions on existing databases. +** +** Additionally, this extension allows the work involved in writing the +** large transaction to be broken down into sub-transactions performed +** sequentially by separate processes. This is useful if the system cannot +** guarantee that a single update process will run for long enough to apply +** the entire update, for example because the update is being applied on a +** mobile device that is frequently rebooted. Even after the writer process +** has committed one or more sub-transactions, other database clients continue +** to read from the original database snapshot. In other words, partially +** applied transactions are not visible to other clients. +** +** "RBU" stands for "Resumable Bulk Update". As in a large database update +** transmitted via a wireless network to a mobile device. A transaction +** applied using this extension is hence refered to as an "RBU update". +** +** +** LIMITATIONS +** +** An "RBU update" transaction is subject to the following limitations: +** +** * The transaction must consist of INSERT, UPDATE and DELETE operations +** only. +** +** * INSERT statements may not use any default values. +** +** * UPDATE and DELETE statements must identify their target rows by +** non-NULL PRIMARY KEY values. Rows with NULL values stored in PRIMARY +** KEY fields may not be updated or deleted. If the table being written +** has no PRIMARY KEY, affected rows must be identified by rowid. +** +** * UPDATE statements may not modify PRIMARY KEY columns. +** +** * No triggers will be fired. +** +** * No foreign key violations are detected or reported. +** +** * CHECK constraints are not enforced. +** +** * No constraint handling mode except for "OR ROLLBACK" is supported. +** +** +** PREPARATION +** +** An "RBU update" is stored as a separate SQLite database. A database +** containing an RBU update is an "RBU database". For each table in the +** target database to be updated, the RBU database should contain a table +** named "data_" containing the same set of columns as the +** target table, and one more - "rbu_control". The data_% table should +** have no PRIMARY KEY or UNIQUE constraints, but each column should have +** the same type as the corresponding column in the target database. +** The "rbu_control" column should have no type at all. For example, if +** the target database contains: +** +** CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c UNIQUE); +** +** Then the RBU database should contain: +** +** CREATE TABLE data_t1(a INTEGER, b TEXT, c, rbu_control); +** +** The order of the columns in the data_% table does not matter. +** +** Instead of a regular table, the RBU database may also contain virtual +** tables or view named using the data_ naming scheme. +** +** Instead of the plain data_ naming scheme, RBU database tables +** may also be named data_, where is any sequence +** of zero or more numeric characters (0-9). This can be significant because +** tables within the RBU database are always processed in order sorted by +** name. By judicious selection of the portion of the names +** of the RBU tables the user can therefore control the order in which they +** are processed. This can be useful, for example, to ensure that "external +** content" FTS4 tables are updated before their underlying content tables. +** +** If the target database table is a virtual table or a table that has no +** PRIMARY KEY declaration, the data_% table must also contain a column +** named "rbu_rowid". This column is mapped to the tables implicit primary +** key column - "rowid". Virtual tables for which the "rowid" column does +** not function like a primary key value cannot be updated using RBU. For +** example, if the target db contains either of the following: +** +** CREATE VIRTUAL TABLE x1 USING fts3(a, b); +** CREATE TABLE x1(a, b) +** +** then the RBU database should contain: +** +** CREATE TABLE data_x1(a, b, rbu_rowid, rbu_control); +** +** All non-hidden columns (i.e. all columns matched by "SELECT *") of the +** target table must be present in the input table. For virtual tables, +** hidden columns are optional - they are updated by RBU if present in +** the input table, or not otherwise. For example, to write to an fts4 +** table with a hidden languageid column such as: +** +** CREATE VIRTUAL TABLE ft1 USING fts4(a, b, languageid='langid'); +** +** Either of the following input table schemas may be used: +** +** CREATE TABLE data_ft1(a, b, langid, rbu_rowid, rbu_control); +** CREATE TABLE data_ft1(a, b, rbu_rowid, rbu_control); +** +** For each row to INSERT into the target database as part of the RBU +** update, the corresponding data_% table should contain a single record +** with the "rbu_control" column set to contain integer value 0. The +** other columns should be set to the values that make up the new record +** to insert. +** +** If the target database table has an INTEGER PRIMARY KEY, it is not +** possible to insert a NULL value into the IPK column. Attempting to +** do so results in an SQLITE_MISMATCH error. +** +** For each row to DELETE from the target database as part of the RBU +** update, the corresponding data_% table should contain a single record +** with the "rbu_control" column set to contain integer value 1. The +** real primary key values of the row to delete should be stored in the +** corresponding columns of the data_% table. The values stored in the +** other columns are not used. +** +** For each row to UPDATE from the target database as part of the RBU +** update, the corresponding data_% table should contain a single record +** with the "rbu_control" column set to contain a value of type text. +** The real primary key values identifying the row to update should be +** stored in the corresponding columns of the data_% table row, as should +** the new values of all columns being update. The text value in the +** "rbu_control" column must contain the same number of characters as +** there are columns in the target database table, and must consist entirely +** of 'x' and '.' characters (or in some special cases 'd' - see below). For +** each column that is being updated, the corresponding character is set to +** 'x'. For those that remain as they are, the corresponding character of the +** rbu_control value should be set to '.'. For example, given the tables +** above, the update statement: +** +** UPDATE t1 SET c = 'usa' WHERE a = 4; +** +** is represented by the data_t1 row created by: +** +** INSERT INTO data_t1(a, b, c, rbu_control) VALUES(4, NULL, 'usa', '..x'); +** +** Instead of an 'x' character, characters of the rbu_control value specified +** for UPDATEs may also be set to 'd'. In this case, instead of updating the +** target table with the value stored in the corresponding data_% column, the +** user-defined SQL function "rbu_delta()" is invoked and the result stored in +** the target table column. rbu_delta() is invoked with two arguments - the +** original value currently stored in the target table column and the +** value specified in the data_xxx table. +** +** For example, this row: +** +** INSERT INTO data_t1(a, b, c, rbu_control) VALUES(4, NULL, 'usa', '..d'); +** +** is similar to an UPDATE statement such as: +** +** UPDATE t1 SET c = rbu_delta(c, 'usa') WHERE a = 4; +** +** Finally, if an 'f' character appears in place of a 'd' or 's' in an +** ota_control string, the contents of the data_xxx table column is assumed +** to be a "fossil delta" - a patch to be applied to a blob value in the +** format used by the fossil source-code management system. In this case +** the existing value within the target database table must be of type BLOB. +** It is replaced by the result of applying the specified fossil delta to +** itself. +** +** If the target database table is a virtual table or a table with no PRIMARY +** KEY, the rbu_control value should not include a character corresponding +** to the rbu_rowid value. For example, this: +** +** INSERT INTO data_ft1(a, b, rbu_rowid, rbu_control) +** VALUES(NULL, 'usa', 12, '.x'); +** +** causes a result similar to: +** +** UPDATE ft1 SET b = 'usa' WHERE rowid = 12; +** +** The data_xxx tables themselves should have no PRIMARY KEY declarations. +** However, RBU is more efficient if reading the rows in from each data_xxx +** table in "rowid" order is roughly the same as reading them sorted by +** the PRIMARY KEY of the corresponding target database table. In other +** words, rows should be sorted using the destination table PRIMARY KEY +** fields before they are inserted into the data_xxx tables. +** +** USAGE +** +** The API declared below allows an application to apply an RBU update +** stored on disk to an existing target database. Essentially, the +** application: +** +** 1) Opens an RBU handle using the sqlite3rbu_open() function. +** +** 2) Registers any required virtual table modules with the database +** handle returned by sqlite3rbu_db(). Also, if required, register +** the rbu_delta() implementation. +** +** 3) Calls the sqlite3rbu_step() function one or more times on +** the new handle. Each call to sqlite3rbu_step() performs a single +** b-tree operation, so thousands of calls may be required to apply +** a complete update. +** +** 4) Calls sqlite3rbu_close() to close the RBU update handle. If +** sqlite3rbu_step() has been called enough times to completely +** apply the update to the target database, then the RBU database +** is marked as fully applied. Otherwise, the state of the RBU +** update application is saved in the RBU database for later +** resumption. +** +** See comments below for more detail on APIs. +** +** If an update is only partially applied to the target database by the +** time sqlite3rbu_close() is called, various state information is saved +** within the RBU database. This allows subsequent processes to automatically +** resume the RBU update from where it left off. +** +** To remove all RBU extension state information, returning an RBU database +** to its original contents, it is sufficient to drop all tables that begin +** with the prefix "rbu_" +** +** DATABASE LOCKING +** +** An RBU update may not be applied to a database in WAL mode. Attempting +** to do so is an error (SQLITE_ERROR). +** +** While an RBU handle is open, a SHARED lock may be held on the target +** database file. This means it is possible for other clients to read the +** database, but not to write it. +** +** If an RBU update is started and then suspended before it is completed, +** then an external client writes to the database, then attempting to resume +** the suspended RBU update is also an error (SQLITE_BUSY). +*/ + +#ifndef _SQLITE3RBU_H +#define _SQLITE3RBU_H + +/* #include "sqlite3.h" ** Required for error code definitions ** */ + +#if 0 +extern "C" { +#endif + +typedef struct sqlite3rbu sqlite3rbu; + +/* +** Open an RBU handle. +** +** Argument zTarget is the path to the target database. Argument zRbu is +** the path to the RBU database. Each call to this function must be matched +** by a call to sqlite3rbu_close(). When opening the databases, RBU passes +** the SQLITE_CONFIG_URI flag to sqlite3_open_v2(). So if either zTarget +** or zRbu begin with "file:", it will be interpreted as an SQLite +** database URI, not a regular file name. +** +** If the zState argument is passed a NULL value, the RBU extension stores +** the current state of the update (how many rows have been updated, which +** indexes are yet to be updated etc.) within the RBU database itself. This +** can be convenient, as it means that the RBU application does not need to +** organize removing a separate state file after the update is concluded. +** Or, if zState is non-NULL, it must be a path to a database file in which +** the RBU extension can store the state of the update. +** +** When resuming an RBU update, the zState argument must be passed the same +** value as when the RBU update was started. +** +** Once the RBU update is finished, the RBU extension does not +** automatically remove any zState database file, even if it created it. +** +** By default, RBU uses the default VFS to access the files on disk. To +** use a VFS other than the default, an SQLite "file:" URI containing a +** "vfs=..." option may be passed as the zTarget option. +** +** IMPORTANT NOTE FOR ZIPVFS USERS: The RBU extension works with all of +** SQLite's built-in VFSs, including the multiplexor VFS. However it does +** not work out of the box with zipvfs. Refer to the comment describing +** the zipvfs_create_vfs() API below for details on using RBU with zipvfs. +*/ +SQLITE_API sqlite3rbu *sqlite3rbu_open( + const char *zTarget, + const char *zRbu, + const char *zState +); + +/* +** Open an RBU handle to perform an RBU vacuum on database file zTarget. +** An RBU vacuum is similar to SQLite's built-in VACUUM command, except +** that it can be suspended and resumed like an RBU update. +** +** The second argument to this function identifies a database in which +** to store the state of the RBU vacuum operation if it is suspended. The +** first time sqlite3rbu_vacuum() is called, to start an RBU vacuum +** operation, the state database should either not exist or be empty +** (contain no tables). If an RBU vacuum is suspended by calling +** sqlite3rbu_close() on the RBU handle before sqlite3rbu_step() has +** returned SQLITE_DONE, the vacuum state is stored in the state database. +** The vacuum can be resumed by calling this function to open a new RBU +** handle specifying the same target and state databases. +** +** If the second argument passed to this function is NULL, then the +** name of the state database is "-vacuum", where +** is the name of the target database file. In this case, on UNIX, if the +** state database is not already present in the file-system, it is created +** with the same permissions as the target db is made. +** +** With an RBU vacuum, it is an SQLITE_MISUSE error if the name of the +** state database ends with "-vactmp". This name is reserved for internal +** use. +** +** This function does not delete the state database after an RBU vacuum +** is completed, even if it created it. However, if the call to +** sqlite3rbu_close() returns any value other than SQLITE_OK, the contents +** of the state tables within the state database are zeroed. This way, +** the next call to sqlite3rbu_vacuum() opens a handle that starts a +** new RBU vacuum operation. +** +** As with sqlite3rbu_open(), Zipvfs users should rever to the comment +** describing the sqlite3rbu_create_vfs() API function below for +** a description of the complications associated with using RBU with +** zipvfs databases. +*/ +SQLITE_API sqlite3rbu *sqlite3rbu_vacuum( + const char *zTarget, + const char *zState +); + +/* +** Configure a limit for the amount of temp space that may be used by +** the RBU handle passed as the first argument. The new limit is specified +** in bytes by the second parameter. If it is positive, the limit is updated. +** If the second parameter to this function is passed zero, then the limit +** is removed entirely. If the second parameter is negative, the limit is +** not modified (this is useful for querying the current limit). +** +** In all cases the returned value is the current limit in bytes (zero +** indicates unlimited). +** +** If the temp space limit is exceeded during operation, an SQLITE_FULL +** error is returned. +*/ +SQLITE_API sqlite3_int64 sqlite3rbu_temp_size_limit(sqlite3rbu*, sqlite3_int64); + +/* +** Return the current amount of temp file space, in bytes, currently used by +** the RBU handle passed as the only argument. +*/ +SQLITE_API sqlite3_int64 sqlite3rbu_temp_size(sqlite3rbu*); + +/* +** Internally, each RBU connection uses a separate SQLite database +** connection to access the target and rbu update databases. This +** API allows the application direct access to these database handles. +** +** The first argument passed to this function must be a valid, open, RBU +** handle. The second argument should be passed zero to access the target +** database handle, or non-zero to access the rbu update database handle. +** Accessing the underlying database handles may be useful in the +** following scenarios: +** +** * If any target tables are virtual tables, it may be necessary to +** call sqlite3_create_module() on the target database handle to +** register the required virtual table implementations. +** +** * If the data_xxx tables in the RBU source database are virtual +** tables, the application may need to call sqlite3_create_module() on +** the rbu update db handle to any required virtual table +** implementations. +** +** * If the application uses the "rbu_delta()" feature described above, +** it must use sqlite3_create_function() or similar to register the +** rbu_delta() implementation with the target database handle. +** +** If an error has occurred, either while opening or stepping the RBU object, +** this function may return NULL. The error code and message may be collected +** when sqlite3rbu_close() is called. +** +** Database handles returned by this function remain valid until the next +** call to any sqlite3rbu_xxx() function other than sqlite3rbu_db(). +*/ +SQLITE_API sqlite3 *sqlite3rbu_db(sqlite3rbu*, int bRbu); + +/* +** Do some work towards applying the RBU update to the target db. +** +** Return SQLITE_DONE if the update has been completely applied, or +** SQLITE_OK if no error occurs but there remains work to do to apply +** the RBU update. If an error does occur, some other error code is +** returned. +** +** Once a call to sqlite3rbu_step() has returned a value other than +** SQLITE_OK, all subsequent calls on the same RBU handle are no-ops +** that immediately return the same value. +*/ +SQLITE_API int sqlite3rbu_step(sqlite3rbu *pRbu); + +/* +** Force RBU to save its state to disk. +** +** If a power failure or application crash occurs during an update, following +** system recovery RBU may resume the update from the point at which the state +** was last saved. In other words, from the most recent successful call to +** sqlite3rbu_close() or this function. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +SQLITE_API int sqlite3rbu_savestate(sqlite3rbu *pRbu); + +/* +** Close an RBU handle. +** +** If the RBU update has been completely applied, mark the RBU database +** as fully applied. Otherwise, assuming no error has occurred, save the +** current state of the RBU update appliation to the RBU database. +** +** If an error has already occurred as part of an sqlite3rbu_step() +** or sqlite3rbu_open() call, or if one occurs within this function, an +** SQLite error code is returned. Additionally, if pzErrmsg is not NULL, +** *pzErrmsg may be set to point to a buffer containing a utf-8 formatted +** English language error message. It is the responsibility of the caller to +** eventually free any such buffer using sqlite3_free(). +** +** Otherwise, if no error occurs, this function returns SQLITE_OK if the +** update has been partially applied, or SQLITE_DONE if it has been +** completely applied. +*/ +SQLITE_API int sqlite3rbu_close(sqlite3rbu *pRbu, char **pzErrmsg); + +/* +** Return the total number of key-value operations (inserts, deletes or +** updates) that have been performed on the target database since the +** current RBU update was started. +*/ +SQLITE_API sqlite3_int64 sqlite3rbu_progress(sqlite3rbu *pRbu); + +/* +** Obtain permyriadage (permyriadage is to 10000 as percentage is to 100) +** progress indications for the two stages of an RBU update. This API may +** be useful for driving GUI progress indicators and similar. +** +** An RBU update is divided into two stages: +** +** * Stage 1, in which changes are accumulated in an oal/wal file, and +** * Stage 2, in which the contents of the wal file are copied into the +** main database. +** +** The update is visible to non-RBU clients during stage 2. During stage 1 +** non-RBU reader clients may see the original database. +** +** If this API is called during stage 2 of the update, output variable +** (*pnOne) is set to 10000 to indicate that stage 1 has finished and (*pnTwo) +** to a value between 0 and 10000 to indicate the permyriadage progress of +** stage 2. A value of 5000 indicates that stage 2 is half finished, +** 9000 indicates that it is 90% finished, and so on. +** +** If this API is called during stage 1 of the update, output variable +** (*pnTwo) is set to 0 to indicate that stage 2 has not yet started. The +** value to which (*pnOne) is set depends on whether or not the RBU +** database contains an "rbu_count" table. The rbu_count table, if it +** exists, must contain the same columns as the following: +** +** CREATE TABLE rbu_count(tbl TEXT PRIMARY KEY, cnt INTEGER) WITHOUT ROWID; +** +** There must be one row in the table for each source (data_xxx) table within +** the RBU database. The 'tbl' column should contain the name of the source +** table. The 'cnt' column should contain the number of rows within the +** source table. +** +** If the rbu_count table is present and populated correctly and this +** API is called during stage 1, the *pnOne output variable is set to the +** permyriadage progress of the same stage. If the rbu_count table does +** not exist, then (*pnOne) is set to -1 during stage 1. If the rbu_count +** table exists but is not correctly populated, the value of the *pnOne +** output variable during stage 1 is undefined. +*/ +SQLITE_API void sqlite3rbu_bp_progress(sqlite3rbu *pRbu, int *pnOne, int*pnTwo); + +/* +** Obtain an indication as to the current stage of an RBU update or vacuum. +** This function always returns one of the SQLITE_RBU_STATE_XXX constants +** defined in this file. Return values should be interpreted as follows: +** +** SQLITE_RBU_STATE_OAL: +** RBU is currently building a *-oal file. The next call to sqlite3rbu_step() +** may either add further data to the *-oal file, or compute data that will +** be added by a subsequent call. +** +** SQLITE_RBU_STATE_MOVE: +** RBU has finished building the *-oal file. The next call to sqlite3rbu_step() +** will move the *-oal file to the equivalent *-wal path. If the current +** operation is an RBU update, then the updated version of the database +** file will become visible to ordinary SQLite clients following the next +** call to sqlite3rbu_step(). +** +** SQLITE_RBU_STATE_CHECKPOINT: +** RBU is currently performing an incremental checkpoint. The next call to +** sqlite3rbu_step() will copy a page of data from the *-wal file into +** the target database file. +** +** SQLITE_RBU_STATE_DONE: +** The RBU operation has finished. Any subsequent calls to sqlite3rbu_step() +** will immediately return SQLITE_DONE. +** +** SQLITE_RBU_STATE_ERROR: +** An error has occurred. Any subsequent calls to sqlite3rbu_step() will +** immediately return the SQLite error code associated with the error. +*/ +#define SQLITE_RBU_STATE_OAL 1 +#define SQLITE_RBU_STATE_MOVE 2 +#define SQLITE_RBU_STATE_CHECKPOINT 3 +#define SQLITE_RBU_STATE_DONE 4 +#define SQLITE_RBU_STATE_ERROR 5 + +SQLITE_API int sqlite3rbu_state(sqlite3rbu *pRbu); + +/* +** Create an RBU VFS named zName that accesses the underlying file-system +** via existing VFS zParent. Or, if the zParent parameter is passed NULL, +** then the new RBU VFS uses the default system VFS to access the file-system. +** The new object is registered as a non-default VFS with SQLite before +** returning. +** +** Part of the RBU implementation uses a custom VFS object. Usually, this +** object is created and deleted automatically by RBU. +** +** The exception is for applications that also use zipvfs. In this case, +** the custom VFS must be explicitly created by the user before the RBU +** handle is opened. The RBU VFS should be installed so that the zipvfs +** VFS uses the RBU VFS, which in turn uses any other VFS layers in use +** (for example multiplexor) to access the file-system. For example, +** to assemble an RBU enabled VFS stack that uses both zipvfs and +** multiplexor (error checking omitted): +** +** // Create a VFS named "multiplex" (not the default). +** sqlite3_multiplex_initialize(0, 0); +** +** // Create an rbu VFS named "rbu" that uses multiplexor. If the +** // second argument were replaced with NULL, the "rbu" VFS would +** // access the file-system via the system default VFS, bypassing the +** // multiplexor. +** sqlite3rbu_create_vfs("rbu", "multiplex"); +** +** // Create a zipvfs VFS named "zipvfs" that uses rbu. +** zipvfs_create_vfs_v3("zipvfs", "rbu", 0, xCompressorAlgorithmDetector); +** +** // Make zipvfs the default VFS. +** sqlite3_vfs_register(sqlite3_vfs_find("zipvfs"), 1); +** +** Because the default VFS created above includes a RBU functionality, it +** may be used by RBU clients. Attempting to use RBU with a zipvfs VFS stack +** that does not include the RBU layer results in an error. +** +** The overhead of adding the "rbu" VFS to the system is negligible for +** non-RBU users. There is no harm in an application accessing the +** file-system via "rbu" all the time, even if it only uses RBU functionality +** occasionally. +*/ +SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent); + +/* +** Deregister and destroy an RBU vfs created by an earlier call to +** sqlite3rbu_create_vfs(). +** +** VFS objects are not reference counted. If a VFS object is destroyed +** before all database handles that use it have been closed, the results +** are undefined. +*/ +SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName); + +#if 0 +} /* end of the 'extern "C"' block */ +#endif + +#endif /* _SQLITE3RBU_H */ + +/************** End of sqlite3rbu.h ******************************************/ +/************** Continuing where we left off in sqlite3rbu.c *****************/ + +#if defined(_WIN32_WCE) +/* #include "windows.h" */ +#endif + +/* Maximum number of prepared UPDATE statements held by this module */ +#define SQLITE_RBU_UPDATE_CACHESIZE 16 + +/* Delta checksums disabled by default. Compile with -DRBU_ENABLE_DELTA_CKSUM +** to enable checksum verification. +*/ +#ifndef RBU_ENABLE_DELTA_CKSUM +# define RBU_ENABLE_DELTA_CKSUM 0 +#endif + +/* +** Swap two objects of type TYPE. +*/ +#if !defined(SQLITE_AMALGAMATION) +# define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;} +#endif + +/* +** The rbu_state table is used to save the state of a partially applied +** update so that it can be resumed later. The table consists of integer +** keys mapped to values as follows: +** +** RBU_STATE_STAGE: +** May be set to integer values 1, 2, 4 or 5. As follows: +** 1: the *-rbu file is currently under construction. +** 2: the *-rbu file has been constructed, but not yet moved +** to the *-wal path. +** 4: the checkpoint is underway. +** 5: the rbu update has been checkpointed. +** +** RBU_STATE_TBL: +** Only valid if STAGE==1. The target database name of the table +** currently being written. +** +** RBU_STATE_IDX: +** Only valid if STAGE==1. The target database name of the index +** currently being written, or NULL if the main table is currently being +** updated. +** +** RBU_STATE_ROW: +** Only valid if STAGE==1. Number of rows already processed for the current +** table/index. +** +** RBU_STATE_PROGRESS: +** Trbul number of sqlite3rbu_step() calls made so far as part of this +** rbu update. +** +** RBU_STATE_CKPT: +** Valid if STAGE==4. The 64-bit checksum associated with the wal-index +** header created by recovering the *-wal file. This is used to detect +** cases when another client appends frames to the *-wal file in the +** middle of an incremental checkpoint (an incremental checkpoint cannot +** be continued if this happens). +** +** RBU_STATE_COOKIE: +** Valid if STAGE==1. The current change-counter cookie value in the +** target db file. +** +** RBU_STATE_OALSZ: +** Valid if STAGE==1. The size in bytes of the *-oal file. +** +** RBU_STATE_DATATBL: +** Only valid if STAGE==1. The RBU database name of the table +** currently being read. +*/ +#define RBU_STATE_STAGE 1 +#define RBU_STATE_TBL 2 +#define RBU_STATE_IDX 3 +#define RBU_STATE_ROW 4 +#define RBU_STATE_PROGRESS 5 +#define RBU_STATE_CKPT 6 +#define RBU_STATE_COOKIE 7 +#define RBU_STATE_OALSZ 8 +#define RBU_STATE_PHASEONESTEP 9 +#define RBU_STATE_DATATBL 10 + +#define RBU_STAGE_OAL 1 +#define RBU_STAGE_MOVE 2 +#define RBU_STAGE_CAPTURE 3 +#define RBU_STAGE_CKPT 4 +#define RBU_STAGE_DONE 5 + + +#define RBU_CREATE_STATE \ + "CREATE TABLE IF NOT EXISTS %s.rbu_state(k INTEGER PRIMARY KEY, v)" + +typedef struct RbuFrame RbuFrame; +typedef struct RbuObjIter RbuObjIter; +typedef struct RbuState RbuState; +typedef struct RbuSpan RbuSpan; +typedef struct rbu_vfs rbu_vfs; +typedef struct rbu_file rbu_file; +typedef struct RbuUpdateStmt RbuUpdateStmt; + +#if !defined(SQLITE_AMALGAMATION) +typedef unsigned int u32; +typedef unsigned short u16; +typedef unsigned char u8; +typedef sqlite3_int64 i64; +#endif + +/* +** These values must match the values defined in wal.c for the equivalent +** locks. These are not magic numbers as they are part of the SQLite file +** format. +*/ +#define WAL_LOCK_WRITE 0 +#define WAL_LOCK_CKPT 1 +#define WAL_LOCK_READ0 3 + +#define SQLITE_FCNTL_RBUCNT 5149216 + +/* +** A structure to store values read from the rbu_state table in memory. +*/ +struct RbuState { + int eStage; + char *zTbl; + char *zDataTbl; + char *zIdx; + i64 iWalCksum; + int nRow; + i64 nProgress; + u32 iCookie; + i64 iOalSz; + i64 nPhaseOneStep; +}; + +struct RbuUpdateStmt { + char *zMask; /* Copy of update mask used with pUpdate */ + sqlite3_stmt *pUpdate; /* Last update statement (or NULL) */ + RbuUpdateStmt *pNext; +}; + +struct RbuSpan { + const char *zSpan; + int nSpan; +}; + +/* +** An iterator of this type is used to iterate through all objects in +** the target database that require updating. For each such table, the +** iterator visits, in order: +** +** * the table itself, +** * each index of the table (zero or more points to visit), and +** * a special "cleanup table" state. +** +** abIndexed: +** If the table has no indexes on it, abIndexed is set to NULL. Otherwise, +** it points to an array of flags nTblCol elements in size. The flag is +** set for each column that is either a part of the PK or a part of an +** index. Or clear otherwise. +** +** If there are one or more partial indexes on the table, all fields of +** this array set set to 1. This is because in that case, the module has +** no way to tell which fields will be required to add and remove entries +** from the partial indexes. +** +*/ +struct RbuObjIter { + sqlite3_stmt *pTblIter; /* Iterate through tables */ + sqlite3_stmt *pIdxIter; /* Index iterator */ + int nTblCol; /* Size of azTblCol[] array */ + char **azTblCol; /* Array of unquoted target column names */ + char **azTblType; /* Array of target column types */ + int *aiSrcOrder; /* src table col -> target table col */ + u8 *abTblPk; /* Array of flags, set on target PK columns */ + u8 *abNotNull; /* Array of flags, set on NOT NULL columns */ + u8 *abIndexed; /* Array of flags, set on indexed & PK cols */ + int eType; /* Table type - an RBU_PK_XXX value */ + + /* Output variables. zTbl==0 implies EOF. */ + int bCleanup; /* True in "cleanup" state */ + const char *zTbl; /* Name of target db table */ + const char *zDataTbl; /* Name of rbu db table (or null) */ + const char *zIdx; /* Name of target db index (or null) */ + int iTnum; /* Root page of current object */ + int iPkTnum; /* If eType==EXTERNAL, root of PK index */ + int bUnique; /* Current index is unique */ + int nIndex; /* Number of aux. indexes on table zTbl */ + + /* Statements created by rbuObjIterPrepareAll() */ + int nCol; /* Number of columns in current object */ + sqlite3_stmt *pSelect; /* Source data */ + sqlite3_stmt *pInsert; /* Statement for INSERT operations */ + sqlite3_stmt *pDelete; /* Statement for DELETE ops */ + sqlite3_stmt *pTmpInsert; /* Insert into rbu_tmp_$zDataTbl */ + int nIdxCol; + RbuSpan *aIdxCol; + char *zIdxSql; + + /* Last UPDATE used (for PK b-tree updates only), or NULL. */ + RbuUpdateStmt *pRbuUpdate; +}; + +/* +** Values for RbuObjIter.eType +** +** 0: Table does not exist (error) +** 1: Table has an implicit rowid. +** 2: Table has an explicit IPK column. +** 3: Table has an external PK index. +** 4: Table is WITHOUT ROWID. +** 5: Table is a virtual table. +*/ +#define RBU_PK_NOTABLE 0 +#define RBU_PK_NONE 1 +#define RBU_PK_IPK 2 +#define RBU_PK_EXTERNAL 3 +#define RBU_PK_WITHOUT_ROWID 4 +#define RBU_PK_VTAB 5 + + +/* +** Within the RBU_STAGE_OAL stage, each call to sqlite3rbu_step() performs +** one of the following operations. +*/ +#define RBU_INSERT 1 /* Insert on a main table b-tree */ +#define RBU_DELETE 2 /* Delete a row from a main table b-tree */ +#define RBU_REPLACE 3 /* Delete and then insert a row */ +#define RBU_IDX_DELETE 4 /* Delete a row from an aux. index b-tree */ +#define RBU_IDX_INSERT 5 /* Insert on an aux. index b-tree */ + +#define RBU_UPDATE 6 /* Update a row in a main table b-tree */ + +/* +** A single step of an incremental checkpoint - frame iWalFrame of the wal +** file should be copied to page iDbPage of the database file. +*/ +struct RbuFrame { + u32 iDbPage; + u32 iWalFrame; +}; + +/* +** RBU handle. +** +** nPhaseOneStep: +** If the RBU database contains an rbu_count table, this value is set to +** a running estimate of the number of b-tree operations required to +** finish populating the *-oal file. This allows the sqlite3_bp_progress() +** API to calculate the permyriadage progress of populating the *-oal file +** using the formula: +** +** permyriadage = (10000 * nProgress) / nPhaseOneStep +** +** nPhaseOneStep is initialized to the sum of: +** +** nRow * (nIndex + 1) +** +** for all source tables in the RBU database, where nRow is the number +** of rows in the source table and nIndex the number of indexes on the +** corresponding target database table. +** +** This estimate is accurate if the RBU update consists entirely of +** INSERT operations. However, it is inaccurate if: +** +** * the RBU update contains any UPDATE operations. If the PK specified +** for an UPDATE operation does not exist in the target table, then +** no b-tree operations are required on index b-trees. Or if the +** specified PK does exist, then (nIndex*2) such operations are +** required (one delete and one insert on each index b-tree). +** +** * the RBU update contains any DELETE operations for which the specified +** PK does not exist. In this case no operations are required on index +** b-trees. +** +** * the RBU update contains REPLACE operations. These are similar to +** UPDATE operations. +** +** nPhaseOneStep is updated to account for the conditions above during the +** first pass of each source table. The updated nPhaseOneStep value is +** stored in the rbu_state table if the RBU update is suspended. +*/ +struct sqlite3rbu { + int eStage; /* Value of RBU_STATE_STAGE field */ + sqlite3 *dbMain; /* target database handle */ + sqlite3 *dbRbu; /* rbu database handle */ + char *zTarget; /* Path to target db */ + char *zRbu; /* Path to rbu db */ + char *zState; /* Path to state db (or NULL if zRbu) */ + char zStateDb[5]; /* Db name for state ("stat" or "main") */ + int rc; /* Value returned by last rbu_step() call */ + char *zErrmsg; /* Error message if rc!=SQLITE_OK */ + int nStep; /* Rows processed for current object */ + int nProgress; /* Rows processed for all objects */ + RbuObjIter objiter; /* Iterator for skipping through tbl/idx */ + const char *zVfsName; /* Name of automatically created rbu vfs */ + rbu_file *pTargetFd; /* File handle open on target db */ + int nPagePerSector; /* Pages per sector for pTargetFd */ + i64 iOalSz; + i64 nPhaseOneStep; + + /* The following state variables are used as part of the incremental + ** checkpoint stage (eStage==RBU_STAGE_CKPT). See comments surrounding + ** function rbuSetupCheckpoint() for details. */ + u32 iMaxFrame; /* Largest iWalFrame value in aFrame[] */ + u32 mLock; + int nFrame; /* Entries in aFrame[] array */ + int nFrameAlloc; /* Allocated size of aFrame[] array */ + RbuFrame *aFrame; + int pgsz; + u8 *aBuf; + i64 iWalCksum; + i64 szTemp; /* Current size of all temp files in use */ + i64 szTempLimit; /* Total size limit for temp files */ + + /* Used in RBU vacuum mode only */ + int nRbu; /* Number of RBU VFS in the stack */ + rbu_file *pRbuFd; /* Fd for main db of dbRbu */ +}; + +/* +** An rbu VFS is implemented using an instance of this structure. +** +** Variable pRbu is only non-NULL for automatically created RBU VFS objects. +** It is NULL for RBU VFS objects created explicitly using +** sqlite3rbu_create_vfs(). It is used to track the total amount of temp +** space used by the RBU handle. +*/ +struct rbu_vfs { + sqlite3_vfs base; /* rbu VFS shim methods */ + sqlite3_vfs *pRealVfs; /* Underlying VFS */ + sqlite3_mutex *mutex; /* Mutex to protect pMain */ + sqlite3rbu *pRbu; /* Owner RBU object */ + rbu_file *pMain; /* List of main db files */ + rbu_file *pMainRbu; /* List of main db files with pRbu!=0 */ +}; + +/* +** Each file opened by an rbu VFS is represented by an instance of +** the following structure. +** +** If this is a temporary file (pRbu!=0 && flags&DELETE_ON_CLOSE), variable +** "sz" is set to the current size of the database file. +*/ +struct rbu_file { + sqlite3_file base; /* sqlite3_file methods */ + sqlite3_file *pReal; /* Underlying file handle */ + rbu_vfs *pRbuVfs; /* Pointer to the rbu_vfs object */ + sqlite3rbu *pRbu; /* Pointer to rbu object (rbu target only) */ + i64 sz; /* Size of file in bytes (temp only) */ + + int openFlags; /* Flags this file was opened with */ + u32 iCookie; /* Cookie value for main db files */ + u8 iWriteVer; /* "write-version" value for main db files */ + u8 bNolock; /* True to fail EXCLUSIVE locks */ + + int nShm; /* Number of entries in apShm[] array */ + char **apShm; /* Array of mmap'd *-shm regions */ + char *zDel; /* Delete this when closing file */ + + const char *zWal; /* Wal filename for this main db file */ + rbu_file *pWalFd; /* Wal file descriptor for this main db */ + rbu_file *pMainNext; /* Next MAIN_DB file */ + rbu_file *pMainRbuNext; /* Next MAIN_DB file with pRbu!=0 */ +}; + +/* +** True for an RBU vacuum handle, or false otherwise. +*/ +#define rbuIsVacuum(p) ((p)->zTarget==0) + + +/************************************************************************* +** The following three functions, found below: +** +** rbuDeltaGetInt() +** rbuDeltaChecksum() +** rbuDeltaApply() +** +** are lifted from the fossil source code (http://fossil-scm.org). They +** are used to implement the scalar SQL function rbu_fossil_delta(). +*/ + +/* +** Read bytes from *pz and convert them into a positive integer. When +** finished, leave *pz pointing to the first character past the end of +** the integer. The *pLen parameter holds the length of the string +** in *pz and is decremented once for each character in the integer. +*/ +static unsigned int rbuDeltaGetInt(const char **pz, int *pLen){ + static const signed char zValue[] = { + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, + -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, 36, + -1, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, -1, -1, -1, 63, -1, + }; + unsigned int v = 0; + int c; + unsigned char *z = (unsigned char*)*pz; + unsigned char *zStart = z; + while( (c = zValue[0x7f&*(z++)])>=0 ){ + v = (v<<6) + c; + } + z--; + *pLen -= z - zStart; + *pz = (char*)z; + return v; +} + +#if RBU_ENABLE_DELTA_CKSUM +/* +** Compute a 32-bit checksum on the N-byte buffer. Return the result. +*/ +static unsigned int rbuDeltaChecksum(const char *zIn, size_t N){ + const unsigned char *z = (const unsigned char *)zIn; + unsigned sum0 = 0; + unsigned sum1 = 0; + unsigned sum2 = 0; + unsigned sum3 = 0; + while(N >= 16){ + sum0 += ((unsigned)z[0] + z[4] + z[8] + z[12]); + sum1 += ((unsigned)z[1] + z[5] + z[9] + z[13]); + sum2 += ((unsigned)z[2] + z[6] + z[10]+ z[14]); + sum3 += ((unsigned)z[3] + z[7] + z[11]+ z[15]); + z += 16; + N -= 16; + } + while(N >= 4){ + sum0 += z[0]; + sum1 += z[1]; + sum2 += z[2]; + sum3 += z[3]; + z += 4; + N -= 4; + } + sum3 += (sum2 << 8) + (sum1 << 16) + (sum0 << 24); + switch(N){ + case 3: sum3 += (z[2] << 8); + case 2: sum3 += (z[1] << 16); + case 1: sum3 += (z[0] << 24); + default: ; + } + return sum3; +} +#endif + +/* +** Apply a delta. +** +** The output buffer should be big enough to hold the whole output +** file and a NUL terminator at the end. The delta_output_size() +** routine will determine this size for you. +** +** The delta string should be null-terminated. But the delta string +** may contain embedded NUL characters (if the input and output are +** binary files) so we also have to pass in the length of the delta in +** the lenDelta parameter. +** +** This function returns the size of the output file in bytes (excluding +** the final NUL terminator character). Except, if the delta string is +** malformed or intended for use with a source file other than zSrc, +** then this routine returns -1. +** +** Refer to the delta_create() documentation above for a description +** of the delta file format. +*/ +static int rbuDeltaApply( + const char *zSrc, /* The source or pattern file */ + int lenSrc, /* Length of the source file */ + const char *zDelta, /* Delta to apply to the pattern */ + int lenDelta, /* Length of the delta */ + char *zOut /* Write the output into this preallocated buffer */ +){ + unsigned int limit; + unsigned int total = 0; +#if RBU_ENABLE_DELTA_CKSUM + char *zOrigOut = zOut; +#endif + + limit = rbuDeltaGetInt(&zDelta, &lenDelta); + if( *zDelta!='\n' ){ + /* ERROR: size integer not terminated by "\n" */ + return -1; + } + zDelta++; lenDelta--; + while( *zDelta && lenDelta>0 ){ + unsigned int cnt, ofst; + cnt = rbuDeltaGetInt(&zDelta, &lenDelta); + switch( zDelta[0] ){ + case '@': { + zDelta++; lenDelta--; + ofst = rbuDeltaGetInt(&zDelta, &lenDelta); + if( lenDelta>0 && zDelta[0]!=',' ){ + /* ERROR: copy command not terminated by ',' */ + return -1; + } + zDelta++; lenDelta--; + total += cnt; + if( total>limit ){ + /* ERROR: copy exceeds output file size */ + return -1; + } + if( (int)(ofst+cnt) > lenSrc ){ + /* ERROR: copy extends past end of input */ + return -1; + } + memcpy(zOut, &zSrc[ofst], cnt); + zOut += cnt; + break; + } + case ':': { + zDelta++; lenDelta--; + total += cnt; + if( total>limit ){ + /* ERROR: insert command gives an output larger than predicted */ + return -1; + } + if( (int)cnt>lenDelta ){ + /* ERROR: insert count exceeds size of delta */ + return -1; + } + memcpy(zOut, zDelta, cnt); + zOut += cnt; + zDelta += cnt; + lenDelta -= cnt; + break; + } + case ';': { + zDelta++; lenDelta--; + zOut[0] = 0; +#if RBU_ENABLE_DELTA_CKSUM + if( cnt!=rbuDeltaChecksum(zOrigOut, total) ){ + /* ERROR: bad checksum */ + return -1; + } +#endif + if( total!=limit ){ + /* ERROR: generated size does not match predicted size */ + return -1; + } + return total; + } + default: { + /* ERROR: unknown delta operator */ + return -1; + } + } + } + /* ERROR: unterminated delta */ + return -1; +} + +static int rbuDeltaOutputSize(const char *zDelta, int lenDelta){ + int size; + size = rbuDeltaGetInt(&zDelta, &lenDelta); + if( *zDelta!='\n' ){ + /* ERROR: size integer not terminated by "\n" */ + return -1; + } + return size; +} + +/* +** End of code taken from fossil. +*************************************************************************/ + +/* +** Implementation of SQL scalar function rbu_fossil_delta(). +** +** This function applies a fossil delta patch to a blob. Exactly two +** arguments must be passed to this function. The first is the blob to +** patch and the second the patch to apply. If no error occurs, this +** function returns the patched blob. +*/ +static void rbuFossilDeltaFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *aDelta; + int nDelta; + const char *aOrig; + int nOrig; + + int nOut; + int nOut2; + char *aOut; + + assert( argc==2 ); + + nOrig = sqlite3_value_bytes(argv[0]); + aOrig = (const char*)sqlite3_value_blob(argv[0]); + nDelta = sqlite3_value_bytes(argv[1]); + aDelta = (const char*)sqlite3_value_blob(argv[1]); + + /* Figure out the size of the output */ + nOut = rbuDeltaOutputSize(aDelta, nDelta); + if( nOut<0 ){ + sqlite3_result_error(context, "corrupt fossil delta", -1); + return; + } + + aOut = sqlite3_malloc(nOut+1); + if( aOut==0 ){ + sqlite3_result_error_nomem(context); + }else{ + nOut2 = rbuDeltaApply(aOrig, nOrig, aDelta, nDelta, aOut); + if( nOut2!=nOut ){ + sqlite3_free(aOut); + sqlite3_result_error(context, "corrupt fossil delta", -1); + }else{ + sqlite3_result_blob(context, aOut, nOut, sqlite3_free); + } + } +} + + +/* +** Prepare the SQL statement in buffer zSql against database handle db. +** If successful, set *ppStmt to point to the new statement and return +** SQLITE_OK. +** +** Otherwise, if an error does occur, set *ppStmt to NULL and return +** an SQLite error code. Additionally, set output variable *pzErrmsg to +** point to a buffer containing an error message. It is the responsibility +** of the caller to (eventually) free this buffer using sqlite3_free(). +*/ +static int prepareAndCollectError( + sqlite3 *db, + sqlite3_stmt **ppStmt, + char **pzErrmsg, + const char *zSql +){ + int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0); + if( rc!=SQLITE_OK ){ + *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + *ppStmt = 0; + } + return rc; +} + +/* +** Reset the SQL statement passed as the first argument. Return a copy +** of the value returned by sqlite3_reset(). +** +** If an error has occurred, then set *pzErrmsg to point to a buffer +** containing an error message. It is the responsibility of the caller +** to eventually free this buffer using sqlite3_free(). +*/ +static int resetAndCollectError(sqlite3_stmt *pStmt, char **pzErrmsg){ + int rc = sqlite3_reset(pStmt); + if( rc!=SQLITE_OK ){ + *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(sqlite3_db_handle(pStmt))); + } + return rc; +} + +/* +** Unless it is NULL, argument zSql points to a buffer allocated using +** sqlite3_malloc containing an SQL statement. This function prepares the SQL +** statement against database db and frees the buffer. If statement +** compilation is successful, *ppStmt is set to point to the new statement +** handle and SQLITE_OK is returned. +** +** Otherwise, if an error occurs, *ppStmt is set to NULL and an error code +** returned. In this case, *pzErrmsg may also be set to point to an error +** message. It is the responsibility of the caller to free this error message +** buffer using sqlite3_free(). +** +** If argument zSql is NULL, this function assumes that an OOM has occurred. +** In this case SQLITE_NOMEM is returned and *ppStmt set to NULL. +*/ +static int prepareFreeAndCollectError( + sqlite3 *db, + sqlite3_stmt **ppStmt, + char **pzErrmsg, + char *zSql +){ + int rc; + assert( *pzErrmsg==0 ); + if( zSql==0 ){ + rc = SQLITE_NOMEM; + *ppStmt = 0; + }else{ + rc = prepareAndCollectError(db, ppStmt, pzErrmsg, zSql); + sqlite3_free(zSql); + } + return rc; +} + +/* +** Free the RbuObjIter.azTblCol[] and RbuObjIter.abTblPk[] arrays allocated +** by an earlier call to rbuObjIterCacheTableInfo(). +*/ +static void rbuObjIterFreeCols(RbuObjIter *pIter){ + int i; + for(i=0; inTblCol; i++){ + sqlite3_free(pIter->azTblCol[i]); + sqlite3_free(pIter->azTblType[i]); + } + sqlite3_free(pIter->azTblCol); + pIter->azTblCol = 0; + pIter->azTblType = 0; + pIter->aiSrcOrder = 0; + pIter->abTblPk = 0; + pIter->abNotNull = 0; + pIter->nTblCol = 0; + pIter->eType = 0; /* Invalid value */ +} + +/* +** Finalize all statements and free all allocations that are specific to +** the current object (table/index pair). +*/ +static void rbuObjIterClearStatements(RbuObjIter *pIter){ + RbuUpdateStmt *pUp; + + sqlite3_finalize(pIter->pSelect); + sqlite3_finalize(pIter->pInsert); + sqlite3_finalize(pIter->pDelete); + sqlite3_finalize(pIter->pTmpInsert); + pUp = pIter->pRbuUpdate; + while( pUp ){ + RbuUpdateStmt *pTmp = pUp->pNext; + sqlite3_finalize(pUp->pUpdate); + sqlite3_free(pUp); + pUp = pTmp; + } + sqlite3_free(pIter->aIdxCol); + sqlite3_free(pIter->zIdxSql); + + pIter->pSelect = 0; + pIter->pInsert = 0; + pIter->pDelete = 0; + pIter->pRbuUpdate = 0; + pIter->pTmpInsert = 0; + pIter->nCol = 0; + pIter->nIdxCol = 0; + pIter->aIdxCol = 0; + pIter->zIdxSql = 0; +} + +/* +** Clean up any resources allocated as part of the iterator object passed +** as the only argument. +*/ +static void rbuObjIterFinalize(RbuObjIter *pIter){ + rbuObjIterClearStatements(pIter); + sqlite3_finalize(pIter->pTblIter); + sqlite3_finalize(pIter->pIdxIter); + rbuObjIterFreeCols(pIter); + memset(pIter, 0, sizeof(RbuObjIter)); +} + +/* +** Advance the iterator to the next position. +** +** If no error occurs, SQLITE_OK is returned and the iterator is left +** pointing to the next entry. Otherwise, an error code and message is +** left in the RBU handle passed as the first argument. A copy of the +** error code is returned. +*/ +static int rbuObjIterNext(sqlite3rbu *p, RbuObjIter *pIter){ + int rc = p->rc; + if( rc==SQLITE_OK ){ + + /* Free any SQLite statements used while processing the previous object */ + rbuObjIterClearStatements(pIter); + if( pIter->zIdx==0 ){ + rc = sqlite3_exec(p->dbMain, + "DROP TRIGGER IF EXISTS temp.rbu_insert_tr;" + "DROP TRIGGER IF EXISTS temp.rbu_update1_tr;" + "DROP TRIGGER IF EXISTS temp.rbu_update2_tr;" + "DROP TRIGGER IF EXISTS temp.rbu_delete_tr;" + , 0, 0, &p->zErrmsg + ); + } + + if( rc==SQLITE_OK ){ + if( pIter->bCleanup ){ + rbuObjIterFreeCols(pIter); + pIter->bCleanup = 0; + rc = sqlite3_step(pIter->pTblIter); + if( rc!=SQLITE_ROW ){ + rc = resetAndCollectError(pIter->pTblIter, &p->zErrmsg); + pIter->zTbl = 0; + }else{ + pIter->zTbl = (const char*)sqlite3_column_text(pIter->pTblIter, 0); + pIter->zDataTbl = (const char*)sqlite3_column_text(pIter->pTblIter,1); + rc = (pIter->zDataTbl && pIter->zTbl) ? SQLITE_OK : SQLITE_NOMEM; + } + }else{ + if( pIter->zIdx==0 ){ + sqlite3_stmt *pIdx = pIter->pIdxIter; + rc = sqlite3_bind_text(pIdx, 1, pIter->zTbl, -1, SQLITE_STATIC); + } + if( rc==SQLITE_OK ){ + rc = sqlite3_step(pIter->pIdxIter); + if( rc!=SQLITE_ROW ){ + rc = resetAndCollectError(pIter->pIdxIter, &p->zErrmsg); + pIter->bCleanup = 1; + pIter->zIdx = 0; + }else{ + pIter->zIdx = (const char*)sqlite3_column_text(pIter->pIdxIter, 0); + pIter->iTnum = sqlite3_column_int(pIter->pIdxIter, 1); + pIter->bUnique = sqlite3_column_int(pIter->pIdxIter, 2); + rc = pIter->zIdx ? SQLITE_OK : SQLITE_NOMEM; + } + } + } + } + } + + if( rc!=SQLITE_OK ){ + rbuObjIterFinalize(pIter); + p->rc = rc; + } + return rc; +} + + +/* +** The implementation of the rbu_target_name() SQL function. This function +** accepts one or two arguments. The first argument is the name of a table - +** the name of a table in the RBU database. The second, if it is present, is 1 +** for a view or 0 for a table. +** +** For a non-vacuum RBU handle, if the table name matches the pattern: +** +** data[0-9]_ +** +** where is any sequence of 1 or more characters, is returned. +** Otherwise, if the only argument does not match the above pattern, an SQL +** NULL is returned. +** +** "data_t1" -> "t1" +** "data0123_t2" -> "t2" +** "dataAB_t3" -> NULL +** +** For an rbu vacuum handle, a copy of the first argument is returned if +** the second argument is either missing or 0 (not a view). +*/ +static void rbuTargetNameFunc( + sqlite3_context *pCtx, + int argc, + sqlite3_value **argv +){ + sqlite3rbu *p = sqlite3_user_data(pCtx); + const char *zIn; + assert( argc==1 || argc==2 ); + + zIn = (const char*)sqlite3_value_text(argv[0]); + if( zIn ){ + if( rbuIsVacuum(p) ){ + assert( argc==2 || argc==1 ); + if( argc==1 || 0==sqlite3_value_int(argv[1]) ){ + sqlite3_result_text(pCtx, zIn, -1, SQLITE_STATIC); + } + }else{ + if( strlen(zIn)>4 && memcmp("data", zIn, 4)==0 ){ + int i; + for(i=4; zIn[i]>='0' && zIn[i]<='9'; i++); + if( zIn[i]=='_' && zIn[i+1] ){ + sqlite3_result_text(pCtx, &zIn[i+1], -1, SQLITE_STATIC); + } + } + } + } +} + +/* +** Initialize the iterator structure passed as the second argument. +** +** If no error occurs, SQLITE_OK is returned and the iterator is left +** pointing to the first entry. Otherwise, an error code and message is +** left in the RBU handle passed as the first argument. A copy of the +** error code is returned. +*/ +static int rbuObjIterFirst(sqlite3rbu *p, RbuObjIter *pIter){ + int rc; + memset(pIter, 0, sizeof(RbuObjIter)); + + rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pTblIter, &p->zErrmsg, + sqlite3_mprintf( + "SELECT rbu_target_name(name, type='view') AS target, name " + "FROM sqlite_schema " + "WHERE type IN ('table', 'view') AND target IS NOT NULL " + " %s " + "ORDER BY name" + , rbuIsVacuum(p) ? "AND rootpage!=0 AND rootpage IS NOT NULL" : "")); + + if( rc==SQLITE_OK ){ + rc = prepareAndCollectError(p->dbMain, &pIter->pIdxIter, &p->zErrmsg, + "SELECT name, rootpage, sql IS NULL OR substr(8, 6)=='UNIQUE' " + " FROM main.sqlite_schema " + " WHERE type='index' AND tbl_name = ?" + ); + } + + pIter->bCleanup = 1; + p->rc = rc; + return rbuObjIterNext(p, pIter); +} + +/* +** This is a wrapper around "sqlite3_mprintf(zFmt, ...)". If an OOM occurs, +** an error code is stored in the RBU handle passed as the first argument. +** +** If an error has already occurred (p->rc is already set to something other +** than SQLITE_OK), then this function returns NULL without modifying the +** stored error code. In this case it still calls sqlite3_free() on any +** printf() parameters associated with %z conversions. +*/ +static char *rbuMPrintf(sqlite3rbu *p, const char *zFmt, ...){ + char *zSql = 0; + va_list ap; + va_start(ap, zFmt); + zSql = sqlite3_vmprintf(zFmt, ap); + if( p->rc==SQLITE_OK ){ + if( zSql==0 ) p->rc = SQLITE_NOMEM; + }else{ + sqlite3_free(zSql); + zSql = 0; + } + va_end(ap); + return zSql; +} + +/* +** Argument zFmt is a sqlite3_mprintf() style format string. The trailing +** arguments are the usual subsitution values. This function performs +** the printf() style substitutions and executes the result as an SQL +** statement on the RBU handles database. +** +** If an error occurs, an error code and error message is stored in the +** RBU handle. If an error has already occurred when this function is +** called, it is a no-op. +*/ +static int rbuMPrintfExec(sqlite3rbu *p, sqlite3 *db, const char *zFmt, ...){ + va_list ap; + char *zSql; + va_start(ap, zFmt); + zSql = sqlite3_vmprintf(zFmt, ap); + if( p->rc==SQLITE_OK ){ + if( zSql==0 ){ + p->rc = SQLITE_NOMEM; + }else{ + p->rc = sqlite3_exec(db, zSql, 0, 0, &p->zErrmsg); + } + } + sqlite3_free(zSql); + va_end(ap); + return p->rc; +} + +/* +** Attempt to allocate and return a pointer to a zeroed block of nByte +** bytes. +** +** If an error (i.e. an OOM condition) occurs, return NULL and leave an +** error code in the rbu handle passed as the first argument. Or, if an +** error has already occurred when this function is called, return NULL +** immediately without attempting the allocation or modifying the stored +** error code. +*/ +static void *rbuMalloc(sqlite3rbu *p, sqlite3_int64 nByte){ + void *pRet = 0; + if( p->rc==SQLITE_OK ){ + assert( nByte>0 ); + pRet = sqlite3_malloc64(nByte); + if( pRet==0 ){ + p->rc = SQLITE_NOMEM; + }else{ + memset(pRet, 0, nByte); + } + } + return pRet; +} + + +/* +** Allocate and zero the pIter->azTblCol[] and abTblPk[] arrays so that +** there is room for at least nCol elements. If an OOM occurs, store an +** error code in the RBU handle passed as the first argument. +*/ +static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){ + sqlite3_int64 nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol; + char **azNew; + + azNew = (char**)rbuMalloc(p, nByte); + if( azNew ){ + pIter->azTblCol = azNew; + pIter->azTblType = &azNew[nCol]; + pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol]; + pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol]; + pIter->abNotNull = (u8*)&pIter->abTblPk[nCol]; + pIter->abIndexed = (u8*)&pIter->abNotNull[nCol]; + } +} + +/* +** The first argument must be a nul-terminated string. This function +** returns a copy of the string in memory obtained from sqlite3_malloc(). +** It is the responsibility of the caller to eventually free this memory +** using sqlite3_free(). +** +** If an OOM condition is encountered when attempting to allocate memory, +** output variable (*pRc) is set to SQLITE_NOMEM before returning. Otherwise, +** if the allocation succeeds, (*pRc) is left unchanged. +*/ +static char *rbuStrndup(const char *zStr, int *pRc){ + char *zRet = 0; + + if( *pRc==SQLITE_OK ){ + if( zStr ){ + size_t nCopy = strlen(zStr) + 1; + zRet = (char*)sqlite3_malloc64(nCopy); + if( zRet ){ + memcpy(zRet, zStr, nCopy); + }else{ + *pRc = SQLITE_NOMEM; + } + } + } + + return zRet; +} + +/* +** Finalize the statement passed as the second argument. +** +** If the sqlite3_finalize() call indicates that an error occurs, and the +** rbu handle error code is not already set, set the error code and error +** message accordingly. +*/ +static void rbuFinalize(sqlite3rbu *p, sqlite3_stmt *pStmt){ + sqlite3 *db = sqlite3_db_handle(pStmt); + int rc = sqlite3_finalize(pStmt); + if( p->rc==SQLITE_OK && rc!=SQLITE_OK ){ + p->rc = rc; + p->zErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + } +} + +/* Determine the type of a table. +** +** peType is of type (int*), a pointer to an output parameter of type +** (int). This call sets the output parameter as follows, depending +** on the type of the table specified by parameters dbName and zTbl. +** +** RBU_PK_NOTABLE: No such table. +** RBU_PK_NONE: Table has an implicit rowid. +** RBU_PK_IPK: Table has an explicit IPK column. +** RBU_PK_EXTERNAL: Table has an external PK index. +** RBU_PK_WITHOUT_ROWID: Table is WITHOUT ROWID. +** RBU_PK_VTAB: Table is a virtual table. +** +** Argument *piPk is also of type (int*), and also points to an output +** parameter. Unless the table has an external primary key index +** (i.e. unless *peType is set to 3), then *piPk is set to zero. Or, +** if the table does have an external primary key index, then *piPk +** is set to the root page number of the primary key index before +** returning. +** +** ALGORITHM: +** +** if( no entry exists in sqlite_schema ){ +** return RBU_PK_NOTABLE +** }else if( sql for the entry starts with "CREATE VIRTUAL" ){ +** return RBU_PK_VTAB +** }else if( "PRAGMA index_list()" for the table contains a "pk" index ){ +** if( the index that is the pk exists in sqlite_schema ){ +** *piPK = rootpage of that index. +** return RBU_PK_EXTERNAL +** }else{ +** return RBU_PK_WITHOUT_ROWID +** } +** }else if( "PRAGMA table_info()" lists one or more "pk" columns ){ +** return RBU_PK_IPK +** }else{ +** return RBU_PK_NONE +** } +*/ +static void rbuTableType( + sqlite3rbu *p, + const char *zTab, + int *peType, + int *piTnum, + int *piPk +){ + /* + ** 0) SELECT count(*) FROM sqlite_schema where name=%Q AND IsVirtual(%Q) + ** 1) PRAGMA index_list = ? + ** 2) SELECT count(*) FROM sqlite_schema where name=%Q + ** 3) PRAGMA table_info = ? + */ + sqlite3_stmt *aStmt[4] = {0, 0, 0, 0}; + + *peType = RBU_PK_NOTABLE; + *piPk = 0; + + assert( p->rc==SQLITE_OK ); + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[0], &p->zErrmsg, + sqlite3_mprintf( + "SELECT (sql LIKE 'create virtual%%'), rootpage" + " FROM sqlite_schema" + " WHERE name=%Q", zTab + )); + if( p->rc!=SQLITE_OK || sqlite3_step(aStmt[0])!=SQLITE_ROW ){ + /* Either an error, or no such table. */ + goto rbuTableType_end; + } + if( sqlite3_column_int(aStmt[0], 0) ){ + *peType = RBU_PK_VTAB; /* virtual table */ + goto rbuTableType_end; + } + *piTnum = sqlite3_column_int(aStmt[0], 1); + + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[1], &p->zErrmsg, + sqlite3_mprintf("PRAGMA index_list=%Q",zTab) + ); + if( p->rc ) goto rbuTableType_end; + while( sqlite3_step(aStmt[1])==SQLITE_ROW ){ + const u8 *zOrig = sqlite3_column_text(aStmt[1], 3); + const u8 *zIdx = sqlite3_column_text(aStmt[1], 1); + if( zOrig && zIdx && zOrig[0]=='p' ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[2], &p->zErrmsg, + sqlite3_mprintf( + "SELECT rootpage FROM sqlite_schema WHERE name = %Q", zIdx + )); + if( p->rc==SQLITE_OK ){ + if( sqlite3_step(aStmt[2])==SQLITE_ROW ){ + *piPk = sqlite3_column_int(aStmt[2], 0); + *peType = RBU_PK_EXTERNAL; + }else{ + *peType = RBU_PK_WITHOUT_ROWID; + } + } + goto rbuTableType_end; + } + } + + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[3], &p->zErrmsg, + sqlite3_mprintf("PRAGMA table_info=%Q",zTab) + ); + if( p->rc==SQLITE_OK ){ + while( sqlite3_step(aStmt[3])==SQLITE_ROW ){ + if( sqlite3_column_int(aStmt[3],5)>0 ){ + *peType = RBU_PK_IPK; /* explicit IPK column */ + goto rbuTableType_end; + } + } + *peType = RBU_PK_NONE; + } + +rbuTableType_end: { + unsigned int i; + for(i=0; iabIndexed[] array. +*/ +static void rbuObjIterCacheIndexedCols(sqlite3rbu *p, RbuObjIter *pIter){ + sqlite3_stmt *pList = 0; + int bIndex = 0; + + if( p->rc==SQLITE_OK ){ + memcpy(pIter->abIndexed, pIter->abTblPk, sizeof(u8)*pIter->nTblCol); + p->rc = prepareFreeAndCollectError(p->dbMain, &pList, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl) + ); + } + + pIter->nIndex = 0; + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pList) ){ + const char *zIdx = (const char*)sqlite3_column_text(pList, 1); + int bPartial = sqlite3_column_int(pList, 4); + sqlite3_stmt *pXInfo = 0; + if( zIdx==0 ) break; + if( bPartial ){ + memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol); + } + p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx) + ); + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){ + int iCid = sqlite3_column_int(pXInfo, 1); + if( iCid>=0 ) pIter->abIndexed[iCid] = 1; + if( iCid==-2 ){ + memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol); + } + } + rbuFinalize(p, pXInfo); + bIndex = 1; + pIter->nIndex++; + } + + if( pIter->eType==RBU_PK_WITHOUT_ROWID ){ + /* "PRAGMA index_list" includes the main PK b-tree */ + pIter->nIndex--; + } + + rbuFinalize(p, pList); + if( bIndex==0 ) pIter->abIndexed = 0; +} + + +/* +** If they are not already populated, populate the pIter->azTblCol[], +** pIter->abTblPk[], pIter->nTblCol and pIter->bRowid variables according to +** the table (not index) that the iterator currently points to. +** +** Return SQLITE_OK if successful, or an SQLite error code otherwise. If +** an error does occur, an error code and error message are also left in +** the RBU handle. +*/ +static int rbuObjIterCacheTableInfo(sqlite3rbu *p, RbuObjIter *pIter){ + if( pIter->azTblCol==0 ){ + sqlite3_stmt *pStmt = 0; + int nCol = 0; + int i; /* for() loop iterator variable */ + int bRbuRowid = 0; /* If input table has column "rbu_rowid" */ + int iOrder = 0; + int iTnum = 0; + + /* Figure out the type of table this step will deal with. */ + assert( pIter->eType==0 ); + rbuTableType(p, pIter->zTbl, &pIter->eType, &iTnum, &pIter->iPkTnum); + if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_NOTABLE ){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("no such table: %s", pIter->zTbl); + } + if( p->rc ) return p->rc; + if( pIter->zIdx==0 ) pIter->iTnum = iTnum; + + assert( pIter->eType==RBU_PK_NONE || pIter->eType==RBU_PK_IPK + || pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_WITHOUT_ROWID + || pIter->eType==RBU_PK_VTAB + ); + + /* Populate the azTblCol[] and nTblCol variables based on the columns + ** of the input table. Ignore any input table columns that begin with + ** "rbu_". */ + p->rc = prepareFreeAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg, + sqlite3_mprintf("SELECT * FROM '%q'", pIter->zDataTbl) + ); + if( p->rc==SQLITE_OK ){ + nCol = sqlite3_column_count(pStmt); + rbuAllocateIterArrays(p, pIter, nCol); + } + for(i=0; p->rc==SQLITE_OK && irc); + pIter->aiSrcOrder[pIter->nTblCol] = pIter->nTblCol; + pIter->azTblCol[pIter->nTblCol++] = zCopy; + } + else if( 0==sqlite3_stricmp("rbu_rowid", zName) ){ + bRbuRowid = 1; + } + } + sqlite3_finalize(pStmt); + pStmt = 0; + + if( p->rc==SQLITE_OK + && rbuIsVacuum(p)==0 + && bRbuRowid!=(pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE) + ){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf( + "table %q %s rbu_rowid column", pIter->zDataTbl, + (bRbuRowid ? "may not have" : "requires") + ); + } + + /* Check that all non-HIDDEN columns in the destination table are also + ** present in the input table. Populate the abTblPk[], azTblType[] and + ** aiTblOrder[] arrays at the same time. */ + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pStmt, &p->zErrmsg, + sqlite3_mprintf("PRAGMA table_info(%Q)", pIter->zTbl) + ); + } + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ + const char *zName = (const char*)sqlite3_column_text(pStmt, 1); + if( zName==0 ) break; /* An OOM - finalize() below returns S_NOMEM */ + for(i=iOrder; inTblCol; i++){ + if( 0==strcmp(zName, pIter->azTblCol[i]) ) break; + } + if( i==pIter->nTblCol ){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("column missing from %q: %s", + pIter->zDataTbl, zName + ); + }else{ + int iPk = sqlite3_column_int(pStmt, 5); + int bNotNull = sqlite3_column_int(pStmt, 3); + const char *zType = (const char*)sqlite3_column_text(pStmt, 2); + + if( i!=iOrder ){ + SWAP(int, pIter->aiSrcOrder[i], pIter->aiSrcOrder[iOrder]); + SWAP(char*, pIter->azTblCol[i], pIter->azTblCol[iOrder]); + } + + pIter->azTblType[iOrder] = rbuStrndup(zType, &p->rc); + assert( iPk>=0 ); + pIter->abTblPk[iOrder] = (u8)iPk; + pIter->abNotNull[iOrder] = (u8)bNotNull || (iPk!=0); + iOrder++; + } + } + + rbuFinalize(p, pStmt); + rbuObjIterCacheIndexedCols(p, pIter); + assert( pIter->eType!=RBU_PK_VTAB || pIter->abIndexed==0 ); + assert( pIter->eType!=RBU_PK_VTAB || pIter->nIndex==0 ); + } + + return p->rc; +} + +/* +** This function constructs and returns a pointer to a nul-terminated +** string containing some SQL clause or list based on one or more of the +** column names currently stored in the pIter->azTblCol[] array. +*/ +static char *rbuObjIterGetCollist( + sqlite3rbu *p, /* RBU object */ + RbuObjIter *pIter /* Object iterator for column names */ +){ + char *zList = 0; + const char *zSep = ""; + int i; + for(i=0; inTblCol; i++){ + const char *z = pIter->azTblCol[i]; + zList = rbuMPrintf(p, "%z%s\"%w\"", zList, zSep, z); + zSep = ", "; + } + return zList; +} + +/* +** Return a comma separated list of the quoted PRIMARY KEY column names, +** in order, for the current table. Before each column name, add the text +** zPre. After each column name, add the zPost text. Use zSeparator as +** the separator text (usually ", "). +*/ +static char *rbuObjIterGetPkList( + sqlite3rbu *p, /* RBU object */ + RbuObjIter *pIter, /* Object iterator for column names */ + const char *zPre, /* Before each quoted column name */ + const char *zSeparator, /* Separator to use between columns */ + const char *zPost /* After each quoted column name */ +){ + int iPk = 1; + char *zRet = 0; + const char *zSep = ""; + while( 1 ){ + int i; + for(i=0; inTblCol; i++){ + if( (int)pIter->abTblPk[i]==iPk ){ + const char *zCol = pIter->azTblCol[i]; + zRet = rbuMPrintf(p, "%z%s%s\"%w\"%s", zRet, zSep, zPre, zCol, zPost); + zSep = zSeparator; + break; + } + } + if( i==pIter->nTblCol ) break; + iPk++; + } + return zRet; +} + +/* +** This function is called as part of restarting an RBU vacuum within +** stage 1 of the process (while the *-oal file is being built) while +** updating a table (not an index). The table may be a rowid table or +** a WITHOUT ROWID table. It queries the target database to find the +** largest key that has already been written to the target table and +** constructs a WHERE clause that can be used to extract the remaining +** rows from the source table. For a rowid table, the WHERE clause +** is of the form: +** +** "WHERE _rowid_ > ?" +** +** and for WITHOUT ROWID tables: +** +** "WHERE (key1, key2) > (?, ?)" +** +** Instead of "?" placeholders, the actual WHERE clauses created by +** this function contain literal SQL values. +*/ +static char *rbuVacuumTableStart( + sqlite3rbu *p, /* RBU handle */ + RbuObjIter *pIter, /* RBU iterator object */ + int bRowid, /* True for a rowid table */ + const char *zWrite /* Target table name prefix */ +){ + sqlite3_stmt *pMax = 0; + char *zRet = 0; + if( bRowid ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pMax, &p->zErrmsg, + sqlite3_mprintf( + "SELECT max(_rowid_) FROM \"%s%w\"", zWrite, pIter->zTbl + ) + ); + if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){ + sqlite3_int64 iMax = sqlite3_column_int64(pMax, 0); + zRet = rbuMPrintf(p, " WHERE _rowid_ > %lld ", iMax); + } + rbuFinalize(p, pMax); + }else{ + char *zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", " DESC"); + char *zSelect = rbuObjIterGetPkList(p, pIter, "quote(", "||','||", ")"); + char *zList = rbuObjIterGetPkList(p, pIter, "", ", ", ""); + + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pMax, &p->zErrmsg, + sqlite3_mprintf( + "SELECT %s FROM \"%s%w\" ORDER BY %s LIMIT 1", + zSelect, zWrite, pIter->zTbl, zOrder + ) + ); + if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){ + const char *zVal = (const char*)sqlite3_column_text(pMax, 0); + zRet = rbuMPrintf(p, " WHERE (%s) > (%s) ", zList, zVal); + } + rbuFinalize(p, pMax); + } + + sqlite3_free(zOrder); + sqlite3_free(zSelect); + sqlite3_free(zList); + } + return zRet; +} + +/* +** This function is called as part of restating an RBU vacuum when the +** current operation is writing content to an index. If possible, it +** queries the target index b-tree for the largest key already written to +** it, then composes and returns an expression that can be used in a WHERE +** clause to select the remaining required rows from the source table. +** It is only possible to return such an expression if: +** +** * The index contains no DESC columns, and +** * The last key written to the index before the operation was +** suspended does not contain any NULL values. +** +** The expression is of the form: +** +** (index-field1, index-field2, ...) > (?, ?, ...) +** +** except that the "?" placeholders are replaced with literal values. +** +** If the expression cannot be created, NULL is returned. In this case, +** the caller has to use an OFFSET clause to extract only the required +** rows from the sourct table, just as it does for an RBU update operation. +*/ +char *rbuVacuumIndexStart( + sqlite3rbu *p, /* RBU handle */ + RbuObjIter *pIter /* RBU iterator object */ +){ + char *zOrder = 0; + char *zLhs = 0; + char *zSelect = 0; + char *zVector = 0; + char *zRet = 0; + int bFailed = 0; + const char *zSep = ""; + int iCol = 0; + sqlite3_stmt *pXInfo = 0; + + p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx) + ); + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){ + int iCid = sqlite3_column_int(pXInfo, 1); + const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4); + const char *zCol; + if( sqlite3_column_int(pXInfo, 3) ){ + bFailed = 1; + break; + } + + if( iCid<0 ){ + if( pIter->eType==RBU_PK_IPK ){ + int i; + for(i=0; pIter->abTblPk[i]==0; i++); + assert( inTblCol ); + zCol = pIter->azTblCol[i]; + }else{ + zCol = "_rowid_"; + } + }else{ + zCol = pIter->azTblCol[iCid]; + } + + zLhs = rbuMPrintf(p, "%z%s \"%w\" COLLATE %Q", + zLhs, zSep, zCol, zCollate + ); + zOrder = rbuMPrintf(p, "%z%s \"rbu_imp_%d%w\" COLLATE %Q DESC", + zOrder, zSep, iCol, zCol, zCollate + ); + zSelect = rbuMPrintf(p, "%z%s quote(\"rbu_imp_%d%w\")", + zSelect, zSep, iCol, zCol + ); + zSep = ", "; + iCol++; + } + rbuFinalize(p, pXInfo); + if( bFailed ) goto index_start_out; + + if( p->rc==SQLITE_OK ){ + sqlite3_stmt *pSel = 0; + + p->rc = prepareFreeAndCollectError(p->dbMain, &pSel, &p->zErrmsg, + sqlite3_mprintf("SELECT %s FROM \"rbu_imp_%w\" ORDER BY %s LIMIT 1", + zSelect, pIter->zTbl, zOrder + ) + ); + if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSel) ){ + zSep = ""; + for(iCol=0; iColnCol; iCol++){ + const char *zQuoted = (const char*)sqlite3_column_text(pSel, iCol); + if( zQuoted[0]=='N' ){ + bFailed = 1; + break; + } + zVector = rbuMPrintf(p, "%z%s%s", zVector, zSep, zQuoted); + zSep = ", "; + } + + if( !bFailed ){ + zRet = rbuMPrintf(p, "(%s) > (%s)", zLhs, zVector); + } + } + rbuFinalize(p, pSel); + } + + index_start_out: + sqlite3_free(zOrder); + sqlite3_free(zSelect); + sqlite3_free(zVector); + sqlite3_free(zLhs); + return zRet; +} + +/* +** This function is used to create a SELECT list (the list of SQL +** expressions that follows a SELECT keyword) for a SELECT statement +** used to read from an data_xxx or rbu_tmp_xxx table while updating the +** index object currently indicated by the iterator object passed as the +** second argument. A "PRAGMA index_xinfo = " statement is used +** to obtain the required information. +** +** If the index is of the following form: +** +** CREATE INDEX i1 ON t1(c, b COLLATE nocase); +** +** and "t1" is a table with an explicit INTEGER PRIMARY KEY column +** "ipk", the returned string is: +** +** "`c` COLLATE 'BINARY', `b` COLLATE 'NOCASE', `ipk` COLLATE 'BINARY'" +** +** As well as the returned string, three other malloc'd strings are +** returned via output parameters. As follows: +** +** pzImposterCols: ... +** pzImposterPk: ... +** pzWhere: ... +*/ +static char *rbuObjIterGetIndexCols( + sqlite3rbu *p, /* RBU object */ + RbuObjIter *pIter, /* Object iterator for column names */ + char **pzImposterCols, /* OUT: Columns for imposter table */ + char **pzImposterPk, /* OUT: Imposter PK clause */ + char **pzWhere, /* OUT: WHERE clause */ + int *pnBind /* OUT: Trbul number of columns */ +){ + int rc = p->rc; /* Error code */ + int rc2; /* sqlite3_finalize() return code */ + char *zRet = 0; /* String to return */ + char *zImpCols = 0; /* String to return via *pzImposterCols */ + char *zImpPK = 0; /* String to return via *pzImposterPK */ + char *zWhere = 0; /* String to return via *pzWhere */ + int nBind = 0; /* Value to return via *pnBind */ + const char *zCom = ""; /* Set to ", " later on */ + const char *zAnd = ""; /* Set to " AND " later on */ + sqlite3_stmt *pXInfo = 0; /* PRAGMA index_xinfo = ? */ + + if( rc==SQLITE_OK ){ + assert( p->zErrmsg==0 ); + rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx) + ); + } + + while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){ + int iCid = sqlite3_column_int(pXInfo, 1); + int bDesc = sqlite3_column_int(pXInfo, 3); + const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4); + const char *zCol = 0; + const char *zType; + + if( iCid==-2 ){ + int iSeq = sqlite3_column_int(pXInfo, 0); + zRet = sqlite3_mprintf("%z%s(%.*s) COLLATE %Q", zRet, zCom, + pIter->aIdxCol[iSeq].nSpan, pIter->aIdxCol[iSeq].zSpan, zCollate + ); + zType = ""; + }else { + if( iCid<0 ){ + /* An integer primary key. If the table has an explicit IPK, use + ** its name. Otherwise, use "rbu_rowid". */ + if( pIter->eType==RBU_PK_IPK ){ + int i; + for(i=0; pIter->abTblPk[i]==0; i++); + assert( inTblCol ); + zCol = pIter->azTblCol[i]; + }else if( rbuIsVacuum(p) ){ + zCol = "_rowid_"; + }else{ + zCol = "rbu_rowid"; + } + zType = "INTEGER"; + }else{ + zCol = pIter->azTblCol[iCid]; + zType = pIter->azTblType[iCid]; + } + zRet = sqlite3_mprintf("%z%s\"%w\" COLLATE %Q", zRet, zCom,zCol,zCollate); + } + + if( pIter->bUnique==0 || sqlite3_column_int(pXInfo, 5) ){ + const char *zOrder = (bDesc ? " DESC" : ""); + zImpPK = sqlite3_mprintf("%z%s\"rbu_imp_%d%w\"%s", + zImpPK, zCom, nBind, zCol, zOrder + ); + } + zImpCols = sqlite3_mprintf("%z%s\"rbu_imp_%d%w\" %s COLLATE %Q", + zImpCols, zCom, nBind, zCol, zType, zCollate + ); + zWhere = sqlite3_mprintf( + "%z%s\"rbu_imp_%d%w\" IS ?", zWhere, zAnd, nBind, zCol + ); + if( zRet==0 || zImpPK==0 || zImpCols==0 || zWhere==0 ) rc = SQLITE_NOMEM; + zCom = ", "; + zAnd = " AND "; + nBind++; + } + + rc2 = sqlite3_finalize(pXInfo); + if( rc==SQLITE_OK ) rc = rc2; + + if( rc!=SQLITE_OK ){ + sqlite3_free(zRet); + sqlite3_free(zImpCols); + sqlite3_free(zImpPK); + sqlite3_free(zWhere); + zRet = 0; + zImpCols = 0; + zImpPK = 0; + zWhere = 0; + p->rc = rc; + } + + *pzImposterCols = zImpCols; + *pzImposterPk = zImpPK; + *pzWhere = zWhere; + *pnBind = nBind; + return zRet; +} + +/* +** Assuming the current table columns are "a", "b" and "c", and the zObj +** paramter is passed "old", return a string of the form: +** +** "old.a, old.b, old.b" +** +** With the column names escaped. +** +** For tables with implicit rowids - RBU_PK_EXTERNAL and RBU_PK_NONE, append +** the text ", old._rowid_" to the returned value. +*/ +static char *rbuObjIterGetOldlist( + sqlite3rbu *p, + RbuObjIter *pIter, + const char *zObj +){ + char *zList = 0; + if( p->rc==SQLITE_OK && pIter->abIndexed ){ + const char *zS = ""; + int i; + for(i=0; inTblCol; i++){ + if( pIter->abIndexed[i] ){ + const char *zCol = pIter->azTblCol[i]; + zList = sqlite3_mprintf("%z%s%s.\"%w\"", zList, zS, zObj, zCol); + }else{ + zList = sqlite3_mprintf("%z%sNULL", zList, zS); + } + zS = ", "; + if( zList==0 ){ + p->rc = SQLITE_NOMEM; + break; + } + } + + /* For a table with implicit rowids, append "old._rowid_" to the list. */ + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){ + zList = rbuMPrintf(p, "%z, %s._rowid_", zList, zObj); + } + } + return zList; +} + +/* +** Return an expression that can be used in a WHERE clause to match the +** primary key of the current table. For example, if the table is: +** +** CREATE TABLE t1(a, b, c, PRIMARY KEY(b, c)); +** +** Return the string: +** +** "b = ?1 AND c = ?2" +*/ +static char *rbuObjIterGetWhere( + sqlite3rbu *p, + RbuObjIter *pIter +){ + char *zList = 0; + if( pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE ){ + zList = rbuMPrintf(p, "_rowid_ = ?%d", pIter->nTblCol+1); + }else if( pIter->eType==RBU_PK_EXTERNAL ){ + const char *zSep = ""; + int i; + for(i=0; inTblCol; i++){ + if( pIter->abTblPk[i] ){ + zList = rbuMPrintf(p, "%z%sc%d=?%d", zList, zSep, i, i+1); + zSep = " AND "; + } + } + zList = rbuMPrintf(p, + "_rowid_ = (SELECT id FROM rbu_imposter2 WHERE %z)", zList + ); + + }else{ + const char *zSep = ""; + int i; + for(i=0; inTblCol; i++){ + if( pIter->abTblPk[i] ){ + const char *zCol = pIter->azTblCol[i]; + zList = rbuMPrintf(p, "%z%s\"%w\"=?%d", zList, zSep, zCol, i+1); + zSep = " AND "; + } + } + } + return zList; +} + +/* +** The SELECT statement iterating through the keys for the current object +** (p->objiter.pSelect) currently points to a valid row. However, there +** is something wrong with the rbu_control value in the rbu_control value +** stored in the (p->nCol+1)'th column. Set the error code and error message +** of the RBU handle to something reflecting this. +*/ +static void rbuBadControlError(sqlite3rbu *p){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("invalid rbu_control value"); +} + + +/* +** Return a nul-terminated string containing the comma separated list of +** assignments that should be included following the "SET" keyword of +** an UPDATE statement used to update the table object that the iterator +** passed as the second argument currently points to if the rbu_control +** column of the data_xxx table entry is set to zMask. +** +** The memory for the returned string is obtained from sqlite3_malloc(). +** It is the responsibility of the caller to eventually free it using +** sqlite3_free(). +** +** If an OOM error is encountered when allocating space for the new +** string, an error code is left in the rbu handle passed as the first +** argument and NULL is returned. Or, if an error has already occurred +** when this function is called, NULL is returned immediately, without +** attempting the allocation or modifying the stored error code. +*/ +static char *rbuObjIterGetSetlist( + sqlite3rbu *p, + RbuObjIter *pIter, + const char *zMask +){ + char *zList = 0; + if( p->rc==SQLITE_OK ){ + int i; + + if( (int)strlen(zMask)!=pIter->nTblCol ){ + rbuBadControlError(p); + }else{ + const char *zSep = ""; + for(i=0; inTblCol; i++){ + char c = zMask[pIter->aiSrcOrder[i]]; + if( c=='x' ){ + zList = rbuMPrintf(p, "%z%s\"%w\"=?%d", + zList, zSep, pIter->azTblCol[i], i+1 + ); + zSep = ", "; + } + else if( c=='d' ){ + zList = rbuMPrintf(p, "%z%s\"%w\"=rbu_delta(\"%w\", ?%d)", + zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1 + ); + zSep = ", "; + } + else if( c=='f' ){ + zList = rbuMPrintf(p, "%z%s\"%w\"=rbu_fossil_delta(\"%w\", ?%d)", + zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1 + ); + zSep = ", "; + } + } + } + } + return zList; +} + +/* +** Return a nul-terminated string consisting of nByte comma separated +** "?" expressions. For example, if nByte is 3, return a pointer to +** a buffer containing the string "?,?,?". +** +** The memory for the returned string is obtained from sqlite3_malloc(). +** It is the responsibility of the caller to eventually free it using +** sqlite3_free(). +** +** If an OOM error is encountered when allocating space for the new +** string, an error code is left in the rbu handle passed as the first +** argument and NULL is returned. Or, if an error has already occurred +** when this function is called, NULL is returned immediately, without +** attempting the allocation or modifying the stored error code. +*/ +static char *rbuObjIterGetBindlist(sqlite3rbu *p, int nBind){ + char *zRet = 0; + sqlite3_int64 nByte = 2*(sqlite3_int64)nBind + 1; + + zRet = (char*)rbuMalloc(p, nByte); + if( zRet ){ + int i; + for(i=0; izIdx==0 ); + if( p->rc==SQLITE_OK ){ + const char *zSep = "PRIMARY KEY("; + sqlite3_stmt *pXList = 0; /* PRAGMA index_list = (pIter->zTbl) */ + sqlite3_stmt *pXInfo = 0; /* PRAGMA index_xinfo = */ + + p->rc = prepareFreeAndCollectError(p->dbMain, &pXList, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl) + ); + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXList) ){ + const char *zOrig = (const char*)sqlite3_column_text(pXList,3); + if( zOrig && strcmp(zOrig, "pk")==0 ){ + const char *zIdx = (const char*)sqlite3_column_text(pXList,1); + if( zIdx ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx) + ); + } + break; + } + } + rbuFinalize(p, pXList); + + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){ + if( sqlite3_column_int(pXInfo, 5) ){ + /* int iCid = sqlite3_column_int(pXInfo, 0); */ + const char *zCol = (const char*)sqlite3_column_text(pXInfo, 2); + const char *zDesc = sqlite3_column_int(pXInfo, 3) ? " DESC" : ""; + z = rbuMPrintf(p, "%z%s\"%w\"%s", z, zSep, zCol, zDesc); + zSep = ", "; + } + } + z = rbuMPrintf(p, "%z)", z); + rbuFinalize(p, pXInfo); + } + return z; +} + +/* +** This function creates the second imposter table used when writing to +** a table b-tree where the table has an external primary key. If the +** iterator passed as the second argument does not currently point to +** a table (not index) with an external primary key, this function is a +** no-op. +** +** Assuming the iterator does point to a table with an external PK, this +** function creates a WITHOUT ROWID imposter table named "rbu_imposter2" +** used to access that PK index. For example, if the target table is +** declared as follows: +** +** CREATE TABLE t1(a, b TEXT, c REAL, PRIMARY KEY(b, c)); +** +** then the imposter table schema is: +** +** CREATE TABLE rbu_imposter2(c1 TEXT, c2 REAL, id INTEGER) WITHOUT ROWID; +** +*/ +static void rbuCreateImposterTable2(sqlite3rbu *p, RbuObjIter *pIter){ + if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_EXTERNAL ){ + int tnum = pIter->iPkTnum; /* Root page of PK index */ + sqlite3_stmt *pQuery = 0; /* SELECT name ... WHERE rootpage = $tnum */ + const char *zIdx = 0; /* Name of PK index */ + sqlite3_stmt *pXInfo = 0; /* PRAGMA main.index_xinfo = $zIdx */ + const char *zComma = ""; + char *zCols = 0; /* Used to build up list of table cols */ + char *zPk = 0; /* Used to build up table PK declaration */ + + /* Figure out the name of the primary key index for the current table. + ** This is needed for the argument to "PRAGMA index_xinfo". Set + ** zIdx to point to a nul-terminated string containing this name. */ + p->rc = prepareAndCollectError(p->dbMain, &pQuery, &p->zErrmsg, + "SELECT name FROM sqlite_schema WHERE rootpage = ?" + ); + if( p->rc==SQLITE_OK ){ + sqlite3_bind_int(pQuery, 1, tnum); + if( SQLITE_ROW==sqlite3_step(pQuery) ){ + zIdx = (const char*)sqlite3_column_text(pQuery, 0); + } + } + if( zIdx ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx) + ); + } + rbuFinalize(p, pQuery); + + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){ + int bKey = sqlite3_column_int(pXInfo, 5); + if( bKey ){ + int iCid = sqlite3_column_int(pXInfo, 1); + int bDesc = sqlite3_column_int(pXInfo, 3); + const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4); + zCols = rbuMPrintf(p, "%z%sc%d %s COLLATE %Q", zCols, zComma, + iCid, pIter->azTblType[iCid], zCollate + ); + zPk = rbuMPrintf(p, "%z%sc%d%s", zPk, zComma, iCid, bDesc?" DESC":""); + zComma = ", "; + } + } + zCols = rbuMPrintf(p, "%z, id INTEGER", zCols); + rbuFinalize(p, pXInfo); + + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1, tnum); + rbuMPrintfExec(p, p->dbMain, + "CREATE TABLE rbu_imposter2(%z, PRIMARY KEY(%z)) WITHOUT ROWID", + zCols, zPk + ); + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0); + } +} + +/* +** If an error has already occurred when this function is called, it +** immediately returns zero (without doing any work). Or, if an error +** occurs during the execution of this function, it sets the error code +** in the sqlite3rbu object indicated by the first argument and returns +** zero. +** +** The iterator passed as the second argument is guaranteed to point to +** a table (not an index) when this function is called. This function +** attempts to create any imposter table required to write to the main +** table b-tree of the table before returning. Non-zero is returned if +** an imposter table are created, or zero otherwise. +** +** An imposter table is required in all cases except RBU_PK_VTAB. Only +** virtual tables are written to directly. The imposter table has the +** same schema as the actual target table (less any UNIQUE constraints). +** More precisely, the "same schema" means the same columns, types, +** collation sequences. For tables that do not have an external PRIMARY +** KEY, it also means the same PRIMARY KEY declaration. +*/ +static void rbuCreateImposterTable(sqlite3rbu *p, RbuObjIter *pIter){ + if( p->rc==SQLITE_OK && pIter->eType!=RBU_PK_VTAB ){ + int tnum = pIter->iTnum; + const char *zComma = ""; + char *zSql = 0; + int iCol; + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 1); + + for(iCol=0; p->rc==SQLITE_OK && iColnTblCol; iCol++){ + const char *zPk = ""; + const char *zCol = pIter->azTblCol[iCol]; + const char *zColl = 0; + + p->rc = sqlite3_table_column_metadata( + p->dbMain, "main", pIter->zTbl, zCol, 0, &zColl, 0, 0, 0 + ); + + if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){ + /* If the target table column is an "INTEGER PRIMARY KEY", add + ** "PRIMARY KEY" to the imposter table column declaration. */ + zPk = "PRIMARY KEY "; + } + zSql = rbuMPrintf(p, "%z%s\"%w\" %s %sCOLLATE %Q%s", + zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl, + (pIter->abNotNull[iCol] ? " NOT NULL" : "") + ); + zComma = ", "; + } + + if( pIter->eType==RBU_PK_WITHOUT_ROWID ){ + char *zPk = rbuWithoutRowidPK(p, pIter); + if( zPk ){ + zSql = rbuMPrintf(p, "%z, %z", zSql, zPk); + } + } + + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1, tnum); + rbuMPrintfExec(p, p->dbMain, "CREATE TABLE \"rbu_imp_%w\"(%z)%s", + pIter->zTbl, zSql, + (pIter->eType==RBU_PK_WITHOUT_ROWID ? " WITHOUT ROWID" : "") + ); + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0); + } +} + +/* +** Prepare a statement used to insert rows into the "rbu_tmp_xxx" table. +** Specifically a statement of the form: +** +** INSERT INTO rbu_tmp_xxx VALUES(?, ?, ? ...); +** +** The number of bound variables is equal to the number of columns in +** the target table, plus one (for the rbu_control column), plus one more +** (for the rbu_rowid column) if the target table is an implicit IPK or +** virtual table. +*/ +static void rbuObjIterPrepareTmpInsert( + sqlite3rbu *p, + RbuObjIter *pIter, + const char *zCollist, + const char *zRbuRowid +){ + int bRbuRowid = (pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE); + char *zBind = rbuObjIterGetBindlist(p, pIter->nTblCol + 1 + bRbuRowid); + if( zBind ){ + assert( pIter->pTmpInsert==0 ); + p->rc = prepareFreeAndCollectError( + p->dbRbu, &pIter->pTmpInsert, &p->zErrmsg, sqlite3_mprintf( + "INSERT INTO %s.'rbu_tmp_%q'(rbu_control,%s%s) VALUES(%z)", + p->zStateDb, pIter->zDataTbl, zCollist, zRbuRowid, zBind + )); + } +} + +static void rbuTmpInsertFunc( + sqlite3_context *pCtx, + int nVal, + sqlite3_value **apVal +){ + sqlite3rbu *p = sqlite3_user_data(pCtx); + int rc = SQLITE_OK; + int i; + + assert( sqlite3_value_int(apVal[0])!=0 + || p->objiter.eType==RBU_PK_EXTERNAL + || p->objiter.eType==RBU_PK_NONE + ); + if( sqlite3_value_int(apVal[0])!=0 ){ + p->nPhaseOneStep += p->objiter.nIndex; + } + + for(i=0; rc==SQLITE_OK && iobjiter.pTmpInsert, i+1, apVal[i]); + } + if( rc==SQLITE_OK ){ + sqlite3_step(p->objiter.pTmpInsert); + rc = sqlite3_reset(p->objiter.pTmpInsert); + } + + if( rc!=SQLITE_OK ){ + sqlite3_result_error_code(pCtx, rc); + } +} + +static char *rbuObjIterGetIndexWhere(sqlite3rbu *p, RbuObjIter *pIter){ + sqlite3_stmt *pStmt = 0; + int rc = p->rc; + char *zRet = 0; + + assert( pIter->zIdxSql==0 && pIter->nIdxCol==0 && pIter->aIdxCol==0 ); + + if( rc==SQLITE_OK ){ + rc = prepareAndCollectError(p->dbMain, &pStmt, &p->zErrmsg, + "SELECT trim(sql) FROM sqlite_schema WHERE type='index' AND name=?" + ); + } + if( rc==SQLITE_OK ){ + int rc2; + rc = sqlite3_bind_text(pStmt, 1, pIter->zIdx, -1, SQLITE_STATIC); + if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ + char *zSql = (char*)sqlite3_column_text(pStmt, 0); + if( zSql ){ + pIter->zIdxSql = zSql = rbuStrndup(zSql, &rc); + } + if( zSql ){ + int nParen = 0; /* Number of open parenthesis */ + int i; + int iIdxCol = 0; + int nIdxAlloc = 0; + for(i=0; zSql[i]; i++){ + char c = zSql[i]; + + /* If necessary, grow the pIter->aIdxCol[] array */ + if( iIdxCol==nIdxAlloc ){ + RbuSpan *aIdxCol = (RbuSpan*)sqlite3_realloc( + pIter->aIdxCol, (nIdxAlloc+16)*sizeof(RbuSpan) + ); + if( aIdxCol==0 ){ + rc = SQLITE_NOMEM; + break; + } + pIter->aIdxCol = aIdxCol; + nIdxAlloc += 16; + } + + if( c=='(' ){ + if( nParen==0 ){ + assert( iIdxCol==0 ); + pIter->aIdxCol[0].zSpan = &zSql[i+1]; + } + nParen++; + } + else if( c==')' ){ + nParen--; + if( nParen==0 ){ + int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan; + pIter->aIdxCol[iIdxCol++].nSpan = nSpan; + i++; + break; + } + }else if( c==',' && nParen==1 ){ + int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan; + pIter->aIdxCol[iIdxCol++].nSpan = nSpan; + pIter->aIdxCol[iIdxCol].zSpan = &zSql[i+1]; + }else if( c=='"' || c=='\'' || c=='`' ){ + for(i++; 1; i++){ + if( zSql[i]==c ){ + if( zSql[i+1]!=c ) break; + i++; + } + } + }else if( c=='[' ){ + for(i++; 1; i++){ + if( zSql[i]==']' ) break; + } + }else if( c=='-' && zSql[i+1]=='-' ){ + for(i=i+2; zSql[i] && zSql[i]!='\n'; i++); + if( zSql[i]=='\0' ) break; + }else if( c=='/' && zSql[i+1]=='*' ){ + for(i=i+2; zSql[i] && (zSql[i]!='*' || zSql[i+1]!='/'); i++); + if( zSql[i]=='\0' ) break; + i++; + } + } + if( zSql[i] ){ + zRet = rbuStrndup(&zSql[i], &rc); + } + pIter->nIdxCol = iIdxCol; + } + } + + rc2 = sqlite3_finalize(pStmt); + if( rc==SQLITE_OK ) rc = rc2; + } + + p->rc = rc; + return zRet; +} + +/* +** Ensure that the SQLite statement handles required to update the +** target database object currently indicated by the iterator passed +** as the second argument are available. +*/ +static int rbuObjIterPrepareAll( + sqlite3rbu *p, + RbuObjIter *pIter, + int nOffset /* Add "LIMIT -1 OFFSET $nOffset" to SELECT */ +){ + assert( pIter->bCleanup==0 ); + if( pIter->pSelect==0 && rbuObjIterCacheTableInfo(p, pIter)==SQLITE_OK ){ + const int tnum = pIter->iTnum; + char *zCollist = 0; /* List of indexed columns */ + char **pz = &p->zErrmsg; + const char *zIdx = pIter->zIdx; + char *zLimit = 0; + + if( nOffset ){ + zLimit = sqlite3_mprintf(" LIMIT -1 OFFSET %d", nOffset); + if( !zLimit ) p->rc = SQLITE_NOMEM; + } + + if( zIdx ){ + const char *zTbl = pIter->zTbl; + char *zImposterCols = 0; /* Columns for imposter table */ + char *zImposterPK = 0; /* Primary key declaration for imposter */ + char *zWhere = 0; /* WHERE clause on PK columns */ + char *zBind = 0; + char *zPart = 0; + int nBind = 0; + + assert( pIter->eType!=RBU_PK_VTAB ); + zPart = rbuObjIterGetIndexWhere(p, pIter); + zCollist = rbuObjIterGetIndexCols( + p, pIter, &zImposterCols, &zImposterPK, &zWhere, &nBind + ); + zBind = rbuObjIterGetBindlist(p, nBind); + + /* Create the imposter table used to write to this index. */ + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 1); + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1,tnum); + rbuMPrintfExec(p, p->dbMain, + "CREATE TABLE \"rbu_imp_%w\"( %s, PRIMARY KEY( %s ) ) WITHOUT ROWID", + zTbl, zImposterCols, zImposterPK + ); + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0); + + /* Create the statement to insert index entries */ + pIter->nCol = nBind; + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError( + p->dbMain, &pIter->pInsert, &p->zErrmsg, + sqlite3_mprintf("INSERT INTO \"rbu_imp_%w\" VALUES(%s)", zTbl, zBind) + ); + } + + /* And to delete index entries */ + if( rbuIsVacuum(p)==0 && p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError( + p->dbMain, &pIter->pDelete, &p->zErrmsg, + sqlite3_mprintf("DELETE FROM \"rbu_imp_%w\" WHERE %s", zTbl, zWhere) + ); + } + + /* Create the SELECT statement to read keys in sorted order */ + if( p->rc==SQLITE_OK ){ + char *zSql; + if( rbuIsVacuum(p) ){ + char *zStart = 0; + if( nOffset ){ + zStart = rbuVacuumIndexStart(p, pIter); + if( zStart ){ + sqlite3_free(zLimit); + zLimit = 0; + } + } + + zSql = sqlite3_mprintf( + "SELECT %s, 0 AS rbu_control FROM '%q' %s %s %s ORDER BY %s%s", + zCollist, + pIter->zDataTbl, + zPart, + (zStart ? (zPart ? "AND" : "WHERE") : ""), zStart, + zCollist, zLimit + ); + sqlite3_free(zStart); + }else + + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){ + zSql = sqlite3_mprintf( + "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' %s ORDER BY %s%s", + zCollist, p->zStateDb, pIter->zDataTbl, + zPart, zCollist, zLimit + ); + }else{ + zSql = sqlite3_mprintf( + "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' %s " + "UNION ALL " + "SELECT %s, rbu_control FROM '%q' " + "%s %s typeof(rbu_control)='integer' AND rbu_control!=1 " + "ORDER BY %s%s", + zCollist, p->zStateDb, pIter->zDataTbl, zPart, + zCollist, pIter->zDataTbl, + zPart, + (zPart ? "AND" : "WHERE"), + zCollist, zLimit + ); + } + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbRbu,&pIter->pSelect,pz,zSql); + }else{ + sqlite3_free(zSql); + } + } + + sqlite3_free(zImposterCols); + sqlite3_free(zImposterPK); + sqlite3_free(zWhere); + sqlite3_free(zBind); + sqlite3_free(zPart); + }else{ + int bRbuRowid = (pIter->eType==RBU_PK_VTAB) + ||(pIter->eType==RBU_PK_NONE) + ||(pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p)); + const char *zTbl = pIter->zTbl; /* Table this step applies to */ + const char *zWrite; /* Imposter table name */ + + char *zBindings = rbuObjIterGetBindlist(p, pIter->nTblCol + bRbuRowid); + char *zWhere = rbuObjIterGetWhere(p, pIter); + char *zOldlist = rbuObjIterGetOldlist(p, pIter, "old"); + char *zNewlist = rbuObjIterGetOldlist(p, pIter, "new"); + + zCollist = rbuObjIterGetCollist(p, pIter); + pIter->nCol = pIter->nTblCol; + + /* Create the imposter table or tables (if required). */ + rbuCreateImposterTable(p, pIter); + rbuCreateImposterTable2(p, pIter); + zWrite = (pIter->eType==RBU_PK_VTAB ? "" : "rbu_imp_"); + + /* Create the INSERT statement to write to the target PK b-tree */ + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pInsert, pz, + sqlite3_mprintf( + "INSERT INTO \"%s%w\"(%s%s) VALUES(%s)", + zWrite, zTbl, zCollist, (bRbuRowid ? ", _rowid_" : ""), zBindings + ) + ); + } + + /* Create the DELETE statement to write to the target PK b-tree. + ** Because it only performs INSERT operations, this is not required for + ** an rbu vacuum handle. */ + if( rbuIsVacuum(p)==0 && p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pDelete, pz, + sqlite3_mprintf( + "DELETE FROM \"%s%w\" WHERE %s", zWrite, zTbl, zWhere + ) + ); + } + + if( rbuIsVacuum(p)==0 && pIter->abIndexed ){ + const char *zRbuRowid = ""; + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){ + zRbuRowid = ", rbu_rowid"; + } + + /* Create the rbu_tmp_xxx table and the triggers to populate it. */ + rbuMPrintfExec(p, p->dbRbu, + "CREATE TABLE IF NOT EXISTS %s.'rbu_tmp_%q' AS " + "SELECT *%s FROM '%q' WHERE 0;" + , p->zStateDb, pIter->zDataTbl + , (pIter->eType==RBU_PK_EXTERNAL ? ", 0 AS rbu_rowid" : "") + , pIter->zDataTbl + ); + + rbuMPrintfExec(p, p->dbMain, + "CREATE TEMP TRIGGER rbu_delete_tr BEFORE DELETE ON \"%s%w\" " + "BEGIN " + " SELECT rbu_tmp_insert(3, %s);" + "END;" + + "CREATE TEMP TRIGGER rbu_update1_tr BEFORE UPDATE ON \"%s%w\" " + "BEGIN " + " SELECT rbu_tmp_insert(3, %s);" + "END;" + + "CREATE TEMP TRIGGER rbu_update2_tr AFTER UPDATE ON \"%s%w\" " + "BEGIN " + " SELECT rbu_tmp_insert(4, %s);" + "END;", + zWrite, zTbl, zOldlist, + zWrite, zTbl, zOldlist, + zWrite, zTbl, zNewlist + ); + + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){ + rbuMPrintfExec(p, p->dbMain, + "CREATE TEMP TRIGGER rbu_insert_tr AFTER INSERT ON \"%s%w\" " + "BEGIN " + " SELECT rbu_tmp_insert(0, %s);" + "END;", + zWrite, zTbl, zNewlist + ); + } + + rbuObjIterPrepareTmpInsert(p, pIter, zCollist, zRbuRowid); + } + + /* Create the SELECT statement to read keys from data_xxx */ + if( p->rc==SQLITE_OK ){ + const char *zRbuRowid = ""; + char *zStart = 0; + char *zOrder = 0; + if( bRbuRowid ){ + zRbuRowid = rbuIsVacuum(p) ? ",_rowid_ " : ",rbu_rowid"; + } + + if( rbuIsVacuum(p) ){ + if( nOffset ){ + zStart = rbuVacuumTableStart(p, pIter, bRbuRowid, zWrite); + if( zStart ){ + sqlite3_free(zLimit); + zLimit = 0; + } + } + if( bRbuRowid ){ + zOrder = rbuMPrintf(p, "_rowid_"); + }else{ + zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", ""); + } + } + + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz, + sqlite3_mprintf( + "SELECT %s,%s rbu_control%s FROM '%q'%s %s %s %s", + zCollist, + (rbuIsVacuum(p) ? "0 AS " : ""), + zRbuRowid, + pIter->zDataTbl, (zStart ? zStart : ""), + (zOrder ? "ORDER BY" : ""), zOrder, + zLimit + ) + ); + } + sqlite3_free(zStart); + sqlite3_free(zOrder); + } + + sqlite3_free(zWhere); + sqlite3_free(zOldlist); + sqlite3_free(zNewlist); + sqlite3_free(zBindings); + } + sqlite3_free(zCollist); + sqlite3_free(zLimit); + } + + return p->rc; +} + +/* +** Set output variable *ppStmt to point to an UPDATE statement that may +** be used to update the imposter table for the main table b-tree of the +** table object that pIter currently points to, assuming that the +** rbu_control column of the data_xyz table contains zMask. +** +** If the zMask string does not specify any columns to update, then this +** is not an error. Output variable *ppStmt is set to NULL in this case. +*/ +static int rbuGetUpdateStmt( + sqlite3rbu *p, /* RBU handle */ + RbuObjIter *pIter, /* Object iterator */ + const char *zMask, /* rbu_control value ('x.x.') */ + sqlite3_stmt **ppStmt /* OUT: UPDATE statement handle */ +){ + RbuUpdateStmt **pp; + RbuUpdateStmt *pUp = 0; + int nUp = 0; + + /* In case an error occurs */ + *ppStmt = 0; + + /* Search for an existing statement. If one is found, shift it to the front + ** of the LRU queue and return immediately. Otherwise, leave nUp pointing + ** to the number of statements currently in the cache and pUp to the + ** last object in the list. */ + for(pp=&pIter->pRbuUpdate; *pp; pp=&((*pp)->pNext)){ + pUp = *pp; + if( strcmp(pUp->zMask, zMask)==0 ){ + *pp = pUp->pNext; + pUp->pNext = pIter->pRbuUpdate; + pIter->pRbuUpdate = pUp; + *ppStmt = pUp->pUpdate; + return SQLITE_OK; + } + nUp++; + } + assert( pUp==0 || pUp->pNext==0 ); + + if( nUp>=SQLITE_RBU_UPDATE_CACHESIZE ){ + for(pp=&pIter->pRbuUpdate; *pp!=pUp; pp=&((*pp)->pNext)); + *pp = 0; + sqlite3_finalize(pUp->pUpdate); + pUp->pUpdate = 0; + }else{ + pUp = (RbuUpdateStmt*)rbuMalloc(p, sizeof(RbuUpdateStmt)+pIter->nTblCol+1); + } + + if( pUp ){ + char *zWhere = rbuObjIterGetWhere(p, pIter); + char *zSet = rbuObjIterGetSetlist(p, pIter, zMask); + char *zUpdate = 0; + + pUp->zMask = (char*)&pUp[1]; + memcpy(pUp->zMask, zMask, pIter->nTblCol); + pUp->pNext = pIter->pRbuUpdate; + pIter->pRbuUpdate = pUp; + + if( zSet ){ + const char *zPrefix = ""; + + if( pIter->eType!=RBU_PK_VTAB ) zPrefix = "rbu_imp_"; + zUpdate = sqlite3_mprintf("UPDATE \"%s%w\" SET %s WHERE %s", + zPrefix, pIter->zTbl, zSet, zWhere + ); + p->rc = prepareFreeAndCollectError( + p->dbMain, &pUp->pUpdate, &p->zErrmsg, zUpdate + ); + *ppStmt = pUp->pUpdate; + } + sqlite3_free(zWhere); + sqlite3_free(zSet); + } + + return p->rc; +} + +static sqlite3 *rbuOpenDbhandle( + sqlite3rbu *p, + const char *zName, + int bUseVfs +){ + sqlite3 *db = 0; + if( p->rc==SQLITE_OK ){ + const int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_URI; + p->rc = sqlite3_open_v2(zName, &db, flags, bUseVfs ? p->zVfsName : 0); + if( p->rc ){ + p->zErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + sqlite3_close(db); + db = 0; + } + } + return db; +} + +/* +** Free an RbuState object allocated by rbuLoadState(). +*/ +static void rbuFreeState(RbuState *p){ + if( p ){ + sqlite3_free(p->zTbl); + sqlite3_free(p->zDataTbl); + sqlite3_free(p->zIdx); + sqlite3_free(p); + } +} + +/* +** Allocate an RbuState object and load the contents of the rbu_state +** table into it. Return a pointer to the new object. It is the +** responsibility of the caller to eventually free the object using +** sqlite3_free(). +** +** If an error occurs, leave an error code and message in the rbu handle +** and return NULL. +*/ +static RbuState *rbuLoadState(sqlite3rbu *p){ + RbuState *pRet = 0; + sqlite3_stmt *pStmt = 0; + int rc; + int rc2; + + pRet = (RbuState*)rbuMalloc(p, sizeof(RbuState)); + if( pRet==0 ) return 0; + + rc = prepareFreeAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg, + sqlite3_mprintf("SELECT k, v FROM %s.rbu_state", p->zStateDb) + ); + while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ + switch( sqlite3_column_int(pStmt, 0) ){ + case RBU_STATE_STAGE: + pRet->eStage = sqlite3_column_int(pStmt, 1); + if( pRet->eStage!=RBU_STAGE_OAL + && pRet->eStage!=RBU_STAGE_MOVE + && pRet->eStage!=RBU_STAGE_CKPT + ){ + p->rc = SQLITE_CORRUPT; + } + break; + + case RBU_STATE_TBL: + pRet->zTbl = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc); + break; + + case RBU_STATE_IDX: + pRet->zIdx = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc); + break; + + case RBU_STATE_ROW: + pRet->nRow = sqlite3_column_int(pStmt, 1); + break; + + case RBU_STATE_PROGRESS: + pRet->nProgress = sqlite3_column_int64(pStmt, 1); + break; + + case RBU_STATE_CKPT: + pRet->iWalCksum = sqlite3_column_int64(pStmt, 1); + break; + + case RBU_STATE_COOKIE: + pRet->iCookie = (u32)sqlite3_column_int64(pStmt, 1); + break; + + case RBU_STATE_OALSZ: + pRet->iOalSz = (u32)sqlite3_column_int64(pStmt, 1); + break; + + case RBU_STATE_PHASEONESTEP: + pRet->nPhaseOneStep = sqlite3_column_int64(pStmt, 1); + break; + + case RBU_STATE_DATATBL: + pRet->zDataTbl = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc); + break; + + default: + rc = SQLITE_CORRUPT; + break; + } + } + rc2 = sqlite3_finalize(pStmt); + if( rc==SQLITE_OK ) rc = rc2; + + p->rc = rc; + return pRet; +} + + +/* +** Open the database handle and attach the RBU database as "rbu". If an +** error occurs, leave an error code and message in the RBU handle. +*/ +static void rbuOpenDatabase(sqlite3rbu *p, int *pbRetry){ + assert( p->rc || (p->dbMain==0 && p->dbRbu==0) ); + assert( p->rc || rbuIsVacuum(p) || p->zTarget!=0 ); + + /* Open the RBU database */ + p->dbRbu = rbuOpenDbhandle(p, p->zRbu, 1); + + if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){ + sqlite3_file_control(p->dbRbu, "main", SQLITE_FCNTL_RBUCNT, (void*)p); + if( p->zState==0 ){ + const char *zFile = sqlite3_db_filename(p->dbRbu, "main"); + p->zState = rbuMPrintf(p, "file://%s-vacuum?modeof=%s", zFile, zFile); + } + } + + /* If using separate RBU and state databases, attach the state database to + ** the RBU db handle now. */ + if( p->zState ){ + rbuMPrintfExec(p, p->dbRbu, "ATTACH %Q AS stat", p->zState); + memcpy(p->zStateDb, "stat", 4); + }else{ + memcpy(p->zStateDb, "main", 4); + } + +#if 0 + if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){ + p->rc = sqlite3_exec(p->dbRbu, "BEGIN", 0, 0, 0); + } +#endif + + /* If it has not already been created, create the rbu_state table */ + rbuMPrintfExec(p, p->dbRbu, RBU_CREATE_STATE, p->zStateDb); + +#if 0 + if( rbuIsVacuum(p) ){ + if( p->rc==SQLITE_OK ){ + int rc2; + int bOk = 0; + sqlite3_stmt *pCnt = 0; + p->rc = prepareAndCollectError(p->dbRbu, &pCnt, &p->zErrmsg, + "SELECT count(*) FROM stat.sqlite_schema" + ); + if( p->rc==SQLITE_OK + && sqlite3_step(pCnt)==SQLITE_ROW + && 1==sqlite3_column_int(pCnt, 0) + ){ + bOk = 1; + } + rc2 = sqlite3_finalize(pCnt); + if( p->rc==SQLITE_OK ) p->rc = rc2; + + if( p->rc==SQLITE_OK && bOk==0 ){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("invalid state database"); + } + + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, 0); + } + } + } +#endif + + if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){ + int bOpen = 0; + int rc; + p->nRbu = 0; + p->pRbuFd = 0; + rc = sqlite3_file_control(p->dbRbu, "main", SQLITE_FCNTL_RBUCNT, (void*)p); + if( rc!=SQLITE_NOTFOUND ) p->rc = rc; + if( p->eStage>=RBU_STAGE_MOVE ){ + bOpen = 1; + }else{ + RbuState *pState = rbuLoadState(p); + if( pState ){ + bOpen = (pState->eStage>=RBU_STAGE_MOVE); + rbuFreeState(pState); + } + } + if( bOpen ) p->dbMain = rbuOpenDbhandle(p, p->zRbu, p->nRbu<=1); + } + + p->eStage = 0; + if( p->rc==SQLITE_OK && p->dbMain==0 ){ + if( !rbuIsVacuum(p) ){ + p->dbMain = rbuOpenDbhandle(p, p->zTarget, 1); + }else if( p->pRbuFd->pWalFd ){ + if( pbRetry ){ + p->pRbuFd->bNolock = 0; + sqlite3_close(p->dbRbu); + sqlite3_close(p->dbMain); + p->dbMain = 0; + p->dbRbu = 0; + *pbRetry = 1; + return; + } + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("cannot vacuum wal mode database"); + }else{ + char *zTarget; + char *zExtra = 0; + if( strlen(p->zRbu)>=5 && 0==memcmp("file:", p->zRbu, 5) ){ + zExtra = &p->zRbu[5]; + while( *zExtra ){ + if( *zExtra++=='?' ) break; + } + if( *zExtra=='\0' ) zExtra = 0; + } + + zTarget = sqlite3_mprintf("file:%s-vactmp?rbu_memory=1%s%s", + sqlite3_db_filename(p->dbRbu, "main"), + (zExtra==0 ? "" : "&"), (zExtra==0 ? "" : zExtra) + ); + + if( zTarget==0 ){ + p->rc = SQLITE_NOMEM; + return; + } + p->dbMain = rbuOpenDbhandle(p, zTarget, p->nRbu<=1); + sqlite3_free(zTarget); + } + } + + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_create_function(p->dbMain, + "rbu_tmp_insert", -1, SQLITE_UTF8, (void*)p, rbuTmpInsertFunc, 0, 0 + ); + } + + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_create_function(p->dbMain, + "rbu_fossil_delta", 2, SQLITE_UTF8, 0, rbuFossilDeltaFunc, 0, 0 + ); + } + + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_create_function(p->dbRbu, + "rbu_target_name", -1, SQLITE_UTF8, (void*)p, rbuTargetNameFunc, 0, 0 + ); + } + + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_RBU, (void*)p); + } + rbuMPrintfExec(p, p->dbMain, "SELECT * FROM sqlite_schema"); + + /* Mark the database file just opened as an RBU target database. If + ** this call returns SQLITE_NOTFOUND, then the RBU vfs is not in use. + ** This is an error. */ + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_RBU, (void*)p); + } + + if( p->rc==SQLITE_NOTFOUND ){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("rbu vfs not found"); + } +} + +/* +** This routine is a copy of the sqlite3FileSuffix3() routine from the core. +** It is a no-op unless SQLITE_ENABLE_8_3_NAMES is defined. +** +** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database +** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and +** if filename in z[] has a suffix (a.k.a. "extension") that is longer than +** three characters, then shorten the suffix on z[] to be the last three +** characters of the original suffix. +** +** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always +** do the suffix shortening regardless of URI parameter. +** +** Examples: +** +** test.db-journal => test.nal +** test.db-wal => test.wal +** test.db-shm => test.shm +** test.db-mj7f3319fa => test.9fa +*/ +static void rbuFileSuffix3(const char *zBase, char *z){ +#ifdef SQLITE_ENABLE_8_3_NAMES +#if SQLITE_ENABLE_8_3_NAMES<2 + if( sqlite3_uri_boolean(zBase, "8_3_names", 0) ) +#endif + { + int i, sz; + sz = (int)strlen(z)&0xffffff; + for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){} + if( z[i]=='.' && sz>i+4 ) memmove(&z[i+1], &z[sz-3], 4); + } +#endif +} + +/* +** Return the current wal-index header checksum for the target database +** as a 64-bit integer. +** +** The checksum is store in the first page of xShmMap memory as an 8-byte +** blob starting at byte offset 40. +*/ +static i64 rbuShmChecksum(sqlite3rbu *p){ + i64 iRet = 0; + if( p->rc==SQLITE_OK ){ + sqlite3_file *pDb = p->pTargetFd->pReal; + u32 volatile *ptr; + p->rc = pDb->pMethods->xShmMap(pDb, 0, 32*1024, 0, (void volatile**)&ptr); + if( p->rc==SQLITE_OK ){ + iRet = ((i64)ptr[10] << 32) + ptr[11]; + } + } + return iRet; +} + +/* +** This function is called as part of initializing or reinitializing an +** incremental checkpoint. +** +** It populates the sqlite3rbu.aFrame[] array with the set of +** (wal frame -> db page) copy operations required to checkpoint the +** current wal file, and obtains the set of shm locks required to safely +** perform the copy operations directly on the file-system. +** +** If argument pState is not NULL, then the incremental checkpoint is +** being resumed. In this case, if the checksum of the wal-index-header +** following recovery is not the same as the checksum saved in the RbuState +** object, then the rbu handle is set to DONE state. This occurs if some +** other client appends a transaction to the wal file in the middle of +** an incremental checkpoint. +*/ +static void rbuSetupCheckpoint(sqlite3rbu *p, RbuState *pState){ + + /* If pState is NULL, then the wal file may not have been opened and + ** recovered. Running a read-statement here to ensure that doing so + ** does not interfere with the "capture" process below. */ + if( pState==0 ){ + p->eStage = 0; + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_exec(p->dbMain, "SELECT * FROM sqlite_schema", 0, 0, 0); + } + } + + /* Assuming no error has occurred, run a "restart" checkpoint with the + ** sqlite3rbu.eStage variable set to CAPTURE. This turns on the following + ** special behaviour in the rbu VFS: + ** + ** * If the exclusive shm WRITER or READ0 lock cannot be obtained, + ** the checkpoint fails with SQLITE_BUSY (normally SQLite would + ** proceed with running a passive checkpoint instead of failing). + ** + ** * Attempts to read from the *-wal file or write to the database file + ** do not perform any IO. Instead, the frame/page combinations that + ** would be read/written are recorded in the sqlite3rbu.aFrame[] + ** array. + ** + ** * Calls to xShmLock(UNLOCK) to release the exclusive shm WRITER, + ** READ0 and CHECKPOINT locks taken as part of the checkpoint are + ** no-ops. These locks will not be released until the connection + ** is closed. + ** + ** * Attempting to xSync() the database file causes an SQLITE_INTERNAL + ** error. + ** + ** As a result, unless an error (i.e. OOM or SQLITE_BUSY) occurs, the + ** checkpoint below fails with SQLITE_INTERNAL, and leaves the aFrame[] + ** array populated with a set of (frame -> page) mappings. Because the + ** WRITER, CHECKPOINT and READ0 locks are still held, it is safe to copy + ** data from the wal file into the database file according to the + ** contents of aFrame[]. + */ + if( p->rc==SQLITE_OK ){ + int rc2; + p->eStage = RBU_STAGE_CAPTURE; + rc2 = sqlite3_exec(p->dbMain, "PRAGMA main.wal_checkpoint=restart", 0, 0,0); + if( rc2!=SQLITE_INTERNAL ) p->rc = rc2; + } + + if( p->rc==SQLITE_OK && p->nFrame>0 ){ + p->eStage = RBU_STAGE_CKPT; + p->nStep = (pState ? pState->nRow : 0); + p->aBuf = rbuMalloc(p, p->pgsz); + p->iWalCksum = rbuShmChecksum(p); + } + + if( p->rc==SQLITE_OK ){ + if( p->nFrame==0 || (pState && pState->iWalCksum!=p->iWalCksum) ){ + p->rc = SQLITE_DONE; + p->eStage = RBU_STAGE_DONE; + }else{ + int nSectorSize; + sqlite3_file *pDb = p->pTargetFd->pReal; + sqlite3_file *pWal = p->pTargetFd->pWalFd->pReal; + assert( p->nPagePerSector==0 ); + nSectorSize = pDb->pMethods->xSectorSize(pDb); + if( nSectorSize>p->pgsz ){ + p->nPagePerSector = nSectorSize / p->pgsz; + }else{ + p->nPagePerSector = 1; + } + + /* Call xSync() on the wal file. This causes SQLite to sync the + ** directory in which the target database and the wal file reside, in + ** case it has not been synced since the rename() call in + ** rbuMoveOalFile(). */ + p->rc = pWal->pMethods->xSync(pWal, SQLITE_SYNC_NORMAL); + } + } +} + +/* +** Called when iAmt bytes are read from offset iOff of the wal file while +** the rbu object is in capture mode. Record the frame number of the frame +** being read in the aFrame[] array. +*/ +static int rbuCaptureWalRead(sqlite3rbu *pRbu, i64 iOff, int iAmt){ + const u32 mReq = (1<mLock!=mReq ){ + pRbu->rc = SQLITE_BUSY; + return SQLITE_INTERNAL; + } + + pRbu->pgsz = iAmt; + if( pRbu->nFrame==pRbu->nFrameAlloc ){ + int nNew = (pRbu->nFrameAlloc ? pRbu->nFrameAlloc : 64) * 2; + RbuFrame *aNew; + aNew = (RbuFrame*)sqlite3_realloc64(pRbu->aFrame, nNew * sizeof(RbuFrame)); + if( aNew==0 ) return SQLITE_NOMEM; + pRbu->aFrame = aNew; + pRbu->nFrameAlloc = nNew; + } + + iFrame = (u32)((iOff-32) / (i64)(iAmt+24)) + 1; + if( pRbu->iMaxFrame

    • oYvD8b~P*b(R# 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